三、SpringBoot Rbbitmq及简单使用

启动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);
    }

}