RABBIT MQ 连接服务配置

最新推荐文章于 2024-06-10 11:34:48 发布
最新推荐文章于 2024-06-10 11:34:48 发布
阅读量1.3k 收藏
点赞数
分类专栏： 日常小结 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wsen1988/article/details/80354755
版权

maven   pom: 

<!-- RABBIT MQ -->
<dependency>
<groupId>org.springframework.amqp</groupId>
<artifactId>spring-amqp</artifactId>
<version>1.1.4.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.amqp</groupId>
<artifactId>spring-rabbit</artifactId>
<version>1.1.4.RELEASE</version>
</dependency>

<!-- RABBIT MQ END -->

mq 主配置文件： spring-rabbit.xml

<?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.1.xsd" >

    <description>rabbitmq 连接服务配置</description>

    <bean id="propertyConfigurerForRabbit"
          class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="order" value="3"/>
        <property name="systemPropertiesModeName" value="SYSTEM_PROPERTIES_MODE_OVERRIDE"/>
        <property name="ignoreResourceNotFound" value="true"/>
        <property name="ignoreUnresolvablePlaceholders" value="true"/>
        <property name="locations">
            <list>
                <value>file:/app/SFiles/ultron/install/rabbit.properties</value>
            </list>
        </property>
    </bean>

    <!-- 连接配置 --><!-- 172.30.16.93 -->
    <rabbit:connection-factory id="connectionFactory" 
    addresses="${rabbit.addresses}" 
    username="${rabbit.user}" 
    password="${rabbit.pwd}" />
    <rabbit:admin connection-factory="connectionFactory" />

    <!-- spring template声明-->
    <rabbit:template id="amqpTemplate" connection-factory="connectionFactory"  message-converter="jsonMessageConverter" />

    <!-- 消息对象json转换类 -->

    <bean id="jsonMessageConverter" class="org.springframework.amqp.support.converter.JsonMessageConverter" />

<!-- 创建生产者 -->
    <rabbit:queue id="send_coupon_by_scenario_queue" name="send_coupon_by_scenario_queue" durable="true" auto-delete="false" exclusive="false" />
<rabbit:queue id="open_account_queue" name="open_account_queue" durable="true" auto-delete="false" exclusive="false" />

<rabbit:direct-exchange name="direct-exchange" durable="true" auto-delete="false" id="direct-exchange">
<rabbit:bindings>
<!-- <rabbit:binding queue="send_coupon_single_queue" key="send_coupon_single_queue" /> -->
<rabbit:binding queue="send_coupon_by_scenario_queue" key="send_coupon_by_scenario_queue" />
<rabbit:binding queue="open_account_queue" key="open_account_queue" />
</rabbit:bindings>
</rabbit:direct-exchange>


<rabbit:listener-container connection-factory="connectionFactory" acknowledge="manual" concurrency= "${listener.concurrency}">
<!-- 指定消费者 -->
<rabbit:listener queues="send_coupon_by_scenario_queue" ref="couponSendByScenarioListener" />
<rabbit:listener queues="open_account_queue" ref="acctOpenAccountMQListener" />
</rabbit:listener-container>

</beans>

rabbit.properties

rabbit.addresses=10.25.76.64:5672
rabbit.user=dev
rabbit.pwd=dev123
listener.concurrency=2

spring启动加载spring-rabbit.xml配置文件

<import resource="classpath:spring-rabbit.xml" />

具体实现 ： 

定义接口： Producer

package com.phzc.ubs.service.rabbit;
public interface Producer<M> {
void produce(String qKey, M m);
void setQueueName(String qName);

}

定义实体类 ： OpenAccountMsg 

package com.phzc.ubs.service.core.pasx.rabbit;
/**
 * 开户信息 mq 
 */
public class OpenAccountMsg {
    private String custId;
    private String custInfo;
    private String acctName;    

    public String getAcctName() {
        return acctName;
    }
    public void setAcctName(String acctName) {
        this.acctName = acctName;
    }
    public String getCustId() {
return custId;
    }
    public void setCustId(String custId) {
this.custId = custId;
    }
    public String getCustInfo() {
return custInfo;
    }
    public void setCustInfo(String custInfo) {
this.custInfo = custInfo;
    }
    @Override
    public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("OpenAccountMsg [");
if (custId != null)
   builder.append("custId=").append(custId).append(", ");
if (custInfo != null)
   builder.append("custInfo=").append(custInfo).append(", ");
if (acctName != null)
   builder.append("acctName=").append(acctName);
builder.append("]");
return builder.toString();
    }
}


定义实现 ： OpenAccountProducer 

package com.phzc.ubs.service.core.pasx.rabbit;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.phzc.ubs.service.rabbit.Producer;

@Component
public class OpenAccountProducer implements Producer<OpenAccountMsg>{
private static Logger logger = LoggerFactory.getLogger(OpenAccountProducer.class);
private static final String DEFAULT_QUEUE_NAME = "open_account_queue";
private String queueName = DEFAULT_QUEUE_NAME;
@Autowired
        private AmqpTemplate amqpTemplate;

@Override
public void produce(String qKey, OpenAccountMsg msg) {
if (StringUtils.isEmpty(qKey)) {
qKey = queueName;
}
logger.info("开户消息：" + msg.toString());
try {
amqpTemplate.convertAndSend(qKey, msg);
} catch (Exception e) {
logger.error("开户异常", e);
}
}

@Override
public void setQueueName(String qName) {
this.queueName = qName;
}
}
 

定义消费者（Listener）： 消费者处理队列内的消息

package com.phzc.ubs.service.core.pasx.rabbit;

import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.core.ChannelAwareMessageListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.alibaba.fastjson.JSON;
import com.rabbitmq.client.Channel;

@Component
public class AcctOpenAccountMQListener implements ChannelAwareMessageListener {
    private static final Logger logger = LoggerFactory.getLogger(AcctOpenAccountMQListener.class);
    @Autowired
    private AcctOpenAccountMQManager acctOpenAccountMQManager;
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
logger.info("=========UBS 开户接收消息：" + message.toString());
try {
   String msgBody = new String(message.getBody());
   OpenAccountMsg openAccountMsg = null;
   if (StringUtils.isNotBlank(msgBody)) {
try {
   openAccountMsg = JSON.parseObject(msgBody, OpenAccountMsg.class);
} catch (Exception e) {
   logger.error("解析消息体出错: " + e.getMessage(), e);
   channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
   return;
}
if (null != openAccountMsg) {
   @SuppressWarnings("unused")
   boolean openFlag = acctOpenAccountMQManager.openAccountForPasxUser(openAccountMsg);
   
           channel.basicAck(message.getMessageProperties().getDeliveryTag(), false); 
}else {
   logger.info("========解析对象出错=======");
   throw new Exception("解析对象出错");
}
   } else {
logger.info("=======开户消息为空=========");
channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
   }
} catch (Exception e) {
    logger.info("======UBS调用ACCT开户处理异常，消息拒绝" +                                         message.getMessageProperties().getDeliveryTag());
   channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
}
    }

}

定义辅助类： 

package com.phzc.ubs.service.core.pasx.rabbit;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.alibaba.fastjson.JSON;
import com.phzc.acct.common.facade.enums.CapTypeEnum;
import com.phzc.acct.common.facade.enums.CuryTypeEnum;
import com.phzc.acct.common.facade.model.DebitAcctInfoAddRequest;
import com.phzc.acct.common.facade.model.DebitAcctInfoResult;
import com.phzc.ubs.common.constants.CommonConstants;
import com.phzc.ubs.common.constants.RespCode;
import com.phzc.ubs.common.dal.model.UsrAcctList;
import com.phzc.ubs.common.facade.enums.AcctTypeEnum;
import com.phzc.ubs.common.integration.acct.DebitAcctInfoClient;
import com.phzc.ubs.service.core.usracctlist.UsrAcctListService;
import com.phzc.ultron.common.constants.code.systemCode.SysCode;
import com.phzc.ultron.runtime.context.UltronApplicationContext;

@Component
public class AcctOpenAccountMQManager {
    
    private static final Logger logger = LoggerFactory.getLogger(AcctOpenAccountMQManager.class); 
    @Autowired
    private DebitAcctInfoClient debitAcctInfoClient;    
    @Autowired
    private UsrAcctListService usrAcctListService;

    public boolean openAccountForPasxUser(OpenAccountMsg openAccountMsg) throws Exception {
String custId = openAccountMsg.getCustId();
String custInfo = openAccountMsg.getCustInfo();
String acctName = openAccountMsg.getAcctName();
logger.info("============= 本次开户开始=========== custId = "+custId);

DebitAcctInfoAddRequest acctAddRequest = newOneDebitAcctInfoAddRequest(custId, custInfo, acctName);
logger.info("=========UBS调用acct开户接口  上送参数 = " + JSON.toJSONString(acctAddRequest));
DebitAcctInfoResult openAccountResult = debitAcctInfoClient.addDebitAcctInfo(acctAddRequest);
logger.info("=========UBS调用acct开户接口  响应 = " + JSON.toJSONString(acctAddRequest));

if(null!=openAccountResult && RespCode.SUCCESS.getReturnCode().equals(openAccountResult.getRespCode()))         {
   // 创建用户子账号。
   UsrAcctList usrAcctList = new UsrAcctList();
   usrAcctList.setCustId(custId);
   usrAcctList.setSubAcctId(AcctTypeEnum.BASEDA.getCode());
   usrAcctList.setAcctType(AcctTypeEnum.BASEDA.getCode());
   usrAcctList.setDcFlag("D");
   usrAcctList.setAcctAlias("def");
   usrAcctList.setStat("N");
   int count = usrAcctListService.insertAccountInfo(usrAcctList);
   if (count < 1) {
logger.error("=========创建用户子账号 失败=========");
   }    
   logger.info("============= 本次开户正常结束=========== custId = "+custId);    
} else {
   logger.error("=========UBS调用acct开户失败==========");
   throw new Exception("UBS调用acct开户失败");
}
return true;
    }
    /**
     * 创建 开户调用ACCT的对象
     */
   private DebitAcctInfoAddRequest newOneDebitAcctInfoAddRequest(String custId, String custInfo, String acctName) {
DebitAcctInfoAddRequest acctAddRequest = new DebitAcctInfoAddRequest();

acctAddRequest.setCustId(custId);
acctAddRequest.setSubAcctId(AcctTypeEnum.BASEDA.getCode());
acctAddRequest.setCapType(CapTypeEnum.CS.getCode());// 资金类型
acctAddRequest.setCuryType(CuryTypeEnum.CNY.getCode());// 币种
acctAddRequest.setAcctType(AcctTypeEnum.BASEDA.getCode());
acctAddRequest.setAcctName(acctName);
acctAddRequest.setCustInfo(custInfo);
acctAddRequest.setSysId(SysCode.SYS_60033.getCode());
acctAddRequest.setBdepId("phzc");// 业务部门代号-枚举
acctAddRequest.setChkValue(getConfigValue(CommonConstants.GLOBAL_ACCT_MD5_KEY));
return acctAddRequest;
    }

    /**
     * 获取配置
     * 
     * @param key
     * @return
     */
    public static String getConfigValue(String key) {
String value = (String) UltronApplicationContext.getApplicationContext(key);
if (StringUtils.isBlank(value)) {
   logger.info("======获取配置失败：key = " + key);
   return null;
}
return value;
    }
}


代码业务逻辑 ： （生产者生产消息）

@Autowired
private OpenAccountProducer openAccountProducer;

OpenAccountMsg openAccountMsg = new OpenAccountMsg();
openAccountMsg.setCustId("2018051811250001");
openAccountMsg.setCustInfo("oracle");
openAccountMsg.setAcctName("scott");
//开户 -- 消息生产
openAccountProducer.produce(null, openAccountMsg);

结束！！！


wsen1988
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
rabbit mq入门例子
04-10
首先，让我们从安装和配置RabbitMQ开始。在大多数操作系统上，可以通过官方提供的包管理器或者下载二进制文件进行安装。安装完成后，启动RabbitMQ服务器并确保其运行正常。 接下来，我们需要创建一个项目来实践...
rabbitmq 连接、通道及线程池说明和配置
热门推荐
convict_EVA的专栏
09-05 2万+
bean id="connectionFactory" class="org.springframework.amqp.rabbit.connection.CachingConnectionFactory"> property name="host" value="${rabbitmq.host}" /> property name="port" value="${rabbit
Rabbitmq安装以及入门
ifspirt的博客
04-02 3094
rabbitmq安装以及入门
【RabbitMQ】RabbitMQ配置与交换机学习
最新发布
weixin_73588491的博客
06-10 3861
RabbitMQ是一个开源的消息代理软件，它实现了高级消息队列协议（AMQP）。RabbitMQ支持多种消息传递协议，具有高可靠性、高可用性和高性能等特点。它允许应用程序通过消息队列进行异步通信，从而实现解耦和负载均衡。RabbitMQ的核心概念包括交换机（Exchange）、队列（Queue）和绑定（Binding），它们共同构成了消息的路由和传递机制。RabbitMQ的架构如图：publisher：生产者，也就是发送消息的一方consumer：消费者，也就是消费消息的一方queue。
Rabbitmq spring boot的配置参数
qq_20004115的博客
01-29 950
spring.rabbitmq.addresses= # 以逗号分隔的客户端应连接的地址列表 spring.rabbitmq.cache.channel.checkout-timeout= # 如果已达到缓存大小，则等待获取通道的持续时间 spring.rabbitmq.cache.channel.size= # 要在缓存中保留的通道数 spring.rabbitmq.cache.connection.mode=channel # 连接工厂缓存模式 spring.rabbitmq.cache.connec.
RabbitMq消息中间件
xuanliang_cpy的博客
09-03 2230
分布式消息中间件：RabbitMq RabbitMq是最广泛被使用的消息代理，类似于ActiveMq，它是一个分布式的消息中间件。 上图来自于官网：是说RabbitMq迄今已经在全球小型企业和大型企业有超过35000个生产部署。也就是说有35000个产品使用了RabbitMq。它是当今最流行的开源消息代理。它也是一个轻量级的并且可以很容易的部署在本地和云环境。它支持多个消息协议。它也可以部署...
RabbitMQ学习之Linux下安装（一）
人参米
04-26 9039
上述内容是我网上找到的比较好并且很完善的安装帖子，我稍稍加工了一下，如果环境没有出现问题的话，基本上还是会比较顺利的安装成功。 原贴路径：http://www.2cto.com/os/201404/292351.html ------------------------------------------------------------------------------------------------------- 刚刚开始安装必然会经历一个很艰难的过程，特别是和我一样Linux也是菜鸟的童鞋们
工具篇--4.1RabbitMq--常用配置参数详解
拽着尾巴的鱼儿的博客
06-14 7977
控制使用一个 RabbitMQ 连接创建的 channel 数量，即 RabbitMQ 连接池中缓存连接时每个连接中的 channel 的数量，缓存的目的是减少连接和销毁的开销。sring.rabbitmq.cache.channel.checkout-timeout 是 Spring Boot 集成 RabbitMQ 客户端连接工厂（ConnectionFactory）的一个属性，用于设置缓存的通道（channel）请求超时时间。如果系统的性能要求比较高，可以考虑关闭重试功能，或者调整重试参数的值。
Rabbit-MQ-Pika：与python pika库的简单Rabbit MQ连接
02-17
**RabbitMQ与Python Pika库的简单连接详解** RabbitMQ是一款开源的消息队列系统，基于AMQP（Advanced Message ...记住，正确配置和管理RabbitMQ服务器以及合理设计交换机、队列和路由键是充分利用其功能的关键。
详解Node.js amqplib 连接 Rabbit MQ最佳实践
10-17
总之，通过合理配置`connection_name`、正确设定队列属性，以及有效地管理和监控`connection`和`channel`，可以显著提升Node.js应用使用amqplib连接RabbitMQ的效率和稳定性。在实际项目中，务必重视这些最佳实践，以...
rabbit_mq的demo
03-18
在提供的"rabbit"压缩包文件中，可能包含了实现以上步骤的代码示例，如配置连接、创建通道、发送和接收消息等。通过阅读和理解这些代码，开发者可以快速上手RabbitMQ，为自己的应用添加消息队列功能。记住，理解和...
Rabbit MQ整体搭建以及demo.rar
04-08
别忘了重启RabbitMQ服务以应用配置更改： ```bash sudo systemctl restart rabbitmq-server ``` ### 3. 管理界面 RabbitMQ提供了一个内置的Web管理界面，用于监控和管理消息队列。默认情况下，它监听15672端口。...
RabbitMQ学习(七)之ConntectionFactory与Conntection的认知
蜗牛慢爬着的博客
07-15 2488
转载来自:http://blog.csdn.net/zhu_tianwei/article/details/40889101 在发送和接收消息重要的类有：ConnectionFactory， Connection，Channel和 QueueingConsumer。 ConntectionFactory类是方便创建与AMQP代理相关联的Connection；下面来看看Conntection
RabbitMQ客户端消费者是单线程消费的吗？顺带分析RabbitMQ客户端源码解释什么是网络协议
舒航的博客
03-18 4008
下面是RabbitMQ客户端消费者的基本示例。 public class Receive { private final static String QUEUE_NAME = "hello"; public static void main(String[] args) throws IOException, TimeoutException { ConnectionFactory factory = new ConnectionFactory(); f
消息队列4：rabbitmq的配置
火焰
04-18 9523
环境： centos8.2 RabbitMQ 3.8.8 Erlang 23.0 rabbitmq的安装参照： 《linux下安装rabbitmq》 本文参照：https://www.rabbitmq.com/configure.html rabbitmq的安装位置为： /usr/local/rabbitmq 一、rabbitmq的日志文件 rabbitmq的默认日志文件位置为： /usr/local/rabbitmq/var/log/rabbitmq/rabbit@*t.log，如下图所示：
关于ssm框架整合初期项目所需要的依赖基本完整
weixin_44850475的博客
03-01 287
pom.xml中的依赖1.1.<dependencies标签中 代码如下 <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.11</version> <scope>test</scope> </dependency>
rabbitmq多数据源连接配置
年少轻狂的好日子，一懂事就结束
11-16 2158
rabbitmq多数据源配置
Spring注解方式整合RabbitMQ
凉茶铺的博客
11-29 895
介绍了使用spring注解的方式整合RabbitMQ
RabbitMQ——最大连接数
hncscwc的博客
08-30 1万+
默认情况下，rabbitmq文件句柄数设置是1024。连接数最多为829，连接数的具体计算方式为： 连接数=（文件句柄数-100）*0.9，计算后的值取整再减2。 例如：（1024-100）*0.9=831.6，取整831再减2得到829。 真正使用时，1024可能无法满足实际需求。这个时候，一般通过ulimit来调整程序的最大文件句柄数。下图为通过ulimit将文件句柄数调整到1024...
Rabbit MQ实现MQTT
10-20
RabbitMQ是一个开源的消息代理，它支持多种消息协议，包括AMQP、MQTT等。RabbitMQ实现MQTT协议的方法如下： 1. 开启RabbitMQ的MQTT插件，可以使用命令rabbitmq-plugins enable rabbitmq_mqtt来开启。 2. 登录RabbitMQ管理端，访问http://localhost:15672/，使用默认的用户名和密码guest进行登录。 3. 在管理端中创建MQTT的Exchange和Queue，并将它们绑定在一起。 4. 在客户端中使用MQTT协议连接到RabbitMQ，并发送和接收消息。 需要注意的是，RabbitMQ实现MQTT协议需要开启MQTT插件，并在管理端中进行相关配置。同时，客户端也需要使用MQTT协议进行连接和通信。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值