RabbitMQ java Spring 开发教程

最新推荐文章于 2024-01-05 14:46:02 发布
最新推荐文章于 2024-01-05 14:46:02 发布
阅读量1.3w 收藏 4
点赞数
分类专栏： RabbitMQ 文章标签： 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014201191/article/details/48490861
版权
RabbitMQ

安装RabitMQ

1：安装RabbitMQ需要先安装Erlang语言开发包。下载地址 http://www.erlang.org/download.html 在win7下安装Erlang最好默认安装。
配置环境变量 ERLANG_HOME C:\Program Files (x86)\erl5.9
添加到PATH %ERLANG_HOME%\bin;
2：安装RabbitMQ 下载地址 http://www.rabbitmq.com/download.html 安装教程：http://www.rabbitmq.com/install-windows.html
配置环境变量 C:\Program Files (x86)\RabbitMQ Server\rabbitmq_server-2.8.0
添加到PATH %RABBITMQ_SERVER%\sbin;
3：进入%RABBITMQ_SERVER%\sbin 目录以管理员身份运行 rabbitmq-plugins.bat
rabbitmq-plugins.bat enable rabbitmq_management
安装完成之后以管理员身份启动 rabbitmq-service.bat
rabbitmq-service.bat stop
rabbitmq-service.bat install
rabbitmq-service.bat start
4：浏览器访问localhost:15672 默认账号：guest 密码：guest

Java 开发RabitMQ

1.下载jar
http://www.rabbitmq.com/releases/rabbitmq-java-client/v3.5.4/rabbitmq-java-client-bin-3.5.4.zip

2.生产者 
package com.rabbit;


import com.rabbitmq.client.*;

public class Send {

    private final static String QUEUE_NAME = "hello";  
    
    public static void main(String[] args) throws Exception {  
        ConnectionFactory factory = new ConnectionFactory();  
        factory.setHost("localhost");  
        Connection connection = factory.newConnection();  
        Channel channel = connection.createChannel();  
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);  
        String message = "Hello World!";  
        channel.basicPublish("", QUEUE_NAME, null, message.getBytes());  
        System.out.println(" [x] Sent '" + message + "'");  
        channel.close();  
        connection.close();  
    }  
}

3.消费者 
package com.rabbit;

import com.rabbitmq.client.Channel;  
import com.rabbitmq.client.Connection;  
import com.rabbitmq.client.ConnectionFactory;  
import com.rabbitmq.client.QueueingConsumer;  
  
public class Reqv {  
    private final static String QUEUE_NAME = "hello";  
  
    public static void main(String[] argv) throws Exception {  
  
        ConnectionFactory factory = new ConnectionFactory();  
        factory.setHost("localhost");  
        Connection connection = factory.newConnection();  
        Channel channel = connection.createChannel();  
  
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);  
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");  
  
        QueueingConsumer consumer = new QueueingConsumer(channel);  
        channel.basicConsume(QUEUE_NAME, true, consumer);  
  
        while (true) {  
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();  
            String message = new String(delivery.getBody());  
            System.out.println(" [x] Received '" + message + "'");  
        }  
    }  
}

Spring RabitMQ

1) 先看一个帖子

1.首先是生产者配置

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
<? 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:context = "http://www.springframework.org/schema/context"
        xmlns:rabbit = "http://www.springframework.org/schema/rabbit"
        xsi:schemaLocation="
             http://www.springframework.org/schema/beans
                 http://www.springframework.org/schema/beans/spring-beans.xsd
             http://www.springframework.org/schema/context
                 http://www.springframework.org/schema/context/spring-context.xsd
             http://www.springframework.org/schema/rabbit
                 http://www.springframework.org/schema/rabbit/spring-rabbit-1.0.xsd">
 
     
    <!-- 连接服务配置  -->
    < rabbit:connection-factory  id = "connectionFactory"  host = "localhost"  username = "guest"
         password = "guest"  port = "5672"   />
         
    < rabbit:admin  connection-factory = "connectionFactory" />
    
    <!-- queue 队列声明-->
    < rabbit:queue  id = "queue_one"  durable = "true"  auto-delete = "false"  exclusive = "false"  name = "queue_one" />
    
    
    <!-- exchange queue binging key 绑定 -->
     < rabbit:direct-exchange  name = "my-mq-exchange"  durable = "true"  auto-delete = "false"  id = "my-mq-exchange" >
         < rabbit:bindings >
             < rabbit:binding  queue = "queue_one"  key = "queue_one_key" />
         </ rabbit:bindings >
     </ rabbit:direct-exchange >
     
     <-- spring amqp默认的是jackson 的一个插件,目的将生产者生产的数据转换为json存入消息队列，由于fastjson的速度快于jackson,这里替换为fastjson的一个实现 -->
     < bean  id = "jsonMessageConverter"   class = "mq.convert.FastJsonMessageConverter" ></ bean >
     
     <-- spring template声明-->
     < rabbit:template  exchange = "my-mq-exchange"  id = "amqpTemplate"   connection-factory = "connectionFactory"   message-converter = "jsonMessageConverter" />
</ beans >

2.fastjson messageconver插件实现


?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
import  org.apache.commons.logging.Log;
import  org.apache.commons.logging.LogFactory;
import  org.springframework.amqp.core.Message;
import  org.springframework.amqp.core.MessageProperties;
import  org.springframework.amqp.support.converter.AbstractMessageConverter;
import  org.springframework.amqp.support.converter.MessageConversionException;
 
import  fe.json.FastJson;
 
public  class  FastJsonMessageConverter   extends  AbstractMessageConverter {
     private  static  Log log = LogFactory.getLog(FastJsonMessageConverter. class );
 
     public  static  final  String DEFAULT_CHARSET =  "UTF-8" ;
 
     private  volatile  String defaultCharset = DEFAULT_CHARSET;
     
     public  FastJsonMessageConverter() {
         super ();
         //init();
     }
     
     public  void  setDefaultCharset(String defaultCharset) {
         this .defaultCharset = (defaultCharset !=  null ) ? defaultCharset
                 : DEFAULT_CHARSET;
     }
     
     public  Object fromMessage(Message message)
             throws  MessageConversionException {
         return  null ;
     }
     
     public  <T> T fromMessage(Message message,T t) {
         String json =  "" ;
         try  {
             json =  new  String(message.getBody(),defaultCharset);
         }  catch  (UnsupportedEncodingException e) {
             e.printStackTrace();
         }
         return  (T) FastJson.fromJson(json, t.getClass());
     }  
     
 
     protected  Message createMessage(Object objectToConvert,
             MessageProperties messageProperties)
             throws  MessageConversionException {
         byte [] bytes =  null ;
         try  {
             String jsonString = FastJson.toJson(objectToConvert);
             bytes = jsonString.getBytes( this .defaultCharset);
         }  catch  (UnsupportedEncodingException e) {
             throw  new  MessageConversionException(
                     "Failed to convert Message content" , e);
         } 
         messageProperties.setContentType(MessageProperties.CONTENT_TYPE_JSON);
         messageProperties.setContentEncoding( this .defaultCharset);
         if  (bytes !=  null ) {
             messageProperties.setContentLength(bytes.length);
         }
         return  new  Message(bytes, messageProperties);
 
     }
}

3.生产者端调用


?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import  java.util.List;
 
import  org.springframework.amqp.core.AmqpTemplate;
 
 
public  class  MyMqGatway {
     
     @Autowired
     private  AmqpTemplate amqpTemplate;
     
     public  void  sendDataToCrQueue(Object obj) {
         amqpTemplate.convertAndSend( "queue_one_key" , obj);
     }  
}

4.消费者端配置(与生产者端大同小异)

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
<? 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:context = "http://www.springframework.org/schema/context"
        xmlns:rabbit = "http://www.springframework.org/schema/rabbit"
        xsi:schemaLocation="
             http://www.springframework.org/schema/beans
                 http://www.springframework.org/schema/beans/spring-beans.xsd
             http://www.springframework.org/schema/context
                 http://www.springframework.org/schema/context/spring-context.xsd
             http://www.springframework.org/schema/rabbit
                 http://www.springframework.org/schema/rabbit/spring-rabbit-1.0.xsd">
 
     
    <!-- 连接服务配置  -->
    < rabbit:connection-factory  id = "connectionFactory"  host = "localhost"  username = "guest"
         password = "guest"  port = "5672"   />
         
    < rabbit:admin  connection-factory = "connectionFactory" />
    
    <!-- queue 队列声明-->
    < rabbit:queue  id = "queue_one"  durable = "true"  auto-delete = "false"  exclusive = "false"  name = "queue_one" />
    
    
    <!-- exchange queue binging key 绑定 -->
     < rabbit:direct-exchange  name = "my-mq-exchange"  durable = "true"  auto-delete = "false"  id = "my-mq-exchange" >
         < rabbit:bindings >
             < rabbit:binding  queue = "queue_one"  key = "queue_one_key" />
         </ rabbit:bindings >
     </ rabbit:direct-exchange >
 
     
      
     <!-- queue litener  观察 监听模式 当有消息到达时会通知监听在对应的队列上的监听对象-->
     < rabbit:listener-container  connection-factory = "connectionFactory"  acknowledge = "auto"  task-executor = "taskExecutor" >
         < rabbit:listener  queues = "queue_one"  ref = "queueOneLitener" />
     </ rabbit:listener-container >
</ beans >


5.消费者端调用

?
1
2
3
4
5
6
7
8
9
import  org.springframework.amqp.core.Message;
import  org.springframework.amqp.core.MessageListener;
 
public  class  QueueOneLitener  implements   MessageListener{
     @Override
     public  void  onMessage(Message message) {
         System.out.println( " data :"  + message.getBody());
     }
}

6.由于消费端当队列有数据到达时，对应监听的对象就会被通知到，无法做到批量获取，批量入库，因此可以在消费端缓存一个临时队列，将mq取出来的数据存入本地队列，后台线程定时批量处理即可

网上的这篇帖子,将路由设置成了direct,这样子保证了一对一的读取和发布,对于路由的exchange请参照这里的说明:http://melin.iteye.com/blog/691265
要特别注意的是,queue队列,其实只是在xml中的配置,并没有实际的意义,读取的时候使用的键值其实就是key,在发送的时候 convertAndSend("queue_one_key", obj),就是键值,不要混淆了

2) 下面介绍我在项目中的应用,这里还可以实现如果有异常,实现了自动重发功能

1、生产者
app.xml配置,将其引入到spring.xml中即可 
<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
	xmlns:aop="http://www.springframework.org/schema/aop"   
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
	xmlns:context="http://www.springframework.org/schema/context"
	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.1.xsd    
	http://www.springframework.org/schema/rabbit 
	http://www.springframework.org/schema/rabbit/spring-rabbit-1.0.xsd">

	<!-- 连接服务配置  -->
	<rabbit:connection-factory id="connectionFactory" 
		host="${rabbitmq.host}" port="${rabbitmq.port}" 
		username="${rabbitmq.username}" password="${rabbitmq.password}"/>  
  	
  	<!-- 创建rabbitAdmin 代理类 -->
    <rabbit:admin connection-factory="connectionFactory" />  
    
    <!-- 创建rabbitTemplate 消息模板类 --> 
    <rabbit:template id="rabbitTemplate"  connection-factory="connectionFactory"/>
    
</beans>
发送数据 
package com.zefun.web.service;
import java.util.HashMap;
import java.util.Map;

import net.sf.json.JSONObject;

import org.apache.log4j.Logger;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import com.zefun.common.consts.App;

/**
 * 消息队列服务类
* @author 
* @date Aug 24, 2015 3:51:04 PM 
*/
@Service
public class RabbitService {
    /** 日志对象 */
    private static Logger logger = Logger.getLogger(RabbitService.class);

    /** rabbit队列模版方法 */
    @Autowired()
    private RabbitTemplate rabbitTemplate;
    
    /**
     * 发送优惠券队列
    * @author 高国藩
    * @date 2015年9月16日 上午11:34:12
    * @param map 参数
     */
    public void sendCoupons(Map<String, Object> map) {
        //App.Queue.SEND_COUPONS 就是对应key值,在消费的时候使用该值
        rabbitTemplate.convertAndSend(App.Queue.SEND_COUPONS, map);
    }
}

1、消费者
app.xml 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    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.1.xsd
    http://www.springframework.org/schema/rabbit
    http://www.springframework.org/schema/rabbit/spring-rabbit-1.0.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.1.xsd">

    <!-- 连接服务配置 -->
    <rabbit:connection-factory id="connectionFactory"
        host="${rabbitmq.host}" port="${rabbitmq.port}" username="${rabbitmq.username}"
        password="${rabbitmq.password}" channel-cache-size="${rabbitmq.channel.cache.size}" />

    <!-- 创建rabbitAdmin 代理类 -->
    <rabbit:admin connection-factory="connectionFactory" />
    
   <rabbit:queue id="queue_member_service_coupon" name="${rabbitmq.wechat.template.notice.coupon}" durable="true"
        auto-delete="false" exclusive="false" />

    <!--路由设置 将队列绑定，属于direct类型 -->
    <rabbit:direct-exchange id="directExchange"
        name="directExchange" durable="true" auto-delete="false">
        <rabbit:bindings>
            <rabbit:binding queue="queue_member_service_coupon" key="${rabbitmq.wechat.template.notice.coupon}" />
        </rabbit:bindings>
    </rabbit:direct-exchange>
    
    <bean id="ackManual"
        class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean">
        <property name="staticField"
            value="org.springframework.amqp.core.AcknowledgeMode.MANUAL" />
    </bean>


    <!-- 优惠券发送通知 -->
    <bean
        class="org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer">
        <property name="connectionFactory" ref="connectionFactory" />
        <property name="acknowledgeMode" ref="ackManual" />
        <property name="queueNames" value="${rabbitmq.wechat.template.notice.coupon}" />
        <property name="messageListener">
            <bean class="com.zefun.wechat.listener.MemberTranscationNoitceCoupon" />
        </property>
        <property name="concurrentConsumers" value="${rabbitmq.concurrentConsumers}" />
        <property name="adviceChain">
            <bean
                class="org.springframework.amqp.rabbit.config.StatelessRetryOperationsInterceptorFactoryBean">
                <property name="messageRecoverer">
                    <bean class="com.zefun.wechat.utils.MQRepublishMessageRecoverer"/>
                </property>
                <property name="retryOperations">
                    <bean class="org.springframework.retry.support.RetryTemplate">
                        <property name="backOffPolicy">
                            <bean
                                class="org.springframework.retry.backoff.ExponentialBackOffPolicy">
                                <property name="initialInterval" value="500" />
                                <property name="multiplier" value="10.0" />
                                <property name="maxInterval" value="10000" />
                            </bean>
                        </property>
                    </bean>
                </property>
            </bean>
        </property>
        <property name="errorHandler">
            <bean class="com.zefun.wechat.utils.MQErrorHandler"/>
        </property>
    </bean>
    
    <bean id="msgConverter" class="org.springframework.amqp.support.converter.SimpleMessageConverter" />

    <rabbit:template id="amqpTemplate" connection-factory="connectionFactory"/>
    
</beans>
消费类 
package com.zefun.wechat.listener;

import java.util.Map;

import net.sf.json.JSONObject;

import org.apache.log4j.Logger;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.core.ChannelAwareMessageListener;
import org.springframework.amqp.support.converter.MessageConversionException;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.beans.factory.annotation.Autowired;

import com.rabbitmq.client.Channel;
import com.zefun.wechat.service.RedisService;
import com.zefun.wechat.utils.App;
import com.zefun.wechat.utils.HttpClientUtil;


public class MemberTranscationNoitceCoupon implements ChannelAwareMessageListener{
    
    @Autowired
    private MessageConverter msgConverter;
    @Autowired
    private RedisService redisService;

    private static final Logger logger = Logger.getLogger(EmployeeServiceNoticeListener.class);
    
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {

        Object obj = null;
        try {
            obj = msgConverter.fromMessage(message);
        } catch (MessageConversionException e) {
            logger.error("convert MQ message error.", e);
        } finally {
            long deliveryTag = message.getMessageProperties().getDeliveryTag();
            if (deliveryTag != App.DELIVERIED_TAG) {
                channel.basicAck(deliveryTag, false);
                message.getMessageProperties().setDeliveryTag(App.DELIVERIED_TAG);
                logger.info("revice and ack msg: " + (obj == null ? message : new String((byte[]) obj)));
            }
        }
        if (obj == null) {
            return;
        }
        Map<?, ?> map = (Map<?, ?>) obj;
        HttpClientUtil.sendPost(getTemplSendUrl(map.get("storeId").toString()), JSONObject.fromObject(map).toString(), null);
        boolean flag = false;
        if (!flag) {
            logger.error("hanler message " + obj + " failed, throw a exception, and it will be retried.");
            throw new RuntimeException("hanler message " + obj + " failed.");//如果此处抛出了异常,那么在消息转换类中会接受到,触发重新加入队列中的时间
        }
    }

    private String getTemplSendUrl(String storeId) {
        String accessToken = redisService.hget(App.Redis.STORE_WECHAT_ACCESS_TOKEN_KEY_HASH, storeId);
        return "https://api.weixin.qq.com/cgi-bin/message/template/send?access_token=" + "HwqNKfoP287p4ddayRVX0PN1-8GFukq776MmwQqaL4OI2oEb4WGzclCaPgQIZZd4I42Xo-beX4XrW5Og3NblI_Auf5dGj1hdPrBuhz5OYHE";
    }
}

消息转换类 
package com.zefun.wechat.utils;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.Map;

import org.apache.log4j.Logger;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.retry.MessageRecoverer;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.beans.factory.annotation.Autowired;

public class MQRepublishMessageRecoverer implements MessageRecoverer {
	
	private static final Logger logger = Logger.getLogger(MQRepublishMessageRecoverer.class);

	@Autowired
	private RabbitTemplate rabbitTemplate;
	
	@Autowired
	private MessageConverter msgConverter;

	@Override
	public void recover(Message message, Throwable cause) {
		Map<String, Object> headers = message.getMessageProperties().getHeaders();
		headers.put("x-exception-stacktrace", getStackTraceAsString(cause));
		headers.put("x-exception-message", cause.getCause() != null ? cause.getCause().getMessage() : cause.getMessage());
		headers.put("x-original-exchange", message.getMessageProperties().getReceivedExchange());
		headers.put("x-original-routingKey", message.getMessageProperties().getReceivedRoutingKey());
		//重新将数据放回队列中
		this.rabbitTemplate.send(message.getMessageProperties().getReceivedExchange(), message.getMessageProperties().getReceivedRoutingKey(), message);
		logger.error("handler msg (" + msgConverter.fromMessage(message) + ") err, republish to mq.", cause);
	}

	private String getStackTraceAsString(Throwable cause) {
		StringWriter stringWriter = new StringWriter();
		PrintWriter printWriter = new PrintWriter(stringWriter, true);
		cause.printStackTrace(printWriter);
		return stringWriter.getBuffer().toString();
	}
}


package com.zefun.wechat.utils;

import java.lang.reflect.Field;
import java.util.Date;

import org.apache.commons.lang.reflect.FieldUtils;
import org.apache.log4j.Logger;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.ErrorHandler;

import com.zefun.wechat.service.RedisService;

public class MQErrorHandler implements ErrorHandler {

    private static final Logger logger = Logger.getLogger(MQErrorHandler.class);

    @Autowired
    private RedisService redisService;
    @Autowired
    private MessageConverter msgConverter;

    @Override
    public void handleError(Throwable cause) {
        Field mqMsgField = FieldUtils.getField(MQListenerExecutionFailedException.class, "mqMsg", true);
        if (mqMsgField != null) {
            try {
                Message mqMsg = (Message) mqMsgField.get(cause);
                Object msgObj = msgConverter.fromMessage(mqMsg);
                logger.error("handle MQ msg: " + msgObj + " failed, record it to redis.", cause);
                redisService.zadd(App.MsgErr.MQ_MSG_ERR_RECORD_KEY, new Double(new Date().getTime()), msgObj.toString());
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {
            logger.error("An error occurred.", cause);
        }
    }

}


package com.zefun.wechat.utils;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.ListenerExecutionFailedException;

public class MQListenerExecutionFailedException extends
        ListenerExecutionFailedException {

    private static final long serialVersionUID = 1L;

    private Message mqMsg;

    public MQListenerExecutionFailedException(String msg, Throwable cause) {
        super(msg, cause);
    }

    public MQListenerExecutionFailedException(String msg, Message mqMsg, Throwable cause) {
        this(msg, cause);
        this.mqMsg = mqMsg;
    }

    public Message getMqMsg() {
        return mqMsg;
    }

}


package com.zefun.wechat.utils;

import org.springframework.amqp.AmqpRejectAndDontRequeueException;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.retry.RejectAndDontRequeueRecoverer;

public class MQRejectAndDontRequeueRecoverer extends
        RejectAndDontRequeueRecoverer {

    @Override
    public void recover(Message message, Throwable cause) {
        throw new MQListenerExecutionFailedException("Retry Policy Exhausted", message,
                new AmqpRejectAndDontRequeueException(cause));
    }

}


properties内容 

rabbitmq.host=127.0.0.1
rabbitmq.port=5672
rabbitmq.username=guest
rabbitmq.password=guest
rabbitmq.concurrentConsumers=5
rabbitmq.channel.cache.size=50
rabbitmq.wechat.template.notice.coupon=queue_member_service_coupon

maven 

		<!-- springmvc rabbitmq -->
		<dependency>
			<groupId>com.rabbitmq</groupId>
			<artifactId>amqp-client</artifactId>
			<version>3.3.0</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.amqp</groupId>
			<artifactId>spring-amqp</artifactId>
			<version>1.3.0.RELEASE</version>
		</dependency>

		<dependency>
			<groupId>org.springframework.amqp</groupId>
			<artifactId>spring-rabbit</artifactId>
			<version>1.3.0.RELEASE</version>
		</dependency>

		<dependency>
			<groupId>org.springframework.retry</groupId>
			<artifactId>spring-retry</artifactId>
			<version>1.0.3.RELEASE</version>
		</dependency>

本案例下载

http://download.csdn.net/detail/u014201191/9113775

http://download.csdn.net/detail/u014201191/9341163


高国藩
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ的使用（JAVA）
..............
11-15 1万+
Java快速上手的MQ上线！
SpringBoot整合 RabbitMQ
我的博客
09-08 934
SpringBoot整合 RabbitMQ 建springboot项目时导入springboot整合rabbitmq依赖包 1,生产者 application.yml配置文件 spring: rabbitmq: port: 5672 password: root username: root virtual-host: /pms host: localhost template: mandatory: true #没有投递到队列，强
RabbitMQ教程大全看这一篇就够了-java版本
又逢乱世
11-06 2938
rabbitmq
RabbitMQ消息确认机制详解
最新发布
m0_72397750的博客
01-05 1583
RabbitMQ消息确认详解：消费者在获取到消息后，会向服务端发送ACK确认，这时消息会立刻删除。消息发布确认要确保消息成功发送到服务端broker。确保RabbitMQ消息的可靠性。开启生产者确认机制，确保生产者的消息能到达队列；设置备份交换机，将无法路由到队列的消息送到备份队列；开启持久化功能，确保消息未消费前在队列中不会丢失；开启消费者应答机制，设置自动应答或手动应答回调；开启消费者失败重试机制，设置重试次数和间隔时间；开启消息恢复机制，重试机会耗尽的消息投递到异常交换机，交由人工处理。
spring boot集成rabbitmq的实例教程
08-28
【Spring Boot集成RabbitMQ】 在Spring Boot应用中集成RabbitMQ，可以让我们的系统实现高效、异步的消息通信。RabbitMQ是一个开源的消息代理，它作为消息中间件，允许不同服务之间通过消息进行通信，提高了系统的...
RabbitMQ Tutorials Java版的解读
06-15
在Java开发中，RabbitMQ 提供了丰富的客户端库，使得Java开发者能够方便地集成和使用消息队列。本教程将对RabbitMQ在Java环境下的使用进行深入解读。 首先，我们需要了解RabbitMQ的基本概念。消息队列是应用程序...
rabbitmq(java)入门教程
11-12
RabbitMQ 是一个基于 AMQP（Advanced Message Queuing Protocol）协议的开源消息队列系统，由 Erlang 语言开发。它主要负责接收生产者发送的消息，并将这些消息可靠地传递给消费者。RabbitMQ 的核心概念包括生产者...
rabbitmq-spring
07-29
Spring框架是一个全面的企业级应用开发框架，它简化了Java应用程序的开发，尤其是面向服务架构（SOA）的应用。 描述中提到的链接是一个博主在中国开源社区OSChina上发布的博客文章，通过这个例子，我们可以学习如何...
RabbitMq与Spring整合实例
11-23
本教程将详细介绍如何将RabbitMQ与Spring框架整合，以实现高效、可靠的异步通信。 首先，集成RabbitMQ到Spring项目中，我们需要在项目中添加必要的依赖。在`pom.xml`文件中，引入Spring AMQP和RabbitMQ的客户端库：...
rabbitmq（java实例）
01-09
rabbitmq（java实例），环境eclipse + maven
rabbitMQ Java开发案例
09-17
javaAPI SpringMVC 集成rabbitMQ 很全的例子,实现了生产消费,重复消费等功能
《RabbitMQ》 | 消息丢失也就这么回事
Cbuc丶的博客
10-24 853
大家好，我是小菜。 一个希望能够成为 吹着牛X谈架构 的男人！如果你也想成为我想成为的人，不然点个关注做个伴，让小菜不再孤单！ 本文主要介绍 RabbitMQ的消息丢失问题 如有需要，可以参考 如有帮助，不忘 点赞 ❥ 微信公众号已开启，小菜良记，没关注的同学们记得关注哦！ 是的，最终是对 RabbitMQ 下手了！ 面试中常见的RabbitMQ面试题也是多了去了，常见的如下： 消息可靠性问题：如何确保发送的消息至少被消费一次？ 延迟消息问题：如何实现消息的延迟投递？ 高可用问题：如何避免单点的MQ故
python rabbitmq 消息重试机制_rabbitMQ消息重试机制
weixin_39718083的博客
03-01 784
消费端在处理消息过程中可能会报错，此时该如何重新处理消息呢？解决方案有以下两种。在redis或者数据库中记录重试次数，达到最大重试次数以后消息进入死信队列或者其他队列，再单独针对这些消息进行处理；使用spring-rabbit中自带的retry功能；第一种方案我们就不再详细说了，我们主要来看一下第二种方案，老规矩，先上代码：spring:rabbitmq:listener:simple:ackno...
Java开发之rabbitMQ的使用
tianzhiwuqis的博客
10-19 790
转自：Java开发之rabbitMQ的使用_范亚明的博客-CSDN博客 一.消息中心简介 (一).应用场景 并发的业务:如抢购 耗时长的业务:如商城中的订单生成 耦合度高的业务:如邮件,短信等提醒功能 (二).常见的消息中间件 1.ActiveMQ ActiveMQ是Apache出品,比较老的一个开源的消息中间件, 是一个完全支持JMS规范的消息中间件. API丰富,以前在中小企业应用广泛 MQ衡量的指标:服务性能,数据存储,集群架构 2.KafKa Kafka是由Apache软件基金会开发的一个
java.lang.IllegalStateException: Failed to introspect Class
w13346019869的博客
09-17 6339
异常内容 [org.springframework.web.context.support.XmlWebApplicationContext] [Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCreationException: Error creating bean with na
【转】Spring AMQP 源码分析 05 - 异常处理
AnY11的专栏
10-03 488
转自 首夜盲毒预言家 ### 准备 ## 目标 了解 Spring AMQP Message Listener 如何处理异常 ## 前置知识 《Spring AMQP 源码分析 04 - MessageListener》 ## 相关资源 Offical doc：&lt;http://docs.spring.io/spring-amqp/docs/1.7.3.RELEASE/refer...
spring和kafka报错：Failed to introspect Class org.springframework.kafka.listener.ContainerProperties
weixin_43675652的博客
12-23 3437
spring和kafka报错：Caused by: java.lang.IllegalStateException: Failed to introspect Class org.springframework.kafka.listener.ContainerProperties报错类型：java.lang.IllegalStateException: Failed to introspect Class [org.springframework.kafka.listener.ContainerProper

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值