spring-boot

spring boot

Spring Boot与缓存

SimpleCacheConfiguration

JSR-107

Java Caching定义了5个核心接口，分别是CachingProvider, CacheManager, Cache, Entry 和 Expiry

• CachingProvider定义了创建、配置、获取、管理和控制多个CacheManager。一个应用可以在运行期访问多个CachingProvider。
• CacheManager定义了创建、配置、获取、管理和控制多个唯一命名的Cache，这些Cache存在于CacheManager的上下文中。一个CacheManager仅被一个CachingProvider所拥有。
• Cache是一个类似Map的数据结构并临时存储以Key为索引的值。一个Cache仅被一个CacheManager所拥有。
• Entry是一个存储在Cache中的key-value对。
• Expiry 每一个存储在Cache中的条目有一个定义的有效期。一旦超过这个时间，条目为过期的状态。一旦过期，条目将不可访问、更新和删除。缓存有效期可以通过ExpiryPolicy设置

Spring缓存抽象

Spring从3.1开始定义了org.springframework.cache.Cache
和org.springframework.cache.CacheManager接口来统一不同的缓存技术；
并支持使用JCache（JSR-107）注解简化我们开发

• Cache接口为缓存的组件规范定义，包含缓存的各种操作集合；
• Cache接口下Spring提供了各种xxxCache的实现；如RedisCache，EhCacheCache , ConcurrentMapCache等；
• 每次调用需要缓存功能的方法时，Spring会检查指定参数的指定的目标方法是否已经被调用过；如果有就直接从缓存中获取方法调用后的结果，如果没有就调用方法并缓存结果后返回给用户。下次调用直接从缓存中获取。
• 使用Spring缓存抽象时我们需要关注以下两点；
  • 确定方法需要被缓存以及他们的缓存策略
  • 从缓存中读取之前缓存存储的数据

几个重要概念&缓存注解

Cache	缓存接口，定义缓存操作。实现有：RedisCache、EhCacheCache、ConcurrentMapCache等
CacheManager	缓存管理器，管理各种缓存（Cache）组件
@Cacheable	主要针对方法配置，能够根据方法的请求参数对其结果进行缓存 参数key不能使用SpEl表达式中的#result，是先走缓存在执行方法，所以拿不到方法的返回值
@CacheEvict	清空缓存
@CachePut	保证方法被调用，又希望结果被缓存。
@EnableCaching	开启基于注解的缓存
keyGenerator	缓存数据时key生成策略
serialize	缓存数据时value序列化策略
@CacheConfig	抽取公共配置
@Caching	组合多个Cache注解使用

@Cacheable/@CachePut/@CacheEvict 主要的参数

名称	说明	样例
cacheNames/value	指定缓存组件的名称（cache的名称），可以使用SpEl表达式	@Cacheable(cacheNames = "emp") @Cacheable(value=”mycache”) @Cacheable(value={”cache1”,”cache2”}
key	缓存数据使用的key，默认是使用方法的参数（cache中k-v的k），可以使用SpEl表达式	@Cacheable(cacheNames = "emp", key = "#id") @Cacheable(cacheNames = "emp", key = "#root.args[0]")
keyGenerator	key的生成器，可以自定义key的生成器，key/keyGenerator二选一使用
cacheManager	指定缓存管理器
cacheResolver	指定获取解析器，与cacheManager二选一
condition	指定符合条件下缓存，可以使用SpEl表达式	condition = "#id > 0"
unless	指定符合条件下不缓存，可以使用SpEl表达式	unless = "#result == null"
sync	是否异步模式
allEntries (@CacheEvict )	是否清空所有缓存内容，缺省为 false，如果指定为 true， 则方法调用后将立即清空所有缓存：	@CacheEvict(cacheNames = "emp", allEntries = true, beforeInvocation = true)
beforeInvocation (@CacheEvict)	是否在方法执行前就清空，缺省为 false，如果指定为 true， 则在方法还没有执行的时候就清空缓存，缺省情况下，如果方法 执行抛出异常，则不会清空缓存	@CacheEvict(cacheNames = "emp", allEntries = true, beforeInvocation = true)

SpEL详解

名字	位置	描述	示例
methodName	root object	当前被调用的方法名	#root.methodName
method	root object	当前被调用的方法	#root.method.name
target	root object	当前被调用的目标对象	#root.target
targetClass	root object	当前被调用的目标对象类	#root.targetClass
args	root object	当前被调用的方法的参数列表	#root.args[0]
caches	root object	当前方法调用使用的缓存列表（如@Cacheable(value={"cache1", "cache2"})），则有两个cache	#root.caches[0].name
argument name	evaluation context	方法参数的名字. 可以直接 #参数名 ，也可以使用 #p0或#a0 的形式，0代表参数的索引；	#iban 、 #a0 、 #p0
result	evaluation context	方法执行后的返回值（仅当方法执行之后的判断有效，如‘unless’，’cache put’的表达式 ’cache evict’的表达式beforeInvocation=false）	#result

SpEL提供了多种运算符

类型	运算符
关系	<，>，<=，>=，==，!=，lt，gt，le，ge，eq，ne
算术	+，- ，* ，/，%，^
逻辑	&&，||，!，and，or，not，between，instanceof
条件	?: (ternary)，?: (elvis)
正则表达式	matches
其他类型	?.，?[…]，![…]，^[…]，$[…]

开始使用

• 导入依赖

  
       org.springframework.boot
       spring-boot-starter-cache
  
  

• 开启缓存注解@EnableCaching

  @SpringBootApplication
  @EnableCaching
  public class SpringbootCacheApplication {
      public static void main(String[] args) {
          SpringApplication.run(SpringbootCacheApplication.class, args);
      }
  }
  

• 缓存注解@Cacheable

  @Cacheable(cacheNames = "emp", key = "#id")
  public Employee getEmployeeById(Integer id) {
      System.out.println("查询了" + id +  "号员工");
      Employee employee = employeeMapper.getEmployeeById(id);
      return employee;
  }
  

• 更新缓存注解@CachePut

  @CachePut(cacheNames = "emp", key = "#result.id")
  public Employee editEmploy(Employee employee) {
      employeeMapper.editEmploy(employee);
      return employee;
  }
  

• 清除缓存注解@CacheEvict

  @CacheEvict(cacheNames = "emp", allEntries = true, beforeInvocation = true)
  public void delEmploy(Integer id) {
     employeeMapper.delEmploy(id);
  }
  

• 公共配置注解@CacheConfig

  @Service
  @CacheConfig(cacheNames = "emp")
  public class EmployeeService {
  
      @Resource
      EmployeeMapper employeeMapper;
  
      @Cacheable( key = "#id")
      public Employee getEmployeeById(Integer id) {
          System.out.println("查询了" + id +  "号员工");
          Employee employee = employeeMapper.getEmployeeById(id);
          return employee;
      }
  }
  

• 组合注解@Caching

  @Caching(
      cacheable = {
          @Cacheable( key = "#name"),
      },
      put = {
          @CachePut( key = "#result.id"),
          @CachePut( key = "#result.name"),
      }
  )
  public Employee getEmployByName(String name) {
      Employee employee = employeeMapper.getEmployeeByName(name);
      return employee;
  }
  

RedisCacheConfiguration

测试使用

• 导入依赖

  
      org.springframework.boot
      spring-boot-starter-data-redis
      2.2.0.RELEASE
  
  

• 配置

  spring.redis.host=localhost
  

• 查看redis自动装配类

  RedisAutoConfiguration自动配置类提供了RedisTemplate、stringRedisTemplate

  RedisTemplate 操作对象k-v 都是Object类型

  stringRedisTemplate 操作对象k-v都是String类型

  @Configuration(proxyBeanMethods = false)
  @ConditionalOnClass(RedisOperations.class)
  @EnableConfigurationProperties(RedisProperties.class)
  @Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
  public class RedisAutoConfiguration {
  
    @Bean
    @ConditionalOnMissingBean(name = "redisTemplate")
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {
        RedisTemplate template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
  
    @Bean
    @ConditionalOnMissingBean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
  
  }
  

• 测试

  操作String

  @SpringBootTest
  class SpringbootCacheApplicationTests {
  
      @Resource
      RedisTemplate redisTemplate;
  
      @Resource
      StringRedisTemplate stringRedisTemplate;
  
  
      /**
       * Redis常见的五种数据类型
       * String（字符串），List（列表），Set（集合），Hash（散列），ZSet（有序集合）
       * stringRedisTemplate.opsForValue();   操作[String（字符串）]
       * stringRedisTemplate.opsForList();    操作[List（列表）]
       * stringRedisTemplate.opsForSet();     操作[Set（集合）]
       * stringRedisTemplate.opsForHash();    操作[Hash（散列）]
       * stringRedisTemplate.opsForZSet();    操作[ZSet（有序集合）]
       */
      @Test
      public void redisTest01() {
          stringRedisTemplate.opsForValue().set("key", "沈云峰");
          stringRedisTemplate.opsForList().leftPush("list01", "1");
          stringRedisTemplate.opsForList().leftPush("list01", "2");
          stringRedisTemplate.opsForList().leftPush("list01", "2");
      }
  }
  

  结果

  127.0.0.1:6379> get key
  "\xe6\xb2\x88\xe4\xba\x91\xe5\xb3\xb0"
  127.0.0.1:6379>

  操作Object

  @SpringBootTest
  class SpringbootCacheApplicationTests {
  
      @Resource
      RedisTemplate redisTemplate;
  
      @Resource
      StringRedisTemplate stringRedisTemplate;
  
      /**
       * redisTemplate.opsForValue();   操作[String（字符串）]
       * redisTemplate.opsForList();    操作[List（列表）]
       * redisTemplate.opsForSet();     操作[Set（集合）]
       * redisTemplate.opsForHash();    操作[Hash（散列）]
       * redisTemplate.opsForZSet();    操作[ZSet（有序集合）]
       */
      @Test
      public void redisTest02() {
          redisTemplate.opsForValue().set(55, 66);
      }
  }
  
  

  结果：全部使用默认JdkSerializationRedisSerializer序列化，结果无法识别

  key：\xAC\xED\x00\x05sr\x00\x11java.lang.Integer\x12\xE2\xA0\xA4\xF7\x81\x878\x02\x00\x01I\x00\x05valuexr\x00\x10java.lang.Number\x86\xAC\x95\x1D\x0B\x94\xE0\x8B\x02\x00\x00xp\x00\x00\x007

  value：

  \xAC\xED\x00\x05sr\x00\x11java.lang.Integer\x12\xE2\xA0\xA4\xF7\x81\x878\x02\x00\x01I\x00\x05valuexr\x00\x10java.lang.Number\x86\xAC\x95\x1D\x0B\x94\xE0\x8B\x02\x00\x00xp\x00\x00\x00B

• 序列化结果无法识别--解决方案

  • 自己将对象转成json
  • 修改RedisTemplate默认的序列号规则

• 使用json序列化

  • 分析

    查看RedisTemplate -> RedisSerializer

    查看RedisSerializer 的实现类

    • OxmSerializer
    • ByteArrayRedisSerializer
    • GenericJackson2JsonRedisSerializer
    • GenericToStringSerializer
    • StringRedisSerializer
    • JdkSerializationRedisSerializer
    • Jackson2JsonRedisSerializer

  • 自定配置类使用Jackson2JsonRedisSerializer

    @Configuration
    public class MyCacheConfig {
        @Bean
        public RedisTemplate myRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
            RedisTemplate template = new RedisTemplate<>();
            template.setConnectionFactory(redisConnectionFactory);
            template.setDefaultSerializer(new Jackson2JsonRedisSerializer(String.class));
            return template;
        }
    }
    

  • 测试

    @SpringBootTest
    class SpringbootCacheApplicationTests {
        @Resource
        RedisTemplate myRedisTemplate;
    
        @Test
        public void redisTest02() {
            myRedisTemplate.opsForValue().set(55, "88");
        }
    }
    

  • 结果

    127.0.0.1:6379> get 55
    "\"88\""
    127.0.0.1:6379>
    

程序使用

• 缓存原理
  • 通过CacheManager管理Cache，Cache组件来缓存数据
  • 引入spring-boot-starter-data-redis组件，RedisCacheManager帮我们创建RedisCache作为缓存组件；RedisCache通过操作Redis来缓存数据
  • 默认保存数据k-v都是Object，利用默认的序列化保存。
• 保存json数据
  • 自定义cacheManager方法

Spring Boot与消息

简介

1. 大多应用中，可通过消息服务中间件来提升系统异步通信、扩展解耦能力、流量消峰

2. 消息服务中两个重要概念

   1. 消息代理（message broker）
   2. 目的地（destination）

   当消息发送者发送消息以后，将由消息代理接管，消息代理保证消息传递到指定目的地。

3. 消息队列主要有两种形式的目的地

   1. 队列（queue）：点对点消息通信（point-to-point）
   2. 主题（topic）：发布（publish）/订阅（subscribe）消息通信

4. 点对点式

   1. 消息发送者发送消息，消息代理将其放入一个队列中，消息接收者从队列中获取消息内容，消息读取后被移出队列
   2. 消息只有唯一的发送者和接受者，但并不是说只能有一个接收者

5. 发布订阅式

   发送者（发布者）发送消息到主题，多个接收者（订阅者）监听（订阅）这个主题，那么就会在消息到达时同时收到消息

6. JMS（Java Message Service）JAVA消息服务

   基于JVM消息代理的规范。ActiveMQ、HornetMQ是JMS实现

7. AMQP（Advanced Message Queuing Protocol）

   高级消息队列协议，也是一个消息代理的规范，兼容JMS
   RabbitMQ是AMQP的实现

JMS和AMQP对比

	JMS	AMQP
定义	Java api	网络线级协议
跨语言	否	是
跨平台	否	是
Model	提供两种消息模型：（1）、Peer-2-Peer（2）、Pub/sub	提供了五种消息模型：（1）direct exchange、（2）fanout exchange、（3）topic change、（4）headers exchange、（5）system exchange 本质来讲，后四种和JMS的pub/sub模型没有太大差别，仅是在路由机制上做了更详细的划分；
支持消息类型	多种消息类型：TextMessage、MapMessage、BytesMessage、StreamMessage、ObjectMessageMessage （只有消息头和属性）	byte[]当实际应用时，有复杂的消息，可以将消息序列化后发送。
综合评价	JMS 定义了JAVA API层面的标准；在java体系中，多个client均可以通过JMS进行交互，不需要应用修改代码，但是其对跨平台的支持较差；	AMQP定义了wire-level层的协议标准；天然具有跨平台、跨语言特性。

Spring对消息队列的支持

• spring-jms提供了对JMS的支持
• spring-rabbit提供了对AMQP的支持
• 需要ConnectionFactory的实现来连接消息代理
• 提供JmsTemplate、RabbitTemplate来发送消息
• @JmsListener（JMS）、@RabbitListener（AMQP）注解在方法上监听消息代理发布的消息
• @EnableJms、@EnableRabbit开启支持

Spring Boot自动配置

• JmsAutoConfiguration
• RabbitAutoConfiguration

RabbitMQ简介

RabbitMQ是一个由erlang开发的AMQP(Advanved Message Queue Protocol)的开源实现。

核心概念

• Message

  消息，消息是不具名的，它由消息头和消息体组成。消息体是不透明的，而消息头则由一系列的可选属性组成，这些属性包括routing-key（路由键）、priority（相对于其他消息的优先权）、delivery-mode（指出该消息可能需要持久性存储）等。

• Publisher

  消息的生产者，也是一个向交换器发布消息的客户端应用程序

• Exchange

  交换器，用来接收生产者发送的消息并将这些消息路由给服务器中的队列。
  Exchange有4种类型：direct(默认)，fanout, topic, 和headers，不同类型的Exchange转发消息的策略有所区别

• Queue

  消息队列，用来保存消息直到发送给消费者。它是消息的容器，也是消息的终点。一个消息可投入一个或多个队列。消息一直在队列里面，等待消费者连接到这个队列将其取走。

• Binding

  绑定，用于消息队列和交换器之间的关联。一个绑定就是基于路由键将交换器和消息队列连接起来的路由规则，所以可以将交换器理解成一个由绑定构成的路由表。
  Exchange 和Queue的绑定可以是多对多的关系。

• Connection

  网络连接，比如一个TCP连接。

• Channel

  信道，多路复用连接中的一条独立的双向数据流通道。信道是建立在真实的TCP连接内的虚拟连接，AMQP 命令都是通过信道发出去的，不管是发布消息、订阅队列还是接收消息，这些动作都是通过信道完成。因为对于操作系统来说建立和销毁 TCP 都是非常昂贵的开销，所以引入了信道的概念，以复用一条 TCP 连接。

• Consumer

  消息的消费者，表示一个从消息队列中取得消息的客户端应用程序。

• Virtual Host

  虚拟主机，表示一批交换器、消息队列和相关对象。虚拟主机是共享相同的身份认证和加密环境的独立服务器域。每个 vhost 本质上就是一个 mini 版的 RabbitMQ 服务器，拥有自己的队列、交换器、绑定和权限机制。vhost 是 AMQP 概念的基础，必须在连接时指定，RabbitMQ 默认的 vhost 是 / 。

• Broker

  表示消息队列服务器实体

rabbitmq.png

RabbitMQ运行机制

• AMQP 中的消息路由

  AMQP 中消息的路由过程和 Java 开发者熟悉的 JMS 存在一些差别，AMQP 中增加了 Exchange 和 Binding 的角色。生产者把消息发布到 Exchange 上，消息最终到达队列并被消费者接收，而 Binding 决定交换器的消息应该发送到那个队列

rabbitmq-run.png

• Exchange 类型

  Exchange分发消息时根据类型的不同分发策略有区别，目前共四种类型

  • direct

    消息中的路由键（routing key）如果和 Binding 中的 binding key 一致， 交换器就将消息发到对应的队列中。路由键与队列名完全匹配，如果一个队列绑定到交换机要求路由键为“dog”，则只转发 routing key 标记为“dog”的消息，不会转发“dog.puppy”，也不会转发“dog.guard”等等。它是完全匹配、单播的模式。

direct.png

• fanout

  每个发到 fanout 类型交换器的消息都会分到所有绑定的队列上去。fanout 交换器不处理路由键，只是简单的将队列绑定到交换器上，每个发送到交换器的消息都会被转发到与该交换器绑定的所有队列上。很像子网广播，每台子网内的主机都获得了一份复制的消息。fanout 类型转发消息是最快的。

fanout.png

• topic

  topic 交换器通过模式匹配分配消息的路由键属性，将路由键和某个模式进行匹配，此时队列需要绑定到一个模式上。它将路由键和绑定键的字符串切分成单词，这些单词之间用点隔开。它同样也会识别两个通配符：符号“#”和符号“”。#*匹配0个或多个单词，*****匹配一个单词。

topic.png

• headers

  headers 匹配 AMQP 消息的 header 而不是路由键， headers 交换器和 direct 交换器完全一致，但性能差很多，目前几乎用不到了。

Springboot整合RabbitMQ

• 导入依赖

  
      org.springframework.boot
      spring-boot-starter-amqp
  
  

• 配置

  spring.rabbitmq.host=192.168.11.220
  spring.rabbitmq.username=guest
  spring.rabbitmq.password=guest
  spring.rabbitmq.virtual-host=/
  spring.rabbitmq.port=5672
  

• 分析RabbitAutoConfiguration自动配置类

  • CachingConnectionFactory自动配置了连接工厂

  • RabbitProperties封装了RabbitMQ配置

  • RabbitTemplate给RabbitMQ发送和接受消息

  • AmqpAdminRabbitMQ系统管理组件

    创建和删除Queue，Exchange，Binding

  • @EnableRabbit和@RabbitListener监听消息队列的内容

• 测试RabbitTemplate

  @SpringBootTest
  class SpringbootRabbitmqApplicationTests {
  
      @Resource
      RabbitTemplate rabbitTemplate;
  
      /**
       * direct：点对点模式
       */
      @Test
      void testDirect() {
          Map msgMap = new HashMap<>();
          msgMap.put("name", "direct");
          msgMap.put("age", 18);
          rabbitTemplate.convertAndSend("exchange.direct", "atguigu", msgMap);
      }
  
      /**
       * fanout：广播模式
       */
      @Test
      void testFanout() {
          Map msgMap = new HashMap<>();
          msgMap.put("name", "fanout");
          msgMap.put("age", 19);
          rabbitTemplate.convertAndSend("exchange.fanout", "", msgMap);
      }
  
      /**
       * topic
       */
      @Test
      void testTopic() {
          Map msgMap = new HashMap<>();
          msgMap.put("name", "topic");
          msgMap.put("age", 20);
          rabbitTemplate.convertAndSend("exchange.topic", "*.news", msgMap);
      }
      /**
       * 获取消息
       */
      @Test
      void getMsg() {
          Object o = rabbitTemplate.receiveAndConvert("atguigu");
          System.out.println(o.getClass());
          System.out.println(o);
      }
  }
  

• 使用Json序列化Message

  @Configuration
  public class MyAMQPConfig {
      @Bean
      public MessageConverter messageConverter() {
          return new Jackson2JsonMessageConverter();
      }
  }
  

• 测试监听消息队列

  @Service
  public class StuServive {
      @RabbitListener(queues = "atguigu")
      public void listenMsg(Message message) {
          System.out.println(message);
      }
  }
  

• 测试AmqpAdmin

      @Resource
      AmqpAdmin amqpAdmin;
  
      /**
       * 系统管理组件
       * amqpAdmin.declare*   创建
       * amqpAdmin.delete*    删除
       */
      @Test
      void testAmqpAdmin() {
  //        amqpAdmin.declareExchange(new DirectExchange("testDirect", true, true));
  //        amqpAdmin.declareQueue(new Queue("testQueue", true));
          amqpAdmin.declareBinding(new Binding("testQueue", Binding.DestinationType.QUEUE, "testDirect", "testExchange", null));
      }