个人中心
gpt4 book ai didi

springboot集成rabbitMQ之对象传输的方法

转载 作者：qq735679552 更新时间：2022-09-27 22:32:09 27 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章springboot集成rabbitMQ之对象传输的方法由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

rabbitmq的安装方法网上有很多教程，这里就不重复了.

在springboot上使用rabbitmq传输字符串和对象，本文所给出的例子是在两个不同的项目之间进行对象和和字符串的传输.

rabbitmq的依赖（在两个项目中一样的配置）:

?
1
2
3
4
<dependency>
   <groupid>org.springframework.boot</groupid>
   <artifactid>spring-boot-starter-amqp</artifactid>
</dependency>

pom配置文件（在两个项目中一样的配置）:

?
1
2
3
4
5
6
7
8
9
spring.application.name: demo1  //项目名
spring.rabbitmq.host: 192.168 . 1.111 //写自己的ip
spring.rabbitmq.port: 5672
spring.rabbitmq.username: guest
spring.rabbitmq.password: guest
spring.rabbitmq.virtual-host: /
spring.rabbitmq.publisher-confirms: true
spring.rabbitmq.publisher-returns: true
spring.rabbitmq.template.mandatory: true

字符转的相互传输（本例使用的topic类型） 。

1>. 首先，在生产者（项目a）中写配置文件，其中生成队列queue，交换机exchange并且进行绑定binding 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import org.springframework.amqp.core.binding;
import org.springframework.amqp.core.bindingbuilder;
import org.springframework.amqp.core.queue;
import org.springframework.amqp.core.topicexchange;
import org.springframework.beans.factory.annotation.qualifier;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
 
/**
  * @author:fdh
  * @description:
  * @date： create in 16:13 2017/12/22
  */
@configuration
public class senderconfigration {
   /**
   *@description: 新建队列 topic.messages
   *@data:16:14 2017/12/22
   */
   @bean (name = "messages" )
   public queue queuemessages(){
     return new queue( "topic.messages" );
   }
   /**
   *@description: 定义交换器
   *@data:16:15 2017/12/22
   */
   @bean
   public topicexchange exchange(){
     return new topicexchange( "exchange" );
   }
   /**
   *@description: 交换机与消息队列进行绑定 队列messages绑定交换机with topic.messages
   *@data:16:18 2017/12/22
   */
   @bean
   binding bindingexchangemessages( @qualifier ( "messages" ) queue queuemessages,topicexchange exchange){
     return bindingbuilder.bind(queuemessages).to(exchange).with( "topic.messages" );
   }
}

2>. 第二步(项目a)，生产者把消息发送到消息队列， 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
  * @author:fdh
  * @description:
  * @date： create in 14:15 2017/12/22
  */
@controller
public class rabbitcontroller {
   @autowired
   private amqptemplate amqptemplate;
   @requestmapping ( "/sendss" )
   public void send1(){
     amqptemplate.convertandsend( "exchange" , "topic.messages" , "hello topic.messages rabbitmq" );
   }
}

3>. 接下来，在消费者（项目b）端写一个监听器，交换器会根据绑定的routing key（topic.messages）把生产者生产的消息放到匹配的消息队列中，监听器会监听相应的消息队列来获取路由到该消息队列上的消息.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.stereotype.component;
import org.springframework.amqp.rabbit.annotation.rabbitlistener;
/**
  * @ author:fdh
  * @ description: 消息队列监听器
  * @ date： create in 14:19 2017/12/22
  */
@component
public class receiver {
  @rabbitlistener (queues = "topic.messages" )
   public void process2(string str1) throws classnotfoundexception{
     system.out.println( "messages ：" +str1);
     system.out.println(thread.currentthread().getname()+ "接收到来自topic.message队列的消息: " +str1);
   }

这样，一个简单的字符串的传输便写好了，下面打开刚才定义的mapping： 192.168.1.111:8080/sendss 。

在消费者端的console窗口便会看到打印的消息 。

springboot集成rabbitMQ之对象传输的方法

以上就是一个简单的传输字符串的例子了.

2. 下面重点介绍一下消费者和生产者之间对象的传输.

对象的传输，要现在生产者（a）中进行序列化，即把对象转化为字节数组进行传输，在消费者中，再把转化的字节数组反序列化为对象。序列化和反序列化的方法很多，这里采用的是java的serializable 接口 。

1>. 在生产者（项目a）和消费者（项目b）的项目中创建实体类.

！注意！：新建实体类boy.java 该实体类在项目a、b中的位置，必须一致，即包名必须一致，在本项目中，boy.java 在项目a、b中都是： import com.fengdonghao.shiro.bean.boy,

实体类也要一致.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package com.fengdonghao.shiro.bean;
import javax.persistence.*;
import java.io.serializable;
/**
  * @author:fdh
  * @description:
  * @date：create in11:14 2017/12/16
  */
@entity
public class boy implements serializable{
   private static final long serialversionuid=1l;
   @id
   @generatedvalue
   private int id;
   private string name;
   private int age;
   @override
   public string tostring() {
     return "boy{" +
         "age=" + age +
         ", id=" + id +
         ", name='" + name + '\ '' +
         '}' ;
   }
//此处省略getter 和setter 方法
}

2>. 在生产者（a）中配置 消息队列，交换器，并进行绑定binding，和在 例子1中的第一步是一样的 。

3>. 在生产者（a）中的rabbitcontroller.java 中另写一个mapping，如下 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@requestmapping ( "/send" )
   public void sendmessage() {
     boy boy= new boy();
     boy.setname( "tim" );
     boy.setage( 11 );
     system.out.println(boy);
     //以下是序列化操作
     //write obj to file
     objectoutputstream oos = null ;
     try {
       oos = new objectoutputstream( new fileoutputstream( new file( "e:\\webpackage\\a.txt" ))); //把序列化之后的字节数组暂时存放在该目录下
       oos.writeobject(boy);
     } catch (ioexception e) {
       e.printstacktrace();
     } finally {
       ioutils.closequietly(oos);
     }
     rabbitmqservice.send( "对象已序列化" );

4>. 在消费者（b）中对字节数组进行反序列化.

在receiver中，重新编写例1重点的监听器 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@rabbitlistener (queues = "topic.messages" )
   public void process2(string str1) {
     system.out.println(thread.currentthread().getname()+ "接收到来自topic.message队列的消息: " +str1+ " 并进行反序列化" );
     file file = new file( "e:\\webpackage\\a.txt" ); //消费者和生产者中路径要保持一致，才能读取文件，进行解析
     objectinputstream ois = null ;
     try {
       ois = new objectinputstream( new fileinputstream(file));
       boy newuser = (boy) ois.readobject();
       system.out.println( "反序列之后:" +newuser);
       system.out.println( "反序列之后getname:" +newuser.getname());
       system.out.println( "反序列之后getage" +newuser.getage());
     } catch (ioexception e) {
       e.printstacktrace();
     } catch (classnotfoundexception e) {
       e.printstacktrace();
     } finally {
       ioutils.closequietly(ois);
       try {
         fileutils.forcedelete(file);
       } catch (ioexception e) {
         e.printstacktrace();
       }
     }
     system.out.println( "messages ：" +str1);
   }

验证mapping: ip：8080/send 。

结果如下:

springboot集成rabbitMQ之对象传输的方法

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我.

原文链接：http://blog.csdn.net/east123321/article/details/78900791 。

最后此篇关于springboot集成rabbitMQ之对象传输的方法的文章就讲到这里了,如果你想了解更多关于springboot集成rabbitMQ之对象传输的方法的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

27 4 0
文章推荐： Java实现基于JDBC操作mysql数据库的方法
文章推荐： ThinkPHP行为扩展Behavior应用实例详解
文章推荐： qq登录，新浪微博登录接口申请过程中遇到的问题
文章推荐： python将每个单词按空格分开并保存到文件中
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com