serversupport.java

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

package com.pub.backserver.net;

import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.util.Date;

import org.apache.log4j.Logger;
import org.apache.log4j.Priority;
import org.apache.mina.common.IoAcceptor;
import org.apache.mina.common.IoAcceptorConfig;
import org.apache.mina.common.IoHandler;
import org.apache.mina.transport.socket.nio.SocketAcceptor;
import org.apache.mina.transport.socket.nio.SocketAcceptorConfig;
import org.apache.mina.util.NewThreadExecutor;

import com.pub.backserver.blackList.BlackDatabase;
import com.pub.backserver.blackList.BlackEntity;
import com.pub.backserver.order.OrderDatabase;
import com.pub.backserver.order.OrderEntity;
import com.pub.backserver.phase.PhaseDatabase;
import com.pub.backserver.phase.PhaseEntity;
import com.pub.backserver.time.TimeDatabase;
import com.pub.berkeleydb.BklyDatabase;
import com.pub.berkeleydb.BklyEnv;
import com.pub.timeswan.Scheduler;
import com.pub.timeswan.TaskWrapper;
import com.pub.util.FileUtils;

public class ServerSupport implements ICallback {

	private static final Logger log = Logger.getLogger(ServerSupport.class);

	private IoAcceptor acceptor = null;

	private ServerHandlerParameter chp = null;

	public ServerSupport() {
	}

	public void setParameter(ServerHandlerParameter chp) {
		this.chp = (ServerHandlerParameter) chp;
	}

	public void init() throws Exception {
		
		//Berkeleydb path initialize
		String path = FileUtils.createDirectory(chp.getTimeBDBPath());
		openBDB(timeBDB, path, chp.getTimeBDBName());

		path = FileUtils.createDirectory(chp.getBlackBDBPath());
		openBDB(blackBDB, path, chp.getBlackBDBName());

		path = FileUtils.createDirectory(chp.getPhaseBDBPath());
		openBDB(phaseBDB, path, chp.getPhaseBDBName());
		
		path = FileUtils.createDirectory(chp.getOrderBDBPath());
		openBDB(orderBDB, path, chp.getOrderBDBName());

		//Synchronization time initialize
//		Date date = getBDBLastSync(chp.getBlackDBLastLoad());
//		timeBDB.Insert(chp.getBlackBDBName(), date);
//		
//		date = getBDBLastSync(chp.getPhaseDBLastLoad());
//		timeBDB.Insert(chp.getPhaseBDBName(), date);
//		
//		date = getBDBLastSync(chp.getOrderDBLastLoad());
//		timeBDB.Insert(chp.getOrderBDBName(), date);

		//Black list
		if (chp.getBlackLoadMode().equalsIgnoreCase("file")) { // 装入文件
			reloadBlack(false, false);
		} else if (chp.getBlackLoadMode().equalsIgnoreCase("DB")) { // 按时间点装入数据库的内容
			reloadBlack(true, true);
		} else { // 全部装入数据库内容
			reloadBlack(true, false);
		}
		
		//Phase list
//		if (chp.getPhaseLoadMode().equalsIgnoreCase("file")) { // 装入文件
//			reloadPhase(false, false);
//		} else if (chp.getPhaseLoadMode().equalsIgnoreCase("DB")) { // 按时间点装入数据库的内容
//			reloadPhase(true, true);
//		} else { // 全部装入数据库内容
//			reloadPhase(true, false);
//		}
		
		//Order list
		if (chp.getOrderLoadMode().equalsIgnoreCase("file")) { // 装入文件
			reloadOrder(false, false);
		} else if (chp.getOrderLoadMode().equalsIgnoreCase("DB")) { // 按时间点装入数据库的内容
			reloadOrder(true, true);
		} else { // 全部装入数据库内容
			reloadOrder(true, false);
		}
		
		// Timer operation
		Scheduler sch = new Scheduler(200);
		sch.start();
		sch.addTask(new TaskWrapper(chp.getBlackBDBsync(), new SyncBlack()));
		sch.addTask(new TaskWrapper(chp.getPhaseBDBsync(), new SyncPhase()));
		sch.addTask(new TaskWrapper(chp.getOrderBDBsync(), new SyncOrder()));
	}

	public boolean startup() throws Exception {
		boolean flag = false;
		IoAcceptorConfig config = new SocketAcceptorConfig();
		SocketAddress address = new InetSocketAddress(chp.serverPort);
		if (chp.processorCount < 0) {
			acceptor = new SocketAcceptor(chp.processorCount,
					new NewThreadExecutor());
		} else {
			acceptor = new SocketAcceptor(1, new NewThreadExecutor());
		}
		IoHandler handler = new ServerHandler(this, chp);
		acceptor.bind(address, handler, config);
		log.debug("Listening on port " + chp.serverPort);
		System.out.println("Liistening on port " + chp.serverPort);
		flag = true;
		return flag;
	}

	public boolean shutdown() throws Exception {
		acceptor.unbind(new InetSocketAddress(chp.serverPort));
		return true;
	}

	// //////////////////////////////////////////////////////////////////////////////

	TimeDatabase timeBDB = new TimeDatabase();

	BlackDatabase blackBDB = new BlackDatabase();

	PhaseDatabase phaseBDB = new PhaseDatabase();

	OrderDatabase orderBDB = new OrderDatabase();

	public int queryBlack(BlackEntity be) {
		return blackBDB.Query(be);
	}

	public int insertBlack(BlackEntity be) {
		return blackBDB.Insert(be);
	}

	public int deleteBlack(BlackEntity be) {
		return blackBDB.Delete(be);
	}

	public int queryPhase(PhaseEntity pe) {
		return phaseBDB.Query(pe);
	}

	public int insertPhase(PhaseEntity pe) {
		return phaseBDB.Insert(pe);
	}

	public int deletePhase(PhaseEntity pe) {
		return phaseBDB.Delete(pe);
	}

	public int deleteOrder(OrderEntity oe) {
		return orderBDB.Delete(oe);
	}

	public int insertOrder(OrderEntity oe) {
		return orderBDB.Insert(oe);
	}

	public int queryOrder(OrderEntity oe) {
		return orderBDB.Query(oe);
	}

	private int openBDB(BklyDatabase bdb, String path, String name) {

		if (path == null || path.length() <= 0) {
			if (log.isEnabledFor(Priority.ERROR)) {
				log.error("Berkeley DB path is null");
			}
			return -100;
		}

		BklyEnv env = new BklyEnv();
		if (env.open(path) != 0) {
			if (log.isEnabledFor(Priority.ERROR)) {
				log.error("open Berkeley DB envirment " + path + " error");
			}
			return -200;
		}

		if (bdb.open(name, env) != 0) {
			if (log.isEnabledFor(Priority.ERROR)) {
				log.error("open Berkeley DB " + name + " error");
			}
			env.close();
			return -200;
		}
		return 0;

	}

	/**
	 * 载入黑名单数据
	 * 
	 * @param fromDB
	 *            boolean 是否从数据库载入
	 * @param delta
	 *            boolean 是否只载入最后更新
	 * @return int
	 */
	public int reloadBlack(boolean fromDB, boolean delta) {
		if (fromDB == false) { // load from file
			return blackBDB.loadFromFile(chp.getBlackLoadFile());
		} else if (delta == false) { // 载入数据库中全部黑名单
			return blackBDB.LoadFromDatabase(chp.getBackDBDriver(), chp
					.getBackDBUrl(), chp.getBackDBUser(), chp.getBackDBPwd(),
					chp.getBlackDBLoadAllSql());
		} else { // 载入数据库中特定时间以后的黑名单
			java.util.Date last = timeBDB.Query(chp.getBlackBDBName());
			String lastUpdate = new java.text.SimpleDateFormat(
					"yyyy-MM-dd HH:mm:ss").format(last);
			Date cur = new Date();

			log.debug("Black delta update after " + lastUpdate);
			int ret = blackBDB.LoadFromDatabase(chp.getBackDBDriver(), chp
					.getBackDBUrl(), chp.getBackDBUser(), chp.getBackDBPwd(),
					String.format(chp.getBlackDBLoadsql(), lastUpdate));
			if (ret >= 0)
				timeBDB.Insert(chp.getBlackBDBName(), cur);
			return ret;
		}
	}

	/**
	 * 载入手机号段
	 * 
	 * @param fromDB
	 * @param delta
	 * @return
	 */
	public int reloadPhase(boolean fromDB, boolean delta) {
		if (fromDB == false) { // load from file
			return phaseBDB.loadFromFile(chp.getPhaseLoadFile());
		} else if (delta == false) { // 载入数据库中全部号段
			return phaseBDB.LoadFromDatabase(chp.getBackDBDriver(), chp
					.getBackDBUrl(), chp.getBackDBUser(), chp.getBackDBPwd(),
					chp.getPhaseDBLoadAllSql());
		} else { // 载入数据库中特定时间以后的号段
			Date last = timeBDB.Query(chp.getPhaseBDBName());
			String lastUpdate = new java.text.SimpleDateFormat(
					"yyyy-MM-dd HH:mm:ss").format(last);
			Date cur = new Date();

			log.debug("Phase delta update after " + lastUpdate);
			int ret = phaseBDB.LoadFromDatabase(chp.getBackDBDriver(), chp
					.getBackDBUrl(), chp.getBackDBUser(), chp.getBackDBPwd(),
					String.format(chp.getPhaseDBLoadsql(), lastUpdate));
			if (ret >= 0)
				timeBDB.Insert(chp.getPhaseBDBName(), cur);
			return ret;
		}
	}

	/**
	 * 装入定购关系
	 * @param fromDB
	 * @param delta
	 * @return
	 */
	public int reloadOrder(boolean fromDB, boolean delta) {
		if (fromDB == false) { // load from file
			return orderBDB.loadFromFile(chp.getOrderLoadFile());
		} else if (delta == false) { // 载入数据库中全部号段
			return orderBDB.LoadFromDatabase(chp.getBackDBDriver(), chp.getBackDBUrl(), chp
					.getBackDBUser(), chp.getBackDBPwd(), chp.getOrderDBLoadAllSql());
		} else { // 载入数据库中特定时间以后的定购关系
			Date last = timeBDB.Query(chp.getOrderBDBName());
			String lastUpdate = new java.text.SimpleDateFormat(
					"yyyy-MM-dd HH:mm:ss").format(last);
			Date cur = new Date();

			log.debug("Order delta update after " + lastUpdate);
			int ret = orderBDB.LoadFromDatabase(chp.getBackDBDriver(), chp.getBackDBUrl(),
					chp.getBackDBUser(), chp.getBackDBPwd(), String.format(
							chp.getOrderDBLoadsql(), lastUpdate));
			if (ret >= 0)
				timeBDB.Insert(chp.getOrderBDBName(), cur);
			return ret;
		}
	}

	private Date getBDBLastSync(String lastTime) {
		Date last = new Date();
		java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat(
				"yyyy-MM-dd HH:mm:ss");
		try {
			last = sdf.parse(lastTime);
		} catch (Throwable ex) {
			if (log.isEnabledFor(Priority.ERROR)) {
				log.error(null, ex);
			}
		}
		return last;
	}

	//Black list timer
	class SyncBlack implements com.pub.timeswan.ITask {
		boolean _run = false;

		public void start() {
			_run = true;
		}

		public boolean running() {
			return _run;
		}

		public void run() {
			try {
				reloadBlack(true, true);
			} catch (Exception ex) {
			} finally {
				_run = false;
			}
		}
	}

	//Phase list timer
	class SyncPhase implements com.pub.timeswan.ITask {
		boolean _run = false;

		public void start() {
			_run = true;
		}

		public boolean running() {
			return _run;
		}

		public void run() {
			try {
				reloadPhase(true, true);
			} catch (Exception ex) {
			} finally {
				_run = false;
			}
		}
	}
	
	//	Order list timer
	class SyncOrder implements com.pub.timeswan.ITask {
		boolean _run = false;

		public void start() {
			_run = true;
		}

		public boolean running() {
			return _run;
		}

		public void run() {
			try {
				reloadOrder(true, true);
			} catch (Exception ex) {
			} finally {
				_run = false;
			}
		}
	}

}