activeMq实践，jms应用

注入工具：

@Autowired

    @Qualifier("lvtuActivityMessageProducer")

    private LvtuMessageProducer lvtuActivityMessageProducer;

<bean id="lvtuActivityMessageProducer" class="com.lvtu.csa.jms.LvtuMessageProducer">

        <property name="template" ref="lvtuActivityJmsTemplate" />

        <property name="destination" value="ActiveMQ.LVTU_APP" />

    </bean>

生产者：

package com.lvtu.csa.jms;

import com.google.common.collect.Maps;

import com.lvmama.com.lvtu.common.jms.LvtuMessage;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.jms.core.JmsTemplate;

import org.springframework.scheduling.annotation.Async;

import java.util.Map;

/**

 * Created by Administrator on 2016/10/12.

 */

public class LvtuMessageProducer {

    private static final Logger LOGGER = LoggerFactory.getLogger(LvtuMessageProducer.class);

    private static Map<String, String[]> topicMap = Maps.newHashMap();

    static {

        String[] activeMqLvtuSso = new String[] { "ActiveMQ.LVTU_SSO.client_sso"};

        String[] activeMqLvtuService = new String[] { "ActiveMQ.LVTU_APP.client_service"};

        String[] activeMqLvtuPush = new String[] { "ActiveMQ.LVTU_PUSH.client_push"};

        topicMap.put("ActiveMQ.LVTU_SSO", activeMqLvtuSso);

        topicMap.put("ActiveMQ.LVTU_APP", activeMqLvtuService);

        topicMap.put("ActiveMQ.LVTU_PUSH", activeMqLvtuPush);

    }

    private JmsTemplate template;

    private String destination;

    /**

     * 向一个 Queue 组发送JMS，达到 Topic 效果

     *

     * <pre>

     * 从 Memcached 获取 JMS 控制参数，对消息进行 复制，移动（升级）操作

     * 控制参数格式：[queue name / group name]=[operation 1.copy 2. move]|[JMS event type]|[new q destination]

     * 对于 group name 的情况，operation 只能为 1

     * 例子：

     *     1. 把order所有消息复制到 ActiveMQ.ORDER.monitor，ActiveMQ.ORDER.monitor2 {ActiveMQ.ORDER=1|*|ActiveMQ.ORDER.monitor,ActiveMQ.ORDER.monitor2}

     * </pre>

     *

     * @param msg

     */

    @Async

    public void sendMsg(LvtuMessage msg) {

        LOGGER.info("JMS发送的消息 => " + msg.toString());

        // 获取队列列表

        String[] queues = topicMap.get(destination);

        for (String queue : queues) {

            template.convertAndSend(queue, msg);

        }

    }

    public void setTemplate(JmsTemplate template) {

        this.template = template;

    }

    public void setDestination(String destination) {

        this.destination = destination;

    }

}

应用接口：

/**

     * 专题活动-通用注册接口

     * */

    @Override

    @ResponseBody

    @RequestMapping("/api.com.user.sso.usual.activity.register/1.0.0")

    public RopResponse<UserActivityRegisterResponse> usualActivityRegister(UserActivityRegisterRequest request) {

        // 校验参数合法性

        RopResponse<UserActivityRegisterResponse> responseBody = validate4UsualActivityRegister(request);

        if (responseBody != null) {

            return responseBody;

        }

        // 手机号码

        String mobile = request.getMobile();

        // 若是专题需要短信验证码，则进行短信验证码校验

        if(request.isCheckMsgAuthCode()) {

            // 短信验证码

            String msgAuthCode = request.getMsgAuthCode();

            // 校验短信验证码

            responseBody = validateUsualMsgAuthCode(mobile, msgAuthCode);

            if (responseBody != null) {

                return responseBody;

            }

            String basicKey = MemcachedConstants.USUAL_CACHEKEY_CONSTANTS.MYLVMM_LVTU_ACTIVITY_AUTH_CODE_MSG_KEY.getCacheKey();

            // 校验成功后，删除验证码

            stringRedisTemplate.delete(basicKey + mobile.trim());

        } else {

            logger.info("Mobile: " + mobile + " 不检查短信验证码，直接进行注册操作！");

        }

        // 发送MQ消息

        sendMQMsg(request);

        String lvsessionid = request.getLvsessionid();

        String timestamp = request.getStamptime();

        RedisPersistentUtils.getInstance("USUAL_ACTIVITY_REGISTER").set(DateUtil.getDateByStr(timestamp, "yyyy-MM-dd HH:mm:ss.S").getTime() + lvsessionid, lvsessionid, 2*60*60);

        return RopResponse.success(new UserActivityRegisterResponse());

    }
 

    private void sendMQMsg(UserActivityRegisterRequest request) {

        LvtuMessage lvtuMessage = LvtuMessageFactory.newRegisterMsg(-1L);

        lvtuMessage.setEventType("USUAL_ACTIVITY_REGISTER");

        String data = null;

        try {

            data = madeData(request);

        } catch (IOException e) {

            logger.info(e);

            return;

        }

        lvtuMessage.setAddition(data);

        lvtuActivityMessageProducer.sendMsg(lvtuMessage);

    }

   

消费者监听配置：

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

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans default-autowire="byName">

    <!-- consumer begin -->

    <bean id="lvtuSSOConsumer" class="com.lvtu.csa.jms.LvtuMessageConsumer">

        <property name="destName" value="ActiveMQ.LVTU_SSO.${lvtu_jms_node}" />

        <property name="processerList">

            <list>

                <ref bean="lvtuDefaultAccessProcesser"/>

                <ref bean="lvtuLoginProcesser" />

                <ref bean="lvtuRegisterProcesser" />

            </list>

        </property>

    </bean>

    

    <bean id="lvtuActivityMessageConsumer" class="com.lvtu.csa.jms.LvtuMessageConsumer">

        <property name="destName" value= "ActiveMQ.LVTU_APP.${lvtu_activity_jms_node}"/>

        <property name="processerList">

            <list>

                <ref bean="usualActivityRegisterMessageProcesser" />

            </list>

        </property>

    </bean>

    

    <!-- consumer end -->

    

    <!-- listener container begin -->

    <bean id="lvtuLoginListenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">

        <property name="connectionFactory" ref="lvtuJmsConnectionFactory" />

        <property name="destination" ref="LVTU_SSO_TOPIC" />

        <property name="messageListener" ref="lvtuLoginListener" />

        <property name="taskExecutor" ref="clientSsoMsgConsumerThreadPool"/>

        <!--

        <property name="concurrentConsumers" value="5" />

        <property name="maxConcurrentConsumers" value="20" />

        -->    

    </bean>

    <bean id="lvtuActivityListenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">

        <property name="connectionFactory" ref="lvtuActivityJmsConnectionFactory" />

        <property name="destination" ref="LVTU_ACTIVITY_TOPIC" />

        <property name="messageListener" ref="lvtuActivityMessageListener" />

    </bean>

    <!-- listener container end -->

    

    <!-- listener begin -->

    <bean id="lvtuLoginListener" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">

        <constructor-arg ref="lvtuSSOConsumer" />

        <property name="defaultListenerMethod" value="receive" />

    </bean>

    <bean id="lvtuActivityMessageListener" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">

        <constructor-arg ref="lvtuActivityMessageConsumer" />

        <property name="defaultListenerMethod" value="receive" />

    </bean>

    <!-- listener end -->

    

    <!-- processer begin -->

    <bean id="lvtuLoginProcesser" class="com.lvtu.csa.usso.mq.processer.LvtuLoginProcesser" />

    <bean id="lvtuRegisterProcesser" class="com.lvtu.csa.usso.mq.processer.LvtuRegisterProcesser" />

    <bean id="lvtuDefaultAccessProcesser" class="com.lvtu.csa.usso.mq.processer.LvtuDefaultAccessProcesser" />

    <bean id="usualActivityRegisterMessageProcesser" class="com.lvtu.csa.usso.mq.processer.UsualActivityRegisterMessageProcesser"/>

    <!-- processer end -->

    <!-- 线程池 -->

    <bean id="clientSsoMsgConsumerThreadPool" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">

        <!-- 核心线程数 -->

        <property name="corePoolSize" value="20" />

        <!-- 最大线程数 -->

        <property name="maxPoolSize" value="30" />

        <!-- 队列最大长度 >=mainExecutor.maxSize -->

        <property name="queueCapacity" value="2000" />

        <!-- 线程池维护线程所允许的空闲时间 -->

        <property name="keepAliveSeconds" value="300" />

        <!-- 线程池对拒绝任务(无线程可用)的处理策略 -->

        <property name="rejectedExecutionHandler">

            <bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy" />

        </property>

    </bean>

</beans>

lvtu_activity_jms_server=tcp://localhost:61616?wireFormat.maxInactivityDuration=0

lvtu_activity_jms_node=client_service

jms_server=tcp://localhost:61616?wireFormat.maxInactivityDuration=0

jms_node=sso

#lvtu_jms_server=tcp://jms.lvmama.com:61616?wireFormat.maxInactivityDuration=0

lvtu_jms_server=tcp://localhost:61616?wireFormat.maxInactivityDuration=0

lvtu_jms_node=client_sso

#主站->无线接口Resource队列

lvtu_resource_jms_node=client_api


对应消费类：

package com.lvtu.csa.usso.mq.processer;

import java.io.ByteArrayInputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.security.NoSuchAlgorithmException;

import java.util.ArrayList;

import java.util.Date;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.UUID;

import net.sf.json.JSONObject;

import org.apache.commons.lang.StringEscapeUtils;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import com.lvmama.com.lvtu.common.jms.LvtuMessage;

import com.lvmama.comm.pet.po.user.UserUser;

import com.lvmama.comm.pet.service.mark.MarkCouponService;

import com.lvmama.comm.pet.service.mobile.MobileClientService;

import com.lvmama.comm.pet.service.sms.SmsRemoteService;

import com.lvmama.comm.pet.service.user.UserUserProxy;

import com.lvmama.comm.pet.vo.favor.CouponCheckParam;

import com.lvmama.comm.utils.UserUserUtil;

import com.lvtu.csa.context.model.user.request.UserMsgAuthCodeRequest;

import com.lvtu.csa.framework.utils.DateUtil;

import com.lvtu.csa.jms.LvtuMessageProcesser;

import com.lvtu.csa.usso.service.sso.UserMsgAuthCodeServiceImpl;

import com.lvtu.csa.usso.utils.RedisPersistentUtils;

import com.lvtu.service.api.rop.service.sso.FavourableActivityUserInfo;

public class UsualActivityRegisterMessageProcesser implements LvtuMessageProcesser {

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

    /** 错误信息存储到redis的目录 */

    private static final String ERROR_MSG_DIR = "USUAL_ACTIVITY";

    @Autowired

    private MobileClientService mobileClientService;

    @Autowired

    private SmsRemoteService smsRemoteService;

    @Autowired

    private UserUserProxy userProxy;

    @Autowired

    private MarkCouponService markCouponService;

    @Autowired

    private UserMsgAuthCodeServiceImpl userMsgAuthCodeService;

    @Override

    public void process(LvtuMessage message) {

        // 仅处理USUAL_ACTIVITY_REGISTER消息（专题活动注册消息）

        if (!"USUAL_ACTIVITY_REGISTER".equals(message.getEventType())) {

            return;

        }

        String data = message.getAddition();

        FavourableActivityUserInfo userInfo = null;

        try {

            userInfo = parseData(data);

            // 注册

            UserUser user = register(userInfo);

            userInfo.setUserId(user.getId());

            userInfo.setUserNo(user.getUserNo());

            userInfo.setRealPassword(user.getRealPass());

            // 生成优惠券，并绑定到用户

            generateCodeAndBindUser(user, userInfo);

            // 发短信

            sendMobileMsg(userInfo);

        } catch (Exception e) {

            logger.error(e);

            // 异常的处理结果记录KEY   key:COM:LVTU:USUAL_ACTIVITY:ERROR_KEYS

            String errorKeys = RedisPersistentUtils.getInstance(ERROR_MSG_DIR).get("ERROR_KEYS");

            String uuid = UUID.randomUUID().toString();

            Map<String, Object> errResult = new HashMap<String, Object>();

            if(null != userInfo) {

                errResult.put("mobile", userInfo.getMobile());

                errResult.put("userId", userInfo.getUserId());

            }

            errResult.put("errMsg", e.getMessage());

            // 将错误信息记录到Redis中

            RedisPersistentUtils.getInstance(ERROR_MSG_DIR).set(uuid, JSONObject.fromObject(errResult).toString());

            // 将记录错误的KEY拼接起来

            if (StringUtils.isBlank(errorKeys)) {

                errorKeys = "COM:LVTU:" + ERROR_MSG_DIR + ":" + uuid;

            } else {

                errorKeys = errorKeys + ",COM:LVTU:" + ERROR_MSG_DIR + ":" + uuid;

            }

            // 将所有key作为数据存入到redis，并将此数据对应的key暴露出去

            RedisPersistentUtils.getInstance(ERROR_MSG_DIR).set("ERROR_KEYS", errorKeys);

        }

    }

    /**

     * 发提醒短信

     * @param userInfo

     */

    @SuppressWarnings("unchecked")

    private void sendMobileMsg(FavourableActivityUserInfo userInfo) {

        // 解析短信相关参数信息Map<短信类型, 短信参数信息>

        Map<String, Object> mobileMsgInfos = parseMobileMsgInfo(userInfo);

        // 发送短信请求实体

        UserMsgAuthCodeRequest request = new UserMsgAuthCodeRequest();

        request.setStamptime(DateUtil.formatDate(new Date(), "yyyy-MM-dd HH:mm:ss.S"));

        request.setMobile(userInfo.getMobile());

        request.setLvsessionid(UUID.randomUUID().toString());

        // 若是用户为刚注册的，则发注册提醒短信

        if(userInfo.isNewRegister()) {

            // 注册短信相关参数

            Map<String, Object> mobileMsgInfo = (Map<String, Object>) mobileMsgInfos.get("needRegistMobileMsg");

            // 短信模板

            request.setTemplateId((String)mobileMsgInfo.get("templateId"));

            // 短信参数KEY

            request.setMsgKeys((String[])mobileMsgInfo.get("msgKeys"));

            // 短信参数值

            request.setMsgValues((String[])mobileMsgInfo.get("msgValues"));

            // 调用普通短信发送接口(专题使用，发送普通提醒短信)

            userMsgAuthCodeService.sendActivityMsg(request);

        } else {

            // 不需要注册的相关短信参数

            Map<String, Object> mobileMsgInfo = (Map<String, Object>) mobileMsgInfos.get("notNeedRegistMobileMsg");

            // 短信模板

            request.setTemplateId((String)mobileMsgInfo.get("templateId"));

            // 短信参数KEY

            request.setMsgKeys((String[])mobileMsgInfo.get("msgKeys"));

            // 短信参数值

            request.setMsgValues((String[])mobileMsgInfo.get("msgValues"));

            // 调用普通短信发送接口(专题使用，发送普通提醒短信)

            userMsgAuthCodeService.sendActivityMsg(request);

        }

        // 其他短信（此列表中的短信默认都全部发送）（保留逻辑，当前此结果为空，即不会执行此段逻辑）

        List<Map<String, Object>> otherMsgInfoList = (List<Map<String, Object>>) mobileMsgInfos.get("otherMobileMsg");

        for (int i = 0; i < otherMsgInfoList.size(); i++) {

            Map<String, Object> mobileMsgInfo = otherMsgInfoList.get(i);

            request.setStamptime(DateUtil.formatDate(new Date(), "yyyy-MM-dd HH:mm:ss.S"));

            request.setTemplateId((String)mobileMsgInfo.get("templateId"));

            request.setMsgKeys((String[])mobileMsgInfo.get("msgKeys"));

            request.setMsgValues((String[])mobileMsgInfo.get("msgValues"));

            userMsgAuthCodeService.sendActivityMsg(request);

        }

    }

    /**

     * 解析短信内容

     * @param userInfo

     * @return

     */

    private Map<String, Object> parseMobileMsgInfo(FavourableActivityUserInfo userInfo) {

        Map<String, Object> result = new HashMap<String, Object>();

        // 短信模板

        String[] templateIds = userInfo.getTemplateIds();

        // 对应短信模板中的参数个数

        Integer[] templateParamNums = userInfo.getTemplateParamNum();

        // 短信参数KEY

        String[] msgKeys = userInfo.getMsgKeys();

        // 短信参数值

        String[] msgValues = userInfo.getMsgValues();

        // 第一个模板为新用户注册成功的短信模板（必输）

        String needRegistTemplateId = templateIds[0];

        Map<String, Object> msgInfoMap = new HashMap<String, Object>();

        msgInfoMap.put("templateId", needRegistTemplateId);

        // 根据短信模板对应的参数个数，从【短信参数KEY】和【短信参数值】中获取参数信息

        Integer tempTemplateParamNum = templateParamNums[0];

        // 定义与参数数量等长的数组

        String[] tempMsgKeys = new String[tempTemplateParamNum];

        String[] tempMsgValues = new String[tempTemplateParamNum];

        // 遍历【短信参数KEY】和【短信参数值】获取对应的属性

        for (int i = 0; i < tempTemplateParamNum; i++) {

            tempMsgKeys[i] = msgKeys[i];

            tempMsgValues[i] = msgValues[i];

        }

        msgInfoMap.put("msgKeys", tempMsgKeys);

        msgInfoMap.put("msgValues", tempMsgValues);

        result.put("needRegistMobileMsg", msgInfoMap);

        

        // 第二个模板为非注册用户的短信模板（必输）

        String notNeedRegistTemplateId = templateIds[1];

        msgInfoMap = new HashMap<String, Object>();

        msgInfoMap.put("templateId", notNeedRegistTemplateId);

        // 第二个模板对应的参数个数

        tempTemplateParamNum = templateParamNums[1];

        // 定义与参数数量等长的数组

        tempMsgKeys = new String[tempTemplateParamNum];

        tempMsgValues = new String[tempTemplateParamNum];

        // 遍历【短信参数KEY】和【短信参数值】从第一个模板的参数数量值起，两个模板中参数个数的和作为结束

        for (int i = templateParamNums[0]; i < templateParamNums[0] + tempTemplateParamNum; i++) {

            tempMsgKeys[i-templateParamNums[0]] = msgKeys[i];

            tempMsgValues[i-templateParamNums[0]] = msgValues[i];

        }

        msgInfoMap.put("msgKeys", tempMsgKeys);

        msgInfoMap.put("msgValues", tempMsgValues);

        result.put("notNeedRegistMobileMsg", msgInfoMap);

        

        // 其他短信模板（保留逻辑）

        List<Map<String, Object>> otherMsgInfoList = new ArrayList<Map<String, Object>>();

        // 模板对应参数开始取值位置

        int startIndex = templateParamNums[0] + templateParamNums[1];

        // 模板对应参数结束取值位置

        int endIndex = templateParamNums[0] + templateParamNums[1];

        // 模板从第三个开始取（前2个有特殊含义）

        for (int i = 2; i < templateIds.length; i++) {

            // 短信模板

            String templateId = templateIds[i];

            // 对应短信模板的参数个数

            Integer templateParamNum = templateParamNums[i];

            // 重置  模板对应参数取值下标位置

            endIndex += templateParamNum;

            // 定义与参数数量等长的数组

            tempMsgKeys = new String[tempTemplateParamNum];

            tempMsgValues = new String[tempTemplateParamNum];

            // 遍历【短信参数KEY】和【短信参数值】，取对应的短信参数

            for (int j = startIndex; j < endIndex; j++) {

                tempMsgKeys[j-startIndex] = msgKeys[j];

                tempMsgValues[j-startIndex] = msgValues[j];

            }

            msgInfoMap = new HashMap<String, Object>();

            msgInfoMap.put("templateId", templateId);

            msgInfoMap.put("msgKeys", tempMsgKeys);

            msgInfoMap.put("msgValues", tempMsgValues);

            otherMsgInfoList.add(msgInfoMap);

            // 重置  模板对应参数开始取值位置

            startIndex += templateParamNum;

        }

        result.put("otherMobileMsg", otherMsgInfoList);

        return result;

    }

    /**

     * 生成优惠券，并绑定到用户

     * @param user

     * @param userInfo

     */

    private void generateCodeAndBindUser(UserUser user, FavourableActivityUserInfo userInfo) {

        // 优惠券批次号

         String couponIds = userInfo.getCouponIds();

        if (StringUtils.isBlank(couponIds)) {

            return;

        }

        // 根据逗号拆分优惠券批次号

        String[] couponIdStrs = couponIds.trim().split(",");

        // 统计相同批次号的个数

        Map<Long, Integer> param = new HashMap<Long, Integer>();

        for (String strCouponId : couponIdStrs) {

            long couponId = Long.valueOf(strCouponId);

            Integer value = param.get(couponId);

            if(value == null) {

                param.put(couponId, 1);

            } else {

                value = value + 1;

                param.put(couponId, value);

            }

        }

        // 标记优惠券是否有发送失败

        boolean flag = false;

        Iterator<Long> it = param.keySet().iterator();

        while (it.hasNext()) {

            Long couponId = it.next();

            CouponCheckParam checkParam = new CouponCheckParam();

            checkParam.setUserId(user.getId());

            checkParam.setCouponId(couponId);

            checkParam.setPlatform("MOBILE");

            checkParam.setGenerateNo(Long.parseLong(String.valueOf(param.get(couponId))));

            checkParam.setDeviceNo(userInfo.getUdid());

            // 调用主站接口，完成优惠券的生成绑定操作

            Map<String, String> result = markCouponService.generateCodeAndBindUser(checkParam);

            if(result != null && !result.isEmpty()) {

                flag = true;

                logger.error("Coupon to fail, CouponId:" + couponId + " UserId:" + userInfo.getUserId() + " UserNo:" + user.getUserNo() + " Mobile:" + userInfo.getMobile());

            }

        }

        // 若是发送优惠券存在失败，则将异常抛出去，统一最外层处理

        if(flag) {

            throw new RuntimeException("批量发送优惠券失败，或部分失败！！" + " UserId:" + userInfo.getUserId() + " UserNo:" + user.getUserNo() + " Mobile:" + userInfo.getMobile());

        }

    }

    private UserUser register(FavourableActivityUserInfo userInfo) {

        // 用户信息

        UserUser user = null;

        // 手机号

        String mobile = userInfo.getMobile();

        if (userProxy.isUserRegistrable(UserUserProxy.USER_IDENTITY_TYPE.MOBILE, mobile)) {

            Map<String, Object> parameters = new HashMap<String, Object>();

            parameters.put("registerIp", userInfo.getIp());

            parameters.put("mobileNumber", mobile);

            parameters.put("channel", userInfo.getSecondChannel());

            // 产生默认用户信息

            user = userProxy.generateUsers(parameters);

            // 将手机号码设置为已验证

            user.setIsMobileChecked("Y");

            // html代码 &解析 ；

            String password = StringEscapeUtils.unescapeHtml(userInfo.getRealPassword());

            // 设置明文密码

            user.setRealPass(password);

            // 设置加密密码

            try {

                user.setUserPassword(UserUserUtil.encodePassword(password));

            } catch (NoSuchAlgorithmException e) {

                logger.error(e.getMessage());

                throw new RuntimeException("用户注册失败：" + e.getMessage());

            }

            // 注册用户

            user = userProxy.register(user);

            logger.info("注册成功：mobile: "+ mobile + "  userId:" + user.getId() + "  userNo:" + user.getUserNo());

            userInfo.setNewRegister(true);

            // 记录用户注册日志

            saveMobilePeristanceLog(userInfo);

        } else {

            logger.info("账号已注册");

            user = userProxy.getUsersByMobOrNameOrEmailOrCard(mobile);

            userInfo.setNewRegister(false);

        }

        return user;

    }

    /**

     * 记录用户注册日志

     * @author wxliyong

     * @date 2015-6-1 下午6:15:46

     */

    @SuppressWarnings("deprecation")

    private void saveMobilePeristanceLog(FavourableActivityUserInfo userInfo) {

        Long appVersion = 0L;

        if (!StringUtils.isEmpty(userInfo.getLvversion())) {

            appVersion = Long.valueOf(userInfo.getLvversion().replaceAll("[.]", ""));

        }

        // 记录注册日志

        mobileClientService.insertMobilePersistanceLog(userInfo.getFirstChannel(), userInfo.getSecondChannel(), userInfo.getUdid(), appVersion, userInfo.getUserId(), com.lvmama.comm.vo.Constant.SSO_EVENT.REGISTER.name(),userInfo.getOsVersion(), userInfo.getUserAgent());

    }

    private FavourableActivityUserInfo parseData(String data) throws Exception {

        try {

            return (FavourableActivityUserInfo) deserialize(data);

        } catch (Exception e) {

            logger.error(e.getMessage());

            throw e;

        }

    }

    /**

     * 将序列化字符串反序列化

     * @author wxliyong

     * @throws IOException

     * @date 2015-4-3 下午4:21:20

     */

    private Object deserialize(String value) throws Exception {

        ByteArrayInputStream byteArrayInputStream = null;

        ObjectInputStream objectInputStream = null;

        try {

            String redStr = java.net.URLDecoder.decode(value, "UTF-8");

            byteArrayInputStream = new ByteArrayInputStream(redStr.getBytes("ISO-8859-1"));

            objectInputStream = new ObjectInputStream(byteArrayInputStream);

            return objectInputStream.readObject();

        } catch (Exception e) {

            logger.error(e);

            throw e;

        } finally {

            if(null != objectInputStream) {

                objectInputStream.close();

            }

            if(null != byteArrayInputStream) {

                byteArrayInputStream.close();

            }

        }

    }

}