rabbitmq客户端服务器模式

1、pom文件

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

2、服务器代码

package org.rabbitmqclient.util;

import com.rabbitmq.client.*;

import java.io.IOException;
public class RpcServer {
    private static final String RPC_QUEUE_NAME = "rpc_queue";

    public static void execute(String host, String userName, String password){
        // 配置连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(host);
        // 需要在管理后台增加一个hry帐号
        factory.setUsername(userName);
        factory.setPassword(password);

        Connection connection = null;
        try {
            // 建立TCP连接
            connection = factory.newConnection();
            // 在TCP连接的基础上创建通道
            final Channel channel = connection.createChannel();
            // 声明一个rpc_queue队列
            channel.queueDeclare(RPC_QUEUE_NAME, false, false, false, null);
            // 设置同时最多只能获取一个消息
            channel.basicQos(1);
            System.out.println(" [RpcServer] Awaiting RPC requests");
            // 定义消息的回调处理类
            Consumer consumer = new DefaultConsumer(channel) {
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    // 生成返回的结果，关键是设置correlationId值
                    AMQP.BasicProperties replyProps = new AMQP.BasicProperties
                            .Builder()
                            .correlationId(properties.getCorrelationId())
                            .build();
                    // 生成返回
                    String response = generateResponse(body);
                    // 回复消息，通知已经收到请求
                    channel.basicPublish( "", properties.getReplyTo(), replyProps, response.getBytes("UTF-8"));
                    // 对消息进行应答
                    channel.basicAck(envelope.getDeliveryTag(), false);
                    // 唤醒正在消费者所有的线程
                    synchronized(this) {
                        this.notify();
                    }
                }
            };
            // 消费消息
            channel.basicConsume(RPC_QUEUE_NAME, false, consumer);
            // 在收到消息前，本线程进入等待状态
            while (true) {
                synchronized(consumer) {
                    try {
                        consumer.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        finally {
            try {
                // 空值判断，为了代码简洁略
                connection.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 暂停10s，并返回结果
     * @param body
     * @return
     */
    private static String generateResponse(byte[] body) {
        System.out.println(" [RpcServer] receive requests: " + new String(body));
        try {
            Thread.sleep(1000 *1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "response:" + new String(body) + "-" + System.currentTimeMillis()+" 服务端处理后的返回信息";
    }

    public static void main(String[] args){
        // rabbitmq的IP地址
        final String rabbitmq_host = "";
        // rabbitmq的用户名称
        final String rabbitmq_user = "user1";
        // rabbitmq的用户密码
        final String rabbitmq_pwd = "123";
        RpcServer.execute(rabbitmq_host, rabbitmq_user, rabbitmq_pwd);
    }

}

3、客户端代码

package org.rabbitmqclient.util;
import com.rabbitmq.client.*;
import org.springframework.util.StringUtils;

import java.io.IOException;
import java.util.UUID;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * rpc客户端
 */
public class RpcClient {
    private static final String RPC_QUEUE_NAME = "rpc_queue";

    public static String execute(String host, String userName, String password, String message){
        // 配置连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(host);
        // 需要在管理后台增加一个hry帐号
        factory.setUsername(userName);
        factory.setPassword(password);

        Connection connection = null;
        Channel channel = null;
        try {
            // 建立TCP连接
            connection = factory.newConnection();
            // 在TCP连接的基础上创建通道
            channel = connection.createChannel();
            // 定义临时队列，并返回生成的队列名称
            String replyQueueName = channel.queueDeclare().getQueue();

            // 唯一标志本次请求
            String corrId = UUID.randomUUID().toString();
            // 生成发送消息的属性
            AMQP.BasicProperties props = new AMQP.BasicProperties
                    .Builder()
                    .correlationId(corrId) // 唯一标志本次请求
                    .replyTo(replyQueueName) // 设置回调队列
                    .build();
            // 发送消息，发送到默认交换机
            channel.basicPublish("", RPC_QUEUE_NAME, props, message.getBytes("UTF-8"));
            System.out.println(" [RpcClient] Requesting : " + message);

            // 阻塞队列，用于存储回调结果
            final BlockingQueue<String> response = new ArrayBlockingQueue<String>(1);
            // 定义消息的回退方法
            channel.basicConsume(replyQueueName, true, new DefaultConsumer(channel) {
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    if (properties.getCorrelationId().equals(corrId)) {
                        response.offer(new String(body, "UTF-8"));
                    }
                }
            });
            // 获取回调的结果
            String result = response.poll(3, TimeUnit.SECONDS);
            System.out.println(" [RpcClient] Result:'" + result + "'");
            if(StringUtils.isEmpty(result)){
                return "返回超时";
            }
            return result;
        }catch (Exception e){
            e.printStackTrace();
            return "";
        }finally {
            try {
                // 空值判断，为了代码简洁略
                channel.close();
                connection.close();
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }
    public static void main(String[] args){
        // rabbitmq的IP地址
        final String rabbitmq_host = "";
        // rabbitmq的用户名称
        final String rabbitmq_user = "user1";
        // rabbitmq的用户密码
        final String rabbitmq_pwd = "123";
        RpcClient.execute(rabbitmq_host, rabbitmq_user, rabbitmq_pwd, "你好");
    }
}

4、客户端发送请求controller

package org.rabbitmqclient.controller;


import org.rabbitmqclient.util.RpcClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/rabbitmq")
public class RabbitController {
    @GetMapping("/send")
    public String send(String message){
        // rabbitmq的IP地址
        final String rabbitmq_host = "";
        // rabbitmq的用户名称
        final String rabbitmq_user = "user1";
        // rabbitmq的用户密码
        final String rabbitmq_pwd = "123";
        return  RpcClient.execute(rabbitmq_host, rabbitmq_user, rabbitmq_pwd, "你好");
    }
}

5、启动类启动mq服务器端

package org.rabbitmqclient;

import org.rabbitmqclient.util.RpcServer;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class RabbitMqApplication {
    public static void main(String[] args) throws Exception {

        SpringApplication.run(RabbitMqApplication.class, args);
        final String rabbitmq_host = "";
        // rabbitmq的用户名称
        final String rabbitmq_user = "user1";
        // rabbitmq的用户密码    }
        final String rabbitmq_pwd = "123";
        RpcServer.execute(rabbitmq_host, rabbitmq_user, rabbitmq_pwd);
    }
}