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

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

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

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

<dependency>
  <groupid>org.springframework.boot</groupid>
  <artifactid>spring-boot-starter-amqp</artifactid>
</dependency>

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

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

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)，生产者把消息发送到消息队列，

/**
 * @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）把生产者生产的消息放到匹配的消息队列中，监听器会监听相应的消息队列来获取路由到该消息队列上的消息。

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窗口便会看到打印的消息

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

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

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

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

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

实体类也要一致。

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，如下

@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重点的监听器

@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

结果如下：

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。

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