Java简单实现MQ架构和思路01
实现一个 MQ（消息队列）架构可以涉及到很多方面，包括消息的生产和消费、消息的存储和传输、消息的格式和协议等等。下面是一个简单的 MQ 架构的实现示例，仅供参考：
定义消息格式和协议：我们可以定义一个简单的消息格式，比如 JSON 格式，包含消息的 ID、内容、发送时间等信息。同时，我们可以定义一个简单的协议，比如 TCP 协议，用来传输消息。
实现消息的存储：我们可以使用数据库或者文件系统等方式来存储消息。对于消息队列来说，可以考虑使用类似于链表的数据结构来存储消息，每个节点包含一个消息和指向下一个节点的指针。
实现消息的生产和消费：我们可以使用多线程来实现消息的生产和消费。具体地，我们可以定义一个生产者线程和多个消费者线程，生产者线程负责从外部系统中获取消息并存储到消息队列中，消费者线程负责从消息队列中获取消息并进行处理。
实现消息的传输：我们可以使用 TCP 协议来传输消息。具体地，我们可以定义一个服务器程序，负责监听指定的端口号，并接受客户端的连接请求。一旦连接建立，服务器程序就可以和客户端进行数据传输。
综上所述，一个简单的 MQ 架构的实现可以包含以上几个部分。实际上，MQ 的实现还涉及到很多其他方面，比如消息的确认和重试、消息的过期和删除、消息的优先级和分区等等。因此，在实际项目中，需要根据具体的需求和场景来进行设计和实现。
以下是一个简单的 Java 消息队列示例代码，使用了多线程和 TCP 协议：
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.LinkedList;
public class MessageQueue {
private LinkedList<Message> queue = new LinkedList<Message>();
public synchronized void putMessage(Message message) {
queue.add(message);
notifyAll();
}
public synchronized Message getMessage() throws InterruptedException {
while (queue.isEmpty()) {
wait();
}
return queue.removeFirst();
}
public static void main(String[] args) {
MessageQueue queue = new MessageQueue();
Producer producer = new Producer(queue);
Consumer consumer1 = new Consumer(queue);
Consumer consumer2 = new Consumer(queue);
producer.start();
consumer1.start();
consumer2.start();
}
}
class Message implements java.io.Serializable {
private static final long serialVersionUID = 1L;
private String id;
private String content;
public Message(String id, String content) {
this.id = id;
this.content = content;
}
public String getId() {
return id;
}
public String getContent() {
return content;
}
}
class Producer extends Thread {
private MessageQueue queue;
public Producer(MessageQueue queue) {
this.queue = queue;
}
public void run() {
try {
ServerSocket serverSocket = new ServerSocket(9999);
while (true) {
Socket socket = serverSocket.accept();
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
Message message = (Message) ois.readObject();
queue.putMessage(message);
ois.close();
socket.close();
}
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}
class Consumer extends Thread {
private MessageQueue queue;
public Consumer(MessageQueue queue) {
this.queue = queue;
}
public void run() {
try {
while (true) {
Message message = queue.getMessage();
System.out.println("Consumer " + getId() + " got message: " + message.getContent());
Socket socket = new Socket("localhost", 9998);
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.writeObject(message);
oos.close();
socket.close();
}
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
}
}
在这个示例中，我们定义了一个简单的消息队列，使用了一个链表来存储消息。然后，我们定义了一个生产者线程和两个消费者线程，生产者线程负责从外部系统中获取消息并存储到消息队列中，消费者线程负责从消息队列中获取消息并进行处理。我们使用 TCP 协议来传输消息，生产者线程监听端口号 9999，消费者线程通过连接 localhost 的 9998 端口来发送消息。在实际应用中，需要根据具体需求进行修改和扩展。
并在此代码基础上增加 协议类和注释
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.LinkedList;
// 消息队列类
public class MessageQueue {
private LinkedList<Message> queue = new LinkedList<Message>();
// 往队列中添加消息
public synchronized void putMessage(Message message) {
queue.add(message);
notifyAll();
}
// 从队列中取出消息
public synchronized Message getMessage() throws InterruptedException {
while (queue.isEmpty()) {
wait();
}
return queue.removeFirst();
}
// 主函数
public static void main(String[] args) {
MessageQueue queue = new MessageQueue();
Producer producer = new Producer(queue);
Consumer consumer1 = new Consumer(queue);
Consumer consumer2 = new Consumer(queue);
producer.start();
consumer1.start();
consumer2.start();
}
}
// 消息类
class Message implements java.io.Serializable {
private static final long serialVersionUID = 1L;
private String type; // 消息类型，例如：ORDER, PAYMENT, SHIPMENT, 等等
private String content; // 消息内容
private String sender; // 消息发送者
private String receiver; // 消息接收者
// 构造方法
public Message(String type, String content, String sender, String receiver) {
super();
this.type = type;
this.content = content;
this.sender = sender;
this.receiver = receiver;
}
// 返回消息类型
public String getType() {
return type;
}
// 返回消息内容
public String getContent() {
return content;
}
// 返回消息发送者
public String getSender() {
return sender;
}
// 返回消息接收者
public String getReceiver() {
return receiver;
}
}
// 编解码协议类
class Protocol {
public static final String HEADER = "MESSAGE"; // 消息头
public static final String DELIMITER = ":"; // 分隔符
// 将消息编码为字符串
public static String encode(Message message) {
return HEADER + DELIMITER + message.getType() + DELIMITER + message.getContent() + DELIMITER
+ message.getSender() + DELIMITER + message.getReceiver();
}
// 将字符串解码为消息
public static Message decode(String messageString) {
String[] parts = messageString.split(DELIMITER);
return new Message(parts[1], parts[2], parts[3], parts[4]);
}
}
// 生产者线程类
class Producer extends Thread {
private MessageQueue queue;
private ServerSocket serverSocket;
// 构造方法
public Producer(MessageQueue queue) {
this.queue = queue;
}
// 启动线程
public void run() {
try {
serverSocket = new ServerSocket(9999); // 监听端口号9999
while (true) {
Socket socket = serverSocket.accept(); // 接收连接
ObjectInputStream in = new ObjectInputStream(socket.getInputStream()); // 创建输入流
String messageString = (String) in.readObject(); // 读取消息字符串
Message message = Protocol.decode(messageString); // 解码消息
queue.putMessage(message); // 添加消息到队列
in.close(); // 关闭输入流
socket.close(); // 关闭连接
}
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}
// 消费者线程类
class Consumer extends Thread {
private MessageQueue queue;
// 构造方法
public Consumer(MessageQueue queue) {
this.queue = queue;
}
// 启动线程
public void run() {
while (true) {
try {
Message message = queue.getMessage(); // 从队列中取出消息
System.out.println("Received message: " + message.getContent()); // 输出消息内容
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
以下是在上面代码基础上增加消息确认和重试功能：
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.LinkedList;
// 消息队列类
public class MessageQueue {
private LinkedList<Message> queue = new LinkedList<Message>();
// 往队列中添加消息
public synchronized void putMessage(Message message) {
queue.add(message);
notifyAll();
}
// 从队列中取出消息
public synchronized Message getMessage() throws InterruptedException {
while (queue.isEmpty()) {
wait();
}
return queue.removeFirst();
}
// 主函数
public static void main(String[] args) {
MessageQueue queue = new MessageQueue();
Producer producer = new Producer(queue);
Consumer consumer1 = new Consumer(queue);
Consumer consumer2 = new Consumer(queue);
producer.start();
consumer1.start();
consumer2.start();
}
}
// 消息类
class Message implements java.io.Serializable {
private static final long serialVersionUID = 1L;
private String type; // 消息类型，例如：ORDER, PAYMENT, SHIPMENT, 等等
private String content; // 消息内容
private String sender; // 消息发送者
private String receiver; // 消息接收者
private boolean confirmed; // 消息是否已确认
private int retryCount; // 消息重试次数
// 构造方法
public Message(String type, String content, String sender, String receiver) {
super();
this.type = type;
this.content = content;
this.sender = sender;
this.receiver = receiver;
confirmed = false;
retryCount = 0;
}
// 返回消息类型
public String getType() {
return type;
}
// 返回消息内容
public String getContent() {
return content;
}
// 返回消息发送者
public String getSender() {
return sender;
}
// 返回消息接收者
public String getReceiver() {
return receiver;
}
// 返回消息是否已确认
public boolean isConfirmed() {
return confirmed;
}
// 设置消息已确认
public void setConfirmed() {
confirmed = true;
}
// 返回消息重试次数
public int getRetryCount() {
return retryCount;
}
// 增加消息重试次数
public void incrementRetryCount() {
retryCount++;
}
}
// 编解码协议类
class Protocol {
public static final String HEADER = "MESSAGE"; // 消息头
public static final String DELIMITER = ":"; // 分隔符
// 将消息编码为字符串
public static String encode(Message message) {
return HEADER + DELIMITER + message.getType() + DELIMITER + message.getContent() + DELIMITER
+ message.getSender() + DELIMITER + message.getReceiver() + DELIMITER + message.isConfirmed()
+ DELIMITER + message.getRetryCount();
}
// 将字符串解码为消息
public static Message decode(String messageString) {
String[] parts = messageString.split(DELIMITER);
Message message = new Message(parts[1], parts[2], parts[3], parts[4]);
message.setConfirmed(Boolean.parseBoolean(parts[5]));
message.incrementRetryCount();
return message;
}
}
// 生产者线程类
class Producer extends Thread {
private MessageQueue queue;
private ServerSocket serverSocket;
// 构造方法
public Producer(MessageQueue queue) {
this.queue = queue;
}
// 启动线程
public void run() {
try {
serverSocket = new ServerSocket(9999); // 监听端口号9999
while (true) {
Socket socket = serverSocket.accept(); // 接收连接
ObjectInputStream in = new ObjectInputStream(socket.getInputStream()); // 创建输入流
ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream()); // 创建输出流
String messageString = (String) in.readObject(); // 读取消息字符串
Message message = Protocol.decode(messageString); // 解码为消息对象
if (!message.isConfirmed()) { // 如果消息未确认
queue.putMessage(message); // 添加到队列中
}
out.writeObject("ACK"); // 发送确认消息
out.flush();
in.close();
out.close();
socket.close();
}
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace
}
}
}Java简单实现MQ架构和思路01的更多相关文章
- 为什么要用消息队列 及 自己如何设计一个mq架构
1. 解耦:如左图, 系统a因为业务需求需要调用系统b,后续因为业务需求可能需要改代码调用系统c,甚至还要考虑被调用的系统挂了访问超时的问题.耦合性太高! 如右图, 系统a产生一条数据发送到消息队列里 ...
- 手把手教你用redis实现一个简单的mq消息队列（java）
众所周知,消息队列是应用系统中重要的组件,主要解决应用解耦,异步消息,流量削锋等问题,实现高性能,高可用,可伸缩和最终一致性架构.目前使用较多的消息队列有 ActiveMQ,RabbitMQ,Zero ...
- 整理下.net分布式系统架构的思路
最近看到有部分招聘信息,要求应聘者说一下分布式系统架构的思路.今天早晨正好有些时间,我也把我们实际在.net方面网站架构的演化路线整理一下,只是我自己的一些想法,欢迎大家批评指正. 首先说明的是.ne ...
- 高吞吐高并发Java NIO服务的架构（NIO架构及应用之一）
高吞吐高并发Java NIO服务的架构(NIO架构及应用之一) http://maoyidao.iteye.com/blog/1149015 Java NIO成功的应用在了各种分布式.即时通信和中 ...
- Java生鲜电商平台-Java后端生成Token架构与设计详解
Java生鲜电商平台-Java后端生成Token架构与设计详解 目的:Java开源生鲜电商平台-Java后端生成Token目的是为了用于校验客户端,防止重复提交. 技术选型:用开源的JWT架构. 1. ...
- java简单数据类型转化
java简单数据类型,有低级到高级为:(byte,short,char)→int→long→float→double (boolean不参与运算转化) 转化可以分为 低级到高级的自动转化 高级到低级的 ...
- 00：Java简单了解
浅谈Java之概述 Java是SUN(Stanford University Network),斯坦福大学网络公司)1995年推出的一门高级编程语言.Java是一种面向Internet的编程语言.随着 ...
- java简单学生成绩管理系统
题目要求: 一. 数据结构要求:(5 分) 1.定义 ScoreInformation 类,其中包括七个私有变量(stunumber, name, mathematicsscore, englishi ...
- MVC架构模式分析与设计（一）---简单的mvc架构
首先 我要感谢慕课网的老师提供视频资料 http://www.imooc.com/learn/69 下面我来进行笔记 我们制作一个简单的mvc架构 制作第一个控制器 testController.cl ...
- java简单词法分析器(源码下载)
java简单词法分析器 : http://files.cnblogs.com/files/hujunzheng/%E7%AE%80%E5%8D%95%E8%AF%8D%E6%B3%95%E5%88%8 ...
随机推荐
- #组合计数，卢卡斯定理#D 三元组
题目 当\(z=0\)时,\(f(x,y,z)=1\), 否则 \[f(x,y,z)=\sum_{x1=1}^x\sum_{y1=1}^y(x-x1+1)(y-y1+1)f(x1,y1,z-1) \] ...
- Jetty的http3模块
启用http3模块,执行如下命令: java -jar $JETTY_HOME/start.jar --add-modules=http3 命令的输出,如下: ALERT: There are ena ...
- 小师妹学JavaIO之:File copy和File filter
目录 简介 使用java拷贝文件 使用File filter 总结 简介 一个linux命令的事情,小师妹非要让我教她怎么用java来实现,哎,摊上个这么杠精的小师妹,我也是深感无力,做一个师兄真的好 ...
- Git 12 IDEA上传本地项目到远程
这里以上传 Spring 开源项目到 Gitee 为例: 1.点击 Create Git Repository 2.选择项目目录 3.添加到缓存库 4.提交到本地库 5.复制远程库地址 6.推送到远程 ...
- climits 与 符号常量
climits 在老式中是 limits.h 一.引入 #include <climits> 或者 #include <limits.h> 二.符号常量 符号常量 表示 CH ...
- consul：啥？我被优化没了？AgileConfig+Yarp替代Ocelot+Consul实现服务发现和自动网关配置
现在软件就业环境不景气,各行各业都忙着裁员优化.作为一个小开发,咱也不能光等着别人来优化咱,也得想办法优化下自己.就拿手头上的工作来说吧,我发现我的微服务应用里,既有AgileConfig这个日志组件 ...
- UE4下实现HTC Vive手柄拾取物品蓝图编程
UE4下实现Vive手柄拾取物品 标签: UE4Vive游戏引擎 目录(?) [-] 创建拾取接口 实现接口 定义拾取 简单说下思路,首先定义拾取接口,然后在需要拾取的物品的蓝图类中实现该接口,最后在 ...
- 力扣461(java)-汉明距离（简单）
题目: 两个整数之间的 汉明距离 指的是这两个数字对应二进制位不同的位置的数目. 给你两个整数 x 和 y,计算并返回它们之间的汉明距离. 示例 1: 输入:x = 1, y = 4输出:2解释:1 ...
- 喜马拉雅 Apache RocketMQ 消息治理实践
简介:本文通过喜马拉雅的RocketMQ治理实践分享,让大家了解使用消息中间件过程中可能遇到的问题,避免实战中踩坑. 作者:曹融,来自喜马拉雅,从事微服务和消息相关中间件开发. 本文通过喜马拉雅 ...
- 深度 | 从DevOps到BizDevOps, 研发效能提升的系统方法
简介:研发效能提升不知从何下手.一头雾水?阿里资深技术专家一文为你揭秘研发效能提升的系统方法. 注:本文是对云栖大会何勉分享内容的整理 这几年"研发效能"一直是热词,很多组织 ...