基于RabbitMq系统重构

阅读更多

一、RabbitMQ 简介
官网：http://www.rabbitmq.com/
rabbitMQ 是 AMQP 用 Erlang 实现的 MQ AMQP 主要是由金融领域的软件专家们贡献的创意，而联合了通讯和软件方面的力量，一起打造出来的规范。只要遵循 AMQP 的协议，任何一种语言都可以开发消息组件乃至中间件本身。我们之前使用的activeMQ是实现了jms接口，只能在java环境使用。


参考博文：http://langyu.iteye.com/blog/759663
AMQP协议是一种二进制协议，提供客户端应用与消息中间件之间异步、安全、高效地交互。从整体来看，AMQP协议可划分为三层：




消息中间件的主要功能是消息的路由(Routing)和缓存(Buffering)。在AMQP中提供类似功能的两种域模型：Exchange 和 Message queue。


二、基本概念

如上图所示rabbitmq主要包括四部分组成
1，P代表生产者，C 代表消费者，X exchange 交换器，Q红色的表示队列
2，P和C都是在客户端，X和Q在服务器端。
3，发送接收的大概流程是，P发送消息至交换器。
4，C先声明一个队列，然后将队列和交换器绑定，接着接受消息。
5，换句话说，P和C互相不知道对方存在。


三、RabbitMQ Server 安装
1，下载地址：http://www.rabbitmq.com/download.html ，支持多种操作系统：

   * Windows: With installer (recommended) | Manual
   * Linux / Unix: Debian / Ubuntu | Fedora / RHEL | Generic Unix | Solaris
   * Mac OS X: Standalone | Generic Unix | Macports | Homebrew
   * Cloud: EC2

三、RabbitMQ原生代码实例
1,交换器类型：direct, topic, headers和 fanout

Exchange在定义的时候是有类型的，以决定到底是哪些Queue符合条件，可以接收消息
fanout
所有bind到此exchange的queue都可以接收消息
direct
通过routingKey和exchange决定的那个唯一的queue可以接收消息
topic
所有符合routingKey(此时可以是一个表达式)的routingKey所bind的queue可以接收消息
表达式符号说明：#代表一个或多个字符，*代表任何字符
例：#.a会匹配a.a，aa.a，aaa.a等
*.a会匹配a.a，b.a，c.a等
注：使用RoutingKey为#，Exchange Type为topic的时候相当于使用fanout

Headers
类型的exchange使用的比较少，它也是忽略routingKey的一种路由方式。是使用Headers来匹配的。Headers是一个键值对，可以定义成Hashtable。发送者在发送的时候定义一些键值对，接收者也可以再绑定时候传入一些键值对，两者匹配的话，则对应的队列就可以收到消息。匹配有两种方式all和any。这两种方式是在接收端必须要用键值"x-mactch"来定义。all代表定义的多个键值对都要满足，而any则代码只要满足一个就可以了。

参考博文：http://www.cnblogs.com/haoxinyue/archive/2012/09/28/2707041.html
实例内容：点对点，工作队列，订阅/发布，路由，主题，RPC
官网实例：http://www.rabbitmq.com/getstarted.html

中文翻译：http://adamlu.net/dev/2011/09/rabbitmq-get-started/

四，spring-amqp
官网：http://projects.spring.io/spring-amqp/
Spring AMQP 是基于 Spring 框架的 AMQP 消息解决方案，提供模板化的发送和接收消息的抽象层，提供基于消息驱动的 POJO。
maven引用：
            org.springframework.amqp        spring-rabbit        1.2.0.RELEASE   
实例：http://docs.spring.io/spring-amqp/reference/html/sample-apps.html

五、tbss与spring整合的日志记录模块

1，虚拟机安装了rabbitMQ，ip:192.168.17.130 默认端口：5672

2,log项目结构，如下图：

图1：原来的facade接口，对外供webservice的接口；
图2：增加基于rabbitmq队列的日志消费者服务项目
图3：集成单元测试：主要是LogProducter与spring中的log-rabbit.xml配置为模拟日志生产者

3，采用rabbitmq重构的目的
     3.1 建立星形的中心处理结构，解决原来webservice的网状部署分布；
     3.2 日志服务利用rabbitmq buffer定义可进行持久，对于日志记录（消费者）状态不关心，即透明，不会因为日志记录服务器宕机而导致主业务回滚或者日志丢失；
  
4，源代码分析
4.1 log-server
pom.xml

    
        log-parent
        com.yolema.log
        1.0.0.20120828
    
    4.0.0

    log-server
    ...
      
        
            org.springframework.amqp
            spring-rabbit
            ${spring.amqp.version}
        
        
            org.springframework
            spring-context
            ${spring.version}
        
       ...
 

LogConsumer.java

package com.yolema.log.server;

import com.yolema.log.core.biz.manager.LoginLogManager;
import com.yolema.log.core.biz.manager.OperateLogManager;
import com.yolema.log.core.model.entity.LoginLog;
import com.yolema.log.core.model.entity.OperateLog;
import com.yolema.log.core.model.enums.LogResultEnum;
import com.yolema.log.core.model.exceptions.LogException;
import com.yolema.log.core.model.results.GenericsResult;
import com.yolema.log.core.vo.operate.LogQueryVo;
import com.yolema.log.ext.facade.order.LogQueryOrder;
import com.yolema.log.ext.facade.results.LogExtResult;
import com.yolema.log.ext.facade.sdo.LoginLogSdo;
import com.yolema.log.ext.facade.sdo.OperateLogSdo;
import com.youlema.tools.jee.beanutils.BeanGeneralConvertor;
import com.youlema.tools.jee.converter.BeanConverter;
import com.youlema.tools.jee.pages.PageList;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.AmqpAdmin;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * 日志记录消费者
 * 

 * User: sys53
 * Date: 13-12-4 下午4:03
 * version $Id: LogProducter.java, v 0.1 Exp $
 */

public class LogConsumer {
    private final static Logger LOG = LoggerFactory.getLogger(LogConsumer.class);

    @Autowired
    private LoginLogManager     loginLogManager;

    @Autowired
    private OperateLogManager   operateLogManager;

    /**
     * 记录一条登录日志
     *
     * @return
     */
    public void recordLoginLog(LoginLogSdo loginLogSdo) {
        try {
            if (loginLogSdo == null) {
                LOG.info("记录登录日志参数不能为null");
                throw new LogException(LogResultEnum.ARGS_CAN_NOT_BE_NULL);
            }
            GenericsResult result = loginLogManager.insert(BeanConverter.convert(
                new LoginLog(), loginLogSdo));

            if (!result.isSuccess()) {
                throw new LogException(result.getResultCode(), result.getResultMsg());
            }

        } catch (LogException e) {
            LOG.error("记录登录日志失败,出现已知异常", e);
        } catch (Exception e) {
            LOG.error("记录登录日志失败，出现未知异常", e);
        }
    }

    /**
     * 记录一条操作日志
     */
    public void recordOperateLog(OperateLogSdo operateLogSdo) {
        try {

            if (operateLogSdo == null) {
                LOG.info("记录操作日志参数不能为null");
                throw new LogException(LogResultEnum.ARGS_CAN_NOT_BE_NULL);
            }

            GenericsResult result = operateLogManager.insert(BeanConverter.convert(
                new OperateLog(), operateLogSdo));

            if (!result.isSuccess()) {
                throw new LogException(result.getResultCode(), result.getResultMsg());
            }

        } catch (LogException e) {
            LOG.error("记录操作日志失败,出现已知异常", e);
        } catch (Exception e) {
            LOG.error("记录操作日志失败，出现未知异常", e);
        }
    }

    /**
     * 查询操作日志列表
     * @param logQueryOrder
     * @return
     */
    public LogExtResult queryOperateLog(LogQueryOrder logQueryOrder){
        LogExtResult extResult = new LogExtResult(true);

        try {

            GenericsResult> result = operateLogManager
                    .queryPageList(BeanConverter.convert(new LogQueryVo(),
                            logQueryOrder));

            if (!result.isSuccess()) {
                throw new LogException(result.getResultCode(), result.getResultMsg());
            }

            extResult.setOperateLogList(BeanGeneralConvertor.convertBeanList2BeanList(
                    OperateLogSdo.class, result.getResultData()));

        } catch (LogException e) {
            LOG.error("查询操作日志失败,出现已知异常", e);
            extResult.setSuccess(false);
            extResult.setResultCode(e.getResultCode());
            extResult.setResultMsg(e.getResultMsg());
        } catch (Exception e) {
            LOG.error("查询操作日志失败，出现未知异常", e);
            extResult.setSuccess(false);
            extResult.setResultMsg(e.getMessage());
        }

        return extResult;
    }
} 

log-rabbit.xml

在spring配置文件中定义由于主题交换类的监听设置
1，rabbit:connection-factory，定义：192.168.17.130 的connectionFactory
2，rabbit:template，定义rabbitTemplate，通过connectionFactory，交换机名为：logExchange，routing-key：log.service
3，定义队列名：log.queue
4，rabbit:topic-exchange 定义交机器，并rabbit:binding绑定在队列:log.queue,匹配所有routing-key是:log.开头的
5，bean id="logConsumer” 定义普通javabean，定义委托监听的执行方法
6，rabbit:listener-container定义在connectionFactory上的监听容器，rabbit:listener定义队列og.queue来的消息采用哪一个委托类方法；
（需要测试的问题，如果同一个队列中，不同的方法，参数是一样的话，可能会同时执行）
LogServer.java

package com.yolema.log.server;

import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 日志服务
 * 

 * User: sys53
 * Date: 13-12-4 下午4:02
 * version $Id: LogServer.java, v 0.1 Exp $
 */
public class LogServer {


    public static void main(String[] args){
        new ClassPathXmlApplicationContext("classpath:/log-*.xml");
    }
} 
直接调用spring架框就可以正常启动rabbitMQ监听容器

4.2生产者（junit单元测试代码）
    LogProducter.java
package com.yolema.log.test.integration;

import com.yolema.log.ext.facade.order.LogQueryOrder;
import com.yolema.log.ext.facade.results.LogExtResult;
import com.yolema.log.ext.facade.sdo.LoginLogSdo;
import com.yolema.log.ext.facade.sdo.OperateLogSdo;
import org.junit.Assert;
import org.junit.Test;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.Date;

/**
 * Write class comments here
 * 

 * User: sys53
 * Date: 13-12-4 下午5:12
 * version $Id: com.yolema.log.test.integration.LogProducter.java, v 0.1 Exp $
 */
public class LogProducter extends BaseTest{

    @Autowired
    private AmqpTemplate amqpTemplate;

    @Test
    public void recordLoginLog(){
        LoginLogSdo sdo = new LoginLogSdo();
        sdo.setClientArea("杭州");
        sdo.setClientBrowser("ie");
        sdo.setClientIp("127.0.0.1");
        sdo.setClientOs("xp");
        sdo.setLogContent("登录成功");
        sdo.setLogTarget("2");
        sdo.setLoginType("1");
        sdo.setLogTime(new Date());
        sdo.setLogResult("SUCCESS");
        amqpTemplate.convertAndSend(sdo);
    }

    @Test
    public void recordOperateLog(){
        OperateLogSdo sdo = new OperateLogSdo();
        sdo.setLogTarget("tbss");
        sdo.setLogTime(new Date());
        sdo.setLogLvl("1");
        sdo.setUrl("http://localhost:8080/tbss");
        sdo.setLogContent("rabbitmq测试增加用户");
        sdo.setSystemCode("tbss-code");
        sdo.setSystemName("tbss-all");
        sdo.setModelCode("user");
        sdo.setModelName("用户");
        sdo.setClientIp("192.168.0.252");
        sdo.setClientBrowser("IE");
        sdo.setClientArea("杭州");
        sdo.setClientOs("mac os x");
        amqpTemplate.convertAndSend(sdo);
       
    }

    @Test
    public void queryOperateLog(){
        LogQueryOrder logQueryOrder = new LogQueryOrder();
        LogExtResult logExtResult =(LogExtResult) amqpTemplate.convertSendAndReceive(logQueryOrder);
        Assert.assertTrue(logExtResult.isSuccess());
        System.out.println(logExtResult.getOperateLogList().size());

    }
} 

1,直接承继BaseTest的集成测试架构（默认定义spring配置）
2，定义三个测试类，发送三个不同参数
     2.1recordLoginLog（） 发送：amqpTemplate.convertAndSend（sdo）参数为LoginLogSdo 类
     2.2recordOperateLog（）发送：amqpTemplate.convertAndSend（sdo）,参数为OperateLogSdo 类
     2.3queryOperateLog(),同步等待队列返回结果amqpTemplate.convertSendAndReceive(logQueryOrder),参数LogQueryOrder 类
log-rabbit.xml

rabbit:template 定义amqpTemplate，在LogProducter 中可以自动注入，connectionFactory同消费者端

六、TBSS系统中非核心业务的架构