SpringBoot系列4-----缓存、消息

一.缓存

1.JSR107

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

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

2.Spring缓存抽象

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

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

3.几个重要概念&缓存注解

1.搭建基本环境

1、导入数据库文件 创建出department和employee表
2、创建javaBean封装数据
3、整合MyBatis操作数据库

• 1.配置数据源信息
• 2.使用注解版的MyBatis；

  • @MapperScan指定需要扫描的mapper接口所在的包

      	@MapperScan("com.atguigu.cache.mapper") 
    

  spring.datasource.url=jdbc:mysql://localhost:3306/spring_cache
  spring.datasource.username=root
  spring.datasource.password=123456
  #spring.datasource.driver-class-name=com.mysql.jdbc.Driver
  
  # 开启驼峰命名匹配规则
  mybatis.configuration.map-underscore-to-camel-case=true
  

1.快速体验缓存

步骤：
默认使用的是ConcurrentMapCacheManager==ConcurrentMapCache；将数据保存在 ConcurrentMap<Object, Object>中
开发中使用缓存中间件；redis、memcached、ehcache；

下面是ConcurrentMapCacheManager：

1. 开启基于注解的缓存 @EnableCaching

   @MapperScan("com.atguigu.cache.mapper")
   @SpringBootApplication
   @EnableCaching
   public class Springboot01CacheApplication {
   
   	public static void main(String[] args) {
   		SpringApplication.run(Springboot01CacheApplication.class, args);
   	}
   }
   

2. 标注缓存注解即可

   1. @Cacheable

   /**
        * 将方法的运行结果进行缓存；以后再要相同的数据，直接从缓存中获取，不用调用方法；
        * CacheManager管理多个Cache组件的，对缓存的真正CRUD操作在Cache组件中，每一个缓存组件有自己唯一一个名字；
        *
   
        *
        * 原理：
        *   1、自动配置类；CacheAutoConfiguration
        *   2、缓存的配置类
        *   org.springframework.boot.autoconfigure.cache.GenericCacheConfiguration
        *   org.springframework.boot.autoconfigure.cache.JCacheCacheConfiguration
        *   org.springframework.boot.autoconfigure.cache.EhCacheCacheConfiguration
        *   org.springframework.boot.autoconfigure.cache.HazelcastCacheConfiguration
        *   org.springframework.boot.autoconfigure.cache.InfinispanCacheConfiguration
        *   org.springframework.boot.autoconfigure.cache.CouchbaseCacheConfiguration
        *   org.springframework.boot.autoconfigure.cache.RedisCacheConfiguration
        *   org.springframework.boot.autoconfigure.cache.CaffeineCacheConfiguration
        *   org.springframework.boot.autoconfigure.cache.GuavaCacheConfiguration
        *   org.springframework.boot.autoconfigure.cache.SimpleCacheConfiguration【默认】
        *   org.springframework.boot.autoconfigure.cache.NoOpCacheConfiguration
        *   3、哪个配置类默认生效：SimpleCacheConfiguration；
        *
        *   4、给容器中注册了一个CacheManager：ConcurrentMapCacheManager
        *   5、可以获取和创建ConcurrentMapCache类型的缓存组件；他的作用将数据保存在ConcurrentMap中；
        *
        *   运行流程：
        *   @Cacheable：
        *   1、方法运行之前，先去查询Cache（缓存组件），按照cacheNames指定的名字获取；
        *      （CacheManager先获取相应的缓存），第一次获取缓存如果没有Cache组件会自动创建。
        *   2、去Cache中查找缓存的内容，使用一个key，默认就是方法的参数；
        *      key是按照某种策略生成的；默认是使用keyGenerator生成的，默认使用SimpleKeyGenerator生成key；
        *          SimpleKeyGenerator生成key的默认策略；
        *                  如果没有参数；key=new SimpleKey()；
        *                  如果有一个参数：key=参数的值
        *                  如果有多个参数：key=new SimpleKey(params)；
        *   3、没有查到缓存就调用目标方法；
        *   4、将目标方法返回的结果，放进缓存中
        *
        *   @Cacheable标注的方法执行之前先来检查缓存中有没有这个数据，默认按照参数的值作为key去查询缓存，
        *   如果没有就运行方法并将结果放入缓存；以后再来调用就可以直接使用缓存中的数据；
        *
        *   核心：
        *      1）、使用CacheManager【ConcurrentMapCacheManager】按照名字得到Cache【ConcurrentMapCache】组件
        *      2）、key使用keyGenerator生成的，默认是SimpleKeyGenerator
        *
        *
        *   几个属性：
        *      cacheNames/value：指定缓存组件的名字;将方法的返回结果放在哪个缓存中，是数组的方式，可以指定多个缓存；
        *
        *      key：缓存数据使用的key；可以用它来指定。默认是使用方法参数的值  1-方法的返回值
        *              编写SpEL； #i d;参数id的值   #a0  #p0  #root.args[0]
        *              getEmp[2]
        *
        *      keyGenerator：key的生成器；可以自己指定key的生成器的组件id
        *              key/keyGenerator：二选一使用;
        *
        *
        *      cacheManager：指定缓存管理器；或者cacheResolver指定获取解析器
        *
        *      condition：指定符合条件的情况下才缓存；
        *              ,condition = "#id>0"
        *          condition = "#a0>1"：第一个参数的值》1的时候才进行缓存
        *
        *      unless:否定缓存；当unless指定的条件为true，方法的返回值就不会被缓存；可以获取到结果进行判断
        *              unless = "#result == null"
        *              unless = "#a0==2":如果第一个参数的值是2，结果不缓存；
        *      sync：是否使用异步模式
   

   2. @CacheEvict

        /**
        * @CacheEvict：缓存清除
        *  key：指定要清除的数据
        *  allEntries = true：指定清除这个缓存中所有的数据
        *  beforeInvocation = false：缓存的清除是否在方法之前执行
        *      默认代表缓存清除操作是在方法执行之后执行;如果出现异常缓存就不会清除
        *
        *  beforeInvocation = true：
        *      代表清除缓存操作是在方法运行之前执行，无论方法是否出现异常，缓存都清除
        *
        *
        */
   

   3. @CachePut

   	/**
   	     * @CachePut：既调用方法，又更新缓存数据；同步更新缓存
   	     * 修改了数据库的某个数据，同时更新缓存；
   	     * 运行时机：
   	     *  1、先调用目标方法
   	     *  2、将目标方法的结果缓存起来
   	     *
   	     * 测试步骤：
   	     *  1、查询1号员工；查到的结果会放在缓存中；
   	     *          key：1  value：lastName：张三
   	     *  2、以后查询还是之前的结果
   	     *  3、更新1号员工；【lastName:zhangsan；gender:0】
   	     *          将方法的返回值也放进缓存了；
   	     *          key：传入的employee对象  值：返回的employee对象；
   	     *  4、查询1号员工？
   	     *      应该是更新后的员工；
   	     *          key = "#employee.id":使用传入的参数的员工id；
   	     *          key = "#result.id"：使用返回后的id
   	     *             @Cacheable的key是不能用#result
   	     *      为什么是没更新前的？【1号员工没有在缓存中更新】
   	     *
   	     */
   	```
   
   

3.整合redis作为缓存

Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。

1. 安装redis：使用docker；
2. 引入redis的starter
3. 配置redis
4. 测试缓存
   原理：CacheManager===Cache 缓存组件来实际给缓存中存取数据
   1. 引入redis的starter，容器中保存的是 RedisCacheManager；
   2. RedisCacheManager 帮我们创建 RedisCache 来作为缓存组件；RedisCache通过操作redis缓存数据的
   3. 默认保存数据 k-v 都是Object；利用序列化保存；如何保存为json
      1. 引入了redis的starter，cacheManager变为 RedisCacheManager；
      2. 默认创建的 RedisCacheManager 操作redis的时候使用的是 RedisTemplate<Object, Object>
      3. RedisTemplate<Object, Object> 是 默认使用jdk的序列化机制
   4. 自定义CacheManager；

@Autowired
	StringRedisTemplate stringRedisTemplate;  //操作k-v都是字符串的
	@Autowired
	RedisTemplate redisTemplate;  //k-v都是对象的
	@Autowired
	RedisTemplate<Object, Employee> empRedisTemplate;

/**
	 * Redis常见的五大数据类型
	 *  String（字符串）、List（列表）、Set（集合）、Hash（散列）、ZSet（有序集合）
	3. 使用RestTemplate操作redis
		  1. redisTemplate.opsForValue();//操作字符串
		  2. redisTemplate.opsForHash();//操作hash 
		  3. redisTemplate.opsForList();//操作list
		  4.redisTemplate.opsForSet();//操作set
		  5.redisTemplate.opsForZSet();//操作有序set 

@Test
	public void test01(){
		//给redis中保存数据
	    //stringRedisTemplate.opsForValue().append("msg","hello");
//		String msg = stringRedisTemplate.opsForValue().get("msg");
//		System.out.println(msg);

//		stringRedisTemplate.opsForList().leftPush("mylist","1");
//		stringRedisTemplate.opsForList().leftPush("mylist","2");
	}

	//测试保存对象
	@Test
	public void test02(){
		Employee empById = employeeMapper.getEmpById(1);
		//默认如果保存对象，使用jdk序列化机制，序列化后的数据保存到redis中
		//redisTemplate.opsForValue().set("emp-01",empById);
		//1、将数据以json的方式保存
		 //(1)自己将对象转为json
		 //(2)redisTemplate默认的序列化规则；改变默认的序列化规则；
		empRedisTemplate.opsForValue().set("emp-01",empById);
	}

二、SpringBoot与消息

1.概述

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

2. 消息服务中两个重要概念：
   消息代理（message broker）和目的地（destination）
   当消息发送者发送消息以后，将有消息代理接管，消息代理保证消息传递到指定目的地。

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

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

   
   

4. 点对点式：

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

5. 发布订阅式：

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

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

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

7. AMQP（Advanced Message Queuing Protocol）

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

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

2. RabbitMQ简介

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

2. 核心概念
   Message：
   消息，消息是不具名的，它有消息头和消息体组成。消息体是不透明的，而消息头则有一系列的可选属性组成，这些属性包括routing-key（路由键）、priority（相对于其他消息的优先权）、delivery-mode（指出 该消息可能需要持久性存储）等。
   Publisher：
   Publisher 消息的生产者，也是一个向交换器发布消息的客户端应用程序。
   Exchange：
   Exchange 交换器，用来接收生产者发送的消息并将这些消息路由给服务器中的队列。 Exchange有4种类型：direct(默认)，fanout, topic, 和headers，不同类型的Exchange转发消息的策略有 所区别
   Queue：
   Queue 消息队列，用来保存消息直到发送给消费者。它是消息的容器，也是消息的终点。一个消息 可投入一个或多个队列。消息一直在队列里面，等待消费者连接到这个队列将其取走。
   Binding：
   Binding 绑定，用于消息队列和交换器之间的关联。一个绑定就是基于路由键将交换器和消息队列连 接起来的路由规则，所以可以将交换器理解成一个由绑定构成的路由表。 Exchange 和Queue的绑定可以是多对多的关系。
   Connection：
   Connection 网络连接，比如一个TCP连接。
   Channel：
   Channel 信道，多路复用连接中的一条独立的双向数据流通道。信道是建立在真实的TCP连接内的虚 拟连接，AMQP 命令都是通过信道发出去的，不管是发布消息、订阅队列还是接收消息，这 些动作都是通过信道完成。因为对于操作系统来说建立和销毁 TCP 都是非常昂贵的开销，所 以引入了信道的概念，以复用一条 TCP 连接。
   Consumer：
   Consumer 消息的消费者，表示一个从消息队列中取得消息的客户端应用程序。
   Virtual Host：
   Virtual Host 虚拟主机，表示一批交换器、消息队列和相关对象。虚拟主机是共享相同的身份认证和加 密环境的独立服务器域。每个 vhost 本质上就是一个 mini 版的 RabbitMQ 服务器，拥有 自己的队列、交换器、绑定和权限机制。vhost 是 AMQP 概念的基础，必须在连接时指定， RabbitMQ 默认的 vhost 是 / 。
   Broker：
   Broker 表示消息队列服务器实体

3.RabbitMQ运行机制

AMQP 中的消息路由

• AMQP 中消息的路由过程和 Java 开发者熟悉的 JMS 存在一些差别，AMQP 中增加了 Exchange 和 Binding 的角色。生产者把消息发布到 Exchange 上，消息最终到达队列并被 消费者接收，而 Binding 决定交换器的消息应该发送到那个队列。
  
  Exchange 类型
  • Exchange分发消息时根据类型的不同分发策略有区别，目前共四种类型： direct、fanout、topic、headers 。headers 匹配 AMQP 消息的 header 而不是路由键， headers 交换器和 direct 交换器完全一致，但性能差很多， 目前几乎用不到了，所以直接看另外三种类型：

1. direct
   

2. fanout
   

3. topic
   

4.RabbitMQ安装

docker pull registry.docker-cn.com/library/rabbitmq:3-nanagement

docker images

docker run -d -p 5672:5672 -p 15672:15672 --name myrabbitmq df0ee1f2343b 

//registry.docker-cn.com/library/rabbit加速地址

5.、RabbitMQ整合

1. 引入 spring-boot-starter-amqp
2. application.yml配置
3. 测试RabbitMQ
   1. AmqpAdmin：管理组件
   2. RabbitTemplate：消息发送处理组件

**
 * 自动配置
 *  1、RabbitAutoConfiguration
 *  2、有自动配置了连接工厂ConnectionFactory；
 *  3、RabbitProperties 封装了 RabbitMQ的配置
 *  4、 RabbitTemplate ：给RabbitMQ发送和接受消息；
 *  5、 AmqpAdmin ： RabbitMQ系统管理功能组件;
 *  	AmqpAdmin：创建和删除 Queue，Exchange，Binding
 *  6、@EnableRabbit +  @RabbitListener 监听消息队列的内容
 *
 */
@EnableRabbit  //开启基于注解的RabbitMQ模式
@SpringBootApplication
public class Springboot02AmqpApplication {

	public static void main(String[] args) {
		SpringApplication.run(Springboot02AmqpApplication.class, args);
	}
}

spring.rabbitmq.host=118.24.44.169
spring.rabbitmq.username=guest

public class Springboot02AmqpApplicationTests {

	@Autowired
	RabbitTemplate rabbitTemplate;

	@Autowired
	AmqpAdmin amqpAdmin;

	@Test
	public void createExchange(){

//		amqpAdmin.declareExchange(new DirectExchange("amqpadmin.exchange"));
//		System.out.println("创建完成");

//		amqpAdmin.declareQueue(new Queue("amqpadmin.queue",true));
		//创建绑定规则

//		amqpAdmin.declareBinding(new Binding("amqpadmin.queue", Binding.DestinationType.QUEUE,"amqpadmin.exchange","amqp.haha",null));

		//amqpAdmin.de
	}

	/**
	 * 1、单播（点对点）
	 */
	@Test
	public void contextLoads() {
		//Message需要自己构造一个;定义消息体内容和消息头
		//rabbitTemplate.send(exchage,routeKey,message);

		//object默认当成消息体，只需要传入要发送的对象，自动序列化发送给rabbitmq；
		//rabbitTemplate.convertAndSend(exchage,routeKey,object);
		Map<String,Object> map = new HashMap<>();
		map.put("msg","这是第一个消息");
		map.put("data", Arrays.asList("helloworld",123,true));
		//对象被默认序列化以后发送出去
		rabbitTemplate.convertAndSend("exchange.direct","atguigu.news",new Book("西游记","吴承恩"));

	}

	//接受数据,如何将数据自动的转为json发送出去
	@Test
	public void receive(){
		Object o = rabbitTemplate.receiveAndConvert("atguigu.news");
		System.out.println(o.getClass());
		System.out.println(o);
	}

	/**
	 * 广播
	 */
	@Test
	public void sendMsg(){
		rabbitTemplate.convertAndSend("exchange.fanout","",new Book("红楼梦","曹雪芹"));
	}
}