常用的三种交换机类型，direct为完整步骤
fanout
“无路由交换机”，说白了就是，使用这个交换机不需要routingkey绑定，和路由没有关系，它是直接绑定到队列的。
生产者
package com.test.rabbitmq.routing;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
/**
* fanout 发布与订阅模式
* 生产者
*/
public class Producer {
public static void main(String[] args) {
// 所有的中间件技术都是基于tcp/ip协议的基础之上构建新型的协议规范，只不过rabbitmq遵循的是amqp
// IP port
// 1:创建连接工程
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("106.14.40.217");
connectionFactory.setPort(5672);
connectionFactory.setUsername("admin");
connectionFactory.setPassword("admin");
connectionFactory.setVirtualHost("/");
Connection connection = null;
Channel channel = null;
try {
// 2.创建连接Connection
connection = connectionFactory.newConnection("生产者");
// 3.通过连接获取通道Channel
channel = connection.createChannel();
// 4.准备消息内容
String message = "Hello 消费者,I'm Fanout-Exchange";
// 5.准备交换机 （消息队列在rabbitmq客户端已经绑定在这里无需绑定） “无路由交换机”，说白了就是，使用这个交换机不需要routingkey绑定，和路由没有关系，它是直接绑定到队列的。
String exchangeName= "fanout-exchange";
// 6.定义路由key fanout模式 指定路由key无用
String routingKey = "";
// 7.指定交换机的类型
String exchangeType = "fanout";
/**
* 8.发送消息给消息中间件rabbitmq-server
*
* @params1: 交换机exchange
* @params2: 路由key routingkey/队列名称
* @params3: 属性配置
* @params4: 发送消息的内容
*/
channel.basicPublish(exchangeName,routingKey,null,message.getBytes());
System.out.println("消息发送成功！！！");
} catch (Exception e) {
e.printStackTrace();
} finally {
// 7.关闭通道
if (channel != null && channel.isOpen()){
try {
channel.close();
} catch (Exception e){
e.printStackTrace();;
}
}
// 8.关闭连接
if (connection != null && connection.isOpen()){
try {
connection.close();
} catch (Exception e){
e.printStackTrace();;
}
}
}
}
}
消费者
package com.test.rabbitmq.routing;
import com.rabbitmq.client.*;
import java.io.IOException;
/**
* fanout 发布与订阅模式
* 消费者
*/
public class Consumer {
public static Runnable runnable = new Runnable() {
@Override
public void run() {
{
// 所有的中间件技术都是基于tcp/ip协议的基础之上构建新型的协议规范，只不过rabbitmq遵循的是amqp
// IP port
// 1:创建连接工程
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("106.14.40.217");
connectionFactory.setPort(5672);
connectionFactory.setUsername("admin");
connectionFactory.setPassword("admin");
connectionFactory.setVirtualHost("/");
// 2.获取队列的名称
final String queueName = Thread.currentThread().getName();
Connection connection = null;
Channel channel = null;
try {
// 3.创建连接Connection
connection = connectionFactory.newConnection("消费者");
// 4.通过连接获取通道Channel
channel = connection.createChannel();
/**
* 5. 申明队列queue存储消息
*
* 如果对两列不存在，则会创建
* Rabbitmq不允许创建两个相同的队列名称，否则会报错。
*
* @params1 队列的名称
* @params2 是否要持久化durable=false 所谓持久化消息是否存盘，如果false 非持久化 true 持久化 非持久化会存盘吗？ 会
* @params3 排他性，是否是独占独立
* @params4 是否自动删除，随着最后一个消费之消息完毕消息以后是否把队列自动删除
* @params5 携带附属参数
*
* 这里如果queue已经被创建过一次了，可以不需要定义
*/
// channel.queueDeclare("queue_test",false,false,false,null);
// 6.定义接收消息的回调
Channel finalChannel = channel;
finalChannel.basicConsume(queueName, true, new DeliverCallback() {
@Override
public void handle(String s, Delivery message) throws IOException {
System.out.println("收到消息是" + new String(message.getBody(), "UTF-8"));
}
}, new CancelCallback() {
@Override
public void handle(String s) throws IOException {
System.out.println("接收失败了");
}
});
System.out.println("开始接收消息");
System.in.read();
} catch (Exception e) {
e.printStackTrace();
} finally {
// 7.关闭通道
if (channel != null && channel.isOpen()){
try {
channel.close();
} catch (Exception e){
e.printStackTrace();;
}
}
// 8.关闭连接
if (connection != null && connection.isOpen()){
try {
connection.close();
} catch (Exception e){
e.printStackTrace();;
}
}
}
}
}
};
public static void main(String[] args) {
// 启动三个线程去执行
new Thread(runnable,"queue1").start();
new Thread(runnable,"queue2").start();
new Thread(runnable,"queue3").start();
}
}
direct
“直接连接交换机”：Producer(生产者)投递的消息被DirectExchange (交换机)转发到通过routingkey绑定到具体的某个Queue(队列)，把消息放入队列,然后Consumer从Queue中订阅消息。
生产者
package com.test.rabbitmq.direct;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
/**
*
* 生产者
*/
public class Producer {
public static void main(String[] args) {
// 所有的中间件技术都是基于tcp/ip协议的基础之上构建新型的协议规范，只不过rabbitmq遵循的是amqp
// IP port
// 1:创建连接工程
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("106.14.40.217");
connectionFactory.setPort(5672);
connectionFactory.setUsername("admin");
connectionFactory.setPassword("admin");
connectionFactory.setVirtualHost("/");
Connection connection = null;
Channel channel = null;
try {
// 2.创建连接Connection
connection = connectionFactory.newConnection("生产者");
// 3.通过连接获取通道Channel
channel = connection.createChannel();
// 4.准备消息内容
String message = "Hello 消费者,I'm direct-Exchange";
// 5.准备交换机 （消息队列在rabbitmq客户端已经绑定在这里无需绑定） “直接连接交换机”：Producer(生产者)投递的消息被DirectExchange (交换机)转发到通过routingkey绑定到具体的某个Queue(队列)，把消息放入队列,然后Consumer从Queue中订阅消息。
String exchangeName= "direct-exchange";
// 6.定义路由key direct模式 指定路由key无用
String routingKey = "email";
// 7.指定交换机的类型
String exchangeType = "direct";
// 如果你用界面把queue和exchange的管理先绑定话，你带吗就不需要编写这些声明代码可以让代码更简洁，但不容易读懂
// 如果用代码声明
// 声明交换机 所谓持久化就是指，交换机会不会随着服务器重启造成丢失，如果true：不丢失，false:丢失。
channel.exchangeDeclare(exchangeName,exchangeType,true);
// 声明队列
channel.queueDeclare("queue4",true,false,false,null);
channel.queueDeclare("queue5",true,false,false,null);
channel.queueDeclare("queue6",true,false,false,null);
// 绑定队列和交换机的关系
/**
* @params1: 队列名称
* @params2: 交换机名称
* @params3: routingkey 路由key
*/
channel.queueBind("queue4",exchangeName,"order");
channel.queueBind("queue5",exchangeName,"order");
channel.queueBind("queue6",exchangeName,"order");
/**
* 8.发送消息给消息中间件rabbitmq-server
*
* @params1: 交换机exchange
* @params2: 路由key routingkey/队列名称
* @params3: 属性配置
* @params4: 发送消息的内容
*/
channel.basicPublish(exchangeName,routingKey,null,message.getBytes());
System.out.println("消息发送成功！！！");
} catch (Exception e) {
e.printStackTrace();
} finally {
// 7.关闭通道
if (channel != null && channel.isOpen()){
try {
channel.close();
} catch (Exception e){
e.printStackTrace();;
}
}
// 8.关闭连接
if (connection != null && connection.isOpen()){
try {
connection.close();
} catch (Exception e){
e.printStackTrace();;
}
}
}
}
}
消费者
package com.test.rabbitmq.direct;
import com.rabbitmq.client.*;
import java.io.IOException;
/**
*
* 消费者
*/
public class Consumer {
public static Runnable runnable = new Runnable() {
@Override
public void run() {
{
// 所有的中间件技术都是基于tcp/ip协议的基础之上构建新型的协议规范，只不过rabbitmq遵循的是amqp
// IP port
// 1:创建连接工程
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("106.14.40.217");
connectionFactory.setPort(5672);
connectionFactory.setUsername("admin");
connectionFactory.setPassword("admin");
connectionFactory.setVirtualHost("/");
// 2.获取队列的名称
final String queueName = Thread.currentThread().getName();
Connection connection = null;
Channel channel = null;
try {
// 3.创建连接Connection
connection = connectionFactory.newConnection("消费者");
// 4.通过连接获取通道Channel
channel = connection.createChannel();
/**
* 5. 申明队列queue存储消息
*
* 如果对两列不存在，则会创建
* Rabbitmq不允许创建两个相同的队列名称，否则会报错。
*
* @params1 队列的名称
* @params2 是否要持久化durable=false 所谓持久化消息是否存盘，如果false 非持久化 true 持久化 非持久化会存盘吗？ 会
* @params3 排他性，是否是独占独立
* @params4 是否自动删除，随着最后一个消费之消息完毕消息以后是否把队列自动删除
* @params5 携带附属参数
*
* 这里如果queue已经被创建过一次了，可以不需要定义
*/
// channel.queueDeclare("queue_test",false,false,false,null);
// 6.定义接收消息的回调
Channel finalChannel = channel;
finalChannel.basicConsume(queueName, true, new DeliverCallback() {
@Override
public void handle(String s, Delivery message) throws IOException {
System.out.println("收到消息是" + new String(message.getBody(), "UTF-8"));
}
}, new CancelCallback() {
@Override
public void handle(String s) throws IOException {
System.out.println("接收失败了");
}
});
System.out.println("开始接收消息");
System.in.read();
} catch (Exception e) {
e.printStackTrace();
} finally {
// 7.关闭通道
if (channel != null && channel.isOpen()){
try {
channel.close();
} catch (Exception e){
e.printStackTrace();;
}
}
// 8.关闭连接
if (connection != null && connection.isOpen()){
try {
connection.close();
} catch (Exception e){
e.printStackTrace();;
}
}
}
}
}
};
public static void main(String[] args) {
// 启动三个线程去执行
new Thread(runnable,"queue1").start();
new Thread(runnable,"queue2").start();
new Thread(runnable,"queue3").start();
}
}
topic
主题路由匹配交换机
通过路由keyroutingKey模糊查询， 路由key设置 * 表示只能有一个， # 表示一个或多个
生产者
package com.test.rabbitmq.topics;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
/**
*
* 生产者
*/
public class Producer {
public static void main(String[] args) {
// 所有的中间件技术都是基于tcp/ip协议的基础之上构建新型的协议规范，只不过rabbitmq遵循的是amqp
// IP port
// 1:创建连接工程
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("106.14.40.217");
connectionFactory.setPort(5672);
connectionFactory.setUsername("admin");
connectionFactory.setPassword("admin");
connectionFactory.setVirtualHost("/");
Connection connection = null;
Channel channel = null;
try {
// 2.创建连接Connection
connection = connectionFactory.newConnection("生产者");
// 3.通过连接获取通道Channel
channel = connection.createChannel();
// 4.准备消息内容
String message = "Hello 消费者,I'm topic-Exchange";
// 5.准备交换机 消息队列在rabbitmq客户端已经绑定在这里无需绑定 主题路由匹配交换机
String exchangeName= "topic-exchange";
// 6.定义路由key topic模式 指定路由key无用 topic 模式 通过路由keyroutingKey模糊查询， 路由key设置 * 表示只能有一个， # 表示一个或多个， 例如#.com.# = 多个参数.com.多个参数
String routingKey = "com.course.order.sss";
// 7.指定交换机的类型
String exchangeType = "topic";
/**
* 8.发送消息给消息中间件rabbitmq-server
*
* @params1: 交换机exchange
* @params2: 路由key routingkey/队列名称
* @params3: 属性配置
* @params4: 发送消息的内容
*/
channel.basicPublish(exchangeName,routingKey,null,message.getBytes());
System.out.println("消息发送成功！！！");
} catch (Exception e) {
e.printStackTrace();
} finally {
// 7.关闭通道
if (channel != null && channel.isOpen()){
try {
channel.close();
} catch (Exception e){
e.printStackTrace();;
}
}
// 8.关闭连接
if (connection != null && connection.isOpen()){
try {
connection.close();
} catch (Exception e){
e.printStackTrace();;
}
}
}
}
}
消费者
package com.test.rabbitmq.topics;
import com.rabbitmq.client.*;
import java.io.IOException;
/**
*
* 消费者
*/
public class Consumer {
public static Runnable runnable = new Runnable() {
@Override
public void run() {
{
// 所有的中间件技术都是基于tcp/ip协议的基础之上构建新型的协议规范，只不过rabbitmq遵循的是amqp
// IP port
// 1:创建连接工程
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("106.14.40.217");
connectionFactory.setPort(5672);
connectionFactory.setUsername("admin");
connectionFactory.setPassword("admin");
connectionFactory.setVirtualHost("/");
// 2.获取队列的名称
final String queueName = Thread.currentThread().getName();
Connection connection = null;
Channel channel = null;
try {
// 3.创建连接Connection
connection = connectionFactory.newConnection("消费者");
// 4.通过连接获取通道Channel
channel = connection.createChannel();
/**
* 5. 申明队列queue存储消息
*
* 如果对两列不存在，则会创建
* Rabbitmq不允许创建两个相同的队列名称，否则会报错。
*
* @params1 队列的名称
* @params2 是否要持久化durable=false 所谓持久化消息是否存盘，如果false 非持久化 true 持久化 非持久化会存盘吗？ 会
* @params3 排他性，是否是独占独立
* @params4 是否自动删除，随着最后一个消费之消息完毕消息以后是否把队列自动删除
* @params5 携带附属参数
*
* 这里如果queue已经被创建过一次了，可以不需要定义
*/
// channel.queueDeclare("queue_test",false,false,false,null);
// 6.定义接收消息的回调
Channel finalChannel = channel;
finalChannel.basicConsume(queueName, true, new DeliverCallback() {
@Override
public void handle(String s, Delivery message) throws IOException {
System.out.println("收到消息是" + new String(message.getBody(), "UTF-8"));
}
}, new CancelCallback() {
@Override
public void handle(String s) throws IOException {
System.out.println("接收失败了");
}
});
System.out.println("开始接收消息");
System.in.read();
} catch (Exception e) {
e.printStackTrace();
} finally {
// 7.关闭通道
if (channel != null && channel.isOpen()){
try {
channel.close();
} catch (Exception e){
e.printStackTrace();;
}
}
// 8.关闭连接
if (connection != null && connection.isOpen()){
try {
connection.close();
} catch (Exception e){
e.printStackTrace();;
}
}
}
}
}
};
public static void main(String[] args) {
// 启动三个线程去执行
new Thread(runnable,"queue1").start();
new Thread(runnable,"queue2").start();
new Thread(runnable,"queue3").start();
}
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
