消息队列入门案例-编码

最新推荐文章于 2022-08-11 10:46:31 发布

Leon_Jinhai_Sun

最新推荐文章于 2022-08-11 10:46:31 发布

阅读量221

点赞数

本文链接：https://blog.csdn.net/Leon_Jinhai_Sun/article/details/100995074

版权

我们就来编写里面的代码,那么我们应该怎么去编写这个代码呢,先把步骤说一下,在使用消息队列的时候呢,

你是不是得有一个队列,那我们是不是先把队列给创建出来,然后有消息的发送者,消息的接收者,就是Provider

和Consumer,那么我们先来看第一个环节,先去创建一个队列,那么这个队列在什么时候创建呢,应该在项目启动的时候

就将项目创建好,先要一个创建队列的一个类,这样的一个对象,帮我们把队列给创建出来,那我们现在用的是SpringBoot,

如果没有用SpringBoot的时候,可以用XML文件去配置bean标签,然后将创建队列的这个类,放到bean标签当中,然后随着

SpringBoot启动,就可以帮我们把队列对象实例化出来,那我们用SpringBoot怎么去做呢,大家还有印象,因为SpringBoot里面

是没有XML的,我们可以通过一个class,加上相应的注解,来解决初始化的问题,所以我现在写一个class,我叫QueueConfig,

队列的一个配置,这个类的作用就是,创建消息队列,那么这个类是不是要在我们项目启动时,初始化出来,所以我们要用一个

@Configuration的注解,然后接下来,让他执行这个类的方法,那么这个方法我们要用一个bean的注解,这个方法他返回一个什么呢,

返回一个Queue,别导错包了,我们用的是

org.springframework.amqp.core.Queue;

然后我们给他取一个名叫createQueue,然后我们return,new一个Queue就可以了,然后我们要给我们的队列起一个名字,比如

叫hello-queue,这个方法的作用是,创建队列,所以我们的SpringBoot在启动时,它会对所有标记了@Configuration的类做

初始化,同时会加有@Bean的方法,这个方法一被执行,就返回Queue,这个Queue就放在IOC容器当中,这是比较简单的,这样我们

一个消息队列的类就写完了

@Configuration
public class QueueConfig {

	/**
	 * 创建队列
	 * @return
	 */
	@Bean
	public Queue createQueue(){
		return new Queue("hello-queue");
	}
}

我们队列的名称叫hello-queue,接下来我们编写一个发送消息的Class,我们起个名比如叫Sender,这里是消息发送者,

然后这个消息发送者,在我们程序运行的时候,是不是让Spring初始化出来,他既不属于WEB层的框架,也不属于业务层

的框架,也不属于持久层的框架,所以我们这里要用哪个注解呢,我们可以用@Component,直接加一个组件的注解,然后这里

我先提供一个方法,这个方法用于专门发送消息的,发送消息的方法,这个方法没有返回值,我们定义成void的就可以了,

可以根据自己的需要来决定返回什么,然后我们叫send,然后send方法我们给他一个入参,这个入参,就是你给我方法什么,

我就给消息队列发送什么,是不是得给消息队列里发送消息了,可是我怎么去拿消息队列呢,在这里SpringBoot已经给我们

封装了,我们用的Queue是

org.springframework.amqp.core.Queue

是封装完的,既然把它封装了,包括对于队列的操作方式,Spring也做封装了,都是在amqp的包下,我们现在想要操作RabbitMQ

怎么办呢,封装了一个类,叫rabbitAmqpTemplate,Spring把template的技术发挥到至极的状态,只要他对什么东西做整合,

最基本的会提供一个操作模板类,我们的模板就是什么什么template,整合hibnate就是hibernateTemplate,整合JDBC

就是jdbcTemplate,那么他在整合Rabbbit的时候呢,提供一个RabbitTemplate,提供操作Rabbit的封装,那么我先需要将他

注入进来

@Autowired
private AmqpTemplate rabbitAmqpTemplate;
	
我们看,它是一个接口,然后我们起个名叫rabbitAmqpTemplate,然后我们可以通过注入进来的这个对象,来进行对消息队列

的一个操作,比如我们现在要发送怎么办呢,下面有一个convertAndSend的方法,然后我们调用哪个呢,有两个参数的,这两个

参数,我们来说一下,第一个参数表示什么意思呢,参数一表示队列的名称,就是你要往哪个队列发送消息,参数二什么呢,消息,

我们之前讲过,消息队列里我们是可以创建多个队列的,我们可以在RabbitMQ里面创建多个消息队列,然后生产者和消费者可以

创建不同的队列,我们在创建队列的时候给他起了一个名称,然后我们在发送消息的时候呢,根据队列的名称来做一个指定,

所以我们要注意的就是,这个名称是不能有重复的了,就是这块需要注意,第一个队列名称,我们要往哪个队列发送消息呢,

我们这里的队列的名称叫"hello-queue",然后要发送什么消息呢,是不是传递过来的msg,这样我们的一个消息发送者就编写完了,

还是比较简单的,然后我们还得编写一个消息的接收者

@Component
public class Sender {

	@Autowired
	private AmqpTemplate rabbitAmqpTemplate;
	/*
	 * 发送消息的方法
	 */
	public void send(String msg){
		//向消息队列发送消息
		//参数一：队列的名称。
		//参数二：消息
		this.rabbitAmqpTemplate.convertAndSend("hello-queue", msg);
	}
}

这个我叫什么呢,叫Receive,这个是消息接收者,然后他也得是一个组件,@Component,然后在这里我们加一个方法,

比如叫process,叫什么都行,那么消息接收者是怎么接收消息的呢,他采用的是一个消息队列的监听器,也就是说如果

你的队列里一旦有变化了,就会触发方法的一个接收,换句话说,你怎么让我们加的方法去接收消息呢,就依赖于消息队列的

事件,我们就在消息接收者的方法上,加一个注解,叫@RabbitListener,那么这个注解什么意思呢,就是我刚刚说的,哪个队列

一旦有变化了,或者有发送者发送消息了,马上就会执行这个方法,因为我们把这个注解加在这个方法上,采用失效通知的方法,

从队列当中接收消息,是这样的一个过程,那么去让他接收哪个队列呢,我们可以创建好多队列是不是,所以这一块他有一个

属性,queues,他是一个数组,他可以对多个队列进行一个监听,那我们现在只有一个队列,只要让他监听一个队列就可以了,

所以我们就不用写数组格式了,直接写一个字符串,你要是写数组,里面要的也是字符串,要的是你队列的名称,队列的名称叫

什么,叫hello-queue,所以把这个队列的名称拿过来,往这里一放,这里就表示去监听这个队列,一旦这个队列里有消息进来了,

马上会触发这个方法,这个方法我们要做的事就是,在队列里把消息拿出来就可以了,他也会把消息传递过来,它会通过一个参数,

String msg就可以了,这个是接收消息的方法,采用消息队列监听机制,然后会把这个消息传递过来,我们在这里直接打印他就可以了

前面可以加上一个标记,这里是什么呢,是receiver,这样我们消息接收方也就搞定了,

@Component
public class Receiver {

	/**
	 * 接收消息的方法。采用消息队列监听机制
	 * @param msg
	 */
	@RabbitListener(queues="hello-queue")
	public void process(String msg){
		System.out.println("receiver: "+msg);
	}
}

然后我们接下来我们再看一下,消息接收方和发送方我们都有了,我们是不是就可以编写测试代码了,回过来找到我们

测试的这个包,我们叫com.learn.test,然后在测试包里我们建立一个测试类,我们建立一个QueueTest,这个是消息队列测试类,

既然是测试类,我们需要加一些注解,@RunWith,然后SpringRunner.class

org.springframework.test.context.junit4.SpringRunner

然后我们还需要加一个@SpringBootTest,然后这里给一个启动类classes=SpringBootMQApplication.class

我们这个启动类叫SpringBootMQApplication,接下来我们写测试方法,测试消息队列,其实我们要做的事你看一下,

我们只要调用send方法就可以了,send方法一旦给消息队列发送消息了,监听事件马上会触发,然后会调用我们的process

方法,然后将消息传递到参数当中,然后我们将消息打印出来,所以我们操作的就是发送者,所以我们要将消息的发送者注入

进来

@RunWith(SpringRunner.class)
@SpringBootTest(classes=SpringBootMQApplication.class)
public class QueueTest {

	@Autowired
	private Sender sender;
	
	/*
	 * 测试消息队列
	 */
	@Test
	public void test1(){
		this.sender.send("Hello RabbitMQ" + new Date());
	}
}
	
接下来我们来做一个测试,所以RabbitMQ,或者消息队列,他使用起来还是比较简单的,无论是RabbitMQ也好,还是ActiveMQ也好,

RocketMQ也好,其实他们的MQ原理上都是一样的,操作上也大致相同,然后不同的是什么呢,就是他们的API可能会有一些变化,

我们根据不同的消息队列去熟悉他的API就可以了,编写代码,第一步创建队列,现在我们队列产生了以后,还记得这个管理界面吧

59.110.158.145:15672

http://59.110.158.145:15672/#/queues

这里会显示你队列里的信息,有多少个这里会显示多少个,然后我们在这里可以看到,我们是不是有一个hello-queue,这个队列就叫

hello-queue,然后状态是什么,然后其他的信息在这里,消息的总量,还有消息读取的流量,在这都会有一些显示,所以我们通过他,

管理我们的消息队列就会更容易一些,当然你也可以删掉,这里有一个delete,我们可以把它删掉,这样你的消息队列就从MQ中删除了,

除非你再运行一遍他才会有,比如我再测试一下,成功了,然后我们再来看,这个队列又出来了,显示的是创建出来的队列的信息,

然后创建生产者,或者消息提供者,就是我们的Sender,然后是消息接收者,然后是启动类,然后是我们的测试代码

<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.learn</groupId>
  <artifactId>springcloud-mq</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>
  
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.12.RELEASE</version>
		<relativePath/> 
	</parent>
	
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
		<thymeleaf.version>3.0.9.RELEASE</thymeleaf.version>
		<thymeleaf-layout-dialect.version>2.2.2</thymeleaf-layout-dialect.version>
	</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>
	
	<!-- 这个插件,可以将应用打包成一个可执行的jar包 -->
	<build>
	    <plugins>
	        <plugin>
	            <groupId>org.springframework.boot</groupId>
	            <artifactId>spring-boot-maven-plugin</artifactId>
	        </plugin>
	    </plugins>
	</build>
  
  
</project>

#server.port=8010
spring.application.name=springcloud-mq
spring.rabbitmq.host=59.110.158.145
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
spring.rabbitmq.port=5672

package com.learn.config;

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

/**
 * 创建消息队列
 * @author Administrator
 *
 */
@Configuration
public class QueueConfig {

	/**
	 * 创建队列
	 * @return
	 */
	@Bean
	public Queue createQueue(){
		return new Queue("hello-queue");
	}
}

package com.learn.config;

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

/**
 * 消息接收者
 * @author Administrator
 *
 */
@Component
public class Receiver {

	/**
	 * 接收消息的方法。采用消息队列监听机制
	 * @param msg
	 */
	@RabbitListener(queues="hello-queue")
	public void process(String msg){
		System.out.println("receiver: "+msg);
	}
}

package com.learn.config;

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

/**
 * 消息发送者
 * @author Administrator
 *
 */
@Component
public class Sender {

	@Autowired
	private AmqpTemplate rabbitAmqpTemplate;
	/*
	 * 发送消息的方法
	 */
	public void send(String msg){
		//向消息队列发送消息
		//参数一：队列的名称。
		//参数二：消息
		this.rabbitAmqpTemplate.convertAndSend("hello-queue", msg);
	}
}

package com.learn;

import org.springframework.amqp.rabbit.annotation.EnableRabbit;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * 自动配置
 * @author Leon.Sun
 */
@SpringBootApplication
@EnableRabbit
public class SpringBootMQApplication {

	public static void main(String[] args) {
		// Spring应用启动起来
		SpringApplication.run(SpringBootMQApplication.class,args);
	}
	
}

package com.learn.test;

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;

import com.learn.SpringBootMQApplication;
import com.learn.config.Sender;

/**
 * 消息队列测试类
 * @author Administrator
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes=SpringBootMQApplication.class)
public class QueueTest {

	@Autowired
	private Sender sender;
	
	/*
	 * 测试消息队列
	 */
	@Test
	public void test1(){
		for(int i=0;i<20;i++) {
			this.sender.send("Hello RabbitMQ" + i);
		}
	}
}