rabbitmq安装使用实例

rabbitmq安装使用及示例

#安装配置
RabbitMQ的运行需要erlang的支持，先安装erlang，再安装rabbitmq服务器。
1>erlang包：
32位下载地址：http://www.erlang.org/download/otp_win64_18.2.1.exe
64位下载地址：http://www.erlang.org/download/otp_win32_18.2.1.exe
双击选择默认安装就好。
2>rabbitmq包
下载地址：http://www.rabbitmq.com/releases/rabbitmq-server/v3.3.4/rabbitmq-server-3.3.4.exe
选择默认安装就好
3>启动rabbitmq服务
cmd，进入到安装目录的sbin文件夹下，命令如下：

rabbit常用命令：
切换到rabbitmq sbin目录，
关闭应用：rabbitmqctl stop_app
清空队列：rabbitmqctl reset（会重置rabbitmq设置，清除用户以及队列消息，谨慎使用！）
重启应用：rabbitmqctl start_app

rabbitmq配置文件

1、rabbitmq.properties(guest默认只能本地登录，不允许远程登录，远程登录需要更改配置文件)
#本地
rmq.ip=127.0.0.1
rmq.port=5672
rmq.manager.user=guest
rmq.manager.password=guest
2、引入jar包 maven管理：

 <dependency>
	<groupId>com.rabbitmq</groupId>
	<artifactId>amqp-client</artifactId>
	<version>5.6.0</version>
</dependency>
<!--整合spring-->
<dependency>
   	<groupId>org.springframework.amqp</groupId>
   	<artifactId>spring-rabbit</artifactId>
   	<version>2.1.4.RELEASE</version>
</dependency>
<dependency>
    <groupId>commons-lang</groupId>
    <artifactId>commons-lang</artifactId>
    <version>2.6</version>
</dependency>

3、spring-context-rabbitmq.xml

web.xml文件配置启动加载spring-context-rabbitmq.xml 文件

<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>classpath*:/spring-context*.xml</param-value>
</context-param>

spring-context-rabbitmq.xml 完整文件如下：

<?xml version="1.0" encoding="UTF-8"?>

 <!-- 引入配置文件 -->
<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
	<property name="locations">
	<list>
	<value>classpath:rabbitmq.properties</value>
	</list>
	</property>
</bean>
 	
<!--创建连接工厂-->
 <rabbit:connection-factory id="connectionFactory"
                           host="${rmq.ip}"
                           port="${rmq.port}"
                           username="${rmq.manager.user}"
                           password="${rmq.manager.password}"/> 
                            
<!--通过指定admin信息，当前生产的exchange和queue信息会在admin自动生成-->
<rabbit:admin connection-factory="connectionFactory"/>

<!--定义消息模板，用于消息的接收和发送-->
<rabbit:template id="rabbitTemplate" connection-factory="connectionFactory" exchange="test_exchange" receive-timeout="10000"/>

<!--创建队列-->
<!-- <rabbit:queue name="test_queue1" auto-delete="false" durable="true" exclusive="false"/> -->
<rabbit:queue name="test_queue2" auto-delete="false" durable="true" exclusive="false"/>

<!--设置转换器类型，并与队列进行绑定-->
<rabbit:topic-exchange name="test_exchange" durable="true" auto-delete="false">
    <rabbit:bindings>
        <rabbit:binding pattern="test_exchange_bind1" queue="test_queue2"/>
        <!-- <rabbit:binding pattern="test_exchange_bind" queue="test_queue2"/>
        <rabbit:binding pattern="test_exchange_bind" queue="test_queue3"/> -->
    </rabbit:bindings>
</rabbit:topic-exchange>

<bean id="taskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
  <property name="corePoolSize" value="2"></property>
  <property name="maxPoolSize" value="5"></property>
 </bean>
 
<!--消费者配置-->
<bean id="testService" class="com.tangchaolizi.test.service.TestService"/>
<!-- 配置监听acknowledeg="manual"设置手动应答，不会丢失消息-->
<rabbit:listener-container connection-factory="connectionFactory" acknowledge="manual" concurrency= "2" task-executor="taskExecutor">
    <!-- <rabbit:listener ref="testService" queue-names="test_queue1"/> -->
    <rabbit:listener ref="testService" queue-names="test_queue2"/>
    <!-- <rabbit:listener ref="testService" queue-names="test_queue3"/> -->
</rabbit:listener-container>

##生产者发送消息 @Autowired private AmqpTemplate amqpTemplate; //向mq发送一条调用消息 amqpTemplate.convertAndSend("test_exchange_bind1",obj);//obj-要发送的消息实体信息 ###消费者消费消息 TestService 消费者实现类： package com.tangchaolizi.test.service; import java.io.Exception; import java.net.URLEncoder;

import org.apache.commons.lang.SerializationUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.beans.factory.annotation.Value;

import com.alibaba.fastjson.JSONObject;
import com.daxin.credit.enterprise.common.utils.HttpPostUtil;
import com.rabbitmq.client.Channel;

//实现监听
public class TestService implements ChannelAwareMessageListener{

public static Logger logger = LoggerFactory.getLogger(TestService.class);
@Override
public void onMessage(Message message, Channel channel) {
	logger.info("收到消息请求---------------------");
	//反序列消息实体，转换成实体
	JSONObject obj = (JSONObject) SerializationUtils.deserialize(message.getBody());
	try {
	    logger.info(obj.toString)
	} catch (Exception e) {
		e.printStackTrace();
	}finally{
		try {
		    //直接ack确认吧，nack的话消息会回到消息队列，消费失败的话会造成队列死循环，一直发送消费消息一直失败
			//具体的业务流程没走的话，在具体业务逻辑中处理消费失败的情况，比如还原为之前的状态
			channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);//确认消息
			logger.info("消息已确认---------------------");
		} catch (Exception e) {
			e.printStackTrace();
		}			
	}
}

}
####目前还在研究rabbitmq,如有错误欢迎指正。