Eclipse下的RabbitMQ

最新推荐文章于 2022-03-29 11:13:57 发布

qq_37522951

最新推荐文章于 2022-03-29 11:13:57 发布

阅读量1.1k

点赞数

分类专栏： rabbitMQ 文章标签： RabbitMQ的简单实现

本文链接：https://blog.youkuaiyun.com/qq_37522951/article/details/83011401

版权

rabbitMQ 专栏收录该内容

0 篇文章

订阅专栏

本文介绍了如何在Eclipse环境中，分别实现非Spring整合和Spring整合的RabbitMQ。首先展示了非Spring环境下引入依赖并编写消费者和生产者的简单步骤。接着，详细说明了Spring整合RabbitMQ的过程，包括配置文件设置、多个消费者的创建以及通过web接口进行交互。目前，消息延迟功能尚未实现，作者承诺后续完善。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

首先先介绍下非spring整合下的RabbitMQ:

引入jar

<dependency>
<groupId>com.rabbitmq</groupId>
<artifactId>amqp-client</artifactId>
<version>3.6.5</version>
</dependency>

编写实现代码

import org.apache.log4j.Logger;

import com.deshangshidai.utils.DateTimeUtils;
import com.deshangshidai.utils.PropertitesReader;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;
/**
 * 
 * @author Administrator
 * 服务器端
 */
//@Deprecated
public class RabbitMQ {
	
	private static final Logger log = Logger.getLogger(RabbitMQ.class);
	//消费者 *** 入参为队列名称
	public static void Server(String queueName)  {
		try{
			/* 建立连接 */
			ConnectionFactory factory = new ConnectionFactory();
			factory.setHost(PropertitesReader.ReadersContext("rabbitmq-slave.properties", "rabbitmq.queue.host"));// MQ的IP
			factory.setPort(Integer.parseInt(PropertitesReader.ReadersContext("rabbitmq-slave.properties", "rabbitmq.queue.port")));// MQ端口
			factory.setUsername(PropertitesReader.ReadersContext("rabbitmq-slave.properties", "rabbitmq.username"));// MQ用户名
			factory.setPassword(PropertitesReader.ReadersContext("rabbitmq-slave.properties", "rabbitmq.password"));// MQ密码
			Connection connection = factory.newConnection();
			Channel channel = connection.createChannel();
	 
			if(queueName==null||queueName.equals("")){
				queueName=RabbitMQmenu.TEST.toString();
			}
			
			/* 声明要连接的队列 */
			channel.queueDeclare(queueName, false, false, false, null);
			log.info(DateTimeUtils.getDateTimeQM()+"------>系统消息队列创建成功！");
			/* 创建消费者对象，用于读取消息 */
			QueueingConsumer consumer = new QueueingConsumer(channel);
			channel.basicConsume(queueName, true, consumer);
	
			/* 读取队列，并且阻塞，即在读到消息之前在这里阻塞，直到等到消息，完成消息的阅读后，继续阻塞循环 */
			while (true) {
				QueueingConsumer.Delivery delivery = consumer.nextDelivery();
				String message = new String(delivery.getBody());
				log.info("【收到消息】---"+DateTimeUtils.getDateTimeQM()+"------>"+message);
			}
		}catch(Exception e){
			log.info(DateTimeUtils.getDateTimeQM()+"------>系统消息队列创建失败！\n"+e.getMessage());
		}
	}
	
	//生产者 *** 入参为队列名称
	public static void client(String queueName){
		try{
			/* 建立连接 */
			ConnectionFactory factory = new ConnectionFactory();
			factory.setHost(PropertitesReader.ReadersContext("rabbitmq-slave.properties", "rabbitmq.queue.host"));// MQ的IP
			factory.setPort(Integer.parseInt(PropertitesReader.ReadersContext("rabbitmq-slave.properties", "rabbitmq.queue.port")));// MQ端口
			factory.setUsername(PropertitesReader.ReadersContext("rabbitmq-slave.properties", "rabbitmq.username"));// MQ用户名
			factory.setPassword(PropertitesReader.ReadersContext("rabbitmq-slave.properties", "rabbitmq.password"));// MQ密码
			Connection connection = factory.newConnection();
			Channel channel = connection.createChannel();
 
		if(queueName==null||queueName.equals("")){
			queueName=RabbitMQmenu.TEST.toString();
		}
        /*业务逻辑*/
        for (int i = 0; i < 1000; i++) {
    		/* 创建消息队列，并且发送消息 */
    		channel.queueDeclare(queueName, false, false, false, null);
    		String message = "测试消息队列"+i;
    		channel.basicPublish("", queueName, null, message.getBytes());
    		Thread.sleep(500);
		}
        log.info("完成");
		/* 关闭连接 */
		channel.close();
		connection.close();
		}catch(Exception e){
			log.info(DateTimeUtils.getDateTimeQM()+"------>请求队列失败，请稍后再试！\n"+e.getMessage());
		}
	}
	
	//测试
	public static void main(String[] args) {
        //生产者
		//client(RabbitMQmenu.TEST.toString());
		//消费者
		Server(RabbitMQmenu.TEST.toString());
	}
}

先运行消费者让队列创建好，在运行生产者往队列里面放消息，在运行消费者输出结果如下：

其次说下自己Spring整合RabbitMQ的实现

引入jar

   <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>3.6.5</version>
    </dependency>
    <!--Spring Retry实现重试操作。-->
	<dependency>
	    <groupId>org.springframework.retry</groupId>
	    <artifactId>spring-retry</artifactId>
	    <version>1.1.5.RELEASE</version>
	</dependency>
    
    <dependency>
       <groupId>org.springframework.amqp</groupId>
       <artifactId>spring-amqp</artifactId>
       <version>1.7.2.RELEASE</version>
    </dependency>
	<dependency>
	    <groupId>org.springframework.amqp</groupId>
	    <artifactId>spring-rabbit</artifactId>
	    <version>1.7.2.RELEASE</version>
	</dependency>

编写spring-rabbitmq.xml文件：rabbitmq的详细配置（）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
     http://www.springframework.org/schema/rabbit
     http://www.springframework.org/schema/rabbit/spring-rabbit-1.2.xsd">
    <!--配置connection-factory，指定连接rabbit server参数 -->
    <rabbit:connection-factory id="connectionFactory"
                               username="root" password="D56D0B70D83E41508EF964D556F51CB4" host="47.93.228.156" port="5672" />
 
    <!--定义rabbit template用于数据的接收和发送 -->
    <rabbit:template id="amqpTemplate" connection-factory="connectionFactory" exchange="exchangeTest"/>
 
    <!--通过指定下面的admin信息，当前producer中的exchange和queue会在rabbitmq服务器上自动生成 -->
    <rabbit:admin id="connectAdmin" connection-factory="connectionFactory"/>
 
    <!--定义queue -->
    <rabbit:queue id="queueTest" name="queueTest" durable="true" auto-delete="false" exclusive="false" declared-by="connectAdmin"/>
  
    <!-- 定义direct exchange，绑定queueTest -->
    <rabbit:direct-exchange name="exchangeTest" durable="true" auto-delete="false" declared-by="connectAdmin">
        <rabbit:bindings>
             <rabbit:binding queue="queueTest" key="queueTestKey"/>
        </rabbit:bindings>
    </rabbit:direct-exchange>
 
    <!-- 消息接收者 -->
    <bean id="messageReceiver" class="com.deshangshidai.rabbitmq.MessageConsumer"></bean>
 
    <!-- queue litener  观察 监听模式 当有消息到达时会通知监听在对应的队列上的监听对象-->
    <rabbit:listener-container connection-factory="connectionFactory">
        <rabbit:listener queues="queueTest" ref="messageReceiver"/>
    </rabbit:listener-container>
 
    <!--定义queue -->
    <rabbit:queue id="queueChris" name="queueChris" durable="true" auto-delete="false" exclusive="false" declared-by="connectAdmin"/>

 
    <!-- 定义direct exchange，绑定queueTest -->
    <rabbit:direct-exchange name="exchangeTest" durable="true" auto-delete="false" declared-by="connectAdmin">
        <rabbit:bindings>
            <rabbit:binding queue="queueChris" key="queueTestChris"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:direct-exchange>
 
    <!-- 消息接收者 -->
    <bean id="receiverChris" class="com.deshangshidai.rabbitmq.ChrisConsumer"></bean>
 
    <!-- queue litener  观察 监听模式 当有消息到达时会通知监听在对应的队列上的监听对象-->
    <rabbit:listener-container connection-factory="connectionFactory">
        <rabbit:listener queues="queueChris" ref="receiverChris"/>
    </rabbit:listener-container>
 
    <!--              分隔线                -->
    <!--配置connection-factory，指定连接rabbit server参数 -->
    <rabbit:connection-factory id="connectionFactory2"
                               username="root" password="D56D0B70D83E41508EF964D556F51CB4" host="47.93.228.156" port="5672"/>
 
    <!--定义rabbit template用于数据的接收和发送 -->
    <rabbit:template id="amqpTemplate2" connection-factory="connectionFactory2"
                     exchange="exchangeTest2"/>
 
    <!--通过指定下面的admin信息，当前producer中的exchange和queue会在rabbitmq服务器上自动生成 -->
    <rabbit:admin id="connectAdmin2" connection-factory="connectionFactory2"/>
 
    <!--定义queue -->
    <rabbit:queue name="queueWuxing" durable="true" auto-delete="false" exclusive="false" declared-by="connectAdmin2"/>
 
    <!-- 定义direct exchange，绑定queueTest -->
    <rabbit:topic-exchange name="exchangeTest2" durable="true" auto-delete="false" declared-by="connectAdmin2">
        <rabbit:bindings>
            <rabbit:binding queue="queueWuxing" pattern="wuxing.#"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:topic-exchange>
 
    <!-- 消息接收者 -->
    <bean id="recieverWuxing" class="com.deshangshidai.rabbitmq.WuxingConsumer"></bean>
 
    <!-- queue litener  观察 监听模式 当有消息到达时会通知监听在对应的队列上的监听对象-->
    <rabbit:listener-container connection-factory="connectionFactory2" >
        <rabbit:listener queues="queueWuxing" ref="recieverWuxing"/>
    </rabbit:listener-container>
</beans>

检查web.xml文件，一定要将spring-rabbitmq.xml放到容器中，例如我的项目：

   <context-param>
       <param-name>contextConfigLocation</param-name>
       <param-value>classpath*:spring/*.xml</param-value>
   </context-param>

编写生产者

/**
 * 
 * @author Administrator
 *
 *         生产者---用户发送
 */
@Service
public class MessageProducer {

	 private Logger logger = LoggerFactory.getLogger(MessageProducer.class);    
	 
	 @Resource(name="amqpTemplate")    
	 private AmqpTemplate amqpTemplate; 
	 
	 @Resource(name="amqpTemplate2")    
	 private AmqpTemplate amqpTemplate2;     
	 public void sendMessage(int i,Object message) throws IOException {        
		 logger.info("to send message:{}", message);   
		 if (i<6) {
			 amqpTemplate.convertAndSend("queueTestKey", message);  
		 }
		 if(i>5) {
			 amqpTemplate.convertAndSend("queueTestChris", message); 
		 }
		 amqpTemplate2.convertAndSend("wuxing.xxxx.wsdwd", message);   
	 }
}

编写消费者1

public class MessageConsumer implements MessageListener{
	

	private Logger logger = LoggerFactory.getLogger(MessageConsumer.class);

	@Override
	public void onMessage(Message message) {
		 try {
			String s=new String(message.getBody(),"UTF-8");
			logger.info("consumer receive message------->:{}", s);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} 
	}
}

编写消费者2

public class ChrisConsumer implements MessageListener{

	 private Logger logger = LoggerFactory.getLogger(ChrisConsumer.class);

	@Override
	public void onMessage(Message message) {
		String s;
		try {
			s = new String(message.getBody(),"UTF-8");
			logger.info("chris receive message------->:{}", s);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

编写消费者3

public class WuxingConsumer implements MessageListener {
	 private Logger logger = LoggerFactory.getLogger(WuxingConsumer.class);

	@Override
	public void onMessage(Message message) {
		try {
			String s=new String(message.getBody(),"UTF-8");
			logger.info("wuxing receive message------->:{}", s);
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

编写controller,通过web访问

	@Resource
	private MessageProducer mp;	

    @RequestMapping(value="/tete")
	public void tete() {
		for (int i = 0; i < 10; i++) {
			
			try {
				mp.sendMessage(i,"消息为："+i);
				
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

访问web，输出结果如下：