switchparameter.java

短信开发用于文件交换处理转发的类模块

package com.sms.platform.switchcenter.parameter;

import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import org.apache.commons.pool.ObjectPool;
import org.apache.commons.pool.impl.StackObjectPool;
import org.apache.log4j.Logger;
import org.jdom.Element;

import com.pub.dataframe.PoolObjectFactory;
import com.pub.util.ReaderXml;
import com.sms.platform.switchcenter.entity.DeliverChannel;
import com.sms.platform.switchcenter.entity.DeliverRouter;
import com.sms.platform.switchcenter.entity.PhoneInfo;
import com.sms.platform.switchcenter.entity.SubmitRouter;


public class SwitchParameter{

	private static Logger log = Logger.getLogger(SwitchParameter.class);

	private static SwitchParameter _instance = null;
	
	private static String parameterPath = "";

    // 处理网关发给合作方上行的线程池
    ThreadPoolExecutor ThreadPool = null;

    // 处理合作方发给网关下行的线程池
    ThreadPoolExecutor MTPool = null;

    // backserver连接池 杜旭add 20070728
    ObjectPool ObjPool = null;	
	
    // 号段信息
    private HashMap<String, PhoneInfo> phoneInfo = null;
    
    // 路由到合作方Session的内存信息
    private List<DeliverRouter> deliverRouter = null;
    
    // 路由到网关 Session的内存信息
    private List<SubmitRouter> submitRouter = null;
    
    // 路由到合作方Session的内存信息
    private List<DeliverChannel> deliverChannel = null;
    
    private int maxSendCount = 3;
    
    int corePoolSize = 1;

    int maximumPoolSize = 1;

    int keepAliveTime = 10;

    String bsIp = "";// 20070728 duxu

    int bsPort = 0;// 20070728 duxu

    int bsTimeout = 2000;// 20070728 duxu

    int bsCount = 10; // 20070728duxu    
    
	// 构造函数
	private SwitchParameter(String parameterPath) throws Exception {

		Element node = ReaderXml.loadSelectElement(parameterPath, "//switch");
		
        corePoolSize = ReaderXml.getChildTextInteger(node, "corePoolSize",1);
        maximumPoolSize = ReaderXml.getChildTextInteger(node,"maximumPoolSize", 1);
        keepAliveTime = ReaderXml.getChildTextInteger(node,"keepAliveTime", 10);

        bsIp = ReaderXml.getChildTextString(node, "bsIp", "");
        bsPort = ReaderXml.getChildTextInteger(node, "bsPort", 0);
        bsTimeout = ReaderXml.getChildTextInteger(node, "bsTimeout", 2000);
        bsCount = ReaderXml.getChildTextInteger(node, "bsCount", 10);		
		
		
        /**
         * 线程池维护线程的最少数量 
         * 线程池维护线程的最大数量 
         * 线程池维护线程所允许的空闲时间 
         * 线程池维护线程所允许的空闲时间的单位
         * 线程池所使用的缓冲队列 线程池对拒绝任务的处理策略 ThreadPoolExecutor.AbortPolicy()
         * 抛出java.util.concurrent.RejectedExecutionException异常
         * ThreadPoolExecutor.CallerRunsPolicy() 重试添加当前的任务，他会自动重复调用execute()方法
         * ThreadPoolExecutor.DiscardOldestPolicy() 抛弃旧的任务
         * ThreadPoolExecutor.DiscardPolicy() 抛弃当前的任务
         */

		ThreadPool = new ThreadPoolExecutor(corePoolSize, maximumPoolSize,keepAliveTime, TimeUnit.SECONDS, new ArrayBlockingQueue(3),
                new ThreadPoolExecutor.CallerRunsPolicy());
        
        /**
         * 连接对象池
         */
        PoolObjectFactory factory = new PoolObjectFactory(bsIp,bsPort, bsTimeout);
        ObjPool = new StackObjectPool(factory);
        
        phoneInfo = PhoneInfo.loadPhoneInfo();
        
        deliverRouter = DeliverRouter.loadDeliverRouter();
        Collections.sort(deliverRouter, new DeliverRouter());
        for (int i = 0; i < deliverRouter.size(); i++) {
            log.debug(deliverRouter.get(i));
        }
		
        submitRouter = SubmitRouter.loadSubmitRouter();
        Collections.sort(submitRouter, new SubmitRouter());
        for (int i = 0; i < submitRouter.size(); i++) {
            log.debug(submitRouter.get(i));
        }
        log.debug("=====================================================================");
        deliverChannel = DeliverChannel.loadDeliverChannel();
        Collections.sort(deliverChannel, new DeliverChannel());
        for (int i = 0; i < deliverChannel.size(); i++) {
            log.debug(deliverChannel.get(i));
        }
        
	}

	/**
	 * 单例模式获得实例的方法
	 * 
	 * @return Global
	 */
	public static synchronized SwitchParameter getInstance(String parameterPath) {
		if (_instance == null) {
			try {
				_instance = new SwitchParameter(parameterPath);
			} catch (Throwable ex) {
				log.error("", ex);
				System.exit(0);
			}
		}

		return _instance;
	}	
	
	/**
	 * 单例模式获得实例的方法
	 * 
	 * @return Global
	 */
	public static synchronized SwitchParameter getInstance() {
		if (_instance == null) {
			try {
				if(parameterPath != null && !parameterPath.equals(""))
					_instance = new SwitchParameter(parameterPath);
			} catch (Throwable ex) {
				log.error("", ex);
				System.exit(0);
			}
		}

		return _instance;
	}

	public void loadSwitchParameter() throws Exception {
        phoneInfo = PhoneInfo.loadPhoneInfo();
        
        deliverRouter = DeliverRouter.loadDeliverRouter();
        Collections.sort(deliverRouter, new DeliverRouter());
        for (int i = 0; i < deliverRouter.size(); i++) {
            log.debug(deliverRouter.get(i));
        }
		
        submitRouter = SubmitRouter.loadSubmitRouter();
        Collections.sort(submitRouter, new SubmitRouter());
        for (int i = 0; i < submitRouter.size(); i++) {
            log.debug(submitRouter.get(i));
        }
        log.debug("=====================================================================");
        deliverChannel = DeliverChannel.loadDeliverChannel();
        Collections.sort(deliverChannel, new DeliverChannel());
        for (int i = 0; i < deliverChannel.size(); i++) {
            log.debug(deliverChannel.get(i));
        }
	}
	
	
	public ThreadPoolExecutor getMTPool() {
		return MTPool;
	}

	public void setMTPool(ThreadPoolExecutor pool) {
		MTPool = pool;
	}

	public ObjectPool getObjPool() {
		return ObjPool;
	}

	public void setObjPool(ObjectPool objPool) {
		ObjPool = objPool;
	}

	public ThreadPoolExecutor getThreadPool() {
		return ThreadPool;
	}

	public void setThreadPool(ThreadPoolExecutor threadPool) {
		ThreadPool = threadPool;
	}

	public HashMap<String, PhoneInfo> getPhoneInfo() {
		return phoneInfo;
	}

	public void setPhoneInfo(HashMap<String, PhoneInfo> phoneInfo) {
		this.phoneInfo = phoneInfo;
	}

	public List<DeliverRouter> getDeliverRouter() {
		return deliverRouter;
	}

	public void setDeliverRouter(List<DeliverRouter> deliverRouter) {
		this.deliverRouter = deliverRouter;
	}

	public int getMaxSendCount() {
		return maxSendCount;
	}

	public void setMaxSendCount(int maxSendCount) {
		this.maxSendCount = maxSendCount;
	}

	public List<SubmitRouter> getSubmitRouter() {
		return submitRouter;
	}

	public void setSubmitRouter(List<SubmitRouter> submitRouter) {
		this.submitRouter = submitRouter;
	}

	public List<DeliverChannel> getDeliverChannel() {
		return deliverChannel;
	}

	public void setDeliverChannel(List<DeliverChannel> deliverChannel) {
		this.deliverChannel = deliverChannel;
	}   
}