checkforsend.java

中国联通短信通信协议

package com.wireless.sms.gwif.smsagent.func;

import java.util.*;
import java.text.*;
import org.apache.log4j.Logger;


import com.wireless.sms.gwif.smsagent.global.LoggerConstant;
import com.wireless.sms.pub.entity.MT;
/**
 * 对下发mt类型进行鉴别,主要功能是限制群发级的mt在stimes[]包含的时段里下发给用户
 * @author Administrator
 *
 */
public class CheckForSend  {

    public static CheckForSend _instance = null;

    private String[] stimes = new String[] {"23", "00", "01", "02", "03", "04", "05", "06", "07"};
    private Set times = new HashSet();
    private SimpleDateFormat simpleDF = new SimpleDateFormat("HH");

    private static boolean physicsSerial = false;

    public SerialCache serialcache = new SerialCache();
    public UnserialCache unserialcache = new UnserialCache();

    private Logger log = LoggerConstant.mt_log;

    private CheckForSend(){
    	for(int i=0; i<stimes.length; i++){
            times.add(stimes[i]);
        }
    }
    public static void init(boolean ps){
        physicsSerial = ps;
    }
    /**返回CheckForSend的实例*/
    public static CheckForSend getInstance(){
    	if(_instance == null)
    		_instance = new CheckForSend();
        return _instance;
    }
//  subtype 1 退订通知2 定制通知3 点播业务4 定制包月业务下发7 包月话单9 代码方式10 首次定制回复信息11 帮助和错误提示12 定制按条业务下发
    /**
     * check规则:
     * 1.首先将判断该mt是否是 技术测试 或者 模拟下发 的类型,如果是则不发送直接入库;
     * 2.如果mt为均衡状态,直接返回1能够下发,同时将在keyMap设定下一条应该下发的mt的curpos,准备猎取匹配下一条顺序mt;
     * 3.不均衡状态的MT首先判断其是否是下一条要发送的mt,如果是则直接返回1,否则在SerialCache缓存起来,等待发送,
     *   同时检测该条mt是否是顺序下发的最后一条mt,如果是则删除在SerialCache中存储的相应映射,如果不是则更新keyMap,
     *   设定下一条应该下发的mt的curpos,准备猎取匹配下一条顺序mt;
     * 4.包月话单或者正常业务信息下发时直接返回 1;
     * 5.其他类型信息将避免在深夜下发,当前时间如果是标称深夜时段则缓存返回 3。
     * @param mt MT
     * @return int  1 能够发送 2 不能发送但能入库 3 不能发送也不能入库，继续放回队列
     *              4 不能发送、不能入库也不能继续放回队列，而是放入缓存等待发送
     */
    public int check(MT mt){
    	/** mtType: 0 技术测试 1 包月话单 2 正常业务信息 3 模拟下发 4 群发信息 5 PUSH下发 6 协议直接下发
    	 * 			7 二进制数据 8 反向退订 9 包月内容信息下发
    	 */
    	/** 首先将判断该mt是否是 技术测试 或者 模拟下发 的类型,如果是则不发送直接入库 */
        String isSend = "1";
        try {//只可能为0或者1				返回一个Map↓(存有键值0~8)					
            isSend = ((String)CommonData  .getMttypeMap().  get(mt.getMtType())).split(":")[0];
        } catch (Exception ex) {
            log.error("mt type Exception : 包月内容下发信息");//如果get(键值)的键值参数不在(0~8)的范围内,将报异常||一般情况是包月内容下发时报
        }

        if (isSend.equals("0")) {//有这几种情况下isSend=0,mt.getMtType=0(技术测试) 或者 3(模拟下发)
            return 2;//不能发送但能入库（一般指 技术测试 和 模拟下发）
        }
        /** 如果mt为均衡状态,返回1能够下发,同时将在keyMap设定下一条应该下发的mt的curpos,准备猎取匹配下一条顺序mt */
        if (mt.getIsImBalance().trim().equals("0") ) {//mt为均衡状态
            if( mt.isSerialFlag() ){//是否要求顺序下发
                if( mt.getTotal() > 1 ){//如果一次下发多条点播回复mt
                    serialcache.addKey(mt);
                }
            }
            else if( physicsSerial){//专为联通顺序下发设计,其他网关一般默认为false
                if( mt.getTotal() > 1 ){
                    unserialcache.addKey(mt);
                }
            }

            return 1;
        }
        /** 不均衡状态的MT首先判断其是否是下一条要发送的mt,如果是则直接返回1,否则在SerialCache缓存起来,等待发送 */
        if( mt.getIsImBalance().trim().equals("1") ){
            if( mt.isSerialFlag() ){
                if( mt.getTotal() > 1 ){
                    if( serialcache.isNext(mt) ){//是否是下一条应该下发的mt
                        serialcache.addKey(mt);//如果为真,则更新或删除serialcache.keymap中的Curpos记录
                        return 1;
                    }
                    else{
                        serialcache.addMT(mt);//如果不是下一条要发送的mt,则进行缓存
                        return 4;
                    }
                }
            }
            else if( physicsSerial){
                if( mt.getTotal() > 1 ){
                    if (unserialcache.isNext(mt)) {
                        return 1;
                    } else {
                        unserialcache.addMT(mt);
                        return 4;
                    }
                }
            }

            return 1;//对于顺序下发不做要求的情况下直接返回1
        }
        /** 包月话单或者正常业务信息下发时直接返回 1 */
        if (mt.getIsImBalance().trim().equals("2") && (mt.getMtType().trim().equals("1")||
        		mt.getMtType().trim().equals("2"))) {
            return 1;
        }
        /** 其他类型信息将避免在深夜下发,当前时间如果是标称深夜时段则缓存返回 3 */
        String hour = simpleDF.format(new java.util.Date());
        if (times.contains(hour)) {
            return 3;
        }

        return 1;

    }
    /** 返回serialcache或者unserialcache是否有缓存的mt等待下发 */
    public boolean isOk(){
        return serialcache.isOk() || unserialcache.isOk();
    }
    /**
     * 顺序是先检查serialcache中的mt,如果有则直接return该mt;如果serialcache中没有则检查unserialcache中是否有mt
     * @return 从cache里缓存的MT
     */
    public MT getMT(){
        if( serialcache.isOk() ){
            return serialcache.getMT();
        }

        if( unserialcache.isOk() ){
            return unserialcache.getMT();
        }

        return null;
    }

	public synchronized String[] getStimes() {
		return stimes;
	}

	public synchronized void setStimes(String[] stimes) {
		this.stimes = stimes;
	}

	/**
     * mtType: 0 技术测试 1 包月话单 2 正常业务信息 3 模拟下发 4 群发信息 5 PUSH下发 6 协议直接下发
     * 			7 二进制数据 8 反向退订 9 包月内容信息下发
     * @param mt MT
     * @return int  1 能够发送 2 不能发送但能入库 3 不能发送也不能入库，继续放回队列
     */
    public int checkForSend(MT mt){

        String isSend = "1";
        try {
            isSend = ((String)CommonData.getMttypeMap().get(mt.getMtType())).split(":")[0];
        } catch (Exception ex) {//一般报异常时的情况是mtType=9
//            LoggerConstant.mt_log.error("mt type error : ", ex);
            LoggerConstant.mt_log.error("mt type error :包月内容信息下发");
        }

        if( "0".equals(isSend) ){//Mttype=0||Mttype=3时isSend=0
            return 2;
        }

        if( "0".equals(mt.getIsImBalance().trim()) || "1".equals(mt.getIsImBalance().trim()) ){
            return 1;
        }

        if( "2".equals(mt.getIsImBalance().trim()) && ("1".equals(mt.getMtType().trim())||
        		"2".equals(mt.getMtType().trim())) ){
            return 1;
        }

        
        String hour = simpleDF.format(new java.util.Date());
        if( times.contains(hour) ){
            return 3;
        }

        return 1;
    }
}