转-项目中用到rabbitMQ的地方2

1.消费者端

Java代码

1. package com.guoxin.rabbitmq;
2. import java.io.IOException;
3. import com.guoxin.parser.download.CreateLog;
4. import com.rabbitmq.client.ConnectionFactory;
5. import com.rabbitmq.client.Connection;
6. import com.rabbitmq.client.Channel;
7. import com.rabbitmq.client.QueueingConsumer;
8. import com.rabbitmq.client.AMQP.Queue.DeclareOk;
9. publicclass Consumer1 {
10. privatefinal String EXCHANGE_NAME = "direct_logs";
11. privatefinal String QUEUE_NAME = "StaticQueue";
12. boolean flag = true;
13. // 创建链接工厂
14. privatestatic ConnectionFactory factory;
15. // 创建链接
16. Connection connection = null;
17. Channel channel = null;
18. String task = "";
19. privatestaticint a=0;
20. public String consumer() {
21. try {
22. factory=Consumer1.getConnectionFactory();
23. factory.setRequestedChannelMax(20);
24. factory.setRequestedFrameMax(0);
25. // factory=new ConnectionFactory();
26. factory.setHost("192.168.1.22");
27. connection = factory.newConnection();
28. // 创建信息通道
29. channel = connection.createChannel();
30. try {
31. // 声明Exchange非持久化
32. channel.exchangeDeclare(EXCHANGE_NAME, "direct", true);
33. // 参数说明：第�?��参数为队列的名字。第二个参数为：设置为true，则rabbitmq在重启之后会重新建立
34. // 第三个参数：设置为true，标识只有创建了该队列的消费者才可以去连接该队列
35. // 第四个参数：设置为false为最后一个消费�?断开后不会自动删除�?
36. // 第五个参数为：队列的其他参数，没有就可以设置为空
37. channel.queueDeclare(QUEUE_NAME, true, false, false, null);
38. channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "StaticState");
39. DeclareOk a = channel.queueDeclarePassive(QUEUE_NAME);
40. //获取队列中的消息个数
41. int c = a.getMessageCount();
42. // System.out.println(c);
43. // System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
44. // 声明一个消费者
45. QueueingConsumer consumer = new QueueingConsumer(channel);
46. // 新消息到达的回调
47. channel.basicConsume(QUEUE_NAME, false, consumer);
48. channel.basicQos(1);
49. while (flag) {
50. // QueueingConsumer.Delivery封装一个消息，和bean的结构相同
51. QueueingConsumer.Delivery delivery = consumer
52. .nextDelivery();
53. // 获取消息
54. String message = new String(delivery.getBody());
55. task = message;
56. channel.basicAck(delivery.getEnvelope().getDeliveryTag(),
57. false);
58. // System.out.println(task);
59. break;
60. }
61. } catch (Exception e) {
62. e.printStackTrace(); }
63. } catch (IOException e1) {
64. e.printStackTrace(); } finally {
65. try {
66. channel.close();
67. connection.close();
68. } catch (IOException e) {
69. e.printStackTrace(); }
70. }
71. return task;
72. }
73. publicsynchronizedstatic ConnectionFactory getConnectionFactory(){
74. if(factory==null){
75. a++;
76. System.out.println("获取次数:"+a);
77. factory=new ConnectionFactory();
78. }
79. return factory;
80. }
81. publicstaticvoid main(String[] argv) throws Exception {
82. Consumer1 consumer1 = new Consumer1();
83. consumer1.consumer();
84. }
85. }

package com.guoxin.rabbitmq;

import java.io.IOException;


import com.guoxin.parser.download.CreateLog;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.client.AMQP.Queue.DeclareOk;

public class Consumer1 {

	private final String EXCHANGE_NAME = "direct_logs";
	private final String QUEUE_NAME = "StaticQueue";
	boolean flag = true;
	// 创建链接工厂
	private static ConnectionFactory factory;
	// 创建链接
	Connection connection = null;
	Channel channel = null;
	String task = "";
	private static int  a=0;
	public String consumer() {
		try {
			factory=Consumer1.getConnectionFactory();
			factory.setRequestedChannelMax(20);
			factory.setRequestedFrameMax(0);

//			factory=new ConnectionFactory();
			factory.setHost("192.168.1.22");
			connection = factory.newConnection();
			// 创建信息通道
			channel = connection.createChannel();
			try {
			// 声明Exchange非持久化
			channel.exchangeDeclare(EXCHANGE_NAME, "direct", true);
			// 参数说明：第�?��参数为队列的名字。第二个参数为：设置为true，则rabbitmq在重启之后会重新建立
			// 第三个参数：设置为true，标识只有创建了该队列的消费者才可以去连接该队列
			// 第四个参数：设置为false为最后一个消费�?断开后不会自动删除�?
			// 第五个参数为：队列的其他参数，没有就可以设置为空
			channel.queueDeclare(QUEUE_NAME, true, false, false, null);
			channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "StaticState");
			DeclareOk a = channel.queueDeclarePassive(QUEUE_NAME);
			//获取队列中的消息个数
			int c = a.getMessageCount();
//			System.out.println(c);
//			System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
			// 声明一个消费者
			QueueingConsumer consumer = new QueueingConsumer(channel);
			// 新消息到达的回调
			channel.basicConsume(QUEUE_NAME, false, consumer);
			channel.basicQos(1);
			while (flag) {
			           //  QueueingConsumer.Delivery封装一个消息，和bean的结构相同
			           QueueingConsumer.Delivery delivery = consumer
							.nextDelivery();
				// 获取消息
				String message = new String(delivery.getBody());
				task = message;
				channel.basicAck(delivery.getEnvelope().getDeliveryTag(),
						false);
//				System.out.println(task);
				break;
				}
			} catch (Exception e) {
				e.printStackTrace();			}
		} catch (IOException e1) {
			e.printStackTrace();		} finally {
			try {
				channel.close();
				connection.close();
			} catch (IOException e) {
				e.printStackTrace();			}
		}
		return task;
	}
    public synchronized  static ConnectionFactory getConnectionFactory(){
    	
    	if(factory==null){
    		a++;
    		System.out.println("获取次数:"+a);
    		factory=new ConnectionFactory();
    		    	}
		return factory;
    }
	public static void main(String[] argv) throws Exception {
		Consumer1 consumer1 = new Consumer1();
		consumer1.consumer();
	}
}

2.生产者端

Java代码

1. package com.guoxin.util;
2. import java.io.IOException;
3. import java.util.List;
4. import org.quartz.JobExecutionContext;
5. import org.quartz.JobExecutionException;
6. import org.springframework.scheduling.quartz.QuartzJobBean;
7. import com.guoxin.bean.Block;
8. import com.guoxin.common.util.Config;
9. import com.guoxin.common.webservice.BmsMailSend;
10. import com.guoxin.log.CreateLog;
11. import com.guoxin.service.Iservice.GetBlockUrlService;
12. import com.rabbitmq.client.Channel;
13. import com.rabbitmq.client.Connection;
14. import com.rabbitmq.client.ConnectionFactory;
15. import com.rabbitmq.client.MessageProperties;
16. import com.rabbitmq.client.AMQP.Queue.DeclareOk;
17. import com.sun.codemodel.JNullType;
18. @SuppressWarnings("deprecation")
19. publicclass DMSMethod extends QuartzJobBean{
20. privatestaticfinal String EXCHANGE_NAME = "direct_logs";
21. privatefinal String QUEUE_NAME = "StaticQueue";
22. private GetBlockUrlService blockservice;
23. public DMSMethod(){
24. blockservice = (GetBlockUrlService)MyApplicationContextUtil.getContext().getBean("blockService");
25. }
26. protectedvoid executeInternal(JobExecutionContext arg0)
27. throws JobExecutionException {
28. ConnectionFactory factory;
29. Connection connection = null;
30. Channel channel = null;
31. try {
32. factory= new ConnectionFactory();
33. factory.setHost("192.168.1.22");
34. // factory.setRequestedChannelMax(20);
35. // factory.setRequestedFrameMax(0);
36. connection= factory.newConnection();
37. channel=connection.createChannel();
38. channel.exchangeDeclare(EXCHANGE_NAME, "direct",true);
39. channel.queueDeclare(QUEUE_NAME, true, false, false, null);
40. DeclareOk a = channel.queueDeclarePassive(QUEUE_NAME);
41. int c = a.getMessageCount();
42. //获得静态版块的链接
43. List<Block> staticList=blockservice.queryBlockUrlStatic();
44. int abc=0;
45. for(Block block:staticList){
46. String task=block.getBlock_url();
47. if(c<15){
48. channel.basicPublish(EXCHANGE_NAME,"StaticState", MessageProperties.PERSISTENT_TEXT_PLAIN, task.getBytes());
49. System.out.println("队列中剩余:"+c);
50. }
51. }
52. } catch (Exception e) {
53. BmsMailSend.sendMail(Short.valueOf(Config.getAttribute("systemNo")),"亲,又发生异常了!" ,(new Throwable().getStackTrace()[0]).toString()+ e.toString());
54. CreateLog.getCreateLogInstance("errorLog").CreateLogs(e,
55. "com.guoxin.util.DMSMethod");
56. }finally{
57. try {
58. channel.close();
59. connection.close();
60. } catch (IOException e) {
61. System.out.println("异常发生");
62. BmsMailSend.sendMail(Short.valueOf(Config.getAttribute("systemNo")),"亲,又发生异常了!" ,(new Throwable().getStackTrace()[0]).toString()+ e.toString());
63. CreateLog.getCreateLogInstance("errorLog").CreateLogs(e,
64. "com.guoxin.util.DMSMethod");
65. }
66. }
67. }
68. public GetBlockUrlService getBlockservice() {
69. return blockservice;
70. }
71. }

package com.guoxin.util;

import java.io.IOException;
import java.util.List;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;

import com.guoxin.bean.Block;
import com.guoxin.common.util.Config;
import com.guoxin.common.webservice.BmsMailSend;
import com.guoxin.log.CreateLog;
import com.guoxin.service.Iservice.GetBlockUrlService;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.MessageProperties;
import com.rabbitmq.client.AMQP.Queue.DeclareOk;
import com.sun.codemodel.JNullType;

@SuppressWarnings("deprecation")
public class DMSMethod extends QuartzJobBean{
	private static final String EXCHANGE_NAME = "direct_logs";
	private final String QUEUE_NAME = "StaticQueue";
	private GetBlockUrlService blockservice;
	
	public DMSMethod(){
	   blockservice = (GetBlockUrlService)MyApplicationContextUtil.getContext().getBean("blockService");
	}


	protected void executeInternal(JobExecutionContext arg0)
			throws JobExecutionException {
		ConnectionFactory factory;
		Connection connection = null;
		Channel channel = null;
		try {
			factory= new ConnectionFactory();
        	factory.setHost("192.168.1.22");
//        	factory.setRequestedChannelMax(20);
//			factory.setRequestedFrameMax(0);
        	connection= factory.newConnection();
        	channel=connection.createChannel();
			channel.exchangeDeclare(EXCHANGE_NAME, "direct",true);
			channel.queueDeclare(QUEUE_NAME, true, false, false, null);
			DeclareOk a = channel.queueDeclarePassive(QUEUE_NAME);
			int c = a.getMessageCount();

			//获得静态版块的链接
			List<Block> staticList=blockservice.queryBlockUrlStatic();
			int abc=0;
			for(Block block:staticList){
		    	  String task=block.getBlock_url();
		    	  if(c<15){
		    		channel.basicPublish(EXCHANGE_NAME,"StaticState", MessageProperties.PERSISTENT_TEXT_PLAIN, task.getBytes());
					System.out.println("队列中剩余:"+c);
					}
		    	}  
    	} catch (Exception e) {
    		BmsMailSend.sendMail(Short.valueOf(Config.getAttribute("systemNo")),"亲,又发生异常了!" ,(new Throwable().getStackTrace()[0]).toString()+ e.toString());
    		CreateLog.getCreateLogInstance("errorLog").CreateLogs(e,
			"com.guoxin.util.DMSMethod");
		}finally{
			try {
				channel.close();
				connection.close();
			} catch (IOException e) {
				System.out.println("异常发生");
				BmsMailSend.sendMail(Short.valueOf(Config.getAttribute("systemNo")),"亲,又发生异常了!" ,(new Throwable().getStackTrace()[0]).toString()+ e.toString());
	    		CreateLog.getCreateLogInstance("errorLog").CreateLogs(e,
				"com.guoxin.util.DMSMethod");
			}
		   
		}
		
	}

	public GetBlockUrlService getBlockservice() {
		return blockservice;
	}



}

以上是在项目中的实际应用，DMSMethod类是采用了spring的定时器来加载的，定时向队列中插入数据，当队列中的数据个数小于15就往队列中放入新的数据。同时查询是调用的service层的接口。在消费者端，我采用的是将一个链接取出来然后就跳出。一般是消费者端是一个死循环，时时刻刻接收生产者往队列中放入得数据。

2.以下是几个不同交换机类型的小例子

1).第一种:发布式的，此种类型交换机忽略路由键值，会将消息发送到它所能知道的队列中

Java代码

1. package com.mq.PublishSubscribe;
2. import com.rabbitmq.client.ConnectionFactory;
3. import com.rabbitmq.client.Connection;
4. import com.rabbitmq.client.Channel;
5. /**
6. * 把消息分发给所有的消费者fanout交换器很简单，你可能从名字上就能猜测出来，它把消息发送给它所知道的所有队列。这正是我们的日志系统所需要的。
7. * @author Administrator
8. *
9. */
10. publicclass EmitLog {
11. privatestaticfinal String EXCHANGE_NAME = "logs";
12. publicstaticvoid main(String[] argv) throws Exception {
13. //创建链接工厂
14. ConnectionFactory factory = new ConnectionFactory();
15. factory.setHost("192.168.1.22");
16. //创建链接
17. Connection connection = factory.newConnection();
18. //创建信息通道
19. Channel channel = connection.createChannel();
20. //声明Exchange非持久化
21. //channel.exchangeDeclare(EXCHANGE_NAME, "fanout",true);这是一个持久化的交换机
22. channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
23. //消息
24. String message = getMessage(argv);
25. String message1="删除";
26. String message2="shanchu1";
27. //发送消息，这个发送消息是忽略路由键值的。它会将消息发送给所有与这个交换机绑定的队列上
28. channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes());
29. channel.basicPublish(EXCHANGE_NAME, "", null, message1.getBytes());
30. channel.basicPublish(EXCHANGE_NAME, "", null, message2.getBytes());
31. System.out.println(" [x] Sent '" + message + "'");
32. channel.close();
33. connection.close();
34. }
35. privatestatic String getMessage(String[] strings){
36. if (strings.length < 1)
37. return"info: Hello World!";
38. return joinStrings(strings, " ");
39. }
40. privatestatic String joinStrings(String[] strings, String delimiter) {
41. int length = strings.length;
42. if (length == 0) return"";
43. StringBuilder words = new StringBuilder(strings[0]);
44. for (int i = 1; i < length; i++) {
45. words.append(delimiter).append(strings[i]);
46. }
47. return words.toString();
48. }
49. }

package com.mq.PublishSubscribe;

import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
/**
 * 把消息分发给所有的消费者fanout交换器很简单，你可能从名字上就能猜测出来，它把消息发送给它所知道的所有队列。这正是我们的日志系统所需要的。


 * @author Administrator
 *
 */
public class EmitLog {

  private static final String EXCHANGE_NAME = "logs";

  public static void main(String[] argv) throws Exception {
    //创建链接工厂
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("192.168.1.22");
    //创建链接
    Connection connection = factory.newConnection();
    //创建信息通道
    Channel channel = connection.createChannel();
    //声明Exchange非持久化
    //channel.exchangeDeclare(EXCHANGE_NAME, "fanout",true);这是一个持久化的交换机
    channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
    //消息
    String message = getMessage(argv);
    String message1="删除";
    String message2="shanchu1";
    //发送消息，这个发送消息是忽略路由键值的。它会将消息发送给所有与这个交换机绑定的队列上
    channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes());
    channel.basicPublish(EXCHANGE_NAME, "", null, message1.getBytes());
    channel.basicPublish(EXCHANGE_NAME, "", null, message2.getBytes());
    System.out.println(" [x] Sent '" + message + "'");

    channel.close();
    connection.close();
  }
  
  private static String getMessage(String[] strings){
    if (strings.length < 1)
    	    return "info: Hello World!";
    return joinStrings(strings, " ");
  }
  
  private static String joinStrings(String[] strings, String delimiter) {
    int length = strings.length;
    if (length == 0) return "";
    StringBuilder words = new StringBuilder(strings[0]);
    for (int i = 1; i < length; i++) {
        words.append(delimiter).append(strings[i]);
    }
    return words.toString();
  }
}

Java代码

1. package com.mq.PublishSubscribe;
2. import com.rabbitmq.client.AMQP;
3. import com.rabbitmq.client.ConnectionFactory;
4. import com.rabbitmq.client.Connection;
5. import com.rabbitmq.client.Channel;
6. import com.rabbitmq.client.Envelope;
7. import com.rabbitmq.client.QueueingConsumer;
8. import com.rabbitmq.client.AMQP.Queue.DeclareOk;
9. import com.rabbitmq.client.AMQP.Queue.DeleteOk;
10. publicclass ReceiveLogs {
11. privatestaticfinal String EXCHANGE_NAME = "logs";
12. publicstaticvoid main(String[] argv) throws Exception {
13. //创建链接工厂
14. ConnectionFactory factory = new ConnectionFactory();
15. factory.setHost("192.168.1.22");
16. //创建链接
17. Connection connection = factory.newConnection();
18. //创建信息通道
19. Channel channel = connection.createChannel();
20. //声明Exchange非持久化
21. channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
22. //采用系统的自动声明的消息队列名
23. String queueName = channel.queueDeclare().getQueue();
24. //将队列绑定到交换机上，没有设定路由键值的，也就是说与这个交换机绑定的所有的队列都会接收到交换机中的消息
25. channel.queueBind(queueName, EXCHANGE_NAME, "");
26. // 参数说明：第一个参数为队列的名字。第二个参数为：设置为true，则rabbitmq在重启之后会重新建立
27. //第三个参数：设置为true，标识只有创建了该队列的消费者才可以去连接该队列
28. //第四个参数：设置为false为最后一个消费者断开后不会自动删除。
29. //第五个参数为：队列的其他参数，没有就可以设置为空
30. channel.queueDeclare("queue123", true, false, false, null);
31. System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
32. //声明一个消费者
33. QueueingConsumer consumer = new QueueingConsumer(channel);
34. //新消息到达的回调
35. channel.basicConsume(queueName, true, consumer);
36. while (true) {
37. //QueueingConsumer.Delivery封装一个消息，和bean的结构相同
38. QueueingConsumer.Delivery delivery = consumer.nextDelivery();
39. //获取消息
40. String message = new String(delivery.getBody());
41. //获取消息信封
42. Envelope message1 =delivery.getEnvelope();
43. //获取消息属性
44. AMQP.BasicProperties message2 =delivery.getProperties();
45. System.out.println(" [x] Received '" + message + "'");
46. System.out.println(" [x] Received Envelope'" + message1 + "'");
47. System.out.println(" [x] Received AMQP.BasicProperties'" + message2 + "'");
48. }
49. }
50. }

package com.mq.PublishSubscribe;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.client.AMQP.Queue.DeclareOk;
import com.rabbitmq.client.AMQP.Queue.DeleteOk;

public class ReceiveLogs {

  private static final String EXCHANGE_NAME = "logs";

  public static void main(String[] argv) throws Exception {
	//创建链接工厂
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("192.168.1.22");
    //创建链接
    Connection connection = factory.newConnection();
    //创建信息通道
    Channel channel = connection.createChannel();
    //声明Exchange非持久化
    channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
    //采用系统的自动声明的消息队列名
    String queueName = channel.queueDeclare().getQueue();
    //将队列绑定到交换机上，没有设定路由键值的，也就是说与这个交换机绑定的所有的队列都会接收到交换机中的消息
    channel.queueBind(queueName, EXCHANGE_NAME, "");
    // 参数说明：第一个参数为队列的名字。第二个参数为：设置为true，则rabbitmq在重启之后会重新建立
    //第三个参数：设置为true，标识只有创建了该队列的消费者才可以去连接该队列
    //第四个参数：设置为false为最后一个消费者断开后不会自动删除。
    //第五个参数为：队列的其他参数，没有就可以设置为空
    channel.queueDeclare("queue123", true, false, false, null);
    System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
    //声明一个消费者
    QueueingConsumer consumer = new QueueingConsumer(channel);
    //新消息到达的回调
    channel.basicConsume(queueName, true, consumer);

    while (true) {
      //QueueingConsumer.Delivery封装一个消息，和bean的结构相同
      QueueingConsumer.Delivery delivery = consumer.nextDelivery();
      //获取消息
      String message = new String(delivery.getBody());
      //获取消息信封
      Envelope message1 =delivery.getEnvelope();
      //获取消息属性
      AMQP.BasicProperties message2 =delivery.getProperties();
      
      System.out.println(" [x] Received '" + message + "'");  
      System.out.println(" [x] Received Envelope'" + message1 + "'");
      System.out.println(" [x] Received AMQP.BasicProperties'" + message2 + "'");
    }
  }
}

2).特定类型的direct

Java代码

1. package com.mq.Routing;
2. import com.rabbitmq.client.ConnectionFactory;
3. import com.rabbitmq.client.Connection;
4. import com.rabbitmq.client.Channel;
5. publicclass EmitLogDirect {
6. privatestaticfinal String EXCHANGE_NAME = "direct_logs";
7. publicstaticvoid main(String[] argv) throws Exception {
8. ConnectionFactory factory = new ConnectionFactory();
9. factory.setHost("192.168.1.22");
10. Connection connection = factory.newConnection();
11. Channel channel = connection.createChannel();
12. channel.exchangeDeclare(EXCHANGE_NAME, "direct");
13. String severity = getSeverity(argv);
14. String message = getMessage(argv);
15. channel.basicPublish(EXCHANGE_NAME, severity, null, message.getBytes());
16. System.out.println(" [x] Sent '" + severity + "':'" + message + "'");
17. channel.close();
18. connection.close();
19. }
20. privatestatic String getSeverity(String[] strings){
21. if (strings.length < 1)
22. return"info";
23. return strings[0];
24. }
25. privatestatic String getMessage(String[] strings){
26. if (strings.length < 2)
27. return"Hello World!";
28. return joinStrings(strings, " ", 1);
29. }
30. privatestatic String joinStrings(String[] strings, String delimiter, int startIndex) {
31. int length = strings.length;
32. if (length == 0 ) return"";
33. if (length < startIndex ) return"";
34. StringBuilder words = new StringBuilder(strings[startIndex]);
35. for (int i = startIndex + 1; i < length; i++) {
36. words.append(delimiter).append(strings[i]);
37. }
38. return words.toString();
39. }
40. }

package com.mq.Routing;

import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;

public class EmitLogDirect {

  private static final String EXCHANGE_NAME = "direct_logs";

  public static void main(String[] argv) throws Exception {
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("192.168.1.22");
    Connection connection = factory.newConnection();
    Channel channel = connection.createChannel();
    channel.exchangeDeclare(EXCHANGE_NAME, "direct");
    String severity = getSeverity(argv);
    String message = getMessage(argv);
    channel.basicPublish(EXCHANGE_NAME, severity, null, message.getBytes());
    System.out.println(" [x] Sent '" + severity + "':'" + message + "'");
    channel.close();
    connection.close();
  }
  private static String getSeverity(String[] strings){
    if (strings.length < 1)
    	    return "info";
    return strings[0];
  }
  private static String getMessage(String[] strings){ 
    if (strings.length < 2)
    	    return "Hello World!";
    return joinStrings(strings, " ", 1);
  }
  private static String joinStrings(String[] strings, String delimiter, int startIndex) {
    int length = strings.length;
    if (length == 0 ) return "";
    if (length < startIndex ) return "";
    StringBuilder words = new StringBuilder(strings[startIndex]);
    for (int i = startIndex + 1; i < length; i++) {
        words.append(delimiter).append(strings[i]);
    }
    return words.toString();
  }
}

Java代码

1. package com.mq.Routing;
2. import com.rabbitmq.client.ConnectionFactory;
3. import com.rabbitmq.client.Connection;
4. import com.rabbitmq.client.Channel;
5. import com.rabbitmq.client.QueueingConsumer;
6. publicclass ReceiveLogsDirect {
7. privatestaticfinal String EXCHANGE_NAME = "direct_logs";
8. publicstaticvoid main(String[] argv) throws Exception {
9. ConnectionFactory factory = new ConnectionFactory();
10. factory.setHost("192.168.1.22");
11. Connection connection = factory.newConnection();
12. Channel channel = connection.createChannel();
13. channel.exchangeDeclare(EXCHANGE_NAME, "direct");
14. String queueName = channel.queueDeclare().getQueue();
15. String queueName1 = channel.queueDeclare().getQueue();
16. channel.queueBind(queueName, EXCHANGE_NAME, "info");
17. channel.queueBind(queueName1, EXCHANGE_NAME, "info1");
18. // if (argv.length < 1){
19. // System.err.println("Usage: ReceiveLogsDirect [info] [warning] [error]");
20. // System.exit(1);
21. // }
22. //
23. // for(String severity : argv){
24. // channel.queueBind(queueName, EXCHANGE_NAME, severity);
25. // }
26. System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
27. QueueingConsumer consumer = new QueueingConsumer(channel);
28. channel.basicConsume(queueName, true, consumer);
29. channel.basicConsume(queueName1, true, consumer);
30. while (true) {
31. QueueingConsumer.Delivery delivery = consumer.nextDelivery();
32. String message = new String(delivery.getBody());
33. String routingKey = delivery.getEnvelope().getRoutingKey();
34. String message1 = new String(delivery.getBody());
35. String routingKey1 = delivery.getEnvelope().getRoutingKey();
36. System.out.println(" [x] Received '" + routingKey + "':'" + message + "'");
37. System.out.println(" [x] Received '" + routingKey1 + "':'" + message1 + "'");
38. }
39. }
40. }

package com.mq.Routing;

import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.QueueingConsumer;

public class ReceiveLogsDirect {

  private static final String EXCHANGE_NAME = "direct_logs";

  public static void main(String[] argv) throws Exception {

    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("192.168.1.22");
    Connection connection = factory.newConnection();
    Channel channel = connection.createChannel();

    channel.exchangeDeclare(EXCHANGE_NAME, "direct");
    String queueName = channel.queueDeclare().getQueue();
    String queueName1 = channel.queueDeclare().getQueue();
    channel.queueBind(queueName, EXCHANGE_NAME, "info");
    channel.queueBind(queueName1, EXCHANGE_NAME, "info1");
//    if (argv.length < 1){
//      System.err.println("Usage: ReceiveLogsDirect [info] [warning] [error]");
//      System.exit(1);
//    }
//    
//    for(String severity : argv){    
//      channel.queueBind(queueName, EXCHANGE_NAME, severity);
//    }
    
    System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

    QueueingConsumer consumer = new QueueingConsumer(channel);
    channel.basicConsume(queueName, true, consumer);
    channel.basicConsume(queueName1, true, consumer);

    while (true) {
      QueueingConsumer.Delivery delivery = consumer.nextDelivery();
      String message = new String(delivery.getBody());
      String routingKey = delivery.getEnvelope().getRoutingKey();
      
      String message1 = new String(delivery.getBody());
      String routingKey1 = delivery.getEnvelope().getRoutingKey();

      System.out.println(" [x] Received '" + routingKey + "':'" + message + "'");   
      System.out.println(" [x] Received '" + routingKey1 + "':'" + message1 + "'");   
    }
  }
}

这个例子中由于队列和info绑定的，所以发送过来的消息只能放到队列queueName中。

3).匹配类型的交换机

Java代码

1. package com.mq.Topics;
2. import com.rabbitmq.client.ConnectionFactory;
3. import com.rabbitmq.client.Connection;
4. import com.rabbitmq.client.Channel;
5. import com.rabbitmq.client.MessageProperties;
6. publicclass EmitLogTopic {
7. privatestaticfinal String EXCHANGE_NAME = "topic_logs";
8. publicstaticvoid main(String[] argv) {
9. Connection connection = null;
10. Channel channel = null;
11. try {
12. ConnectionFactory factory = new ConnectionFactory();
13. factory.setHost("192.168.1.22");
14. connection = factory.newConnection();
15. channel = connection.createChannel();
16. channel.exchangeDeclare(EXCHANGE_NAME, "topic");
17. String routingKey = getRouting(argv);
18. String message = getMessage(argv);
19. channel.basicPublish(EXCHANGE_NAME, routingKey, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
20. System.out.println(" [x] Sent '" + routingKey + "':'" + message + "'");
21. }
22. catch (Exception e) {
23. e.printStackTrace();
24. }
25. finally {
26. if (connection != null) {
27. try {
28. connection.close();
29. }
30. catch (Exception ignore) {}
31. }
32. }
33. }
34. privatestatic String getRouting(String[] strings){
35. if (strings.length < 1)
36. return"anonymous.info.abc";
37. return strings[0];
38. }
39. privatestatic String getMessage(String[] strings){
40. if (strings.length < 2)
41. return"Hello World!";
42. return joinStrings(strings, " ", 1);
43. }
44. privatestatic String joinStrings(String[] strings, String delimiter, int startIndex) {
45. int length = strings.length;
46. if (length == 0 ) return"";
47. if (length < startIndex ) return"";
48. StringBuilder words = new StringBuilder(strings[startIndex]);
49. for (int i = startIndex + 1; i < length; i++) {
50. words.append(delimiter).append(strings[i]);
51. }
52. return words.toString();
53. }
54. }

package com.mq.Topics;

import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.MessageProperties;

public class EmitLogTopic {

  private static final String EXCHANGE_NAME = "topic_logs";

  public static void main(String[] argv) {
    Connection connection = null;
    Channel channel = null;
    try {
      ConnectionFactory factory = new ConnectionFactory();
      factory.setHost("192.168.1.22");
  
      connection = factory.newConnection();
      channel = connection.createChannel();

      channel.exchangeDeclare(EXCHANGE_NAME, "topic");

      String routingKey = getRouting(argv);
      String message = getMessage(argv);

      channel.basicPublish(EXCHANGE_NAME, routingKey, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
      System.out.println(" [x] Sent '" + routingKey + "':'" + message + "'");

    }
    catch  (Exception e) {
      e.printStackTrace();
    }
    finally {
      if (connection != null) {
        try {
          connection.close();
        }
        catch (Exception ignore) {}
      }
    }
  }
  
  private static String getRouting(String[] strings){
    if (strings.length < 1)
    	    return "anonymous.info.abc";
    return strings[0];
  }

  private static String getMessage(String[] strings){ 
    if (strings.length < 2)
    	    return "Hello World!";
    return joinStrings(strings, " ", 1);
  }
  
  private static String joinStrings(String[] strings, String delimiter, int startIndex) {
    int length = strings.length;
    if (length == 0 ) return "";
    if (length < startIndex ) return "";
    StringBuilder words = new StringBuilder(strings[startIndex]);
    for (int i = startIndex + 1; i < length; i++) {
        words.append(delimiter).append(strings[i]);
    }
    return words.toString();
  }
}

Java代码

1. package com.mq.Topics;
2. import com.rabbitmq.client.ConnectionFactory;
3. import com.rabbitmq.client.Connection;
4. import com.rabbitmq.client.Channel;
5. import com.rabbitmq.client.QueueingConsumer;
6. publicclass ReceiveLogsTopic {
7. privatestaticfinal String EXCHANGE_NAME = "topic_logs";
8. privatestaticfinal String QUEUE_NAME = "DL";
9. publicstaticvoid main(String[] argv) {
10. Connection connection = null;
11. Channel channel = null;
12. try {
13. ConnectionFactory factory = new ConnectionFactory();
14. factory.setHost("192.168.1.22");
15. connection = factory.newConnection();
16. channel = connection.createChannel();
17. channel.exchangeDeclare(EXCHANGE_NAME, "topic");
18. // String queueName = channel.queueDeclare().getQueue();
19. channel.queueDeclare(QUEUE_NAME, true, false, false, null);
20. channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "anonymous.*");
21. System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
22. //消费者接受到一个消息并作长时间处理时，有可能发生意外状况，
23. //如运行“Consumer”的机器突然关闭，这时这个消息所要执行的任务
24. //可能没有得到正确处理。
25. //RabbitMQ会一直等到处理某个消息的“Consumer”的链接失去之后，
26. //才确定这个消息没有正确处理，从而RabbitMQ重发这个消息
27. //初始化“Consumer”时有个auto参数，如果设置为true，这个Consumer在收到消息之后会马上返回ack。
28. //我们的应用应该是在消息的任务处理完之后再ack，因此初始化“Consumer”时这个参数应该置为false
29. QueueingConsumer consumer = new QueueingConsumer(channel);
30. channel.basicConsume(QUEUE_NAME, false, consumer);
31. //basicQos方法来限制“Consumer”没有ack的消息数目
32. channel.basicQos(1);
33. while (true) {
34. QueueingConsumer.Delivery delivery = consumer.nextDelivery();
35. String message = new String(delivery.getBody());
36. String routingKey = delivery.getEnvelope().getRoutingKey();
37. System.out.println(" [x] Received '" + routingKey + "':'" + message + "'");
38. channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
39. }
40. }
41. catch (Exception e) {
42. e.printStackTrace();
43. }
44. finally {
45. if (connection != null) {
46. try {
47. connection.close();
48. }
49. catch (Exception ignore) {}
50. }
51. }
52. }
53. }

package com.mq.Topics;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.QueueingConsumer;

public class ReceiveLogsTopic {

  private static final String EXCHANGE_NAME = "topic_logs";
  private static final String QUEUE_NAME = "DL";

  public static void main(String[] argv) {
    Connection connection = null;
    Channel channel = null;
    try {
      ConnectionFactory factory = new ConnectionFactory();
      factory.setHost("192.168.1.22");
  
      connection = factory.newConnection();
      channel = connection.createChannel();

      channel.exchangeDeclare(EXCHANGE_NAME, "topic");
//    String queueName = channel.queueDeclare().getQueue();
      channel.queueDeclare(QUEUE_NAME, true, false, false, null);
      channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "anonymous.*");
    
      System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
      //消费者接受到一个消息并作长时间处理时，有可能发生意外状况，
      //如运行“Consumer”的机器突然关闭，这时这个消息所要执行的任务
      //可能没有得到正确处理。
      //RabbitMQ会一直等到处理某个消息的“Consumer”的链接失去之后，
      //才确定这个消息没有正确处理，从而RabbitMQ重发这个消息
      //初始化“Consumer”时有个auto参数，如果设置为true，这个Consumer在收到消息之后会马上返回ack。
      //我们的应用应该是在消息的任务处理完之后再ack，因此初始化“Consumer”时这个参数应该置为false
      QueueingConsumer consumer = new QueueingConsumer(channel);
      channel.basicConsume(QUEUE_NAME, false, consumer);
      //basicQos方法来限制“Consumer”没有ack的消息数目
      channel.basicQos(1);
      while (true) {
        QueueingConsumer.Delivery delivery = consumer.nextDelivery();
        String message = new String(delivery.getBody());
        String routingKey = delivery.getEnvelope().getRoutingKey();
        System.out.println(" [x] Received '" + routingKey + "':'" + message + "'");   
        channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
      }
    }
    catch  (Exception e) {
      e.printStackTrace();
    }
    finally {
      if (connection != null) {
        try {
          connection.close();
        }
        catch (Exception ignore) {}
      }
    }
  }
}