启动rabbitmq服务,我是采用docker启动的Docker安装Rbbitmq【windows】,访问地址http://localhost:15672 账号:guest,密码:guest
1.引入rabbitmq相关的依赖包
<!-- 使用抽象级MQ接口 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
2.appliction.yml配置文件,注意:重要的是要配置rabbitmq,其他配置只是方便测试
server:
port: 7002
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driverClassName: com.mysql.jdbc.Driver
url: jdbc:mysql://localhost:3306/facebook_hr?characterEncoding=utf8&useSSL=false&zeroDateTimeBehavior=convertToNull&serverTimezone=UTC
username: root
password: 123456
initialSize: 2
minIdle: 4
maxActive: 20
# 配置获取连接等待超时的时间
maxWait: 60000
# 配置间隔多久才进行一次检测,检测需要关闭的空闲连接,单位是毫秒
timeBetweenEvictionRunsMillis: 60000
# 配置一个连接在池中最小生存的时间,单位是毫秒
minEvictableIdleTimeMillis: 30000
validationQuery: select 'x'
testWhileIdle: true
testOnBorrow: false
testOnReturn: false
# 打开PSCache,并且指定每个连接上PSCache的大小
poolPreparedStatements: true
maxPoolPreparedStatementPerConnectionSize: 20
# 配置监控统计拦截的filters,去掉后监控界面sql无法统计,'wall'用于防火墙
filters: stat,wall,slf4j
# 通过connectProperties属性来打开mergeSql功能;慢SQL记录
connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
rabbitmq:
host: localhost
port: 5672
username: guest
password: guest
#logger配置
logging:
config: classpath:logback-spring.xml
## 该配置节点为独立的节点,有很多同学容易将这个配置放在spring的节点下,导致配置无法被识别
mybatis:
#注意:一定要对应mapper映射xml文件的所在路径
mapper-locations: classpath:mapper/*.xml
# 注意:对应实体类的路径
typeAliasesPackage: com.weigang.pojo
3.队列配置
package com.weigang.config;
import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RabbitMqConfig {
@Bean
public Queue helloQueue() {
/**
* @param name 队列名字
* @param durable 声明一个持久队列(该队列将在服务器重启后继续存在),则为true
*/
return new Queue("wg_hello",true);
}
}
4.发送者
/**
* @author weigang
* @description
* <>@Component:把普通pojo实例化到spring容器中,相当于配置文件中的<bean id="" class=""/></>
*
* @date 2019/9/27 17:07
*/
@Slf4j
@Component
public class UserSenderMq {
@Autowired
private AmqpTemplate rabbitTemplate;
public void sendToMq(String name) {
log.info("-----------------------------开始发送用户信息--------------------------------");
String context = "用户的的名字为:" + name;
System.out.println("Sender message is: " + context);
/**
* 发送消息
* @param routingKey 路由键
* @param message 信息
*/
this.rabbitTemplate.convertAndSend("wg_hello", context);
log.info("-----------------------------结束发送用户信息--------------------------------");
}
}
@SuppressWarnings("all")
@Repository
@Mapper
public interface HrUserMapper{
//获取用户列表
List<HrUserEntity> selectAllUser();
//获取单条记录
HrUserEntity getUser(int id);
}
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.weigang.dao.HrUserMapper">
<!--获取用户列表-->
<select id="selectAllUser" resultType="com.weigang.pojo.HrUserEntity">
select id,age,name from hr_user
</select>
<!--获取单条记录-->
<select id="getUser" resultType="com.weigang.pojo.HrUserEntity">
select id,age,name from hr_user where id = #{id}
</select>
</mapper>
package com.weigang.service;
import com.weigang.dao.HrUserMapper;
import com.weigang.pojo.HrUserEntity;
import com.weigang.service.handler.UserSenderMq;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* @author weigang
* @description
* @date 2019/9/20 9:50
*/
@Slf4j
@Service
public class HrUserService {
@Autowired
private HrUserMapper hrUserMapper;
@Autowired
private UserSenderMq userSenderMq;
/**
* 获取列表
*/
public List<HrUserEntity> getUsers(){
List<HrUserEntity> users = hrUserMapper.selectAllUser();
//发送到mq队列中
userSenderMq.sendObjectToMq(users);
return users;
}
/**
* 获取单条记录
* @param id
* @return com.weigang.pojo.HrUserEntity
*/
public HrUserEntity getUser(int id){
HrUserEntity user = hrUserMapper.getUser(id);
//发送到mq队列中
userSenderMq.sendToMq(user.getName());
return hrUserMapper.getUser(id);
}
}
package com.weigang.controller;
import com.weigang.pojo.HrUserEntity;
import com.weigang.service.HrUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
/**
* @author weigang
* @description
* @date 2019/9/20 10:09
*/
@RestController
@RequestMapping("/user")
public class HrUserController {
@Autowired
private HrUserService hrUserService;
/**
* 获取列表
*/
@GetMapping(value = "/getUsers")
public List<HrUserEntity> getUsers(){
return hrUserService.getUsers();
}
/**
* 获取用户单条记录
* @param id
* @return com.weigang.pojo.HrUserEntity
*/
@GetMapping(value = "/getUser/{id}")
public HrUserEntity getUser(@PathVariable("id") int id){
return hrUserService.getUser(id);
}
}
5.可以去rabbitmq管理页面查看是否完成消息的发送,效果图如下:
6.消费者
package com.weigang.service.handler;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
/**
* @author weigang
* @description
* <>
* 发送者和接收者的queue name必须一致,不然接收不到消息。Direct模式相当于一对一模式,
* 一个消息被发送者发送后,会被转发到一个绑定的消息队列中,然后被一个接收者接收。
* @RabbitListener(queues = "wg_hello"):监听队列名
* </>
* @date 2019/9/28 11:30
*/
@Component
@RabbitListener(queues = "wg_hello")
public class UserReceiver {
@RabbitHandler
public void process(String name) {
System.out.println("Receiver message is: " + name);
}
}
RabbitMQ发送对象
1.json格式话工具类
package com.weigang.utils;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.util.JSONPObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;
import java.io.IOException;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
@Slf4j
public class JsonUtil {
private static ObjectMapper mapper = createMapper();
public static ObjectMapper getMapper() {
return mapper;
}
public static ObjectMapper createMapper() {
ObjectMapper result = new ObjectMapper();
// 设置输入时忽略在JSON字符串中存在但Java对象实际没有的属性
result.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
result.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
result.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
// 设置输出时包含属性的风格
result.setSerializationInclusion(Include.NON_EMPTY);
return result;
}
public static Map readValue(String json) {
try {
return mapper.readValue(json, Map.class);
} catch (IOException e) {
log.warn("read json string error", e);
return null;
}
}
public static String readValueString(String json, String key) {
Map map = readValue(json);
if (map == null) {
return null;
}
return map.get(key).toString();
}
public static <E> String beanToJson(E object) {
try {
String s = mapper.writeValueAsString(object);
if ("null".equals(s)){
s = null;
}
return s;
} catch (IOException e) {
log.warn("write to json string error:" + object, e);
return null;
}
}
public static <E> E jsonToBean(InputStream input, Class<E> clazz) {
if (input == null) {
return null;
}
try {
return mapper.readValue(input, clazz);
} catch (IOException e) {
log.warn("parse json error", e);
return null;
}
}
public static <E> E jsonToBean(String str, Class<E> clazz) {
if (StringUtils.isEmpty(str)) {
return null;
}
try {
return mapper.readValue(str, clazz);
} catch (IOException e) {
log.warn("parse json string error:" + str, e);
return null;
}
}
public static <E> E jsonToBean(String str, TypeReference<E> typeReference) {
if (StringUtils.isEmpty(str)) {
return null;
}
try {
return mapper.readValue(str, typeReference);
} catch (IOException e) {
log.warn("parse json string error:" + str, e);
return null;
}
}
public static <E> List<E> jsonToList(String str, Class<?> elementClasses) {
if (StringUtils.isEmpty(str)) {
return null;
}
try {
JavaType javaType = getCollectionType(ArrayList.class, elementClasses);
return (List<E>) mapper.readValue(str, javaType);
} catch (IOException e) {
log.warn("parse json string error:" + str, e);
return null;
}
}
public static JsonNode parseNode(String text) {
try {
return mapper.readTree(text);
} catch (IOException e) {
log.warn("parse json error:" + text, e);
return null;
}
}
/**
<<<<<<< Updated upstream
* 获取泛型的Collection GoodsCategoryType
=======
* 获取泛型的Collection GoodsCategoryTypeVo
>>>>>>> Stashed changes
*
* @param collectionClass 泛型的Collection
* @param elementClasses 元素类
* @return JavaType Java类型
*/
public static JavaType getCollectionType(Class<?> collectionClass, Class<?>... elementClasses) {
return mapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);
}
/**
* 输出JSONP格式数据.
*/
public static String beanToJsonP(String functionName, Object object) {
return beanToJson(new JSONPObject(functionName, object));
}
}
rabbitmq配置文件
@Bean
public Queue objectQueue() {
/**
* @param name 队列名字
* @param durable 声明一个持久队列(该队列将在服务器重启后继续存在),则为true
*/
return new Queue(Constants.OBJECT_RABBITMQ_QUEUE, true);
}
/**
* 常量
* @author weigang
* @date 2019/9/28 21:25
*/
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public static class Constants {
private static final String HELLO_RABBITMQ_QUEUE = "wg_hello";
private static final String OBJECT_RABBITMQ_QUEUE = "wg_object";
}
发送者
public void sendObjectToMq(List<HrUserEntity> users) {
log.info("-----------------------------开始发送用户信息--------------------------------");
String context = JsonUtil.beanToJson(users);
System.out.println("Sender message is: " + context);
this.rabbitTemplate.convertAndSend("wg_object", context);
log.info("-----------------------------结束发送用户信息--------------------------------");
}
消费者
@Component
@RabbitListener(queues = "wg_object")
public class UserReceiver {
@RabbitHandler
public void process(String message) {
System.out.println("Receiver message is: " + message);
}
}