SpringBoot整合RabbitMQ_spring boot 配置rabbitmq 15672-CSDN博客

本文链接：https://blog.csdn.net/zhaodj5660/article/details/79853007

一 . SpringBoot整合RabbitMQ(此例考察默认的Direct模式)

　　SpringBoot整合RabbitMQ非常简单!感觉SpringBoot真的极大简化了开发的搭建环境的时间..这样我们程序员就可以把更多的时间用在业务上了,下面开始搭建环境:

　　1. 首先创建两个maven工程,这是为了模拟分布式应用系统中,两个应用之间互相交流的过程,一个发送者(Sender),一个接收者(Receiver)

2. 紧接着,配置pom.xml文件,注意其中用到了springboot对于AMQP(高级消息队列协议,即面向消息的中间件的设计)；　

01. 父类pom.xml文件：　

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>rabbitmq_test</groupId>
    <artifactId>rabbitmq0408</artifactId>
    <version>1.0-SNAPSHOT</version>

    <packaging>pom</packaging>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>    <!--//jdk版本号-->
        <spring-cloud.version>Edgware.SR1</spring-cloud.version>   <!--//spring cloud的版本号-->
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>    <!--  //统一整个项目中的spring-cloud的版本号 -->
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

</project>

（转）<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.4.0.RELEASE</version>
    </parent>
    <properties>
        <java.version>1.7</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
            <scope>true</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!-- 添加springboot对amqp的支持 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
            <scope>provided</scope>
        </dependency>
    </dependencies>

02. send的pom.xml文件：　

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.zdj.rabbitmq</groupId>
	<artifactId>springboot-rabbitmq-sender</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>springboot-rabbitmq-sender</name>
	<description>Demo project for Spring Boot</description>

	<parent>
		<groupId>rabbitmq_test</groupId>
		<artifactId>rabbitmq0408</artifactId>
		<version>1.0-SNAPSHOT</version>
	</parent>

	<build>
		<finalName>springboot-rabbitmq-sender</finalName>
	</build>

</project>

3. 紧接着,我们编写发送者相关的代码.首先毫无疑问,要书写启动类:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringbootRabbitmqSenderApplication {

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

　4. 接着在application.yaml中,去编辑和RabbitMQ相关的配置信息,配置信息的代表什么内容根据键就能很直观的看出了.这里端口是5672,不是15672...15672是管理端的端口!

spring:
  application:
    name: spring-boot-rabbitmq-sender
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest

　5.随后,配置Queue(消息队列).那注意由于采用的是Direct模式,需要在配置Queue的时候,指定一个键,使其和交换机绑定.

package com.zdj.rabbitmq;

import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 配置Queue（消息队列）
 * 由于采用的是direct模式，需要在配置Queue的时候，指定一个键，使其和交换机绑定
 * Created by Administrator on 2018/4/8.
 */
@Configuration
public class SenderConf {
    @Bean
    public Queue queue(){
        return new Queue("queue");
    }
}

　6.接着就可以发送消息啦!在SpringBoot中,我们使用AmqpTemplate去发送消息!代码如下:

package com.zdj.rabbitmq;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 在springboot中，我们使用的是AmqpTemplate发送消息
 * Created by Administrator on 2018/4/8.
 */

@Component
public class HelloSender {
    @Autowired
    private AmqpTemplate template;

    public void send(){
        template.convertAndSend("queue","hello,rabbitmq!!~~");
    }

}

　 7. 编写测试类!这样我们的发送端代码就编写完了~

package com.zdj.rabbitmq;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest(classes =SpringbootRabbitmqSenderApplication.class)
public class SpringbootRabbitmqSenderApplicationTests {

   @Autowired
   private HelloSender helloSender;

   @Test
   public void contextLoads() {

      helloSender.send();

   }

}

　8. 接着我们编写接收端.

接收端的pom文件,application.yaml(修改spring.application.name),Queue配置类,App启动类都是一致的!这里省略不计.（发现默认的8080端口被占用，于是重新设置端口；）

spring:
  application:
    name: spring-boot-rabbitmq-receiver
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest
server:
  port: 8888

主要在于我们需要配置监听器去监听绑定到的消息队列,当消息队列有消息的时候,予以接收,代码如下:

package com.zdj.rabbitmq;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * Created by Administrator on 2018/4/8.
 */

@Component
public class HelloReceive {

    @RabbitListener(queues = "queue")//监听器监听指定的Queue
    public void process(String  str){
        System.out.println("Receive : "+str );
    }
}

　　9 . 接下来就可以测试啦,首先启动接收端的应用（SpringbootRabbitmqReceiverApplication）,紧接着运行发送端的单元测试SpringbootRabbitmqSenderApplicationTests）,接收端应用打印出来接收到的消息,测试即成功!

　　需要注意的地方,Direct模式相当于一对一模式,一个消息被发送者发送后,会被转发到一个绑定的消息队列中,然后被一个接收者接收!

补充： rabbitmq还可以支持发送对象，由于涉及到序列化和反序列化，该对象必须要实现Serializable接口；

a . 在springboot-rabbitmq-receiver 和 springboot-rabbitmq-sender 两个包下面都加上User对象；

import java.io.Serializable;

/**
 * 考察rabbitmq 发送对象的情形，建接收该对象的实体类
 */
public class User implements Serializable{

    private String username;
    private String password;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

b . 修改HelloSender：

@Component
public class HelloSender {
    @Autowired
    private AmqpTemplate template;

    public void send(){
//      01  .发送字符串
//       template.convertAndSend("queue","hello,rabbitmq!!~~");

//       02.   发送对象
        User user=new User();
        user.setUsername("zdj");
        user.setPassword("123123");
        template.convertAndSend("queue",user);

    }

}

c . 修改HelloReceiver:

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * Created by Administrator on 2018/4/8.
 */

@Component
public class HelloReceive {

//      01  .   rabbitmq发送的字符串
//    @RabbitListener(queues = "queue")//监听器监听指定的Queue
//    public void process(String  str){
//       System.out.println("Receive : "+str );
        //  测试结果：  Receive : hello ,rabbitmq!!~~
//    }

//      02.  测试 rabbitmq发送对象--此处接收对象
    @RabbitListener(queues = "queue")//监听器监听指定的Queue
    public void process(User user){
        System.out.println("Receive 对象 ： "+user);
        //   测试结果：  Receive 对象 ： com.zdj.rabbitmq.User@60660011
    }

}

d . 启动Receiver应用，再启动Sender的测试类，receiver端成功接收user对象则成功