RabbitMQ工厂&工具类

最新推荐文章于 2024-10-09 23:55:26 发布
最新推荐文章于 2024-10-09 23:55:26 发布
阅读量1.4k 收藏 3
点赞数
分类专栏： RabbitMQ 文章标签： rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mengqingming1/article/details/106058144
版权

rabbitMq工厂类，封装了创建连接，释放连接等操作

import java.io.IOException;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.util.concurrent.TimeoutException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

/**
 * rabbit工厂类
 *
 * @since 2018/12/13
 */
@Component
public class RabbitMqConnectionFactory {
    private static final Logger log = LoggerFactory.getLogger(RabbitMqConnectionFactory.class);

    private static ConnectionFactory connectionFactory = new ConnectionFactory();

    private static String addresses;

    private static int port;

    private static String username;

    private static String password;

    private static String virtualHost;

    /**
     * 设置addresses
     *
     * @param addresses addresses
     */
    @Value("${spring.rabbitmq.host}")
    public void setAddresses(String addresses) {
        setAddressesValue(addresses);
    }

    /**
     * 设置port
     *
     * @param port port
     */
    @Value("${spring.rabbitmq.port}")
    public void setPort(int port) {
        setPortValue(port);
    }

    /**
     * 设置username
     *
     * @param username username
     */
    @Value("${spring.rabbitmq.username}")
    public void setUsername(String username) {
        setUsernameValue(username);
    }

    /**
     * 设置password
     *
     * @param password password
     */
    @Value("${spring.rabbitmq.password}")
    public void setPassword(String password) {
        setPasswordValue(password);
    }

    /**
     * 设置virtualHost
     *
     * @param virtualHost virtualHost
     */
    @Value("${spring.rabbitmq.virtual-host}")
    public void setVirtualHost(String virtualHost) {
        setVirtualHostValue(virtualHost);
    }

    /**
     * 只创建一个ConnectionFactory
     * 双重检查加锁
     *
     * @return
     */
    private static ConnectionFactory getSingleInstance() {
        // 设置服务地址
        connectionFactory.setHost(addresses);

        // AMQP 5672
        connectionFactory.setPort(port);
        try {
            connectionFactory.useSslProtocol();
        } catch (NoSuchAlgorithmException e) {
            log.debug("NoSuchAlgorithmException :{}", e);
        } catch (KeyManagementException e) {
            log.debug("KeyManagementException :{}", e);
        }

        // 用户名
        connectionFactory.setUsername(username);

        // 密码
        connectionFactory.setPassword(password);

        // vhost
        connectionFactory.setVirtualHost(virtualHost);

        //  设置自动恢复
        connectionFactory.setAutomaticRecoveryEnabled(true);
        return connectionFactory;
    }

    /**
     * 创建连接
     *
     * @return Connection Connection
     */
    public static synchronized Connection getConnection() {
        getSingleInstance();
        Connection connection = null;

        int connectionNumber = 1;

        log.debug("RabbitMqConnectionFactory getConnection start ========== : {}", connectionNumber);

        do {
            try {
                log.debug("RabbitMqConnectionFactory getConnection :{}", connectionNumber);
                ++connectionNumber;
                connection = connectionFactory.newConnection();

                if (null != connection) {
                    log.debug("RabbitMqConnectionFactory getConnection  connection success");
                    break;
                }
            } catch (IOException e) {
                log.error("RabbitMqConnectionFactory getConnection error , connection bumber : {}",
                        connectionNumber - 1);
                log.error("IOException:{}",e);
            } catch (TimeoutException e) {
                log.error("RabbitMqConnectionFactory getConnection error , connection bumber : {}",
                        connectionNumber - 1);
                log.error("TimeoutException:{}",e);
            }
        } while (connectionNumber < 3);

        log.debug("RabbitMqConnectionFactory getConnection end ========== : {}", connectionNumber - 1);
        return connection;
    }

    /**
     * 关闭资源
     *
     * @param connection connection
     * @param channel    channel
     */
    public static void closeResource(Connection connection, Channel channel) {
        if (null != channel) {
            try {
                channel.close();
            } catch (IOException e) {
                log.error("IO Exception {}", e);
                log.error("IOException:{}",e);
                throw new CommonException("IO Exception");
            } catch (TimeoutException e) {
                log.error("Timeout Exception {}", e);
                log.error("TimeoutException:{}",e);
                throw new CommonException("Timeout Exception");
            }
        }
        if (null != connection) {
            try {
                connection.close();
            } catch (IOException e) {
                log.error("IOException:{}",e);
                log.error("IO Exception {}", e);
                throw new CommonException("IO Exception");
            }
        }
    }

    /**
     * 设置addressesValue
     *
     * @param addressesValue addressesValue
     */
    public static void setAddressesValue(String addressesValue) {
        RabbitMqConnectionFactory.addresses = addressesValue;
    }

    /**
     * 设置portValue
     *
     * @param portValue portValue
     */
    public static void setPortValue(int portValue) {
        RabbitMqConnectionFactory.port = portValue;
    }

    /**
     * 设置 passwordValue
     *
     * @param passwordValue passwordValue
     */
    public static void setPasswordValue(String passwordValue) {
        RabbitMqConnectionFactory.password = passwordValue;
    }

    /**
     * 设置 virtualHostValue
     *
     * @param virtualHostValue virtualHostValue
     */
    public static void setVirtualHostValue(String virtualHostValue) {
        RabbitMqConnectionFactory.virtualHost = virtualHostValue;
    }

    /**
     * 设置usernameValue
     *
     * @param usernameValue usernameValue
     */
    public static void setUsernameValue(String usernameValue) {
        RabbitMqConnectionFactory.username = usernameValue;
    }

    /**
     * 获取ip
     *
     * @return str ip地址
     */
    public static String getAddresses() {
        return addresses;
    }

    /**
     * 获取端口
     *
     * @return port 获取端口
     */
    public static int getPort() {
        return port;
    }

    /**
     * 获取登录用户名
     *
     * @return username 登录用户名
     */
    public static String getUsername() {
        return username;
    }

    /**
     * 获取登录用户密码
     *
     * @return username 登录用户密码
     */
    public static String getPassword() {
        return password;
    }
}

工具类：
封装了从mq上拉取消息，以及发送消息到mq上

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.concurrent.TimeoutException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.GetResponse;
import com.rabbitmq.client.impl.recovery.RecordedQueue;

/**
 * McdRabbitMqUtil
 *
 * @since 2019/12/3
 */
@Component
public final class RabbitMqUtil {
    private static final Logger logger = LoggerFactory.getLogger(RabbitMqUtil.class);

    private RabbitMqUtil() {
    }

    /**
     * 根据序列名称、taskinfo字符串发送rabbit信息
     *
     * @param queueName queueName
     * @param taskInfo  taskInfo
     * @throws IOException      IOException
     * @throws TimeoutException TimeoutException
     */
    public static void sendMessageByQueueNameAndTaskInfo(String queueName, String taskInfo) {
        Connection connection = null;
        Channel channel = null;
        try {
            //  获取一个连接
            connection = RabbitMqConnectionFactory.getConnection();
            //  从连接中获取一个通道
            channel = connection.createChannel();
            //  创建队列声明。第二个参数为true，表示序列持久化； 第二个参数为false，表示不进行序列持久化
            channel.queueDeclare(queueName, true, false, false, null);

            //  发送消息。第三个参数设置为MessageProperties.PERSISTENT_TEXT_PLAIN，表示消息持久化
            channel.basicPublish(RecordedQueue.EMPTY_STRING, queueName, null, taskInfo.getBytes("utf-8"));
            logger.info(" [x] Sent '{}'", taskInfo);
        } catch (IOException e) {
            logger.error("IO Exception {}", e);
            throw new CommonException("IO Exception");
        } finally {
            RabbitMqConnectionFactory.closeResource(connection, channel);
        }
    }

    /**
     * 根据队列名称消费消息
     *
     * @param queueName queueName
     * @return String message
     */
    public static String receiveMessageByQueueName(String queueName) {

        GetResponse responseMessage = null;
        Connection connection = null;
        Channel channel = null;
        try {
            //  获取连接
            connection = RabbitMqConnectionFactory.getConnection();
            //  创建频道
            channel = connection.createChannel();
            //  自动确认消息
            boolean autoAck = true;

            //  队列声明
            channel.queueDeclare(queueName, true, false, false, null);

            responseMessage = channel.basicGet(queueName, autoAck);

        } catch (IOException e) {
            logger.error("IO Exception {}", e);
            throw new CommonException("IO Exception");
        } finally {
            RabbitMqConnectionFactory.closeResource(connection, channel);
        }

        //  定义返回结果数据
        String result = "";
        if (null != responseMessage) {
            try {
                result = new String(responseMessage.getBody(), "UTF-8");
                String ip = null;
                String host = null;
                try {
                    InetAddress ia = InetAddress.getLocalHost();
                    //  获取计算机主机名
                    host = ia.getHostName();
                    //  获取计算机IP
                    ip = ia.getHostAddress();
                } catch (UnknownHostException e) {
                    logger.error("UnknownHost Exception {}", e);
                }
                sendMessageByQueueNameAndTaskInfo("MESSAGE-MONITOR", result + "|" + ip + "|" + host);
            } catch (UnsupportedEncodingException e) {
                logger.error("UnsupportedEncoding Exception {}", e);
                throw new CommonException("UnsupportedEncoding Exception");
            }

        }
        return result;

    }
}

使用：
设置定时任务，定时去mq上取消息，然后处理

import java.io.IOException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import com.fasterxml.jackson.databind.ObjectMapper;
/**
 * 子任务队列中接收消息，进行处理
 *
 * @author ryz
 * @since 2020-05-11
 */
@Component
public class SubTask {

    private static final Logger LOGGER = LoggerFactory.getLogger(SubTask.class);

    @Value("${engine.version.name}")
    private String EngineVersionName;

    @Value("${engine.version.code}")
    private String EngineVersionCode;


    @Autowired
    private AnalysisEngineService analysisEngineService;
	//30秒执行一次
    @Scheduled(fixedRate = 30000)
    public void process() throws IOException {
        String queueName = EngineVersionName + "-" + EngineVersionCode;
        String msg = RabbitMqUtil.receiveMessageByQueueName(queueName);
        if (StringUtil.isEmpty(msg)) {
            LOGGER.info(queueName + " is empty...");
            return;
        }
        //消息转成对应的bean
        TaskDto hapInfo = new ObjectMapper().readValue(msg, TaskDto.class);
        analysisEngineService.doService(hapInfo);
    }
}
RabbitMQ工具类及测试类(完整版)
12-24
RabbitMQClientUtil是MQ的测试工具类，他封装了fanout、direct、topic三种exchange模式，并包括发送数据和接收数据。 Test1、Test2是测试类 使用maven管理，在pom.xml文件中引入如下代码： <!-- Rabbitmq工具包 --> com.rabbitmq amqp-client 3.6.5 rabbitmq.properties配置文件根据自己需要自行放在，放置完毕后，请自己修改util中的文件地址
队列工厂之RabbitMQ
weixin_34239169的博客
03-14 147
本次和大家分享的是RabbitMQ队列的用法，前一篇文章队列工厂之(MSMQ)中在描述的时候已经搭建了简单工厂，因此本章内容是在其之上扩充的子项不再过多讲解工厂的代码了；RabbitMQ应该是现在互联网公司消息队列用的最多的一种之一吧，看看招聘基本都会有这个单词的出现，她相比前一篇分享的MSMQ来说配置更多样化，安装步骤数两者都差不多吧，最大差别MSMQ是windows捆绑的服务几乎只能在wind...
调用RabbitMQ工具类Sender在Controller中完成消息发送
最新发布
ll2695015910的博客
10-09 1800
hi() 和 hello1() 方法 使用第一个 send()，通过默认交换器发送消息，直接使用路由键进行简单路由。hello2() 方法 使用第二个 send()，通过自定义交换器和路由键发送消息，支持更加灵活的消息路由。由此我们可以知道，
在 Windows 上安装Rabbit MQ 指南
weixin_34220623的博客
11-01 151
rabbitMQ是一个在AMQP协议标准基础上完整的，可服用的企业消息系统。他遵循Mozilla Public License开源协议。采用 Erlang 实现的工业级的消息队列(MQ)服务器。      RabbitMQ的官方站：http://www.rabbitmq.com/        AMQP(高级消息队列协议) 是一个异步消息传递所使用的应用层协议规范，作为线路层协议，而不是API（...
RabbitMq
Sy000223的博客
11-26 1355
1、界面管理 2、代码实现点对点的消息发送与消费 /** * @author Suny * @data 2021/11/1 20:36 * @description 生产者 */ public class ProducerDemo01 { public static void main(String[] args) throws Exception { //创建mq的链接工厂 ConnectionFactory factory = new Connection
RabbitMQ基础知识
J789456_154的博客
04-02 247
我了解到的是，mq（message queue）既消息队列，他可以加速消息的传输，举个例子。例如：在淘宝网买手机，一时间有成千上万的提交量，这时候就会用到mq，可以完成大量数据的交易，保证订单的无误性。RobbitConfig是一些通道的配置，这里也体现了springboot的便捷，可以不用配置工厂。，至于为什么非要写到test中，这个是固定的，写那里其实无所谓但是写到test是普遍认同的。先建立maven工程。第三部分：创建消费者！有两个监听者，和一个发布者，例如：一个up主，2个粉丝的关系。
RabbitMQ工具类实现配置文件动态创建队列和绑定
02-21
本篇文章将重点讲解如何使用RabbitMQ结合Java实现一个工具类，动态地根据配置文件创建队列和绑定。 首先，我们需要了解RabbitMQ的基本概念。在RabbitMQ中，队列（Queue）是存储消息的地方，生产者（Producer）发送...
C# RabbitMQ Helper 帮助类
10-25
2. **连接管理**：该帮助类提供了便捷的连接工厂，能够自动管理和恢复与RabbitMQ服务器的连接，确保服务的稳定性和可靠性。 3. **频道操作**：简化了通道的创建和关闭，避免了手动管理通道可能导致的资源泄露问题。...
RabbitMQ-分布式消息队列（C#实例、文档、工具类）
08-30
在这个“RabbitMQ-分布式消息队列”资源包中，包含了C#语言的实例、相关文档以及可能的工具类，帮助开发者更高效地理解和应用RabbitMQ。 1. **RabbitMQ基本概念**： - **消息队列**：消息队列是RabbitMQ的核心，它...
基于RabbitMQ的Java工具类动态管理队列与绑定策略
资源摘要信息:"本文档重点讲述如何使用RabbitMQ工具类通过配置文件动态创建队列和绑定的过程。首先需要了解RabbitMQ的基本概念和Java中的RabbitMQ客户端库的使用方法。RabbitMQ是一种广泛使用的开源消息代理软件，它...
C#版本高性能RabbitMQ帮助类
03-24
本篇将详细介绍C#版本下如何构建高性能的RabbitMQ帮助类，以便更好地利用这一强大的工具。 首先，我们需要理解RabbitMQ的基本概念。RabbitMQ是一个基于AMQP（Advanced Message Queuing Protocol）协议的消息代理，...
Rabbitmq工具类，java工具类RabbitmqUtil
10-29
1、java工具类RabbitmqUtil是本人封装好的直接使用 2、常用的方法都在里面 3、改一下初始化配置参数就行
RabbitMQ工具类封装实现
10-26
封装了RabbitMQ的订阅者线程和发布者线程（还有个初始化工厂的连接工具类），另外附加一个安卓的使用demo
RabbitMQ抽取连接工厂工具类
Leon_Jinhai_Sun的博客
01-20 332
RabbitMQ抽取连接工厂工具类
RabbitMQ_Java
Mudrock__的博客
11-23 659
未整合SpringBoot的原生Java与RabbitMQ
RabbitMQ实战
InterceptWall的博客
08-28 2204
解耦：在项目启动之初来预测将来会碰到什么需求是极其困难的。消息中间件在处理过程中间插入了一个隐含的、基于数据的接口层，两边的处理过程都要实现这一接口，这允许你独立地扩展或修改两边的处理过程，只要确保它们遵守同样的接口约束即可冗余〈存储) 有些情况下，处理数据的过程会失败。消息中间件可以把数据进行持久化直到它们已经被完全处理，通过这一方式规避了数据丢失风险。在把 个消息从消息中间件中删除之前，需要你的处理系统明确地指出该消息己经被处理完成，从而确保你的数据被安全地保存直到你使用完毕。...
RabbitMQ学习笔记四：连接工具类的封装
weixin_45020617的博客
07-11 503
1.创建连接工具类 import com.rabbitmq.client.Channel; import com.rabbitmq.client.Connection; import com.rabbitmq.client.ConnectionFactory; /** * 连接工具类 */ public class RabbitMQUtils { private static ConnectionFactory factory; static { //类加载时
RabbitMQ Java搭建实战——简单模式
qq_38063429的博客
01-07 280
首先添加maven依赖 <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>5.6.0</version> </dependency> 编写消息生产者 编写消息生产者ProducerHelloWord import com.rabbitmq.client.Ch
Rabbitmq生产者与消费者
iummiw的博客
04-11 1675
新建maven项目 导入依赖 <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>5.14.2</version> </dependency> 编写生产者 // 1.设置参数 ConnectionFa
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值
>