九、SpringBoot与缓存

1. JSR-107

用得少，主要用的是Spring缓存抽象和缓存中间件（如redis）。

2. Spring缓存抽象

搭建基本环境

1. 新建项目
   
   
2. 新建数据库
   
3. 新建数据表

   SET FOREIGN_KEY_CHECKS=0;DROP TABLE IF EXISTS `department`;
   CREATE TABLE `department` (`id` int(11) NOT NULL AUTO_INCREMENT,`departmentName` varchar(255) DEFAULT NULL,PRIMARY KEY (`id`)
   ) ENGINE=InnoDB DEFAULT CHARSET=utf8;DROP TABLE IF EXISTS `employee`;
   CREATE TABLE `employee` (`id` int(11) NOT NULL AUTO_INCREMENT,`lastName` varchar(255) DEFAULT NULL,`email` varchar(255) DEFAULT NULL,`gender` int(2) DEFAULT NULL,`d_id` int(11) DEFAULT NULL,PRIMARY KEY (`id`)
   ) ENGINE=InnoDB DEFAULT CHARSET=utf8;INSERT INTO employee(lastName,email,gender,d_id)VALUES('zhangsan','zhangsan@qq.com',1,1);
   INSERT INTO employee(lastName,email,gender,d_id)VALUES('lisi','lisi@qq.com',0,2);
   

   
4. 创建JavaBean，在com/angenin/cache下新建一个bean包，然后新建和数据表对应的两个bean
   Department

   package com.angenin.cache.bean;public class Department {private Integer id;private String departmentName;public Department() {super();// TODO Auto-generated constructor stub}public Department(Integer id, String departmentName) {super();this.id = id;this.departmentName = departmentName;}public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getDepartmentName() {return departmentName;}public void setDepartmentName(String departmentName) {this.departmentName = departmentName;}@Overridepublic String toString() {return "Department [id=" + id + ", departmentName=" + departmentName + "]";}
   }
   

   Employee

   package com.angenin.cache.bean;public class Employee {private Integer id;private String lastName;private String email;private Integer gender; //性别 1男  0女private Integer dId;public Employee() {super();}public Employee(Integer id, String lastName, String email, Integer gender, Integer dId) {super();this.id = id;this.lastName = lastName;this.email = email;this.gender = gender;this.dId = dId;}public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getLastName() {return lastName;}public void setLastName(String lastName) {this.lastName = lastName;}public String getEmail() {return email;}public void setEmail(String email) {this.email = email;}public Integer getGender() {return gender;}public void setGender(Integer gender) {this.gender = gender;}public Integer getdId() {return dId;}public void setdId(Integer dId) {this.dId = dId;}@Overridepublic String toString() {return "Employee [id=" + id + ", lastName=" + lastName + ", email=" + email + ", gender=" + gender + ", dId="+ dId + "]";}
   }
   

5. 整合Mybatis操作数据库，配置数据源信息，在resources/application.properties中添加：

   spring.datasource.url=jdbc:mysql://localhost:3306/spring_cache?serverTimezone=GMT
   spring.datasource.username=root
   spring.datasource.password=123456
   #Driver可不写，会根据连接自动添加
   #spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver#开启驼峰命名规则
   mybatis.configuration.map-underscore-to-camel-case=true
   

6. 在cache包下新建一个mapper包，用于存放mapper接口，并写上对应mapper接口。
   EmployeeMapper

   public interface EmployeeMapper {@Select("SELECT * FROM employee WHERE id=#{id}")Employee getEmpById(Integer id);@Insert("INSERT INTO employee(lastName,email,gender,d_id)VALUES(#{lastName},#{email},#{gender},#{dId})")void insertEmployee(Employee employee);@Update("UPDATE employee SET lastName=#{lastName},email=#{email},gender=#{gender},d_id=#{dId} WHERE id=#{id}")void updateEmp(Employee employee);@Delete("DELETE FROM employee WHERE id=#{id}")void deleteEmpById(Integer id);}
   

7. 在Springboot01CacheApplication主配置类上加上@MapperScan("com.angenin.cache.mapper")
8. 在test目录下的Springboot01CacheApplicationTests测试类中测试

   @SpringBootTest
   class Springboot01CacheApplicationTests {@AutowiredEmployeeMapper employeeMapper;@Testvoid contextLoads() {Employee employee = employeeMapper.getEmpById(1);System.out.println(employee);}}
   

9. 在cache包下新建service/EmployeeService

   @Service
   public class EmployeeService {@AutowiredEmployeeMapper employeeMapper;public Employee getEmp(Integer id){System.out.println("查询" + id + "号员工");Employee emp = employeeMapper.getEmpById(id);return emp;}}
   

10. 在cache包下新建controller/EmployeeController

    @RestController
    public class EmployeeController {@AutowiredEmployeeService employeeService;@GetMapping("/emp/{id}")public Employee getEmployee(@PathVariable("id") Integer id){Employee emp = employeeService.getEmp(id);return emp;}}
    

11. 启动项目，在浏览器输入http://localhost:8080/emp/2
    

使用缓存

基本步骤：

1. 开启基于注解的缓存（@EnableCaching）
2. 标注缓存注解（@Cacheable、@CachePut、@CacheEvict）

@EnableCaching（开启基于注解的缓存）

在主配置类上加上@EnableCaching，开启基于注解的缓存。

缓存注解

CacheManager管理多个Cache组件，对缓存的真正CRUD操作在Cache组件中，每个缓存组件都有自己唯一的名字。

@Cacheable

属性

1. cacheNames/value：指定缓存组件的名字，将方法的返回结果放到哪个缓存中是数组的方式，可以指定多个缓存。
2. key：缓存数据使用的key，可以用它来指定key，默认使用方法参数的值（如传过来一个1，那么1为key，value为返回值），可以编写SpEL（如参数id的值可以用#id，#a0，#p0，#root.args[0]来取出）。
   
3. keyGenerator：key的生成器，可以自己指定key的生成器的组件id（自己注册的返回KeyGenerator的组件）。（key和keyGenerator二选一）

   import org.springframework.cache.interceptor.KeyGenerator;//自定义key的生成器
   @Configuration
   public class MyCacheConfig {@Bean("myKeyGenerator")public KeyGenerator keyGenerator(){return new KeyGenerator() {@Overridepublic Object generate(Object o, Method method, Object... objects) {return method.getName() + "[" + Arrays.asList(objects).toString() + "]";}};}
   }
   

4. cacheManager：指定缓存管理器
5. cacheResolver：指定获取解析器（与cacheManager二选一，作用相同）
6. condition：指定符合条件的情况下才缓存。（例：condition = “#a0>1”（当第一个参数大于1才进行缓存））
7. unless：除非（否定缓存），当unless指定的条件为true，方法的返回值就不会被缓存，可以对获取到的结果进行判断（例1：#a0==2（当第一个参数为2时不缓存））（例2：unless = “#result == null”（#result为获取的结果，对获取的结果进行非空判断，如果为空，就不缓存））。（condition与unless相反，一个满足就缓存，一个满足不缓存）
8. sync：是否使用异步模式，默认为false。（开启后(1)不支持unless了，(2)只能指定一个缓存，(3)不能合并其他与缓存相关的操作）

• 在application.properties中添加
  logging.level.com.angenin.cache.mapper=debug开启日志。
• 然后运行项目，多次在浏览器中输入http://localhost:8080/emp/2查询相同用户，从控制台输入的日志可以看出每次都对数据库进行查询。
  
• 在Springboot01CacheApplication主配置类上加上@EnableCaching开启基于注解的缓存。
• 在EmployeeService的getEmp方法上添加@Cacheable(value = "emp")，将方法的运行结果进行缓存，以后再要相同的数据，直接从缓存中获取，不用调用方法。
• 重新运行项目，多次在浏览器中输入http://localhost:8080/emp/2查询相同用户，控制台只在第一次查询时查询了数据库，并且之后的查询连EmployeeService的getEmp方法都没进入，数据直接从缓存中获取。
  

@CachePut（既调用方法，又更新缓存）

• @CachePut与@Cacheable的区别
  @Cacheable是先到缓存里查找有没有要查的数据，如果有就直接用缓存里的数据，不调用方法操作数据库，如果没有再调用方法操作数据库并把返回的数据保存到缓存里。（前置处理）（用于查询）
  @CachePut是每次都先调用方法进行数据库操作，并把返回的数据保存到缓存里，如果缓存里已经有了就覆盖原来的数据。（后置处理）（用于修改）
• 运行时机：先调用目标方法，再将目标方法的返回结果保存到缓存中。（属性比@Cacheable少了一个sync，其他相同）
• 应用场景：修改了数据库的某个数据，同时更新缓存。

例：
在EmployeeMapper中添加

@CachePut(value = "emp")public Employee updateEmp(Employee employee){System.out.println("updateEmp：" + employee);employeeMapper.updateEmp(employee);return employee;}

在EmployeeController中添加

  @GetMapping("/emp")public Employee update(Employee employee){Employee emp = employeeService.updateEmp(employee);return emp;}

• 启动项目，浏览器中输入http://localhost:8080/emp/1查询1号员工，让1号员工数据放到缓存中。（此时放入缓存的数据：key为1，value为1号员工数据）
  
• 在浏览器中输入http://localhost:8080/emp?id=1&lastName=zhangsan&email=zhangsan@163.com，修改1号员工信息。（此时放入缓存的数据：key为传入的employee对象，value为更新后1号员工数据）
  
• 输入http://localhost:8080/emp/1再次查询1号员工信息，结果是没更新的1号员工数据。
  
• 所以需要在@CachePut中添加key = "#employee.id"，指定更新后的保存到缓存的key与查询的相同。
• 先修改数据库中1号员工的数据。
  
• 重复刚刚的步骤，先查询、插入再查询，结果为更新后的员工信息。
  

@CacheEvict（缓存清除）

（用于删除）（后置处理，可用beforeInvocation属性改为前置）
属性比@Cacheable少了sync，多了allEntries和beforeInvocation。

• allEntries：清空value指定缓存的数据，默认为false。

• beforeInvocation：缓存清除是否在目标方法之前执行，默认为false。（如果改为之前执行，那么是先删除，然后再执行目标方法，就算目标方法出现异常，数据也删除了，而默认是后置，如果目标方法出现异常，则数据没删除）

  例：
  在EmployeeMapper中添加

  @CacheEvict(value = "emp", key = "#id")
  public void deleteEmp(Integer id){System.out.println("deleteEmp：" + id);//数据库只有两个数据，这里就不删除了，只清理缓存中的数据//employeeMapper.deleteEmpById(id);
  }
  

  在EmployeeController中添加

  @GetMapping("/delemp")
  public String deleteEmp(Integer id){employeeService.deleteEmp(id);return "success";
  }
  

• 启动项目，在浏览器中输入http://localhost:8080/emp/1查询1号员工，把数据放到缓存中。
  

• 输入http://localhost:8080/delemp?id=1删除1号员工。（因为没真正调用删除，所以只是删除缓存）
  

• 再次输入http://localhost:8080/emp/1查询1号员工，重新进行数据库查询，删除缓存数据成功。
  

@Caching（三合一）

@Caching是@Cacheable、@CachePut和@CacheEvict的组合，用于多个复杂的规则。

例：
在EmployeeMapper中添加：

    @Select("SELECT * FROM employee WHERE lastName=#{lastName}")Employee getEmpByLastName(String lastName);

在EmployeeService中添加：

    @Caching(cacheable = {   //cacheable为@Cacheable的数组@Cacheable(value = "emp", key = "#lastName")    //把传入的lastName作为key，value为返回结果放入缓存中},put = { //是@CachePut的数组//加了@CachePut之后，每次都会执行目标方法@CachePut(value = "emp", key = "#result.id"), //把返回结果的id作为key，value为返回结果放入缓存中@CachePut(value = "emp", key = "#result.email") //以邮箱为key，放入缓存中}//evict为@CacheEvict的数组)public Employee getEmpByLastName(String lastName){Employee employee = employeeMapper.getEmpByLastName(lastName);return employee;}

在EmployeeController中添加：

    @GetMapping("/emp/lastName/{lastName}")public Employee getEmpByLastName(@PathVariable("lastName") String lastName){return employeeService.getEmpByLastName(lastName);}

启动项目，在浏览器输入http://localhost:8080/emp/lastName/zhangsan，按照用户名查询。

@CacheConfig（缓存配置注解）

可以在EmployeeService类上加上@CacheConfig注解，在@CacheConfig里写上cacheNames = "emp"属性，那么这个缓存配置类里的缓存注解都可以不加value = "emp"。
即：在@CacheConfig中添加的属性，在这个配置类的所有缓存注解都有@CacheConfig里的属性。

缓存的原理

缓存的自动配置类：CacheAutoConfiguration
缓存的配置类（优先级是按照从上到下顺序，上面的优先级高于下面的）：

默认生效的缓存配置类

在application.properties加上

#开启自动配置报告（项目启动的时候就会打印配置报告）
debug=true

• Positive matches里只有SimpleCacheConfiguration，说明只有SimpleCacheConfiguration生效（默认生效的缓存配置类）。
  • SimpleCacheConfiguration：给容器中注册了一个ConcurrentMapCacheManager（缓存管理器）组件。
    • ConcurrentMapCacheManager：可以获取和创建ConcurrentMapCache类型的缓存组件。
      • ConcurrentMapCache：将数据保存在ConcurrentMap中。

@Cacheable的运行流程

1. 方法运行前，先去查询Cache（缓存组件），按照cacheNames指定的名字获取（CacheManager先获取相应的缓存），第一个获取缓存如果没有Cache组件就会自动创建，然后把创建的Cache对象放到cacheMap保存。
2. 获取到Cache后，去Cache中查找缓存的内容，使用一个key，默认是方法的参数值。key是按照某种策略生成的，默认使用keyGenerator（SimpleKeyGenerator）生成。
   SimpleKeyGenerator生成key的默认策略
   • 如果没参数：key = new SimpleKey()
   • 如果一个有参数：key = 参数的值
   • 如果有多个参数：key = new SimpleKey(params)
3. 如果没查到缓存，就调用目标方法。
4. 将目标方法返回的结果放到缓存里。

总结：@Cacheable标注的方法执行之前先检查缓存中有没有这个数据，默认按照参数值作为key去查询缓存，如果没有就运行方法并将结果放入缓存，之后再调用就可以直接使用缓存中的数据。

核心：

• 使用CacheManager（ConcurrentMapCacheManager）按照名字得到Cache（ConcurrentMapCache）组件
• key使用keyGenerator（SimpleKeyGenerator）生成的

3. 整合Redis

springboot默认使用的是ConcurrentMapCacheManager==>ConcurrentMapCache，将数据保存到ConcurrentMap<String, Cache>中。
一般在开发中使用缓存中间件（redis、memcached、ehcache）比使用springboot原生缓存比较多。
redis的官网：https://redis.io/
redis的中文官网：http://redis.cn/

搭建环境

使用之前在linux上docker拉取的redis镜像docker pull redis。（Docker基础入门学习笔记，NoSQL-Redis学习笔记）
需要在本地下载一个redis连接工具（例如：Redis Desktop Manager简称RDM（下载 密码:vpjv））。

1. 登上linux，如果出现这个错误，用systemctl start docker.service启动docker。（可以用``命令设置docker开机启动）
   
   
2. docker run -d -p 6379:6379 --name myRedis redis:5.0.5运行redis。
   
3. 打开RDM测试redis连接。（我的是mac系统，windows版的界面可能不一样，刚开始打开是英文版的，可以在右上角设置里改成中文）
   
   测试连接后点击确定
   
   
4. 在RDM上测试redis命令（redis所有的命令可以在官方http://redis.cn/commands.html查看）
   
   
5. 在项目的pom.xml中引入redis的starter。

    <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency>
   

6. 在项目application.properties中配置redis。

   #配置redis（linux的ip）
   spring.redis.host=10.211.55.17
   

7. 在Springboot01CacheApplicationTests测试类中测试

   @Autowired
   StringRedisTemplate stringRedisTemplate;    //操作k-v都是字符串的@Autowired
   RedisTemplate redisTemplate;    //操作k-v都是对象的/*** Redis常见的五大数据类型* String（字符串）、List（列表）、Set（集合）、Hash（散列）、ZSet（有序集合）* stringRedisTemplate.opsForValue()    String（字符串）* stringRedisTemplate.opsForList()     List（列表）* stringRedisTemplate.opsForSet()      Set（集合）* stringRedisTemplate.opsForHash()     Hash（散列）* stringRedisTemplate.opsForZSet()     ZSet（有序集合）** redisTemplate的方法和stringRedisTemplate，不同的是redisTemplate操作k-v都是对象的，而操作k-v都是字符串的*/
   //测试stringRedisTemplate
   @Test
   public void test01(){stringRedisTemplate.opsForValue().append("msg", "hello");String msg = stringRedisTemplate.opsForValue().get("msg");System.out.println(msg);stringRedisTemplate.opsForList().leftPush("mylist", "666");stringRedisTemplate.opsForList().leftPush("mylist", "777");String mylist = stringRedisTemplate.opsForList().leftPop("mylist");System.out.println(mylist);
   }
   

   
   
   再添加一个方法来测试redisTemplate

   @Test
   public void test02(){Employee employee = employeeMapper.getEmpById(1);//如果保存对象，默认使用jdk系列化机制，系列化后的数据保存到redis中redisTemplate.opsForValue().set("emp01", employee);  //append是追加字符串的，set才是添加对象的，并且每次提交相同的key时，原来的value会被新的value覆盖
   }
   

   运行后出现错误：DefaultSerializer requires a Serializable payload but received an object of type（需要系列化Employee）
   让Employee类实现Serializable完成系列化后，再重新运行。
   
   将数据以json的形式保存到redis：
   • 自己将对象转为json（如使用gson）
   • 修改redisTemplate默认的系列化（默认使用的是jdk的系列化器）
     新建一个MyRedisConfig配置类

     @Configuration
     public class MyRedisConfig {@Beanpublic RedisTemplate<Object, Object> empRedisTemplate(RedisConnectionFactory redisConnectionFactory)throws UnknownHostException {RedisTemplate<Object, Object> template = new RedisTemplate<>();template.setConnectionFactory(redisConnectionFactory);Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<Object>(Object.class);//设置默认的系列化器为Jackson2JsonRedisSerializertemplate.setDefaultSerializer(serializer);return template;}
     }
     

     如果在测试类中添加：

     //自定义RedisTemplate
     @Autowired
     RedisTemplate<Object, Object> empRedisTemplate;@Test
     public void test03(){Employee employee = employeeMapper.getEmpById(1);empRedisTemplate.opsForValue().set("emp01", employee);
     }
     

     

使用redis缓存

启动项目，浏览器输入http://localhost:8080/emp/1，redis多出了使用jdk系列化后的数据。

在MyRedisConfig中自定义一个cacheManager，让保存到redis的数据为json格式。（当容器中有多个RedisCacheManager时，需要用@Primary指定哪个是默认CacheManager，否则会报错）

    //springboot参数需要传入一个RedisConnectionFactory//新建一个RedisCacheConfiguration对象可以来定制缓存的一些规则//如果注册了多个RedisCacheManager，如果不指定哪个是默认的RedisCacheManager就会报错，//@Primary  //@Primary指定默认使用的RedisCacheManager@Beanpublic RedisCacheManager myCacheManager(RedisConnectionFactory connectionFactory) {//RedisCacheConfiguration.defaultCacheConfig()会返回一个RedisCacheConfiguration对象//serializeValuesWith为设置系列化RedisCacheConfiguration cacheConfiguration = RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer//(new Jackson2JsonRedisSerializer<Object>(Object.class)));//GenericJackson2JsonRedisSerializer为通用Json序列化器，不需要传参(new GenericJackson2JsonRedisSerializer()));//使用RedisCacheConfiguration创建RedisCacheManagerRedisCacheManager cm = RedisCacheManager.builder(connectionFactory).cacheDefaults(cacheConfiguration).build();return cm;}

1. 在mapper包里新建一个DepartmentMapper

   public interface DepartmentMapper {@Select("SELECT * FROM department WHERE id=#{id}")Department getDeptById(Integer id);
   }
   

2. 在service包里新建一个DepartmentService

   @Service
   public class DepartmentService {@AutowiredDepartmentMapper departmentMapper;@Cacheable(cacheNames = "dept")public Department getDeptById(Integer id){System.out.println("查询部门" + id);Department department = departmentMapper.getDeptById(id);return department;}
   }
   

3. 在controller包里新建一个DepartmentController

   @RestController
   public class DepartmentController {@AutowiredDepartmentService departmentService;@GetMapping("/dept/{id}")public Department getDept(@PathVariable("id") Integer id){return departmentService.getDeptById(id);}
   }
   

4. 在数据库中的department插入一条数据
5. 启动项目，输入http://localhost:8080/dept/1查询1号部门
   
   
6. 再次查询出现错误，LinkedHashMap无法转换为Department
   
   
   原因是因为redis返回回来的是一个LinkedHashMap
   解决办法：在MyRedisConfig的myCacheManager中new GenericJackson2JsonRedisSerializer时传入String.valueOf(JsonTypeInfo.As.PROPERTY)即可解决类型转换问题。
   

使用缓存管理器主动把数据添加到缓存里

修改DepartmentService中的getDeptById方法

    @Qualifier("myCacheManager")    //指定使用myCacheManager缓存管理器@AutowiredRedisCacheManager myCacheManager;@Cacheable(cacheNames = "dept")public Department getDeptById(Integer id){System.out.println("查询部门" + id);Department department = departmentMapper.getDeptById(id);//获取指定缓存Cache dept = myCacheManager.getCache("dept");dept.put(department.getId(), department);return department;}

原理

• CacheManager创建Cache组件，缓存组件来实际给缓存中存取数据。
• 引入redis的starter，默认的SimpleCacheConfiguration不生效了，换成RedisCacheConfiguration生效。
• 这是因为SimpleCacheConfiguration类上有@ConditionalOnMissingBean(CacheManager.class)，而RedisCacheConfiguration类给容器中注册了一个RedisCacheManager组件（RedisCacheConfiguration的优先级比SimpleCacheConfiguration高）。
  • RedisCacheManager帮我们创建RedisCache来作为缓存，RedisCache通过操作redis缓存数据。
• 默认保存数据k-v都是object，利用系列化保存。
  • 引入了redis的starter，cacheManager变为RedisCacheManager。
  • 默认创建的RedisCacheManager操作redis的时候使用的是RedisTemplate<Object, Object>。
  • RedisTemplate<Object, Object>是默认使用jdk的系列化机制的。
  • 转为json需要自定义cacheManager。

十、SpringBoot与消息

1. JMS与AMQP

2. RabbitMQ

3. 整合RabbitMQ

安装RabbitMQ

在linux的docker里拉取RabbitMQ镜像docker pull rabbitmq:3.8.3-management（management是带web的管理界面）。
5672是客户端和RabbitMQ进行通信的端口。
15672是管理界面访问web页面的端口。

docker run -d -p 5672:5672 -p 15672:15672 --name myRabbitMQ 容器id

在浏览器输入http://10.211.55.17:15672/（10.211.55.17是我linux的ip）

账号密码都为guest

使用RabbitMQ

1. 新建三个交换器（exchange.direct（点对点）、exchange.fanout（广播）、exchange.topic（模糊匹配））
   
   
2. 新建队列（atguigu、atguigu.news、atguigu.emps、gulixueyuan.news）
   
   
3. 点回Exchanges，把4个队列和交换器绑定。
   1. 点击进入exchange.direct
      
      
   2. 点击进入exchange.direct
      
   3. 点击进入exchange.topic（与前两个不同的是绑定的路由键用了#和*（#代表0个或多个单词，*代表一个单词））
      
      
4. 给每个交换器发送消息，测试队列的接收情况
   1. 点进exchange.direct
      
      
      
      点进atguigu队列，查看消息
      
   2. 点进exchange.fanout
      
      因为exchange.fanout是广播型的交换器，所以只要绑定了的队列，都会发送消息。
      
   3. 点进exchange.topic
      
      atguigu开头的都加了两次
      
      
      atguigu.news符合atguigu.#和*.atguigu，所以队列都接收到消息。
      

创建项目

在application.properties中配置RabbitMQ的基本信息

spring.rabbitmq.host=10.211.55.17
#不写，默认端口为5672
#spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
#不写，默认为/
#spring.rabbitmq.virtual-host=/

自动配置

RabbitAutoConfiguration中

1. RabbitProperties封装了RabbitMQ的配置
2. 自动配置了连接工厂ConnectionFactory
3. 自动配置了RabbitTemplate：给RabbitMQ发送和接收消息
4. 自动配置了AmqpAdmin：RabbitMQ系统管理功能组件（创建和删除Queue、Exchange、Binding）

使用RabbitTemplate

在测试类中

1. 测试单播

       @AutowiredRabbitTemplate rabbitTemplate;//1. 单播（点对点）//发送数据@Testpublic void test01(){//使用send可以自定义信息体的内容和消息头（需要自定义消息头使用）//rabbitTemplate.send(exchang, roteKey, message);//convertAndSend只需要传入要发送的对象，自动系列化发送给RabbitMQ（object默认当成消息体）//rabbitTemplate.convertAndSend(exchang, roteKey, object);Map<String, Object> map = new HashMap<>();map.put("msg", "第一个消息");map.put("data", Arrays.asList("hello", 123, true));//对象被默认系列化（默认使用jdk的系列化）以后发送出去rabbitTemplate.convertAndSend("exchange.direct", "atguigu.news", map);}
   

   在atguigu.news队列接收到的数据。
   
   在测试类中接收队列里的消息

       @Testpublic void test02(){//receive返回的是message，包含消息头和消息体//rabbitTemplate.receiveAndConvert(queueName);//receiveAndConvert会先把消息体转为原来的数据类型再返回//rabbitTemplate.receiveAndConvert(queueName);Object o = rabbitTemplate.receiveAndConvert("atguigu.news");System.out.println(o.getClass());System.out.println(o);}    
   

   
   队列中被接收的数据就会被删除。

   RabbitTemplate在发送消息时，由messageConverter负责系列化，messageConverter默认使用的是SimpleMessageConverter，SimpleMessageConverter里面使用的就是jdk的系列化规则。

   修改系列化规则：
   在config包下新建MyAMQPConfig配置类

   import org.springframework.amqp.support.converter.MessageConverter;@Configuration
   public class MyAMQPConfig {//自定义MessageConverter，并添加到容器中@Beanpublic MessageConverter messageConverter(){return new Jackson2JsonMessageConverter();}}
   

   重新发送数据后在exchange.direct队列中接收到的消息。
   
   在测试类中接收也能把json转为原来的类型。
   

2. 测试广播
   在bean包里新建一个Book类

   public class Book {private String bookName;private String author;//有参无参构造器，get/set方法，toString方法
   }
   

   在测试类中添加

   //2. 广播
   @Test
   public void test03(){//因为是广播，不需要roteKey，所以第二个参数roteKey留空rabbitTemplate.convertAndSend("exchange.fanout", new Book("西游记", "吴承恩"));
   }
   

每个队列都接收到消息，并且自定义的类也可以识别转为json形式（已经提前清空了所有队列的消息（点进队列，下面有个Delete按钮，有个Purge Messages按钮可以清空队列数据））

实际使用

在实际的开发中，需要监听指定的队列，一旦监听的队列更新，就需要执行相应的操作。

@EnableRabbit

在Springboot02AmqpApplication主配置类上添加@EnableRabbit注解，开启基于注解的RabbitMQ。

@RabbitListener

在service包下新建BookService（@RabbitListener注解监听指定队列）

@Service
public class BookService {//@RabbitListener监听队列//queues属性为数组，可以监听多个队列@RabbitListener(queues = {"atguigu.news"})public void receive(Book book){System.out.println("收到消息" + book);}}

接收到刚刚保存的book对象

如果需要接收消息头信息

//是org.springframework.amqp.core的Message包
//import org.springframework.amqp.core.Message;@RabbitListener(queues = "atuguigu.news")public void receive2(Message message){//消息头System.out.println(message.getMessageProperties());//消息体System.out.println(message.getBody());}

在测试类中往队列发送消息（此时监听器生效，会在队列写入数据后触发监听器执行BookService的receive方法）

获取到的消息体还没反系列化。

使用AmqpAdmin

    @AutowiredAmqpAdmin amqpAdmin;@Testpublic void create(){//创建Exchange//declareExchange需要传入一个Exchange对象//new DirectExchange时可以传入规则name, durable, autoDelete, arguments（这里只传入一个name）amqpAdmin.declareExchange(new DirectExchange("amqpadmin.exchange.direct"));System.out.println("创建完成");}

//第一个参数为队列名，第二个为是否持久化
amqpAdmin.declareQueue(new Queue("amqpadmin.queue", true));

        //创建绑定规则//第一个参数为目的地，第二为目的地类型（Binding.DestinationType.QUEUE和Binding.DestinationType.EXCHANGE）// 第三个是交换器名，第四个是路由键，第五个是参数头信息amqpAdmin.declareBinding(new Binding("amqpadmin.queue", Binding.DestinationType.QUEUE,"amqpadmin.exchange.direct", "amqp.haha", null));

点进amqpadmin.exchange.direct交换器，绑定了amqp.queue队列，并且路由键为amqp.haha。

    //删除QueueamqpAdmin.deleteQueue("amqpadmin.queue");//删除ExchangeamqpAdmin.deleteExchange("amqpadmin.exchange.direct");

下一篇笔记：待更新

学习视频（p1-p19）：https://www.bilibili.com/video/BV1KW411F7oX?p=1