RabbitMQ组件封装

最新推荐文章于 2024-06-12 02:37:29 发布
最新推荐文章于 2024-06-12 02:37:29 发布
阅读量2.6k 收藏 16
点赞数 2
分类专栏： rabbitmq java 文章标签： rabbitmq 分布式 java elastic-job zookeeper
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43636291/article/details/122093458
版权

1.组件需求

需求：需要单独设计一个模块用来封装rabbitmq 其他应用之间引用，做简单少量的配置,即可发送消息，消息的发送要保证可靠的投递

2.组件架构选型

消息组件：rabbitMQ
消息可靠性保证：使用elasticjob查询数据库相关表记录来对消息进行可靠投递

3.模块分类请添加图片描述

相关依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <modules>
        <module>rabbit-common</module>
        <module>rabbit-api</module>
        <module>rabbit-core-producer</module>
        <module>rabbit-task</module>
        <module>rabbit-test</module>
    </modules>
    <parent>
        <artifactId>spring-boot-starter-parent</artifactId>
        <groupId>org.springframework.boot</groupId>
        <version>2.1.5.RELEASE</version>
        <relativePath/>
    </parent>
    <groupId>cn.xp.rabbitmq.parent</groupId>
    <artifactId>rabbitmq-parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <name>rabbit-parent</name>
    <packaging>pom</packaging>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <java.version>8</java.version>
        <fasterxml.uuid.version>3.1.4</fasterxml.uuid.version>
        <org.codehaus.jackson.version>1.9.13</org.codehaus.jackson.version>
        <druid.version>1.0.24</druid.version>
        <elastic-job.version>2.1.4</elastic-job.version>
        <guava.version>20.0</guava.version>
        <commons-fileupload.version>1.2.2</commons-fileupload.version>
        <commons-lang3.version>3.3.1</commons-lang3.version>
        <commons-io.version>2.4</commons-io.version>
        <commons-collections.version>3.2.2</commons-collections.version>
        <curator.version>2.11.0</curator.version>
        <fastjson.version>1.1.26</fastjson.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>${guava.version}</version>
        </dependency>
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>${commons-fileupload.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>${commons-io.version}</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson.version}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-mapper-asl</artifactId>
            <version>${org.codehaus.jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.uuid</groupId>
            <artifactId>java-uuid-generator</artifactId>
            <version>${fasterxml.uuid.version}</version>
        </dependency>
    </dependencies>



</project>

1.rabbit- api

请添加图片描述
1.message消息传输类

package com.xp.rabbitmq.api;

import lombok.Data;

import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;

/**
 * @Author xp
 * @Description 消息类
 **/
@Data
public class Message implements Serializable {
    /* 消息的ID*/
    private String messageId;

    /* 消息的主题/消息的交换机 */
    private String messageTopic="";

    /*消息的路由规则*/
    private String messageRouteKey="";


    /*消息的属性*/
    private Map<String,Object> messageAttribute=new HashMap<>();

    /*消息类型:默认是确认模式*/
    private String messageType=MessageType.CONFIRM;

    /*消息延迟时间*/
    private Long messageDelay;

    public Message() {
    }

    public Message(String messageId, String messageTopic, String messageRouteKey, Map<String, Object> messageAttribute, String messageType, Long messageDelay) {
        this.messageId = messageId;
        this.messageTopic = messageTopic;
        this.messageRouteKey = messageRouteKey;
        this.messageAttribute = messageAttribute;
        this.messageType = messageType;
        this.messageDelay = messageDelay;
    }

    public Message(String messageId, String messageTopic, String messageRouteKey, Map<String, Object> messageAttribute, Long messageDelay) {
        this.messageId = messageId;
        this.messageTopic = messageTopic;
        this.messageRouteKey = messageRouteKey;
        this.messageAttribute = messageAttribute;
        this.messageDelay = messageDelay;
    }
}

2.使用建造者模式构造message—MessageBuilder

package com.xp.rabbitmq.api;

import com.xp.rabbitmq.exception.MessageRuntimeException;
import org.apache.commons.lang3.StringUtils;

import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

/**
 * @Author xp
 * @Description 建造者模式：链式创建对象
 **/
public class MessageBuilder {
    /* 消息的ID*/
    private String messageId;
    /* 消息的主题 */
    private String messageTopic;
    /*消息的路由规则*/
    private String messageRouteKey="";
    /*消息的属性*/
    private Map<String,Object> messageAttribute=new HashMap<>();
    /*消息类型:默认是确认模式*/
    private String messageType=MessageType.CONFIRM;
    /*消息延迟时间*/
    private Long messageDelay;

    public MessageBuilder() {
    }

    public static MessageBuilder builder(){
        return new MessageBuilder();
    }

    public MessageBuilder withMessageId(String messageId){
        this.messageId=messageId;
        return this;
    }

    public MessageBuilder withMessageTopic(String messageTopic){
        this.messageTopic=messageTopic;
        return this;
    }

    public MessageBuilder withMessageRouteKey(String messageRouteKey){
        this.messageRouteKey=messageRouteKey;
        return this;
    }

    public MessageBuilder withMessageAttributes(Map<String,Object> messageAttribute){
        this.messageAttribute=messageAttribute;
        return this;
    }
    public MessageBuilder withMessageAttribute(String key,Object properties){
        this.messageAttribute.put(key,properties);
        return this;
    }
    public MessageBuilder withMessageType(String messageType){
        this.messageType=messageType;
        return this;
    }
    public MessageBuilder withMessageDelay(Long messageDelay){
        this.messageDelay=messageDelay;
        return this;
    }
    public Message build(){
        if(StringUtils.isEmpty(this.messageId)){
            this.messageId= UUID.randomUUID().toString();
        }
        if(StringUtils.isEmpty((this.messageTopic))){
            throw new MessageRuntimeException("消息主题不能为空");
        }

        Message message=new Message(messageId,messageTopic,messageRouteKey,messageAttribute,messageType,messageDelay);

        return message;
    }


}

3.消息发送类MessageProducer

package com.xp.rabbitmq.api;

import com.xp.rabbitmq.exception.MessageRuntimeException;

import java.util.List;

/*
消息发送接口
 */
public interface MessageProducer {

    void send(Message message) throws MessageRuntimeException;
    void send(Message message,SendCallback sendCallback) throws MessageRuntimeException;
    void send(List<Message> messageList) throws MessageRuntimeException;
    void send(List<Message> messageList,SendCallback sendCallbackList) throws MessageRuntimeException;


}

4.消息分类MessageType

package com.xp.rabbitmq.api;

/**
 * @Author xp
 * @Description 消息类型
 **/
public class MessageType {
    /* 快速消息：不用确认，不用必须可靠 */
    public static final String RAPID="0";

    /* 确认消息：需要回调确认*/
    public static final String CONFIRM="1";


    /* 可靠消息：必须保证消息发送*/
    public static final String RELIABLE="2";

}

5.相关异常处理

package com.xp.rabbitmq.exception;

/**
 * @Author xp
 * @Description 消息未严格封装异常类
 **/
public class MessageException extends Exception{

    public MessageException() {
        super();
    }
    public MessageException(String exception) {
        super(exception);
    }
    public MessageException(String exception,Throwable throwable) {
        super(exception,throwable);
    }
    public MessageException(Throwable throwable) {
        super(throwable);
    }




}

package com.xp.rabbitmq.exception;

/**
 * @Author xp
 * @Description 运行时异常
 **/
public class MessageRuntimeException extends RuntimeException{
    public MessageRuntimeException() {
        super();
    }
    public MessageRuntimeException(String exception) {
        super(exception);
    }
    public MessageRuntimeException(String exception,Throwable throwable) {
        super(exception,throwable);
    }
    public MessageRuntimeException(Throwable throwable) {
        super(throwable);
    }
}

2.rabbit-common

请添加图片描述
包含消息进行序列化 反序列化处理
1.序列化接口Serializer

package com.xp.rabbit.common.serializer;

public interface Serializer {
    //对象序列化为byte数组
    byte[] serializerRaw(Object object);
    //对象序列化string
    String serializer(Object object);
    //string反序列化对象
    <T>T deserializer(String content);
    //数组反序列化对象
    <T>T deserializer( byte[] content);
}

2.相关实现 SerializerImpl

package com.xp.rabbit.common.impl;

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.xp.rabbit.common.serializer.Serializer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;


/**
 * @Author xp
 * @Description
 **/
public class SerializerImpl implements Serializer {
    private static final Logger LOGGER= LoggerFactory.getLogger(SerializerImpl.class);
    private static final ObjectMapper mapper=new ObjectMapper();
    static {
        mapper.disable(SerializationFeature.INDENT_OUTPUT);
        mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
        mapper.configure(JsonParser.Feature.ALLOW_COMMENTS,true);
        mapper.configure(JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER,true);
        mapper.configure(JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS,true);
        mapper.configure(JsonParser.Feature.ALLOW_NUMERIC_LEADING_ZEROS,true);
        mapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES,true);
        mapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS,true);
        mapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES,true);
    }

    private final JavaType type;

    public SerializerImpl(JavaType type) {
        this.type = type;
    }

    public static SerializerImpl createParametricType(Class<?> cls){
        return new SerializerImpl(mapper.getTypeFactory().constructType(cls));
    }

    @Override
    public byte[] serializerRaw(Object object) {
        try{
            return mapper.writeValueAsBytes(object);
        }catch (JsonProcessingException e){
            LOGGER.error("序列化出错",e);
        }
        return null;
    }

    @Override
    public String serializer(Object object) {
        try{
            return mapper.writeValueAsString(object);
        }catch (JsonProcessingException e){
            LOGGER.error("序列化出错",e);
        }
        return null;
    }

    @Override
    public <T> T deserializer(String content) {
        try{
            return mapper.readValue(content,type);
        }catch (IOException e){
            LOGGER.error("反序列化出错",e);
        }
        return null;
    }

    @Override
    public <T> T deserializer(byte[] content) {
        try{
            return mapper.readValue(content,type);
        }catch (IOException e){
            LOGGER.error("反序列化出错",e);
        }
        return null;
    }
}

3.单例工厂模式产生序列化对象

package com.xp.rabbit.common.serializer;

/**
 * @Author xp
 * @Description
 **/
public interface SerializerFactory {

    Serializer create();
}



package com.xp.rabbit.common.impl;

import com.xp.rabbit.common.serializer.Serializer;
import com.xp.rabbit.common.serializer.SerializerFactory;
import com.xp.rabbitmq.api.Message;

/**
 * @Author xp
 * @Description
 **/
public class SerializerFactoryImpl implements SerializerFactory {
    public static final SerializerFactoryImpl INSTANCE=new SerializerFactoryImpl();
    @Override
    public Serializer create() {
        return SerializerImpl.createParametricType(Message.class);
    }
}

4.对象转json类

package com.xp.rabbit.common.util;

import java.util.ArrayList;
import java.util.List;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;

/**
 * 	$FastJsonConvertUtil java对象与json进行转换的通用工具类
 * 
 *
 */
public class FastJsonConvertUtil {

	private static final SerializerFeature[] featuresWithNullValue = { SerializerFeature.WriteMapNullValue, SerializerFeature.WriteNullBooleanAsFalse,
	        SerializerFeature.WriteNullListAsEmpty, SerializerFeature.WriteNullNumberAsZero, SerializerFeature.WriteNullStringAsE
最低0.47元/天 解锁文章
我就是我，是不一样的烟火
关注
  • 2
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
springboot微服务： 整合 RabbitMQ、发送、监听
CTRA®王大大技术中心
11-20 714
一、springboot项目整合RabbitMQ 1、引入POM <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 2、改 yaml （properties） spring.rabbitmq.host=192.168.159.13
c# RabbitMQ封装类，连接发送接收解析都支持
07-23
c# RabbitMQ封装类，连接发送接收解析都支持
RabbitMQ安装配置，封装工具类，发送消息及监听，延迟消息
最新发布
qq_30166465的博客
06-12 477
【代码】RabbitMQ配置及工具类。
基于NetCore的RabbitMQ使用
weixin_43872830的博客
12-25 3051
NetCore中集成RabbitMQ的使用
工具篇7--RocketMq消息模型介绍
拽着尾巴的鱼儿的博客
06-27 1499
作为一个国产的消息中间件，阿里参考Kafka 开发了RocketMq 进行消息通信，它具有分布式，高可用、高吞吐、可伸缩的特性，本文对于其模型进行探究；模型图中已经展示了RocketMq的几个重要组件，与kafka 不同的是这里多出了一个叫NameServer的组件；对broker 进行维护，并对消息消息进行路由；
rabbitMQ封装c#
08-23
rabbitmq封装，采用连接池，频道也是采用连接池。减少频繁连接造成的资源消耗。如果代码有误的地方请指出。
消息中间件之RabbitMQ（二）java API的使用
陆林烽的博客
08-05 331
目录java API编程简单实例amqp client 方法参数说明RabbitMQ 常见配置TTL（Time To Live）消息的过期时间死信队列优先队列延迟队列服务端流控（Flow Control)消费端限流Spring 集成 RabbitMQSpringBoot 集成 RabbitMQ java API编程 简单实例 引入pom <dependency> <groupId>com.rabbitmq</groupId> <artifactId&gt
RabbitMQ工具类封装实现
10-26
本篇文章将重点讲解如何进行RabbitMQ的工具类封装，以及在Android环境下的使用。 首先，`MQSubscribeService.java`代表的是订阅者服务，它是接收和处理来自RabbitMQ的消息的组件。在封装订阅者线程时，通常会包括...
RabbitMQ封装.rar
09-17
交换机是RabbitMQ中处理消息的关键组件。它可以有不同的类型，如直接（direct）、主题（topic）、头部（headers）和扇出（fanout）。封装时，可以创建方法来根据需求创建指定类型的交换机。 3. **创建队列** 队列...
C#的Demo项目：RabbitMQ封装和使用
05-23
交换机是RabbitMQ中的核心组件，它决定了消息如何路由到队列。 1. **Direct Exchange**（直连交换机）：最简单的交换机类型，按照路由键（Routing Key）将消息精确地投递给对应的队列。在C#项目中，可以创建一个...
tp6使用rabbitmq
09-22
6. **创建消费者**：消费者是接收并处理队列中消息的组件。同样需要创建一个服务，建立AMQP连接和通道，然后使用`basic_consume`方法监听队列。消费者通常在一个无限循环中运行，当有新消息时，会触发回调函数来处理...
封装好的mqtt和rabbitmq可以直接使用
12-08
设备通过rabbitmq推送一条消息给mqtt服务器 mqtt服务器收到消息后设备进行上线或下线操作，上线后对mqtt客户端进行缓存，缓存后定时上报数据给第三方平台
springboot使用rabbitmq工具类
03-29
springboot使用rabbitmq工具类,里面包含比较原生的方法,还有一套是我结合springboot框架写的一套方法,里面有两个方法,看情况使用,一般使用框架的方法比较好,因为框架方法时前辈们封装好经过检验的没有问题的方法,自己写的方法比较简陋,参考下原理即可.
RabbitMQ-Java 简单使用
qq_50523945的博客
05-30 1631
参考非常详细的博主教程：https://www.cnblogs.com/dtdx/p/14362760.htmlSpringBoot+Java 版教程：https://blog.csdn.net/lgl782519197/article/details/1137755691、IDEDA内构建一个maven工程（jdk1.8）2：导入rabbitmq的maven依赖3：启动rabbitmq-server服务4：定义生产者、定义消费者。
RabbitMQ---消息中间件
未来的博客
04-20 160
RabbitMQ—消息中间件 1、什么是MQ？ MQ全称 Message Queue（消息队列），是在消息的传输过程中保存消息的容器。多用于分布式系统之间进行通信。 是一个开源的消息代理和队列服务器，用来通过普通协议在完全不同的应用之间共享数据。使用 Erlang 语音编写，基于 AMQP 协议。 2、MQ的优缺点 优点： 应用解耦：提高系统容错性和可维护性。 异步提速：提升用户体验和系统吞吐量。 削峰填谷：提高系统稳定性。 缺点： 系统可用性降低。 系统引用的外部依赖越多，系统稳定性越差，一旦
2.1 ：封装rabbitmq
qq_44949002的博客
05-17 557
架构封装得思考何时调用开发者的方法，开发者的思想是如何处理 1.定义交换机的名字和事件常量 public interface EventConstact { /** * 交换机的名称 */ String EXCHANGE_NAME = "event-exchange"; /** * 事件类型常量 */ String EVENT_LOGIN = "login";//用户登录事件 String EVENT_HOTAL_INS
springboot中rabbitmq集成——多项目
坤哥的博客
04-08 4428
这里以两个项目为例，一个消息的生产者，一个消息的消费者，接着上篇单项目的讲。目录结构： rabbitmq作为消息生产者，发送消息。rabbitmqreceiver消息的接收者，消费消息。 发送字符串的时候在两个项目之间是没问题的，大家可以自己测试。发送端代码： public void run(String... args) throws Exception { User us
SpringCloud（6）— RabbitMQ(消息队列)
shaopengjie的博客
12-13 1504
MQ（MessageQueue）,中文含义为消息队列，用来存放消息，也就是事件驱动模式中的 BrokerRabbitMQ：现阶段使用最多的MQ技术，优点在于消息的低延迟和可靠性ActiveMQ：开发语言基于Java,可以进行深度定制RocketMQ：开发语言基于Java,可以进行深度定制，阿里巴巴开发Kafka：单机吞吐量很高，但消息可靠性不高。RabbitMQ通过 VirtualHost 进行隔离，相互不可见。RabbitMQ中的相关概念channel：操作MQ的工具。
较完善的rabbitmq消息队列工具类
zhiqiang_zhao
05-13 1464
包含： 1 生产者补单队列 2 生产者重试机制 3 消费者重试机制 4 可靠性投递，最终事务一致原则 5 消费端限流 （服务端限流内存和磁盘配置此处不涉及） rabbitConfig全局配置 package org.jeecg.boot.starter.rabbitmq.config; import lombok.extern.slf4j.Slf4j; import org.springframework.amqp.core.Message; import org.springframe
springboot封装了几个
05-13
Spring Boot 封装了很多常用的功能和组件，包括： 1. 自动配置：根据 classpath 中的依赖自动配置 Spring 环境，无需手动配置。 2. 嵌入式 Web 服务器：Spring Boot 内置 Tomcat、Jetty 或 Undertow 等嵌入式 Web 服务器，无需手动部署。 3. Spring MVC：Spring Boot 集成了 Spring MVC，支持 RESTful API。 4. 数据库访问：Spring Boot 集成了 Spring Data JPA 和 Spring JDBC，支持多种数据库操作。 5. 缓存支持：Spring Boot 集成了多种缓存框架，包括 Ehcache、Redis、Caffeine 等。 6. 消息队列：Spring Boot 集成了多种消息队列，包括 RabbitMQ、Kafka 等。 7. 安全框架：Spring Boot 集成了 Spring Security，提供了身份认证和授权功能。 8. 监控和管理：Spring Boot 集成了 Actuator，提供了应用程序的监控和管理功能。 除此之外，Spring Boot 还提供了很多其他的功能和组件，例如邮件发送、定时任务、文件上传、Web Socket 等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值