springmvc整合rabbitmq实现消息发送消息确认

springmvc整合rabbitmq实现消息发送消息确认
首先springmvc创建项目的教程，这里就不多说了，现在重点看一下springmvc整合rabbitmq的教程。
首先引入jar包我这里用的是2.1.6版本

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

在配置文件中配上rabbitmq的配置

# rabbit ip
rabbit.host=127.0.0.1
# rabbit 端口
rabbit.port=5672
# rabbit 用户名
rabbit.username=admin
# rabbit 密码
rabbit.password=123456

使用xml配置消息发送者

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/rabbit
 	http://www.springframework.org/schema/rabbit/spring-rabbit.xsd
     http://www.springframework.org/schema/context
     http://www.springframework.org/schema/context/spring-context-4.0.xsd
 	http://www.springframework.org/schema/beans
 	http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">

    <!-- 配置连接工厂 -->
    <rabbit:connection-factory id="connectionFactory"
                               host="${rabbit.host}" port="${rabbit.port}"
                               username="${rabbit.username}" password="${rabbit.password}"
     publisher-confirms="true" publisher-returns="true" />

    <!-- 定义mq管理 -->
    <rabbit:admin connection-factory="connectionFactory" />

    <!-- 声明队列  durable参数设置队列持久化 -->
    <rabbit:queue name="queue" auto-declare="true" durable="true" />

    <!-- 定义交换机绑定队列（路由模式）设置交换机持久化 -->
    <rabbit:direct-exchange name="IExchange" id="IExchange" durable="true">
        <rabbit:bindings>
            <rabbit:binding queue="queue" key="queuekey" />
        </rabbit:bindings>
    </rabbit:direct-exchange>

    <!-- 消息对象json转换类 -->
    <bean id="jsonMessageConverter"
          class="org.springframework.amqp.support.converter.Jackson2JsonMessageConverter" />

    <!--消息是否成功发送到Exchange 的回调-->
    <bean id="CallBackMQ" class="com.hyn.web.CallBackMQ"></bean>
    <!--消息从Exchange路由到队列的回调，注意这里只有路由失败的时候才会调此方法-->
    <bean id="ReturnCall" class="com.hyn.web.ReturnCall"></bean>
    <!-- 定义模版 -->
    <rabbit:template id="rabbitTemplate"
                     connection-factory="connectionFactory" exchange="IExchange"
                     message-converter="jsonMessageConverter" confirm-callback="CallBackMQ"
                     mandatory="true"
                     return-callback="ReturnCall" />

</beans>

由于配置文件中配置着两个回调，现在我们再来实现这两个回调方法

public class ReturnCall implements RabbitTemplate.ReturnCallback {
    /**
    *只有消息从Exchange路由到Queue失败才会回调这个方法
     */
    @Override
    public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
        System.out.println("消息从Exchage路由到Queue失败");
    }
}

public class CallBackMQ implements RabbitTemplate.ConfirmCallback {
    @Override
    public void confirm(CorrelationData correlationData, boolean b, String s) {
        if (b) {
            //设置消息投递成功
            System.out.println("消息投递成功");
        } else {
            //消息投递失败
            System.out.println("消息投递失败");
        }
    }
}

这两个回调方法实现后，通过bean注入到rabbitTemplate当消息发送失败后，就会触发这两个方法，我们可以在这两个方法中实现自己的业务逻辑。
接下来创建消息生产者的Controller

@RestController
@RequestMapping("rabbitTest")
public class RabbitController {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @RequestMapping(value="rabbit",method= RequestMethod.GET)
    public String rabbit(){

        HashMap<String, String> map = new HashMap<String, String>();
        map.put("id", "1");
        map.put("name", "zhangsan");
        //根据key发送到对应的队列
        rabbitTemplate.convertAndSend("queuekey", map);

        map.put("id", "2");
        map.put("name", "lisi");
        //根据key发送到对应的队列
        rabbitTemplate.convertAndSend("queuekey", map);
        return "success";
    }
}

以上消息的生产者配置完成，接下来我们配置消费者。消费者配置比生产者要稍微简单点。
消费者同样配置一个xml，放到项目的resource下

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/rabbit
 	http://www.springframework.org/schema/rabbit/spring-rabbit.xsd
     http://www.springframework.org/schema/context
     http://www.springframework.org/schema/context/spring-context-4.0.xsd
 	http://www.springframework.org/schema/beans
 	http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">

    <!-- 配置连接工厂 -->
    <rabbit:connection-factory id="connectionFactory"
                               host="${rabbit.host}" port="${rabbit.port}"
                               username="${rabbit.username}" password="${rabbit.password}"
     />

    <!-- 定义mq管理 -->
    <rabbit:admin connection-factory="connectionFactory" />

    <!-- 声明队列 -->
    <rabbit:queue name="queue" auto-declare="true" durable="true" />

    <!-- 定义消费者 -->
    <bean name="queuehandler" class="com.hyn.web.RecvHandler" />

    <!-- 定义消费者监听队列 acknowledge设置消费者手动确认消息 原因是：rabbitmq默认是自动确认消息的，不管消费者有没有消费成功
    只要消费者收到消息后就直接确认了，确认后rabbitmq就会将队列中的消息删除掉 如果消费者收到消息后实际没有消费成功，就会导致消息丢失
        -->
    <rabbit:listener-container
            connection-factory="connectionFactory" acknowledge="manual">
        <rabbit:listener ref="queuehandler" queues="queue" />
    </rabbit:listener-container>

</beans>

然后书写消费者代码，大家可以详细看代码中的注释。

public class RecvHandler implements ChannelAwareMessageListener {

    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        boolean falg = false;
        try {
            // msg就是rabbitmq传来的消息，需要的同学自己打印看一眼
            // 使用jackson解析
            String s = new String(message.getBody());
            System.out.println(s);
            falg = true;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            MessageProperties properties = message.getMessageProperties();
            long tag = properties.getDeliveryTag();
            //消费成功后将手动确认消息
            if (falg) {
                //消息确认，发送成功
                channel.basicAck(tag, false);
            } else {
                //如果发送失败，消息会重新进入队列，再次被这个消费者消费
                //消息发送失败后，也可以将消息发送到别的队列，让其他消费者进行消费
                //第三个参数 true为重新将消息放入队列，如果设置为false，则抛弃这条消息
                channel.basicNack(tag, false, true);
            }
        }

    }



}

完成以上配置，功能就基本实现了，我们可以从浏览器访问生产者接口，此时生产者生产消息，消费者直接消费消息。