routedao.java

中国移动定位引擎的客户端

package ffcs.lbp.dao;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;

import ffcs.config.Config;
import ffcs.config.Module;
import ffcs.db.DBPool;
import ffcs.db.JdbcUtil;
import ffcs.logging.Log;
import ffcs.logging.LogFactory;
import ffcs.util.SysUtil;
/**
* <p>Title: 小区推送LBP项目</p>
* <p>Description:
*  查询SAG外部实体路由，和回送时，寻找位置信息管理模块的路由
*  当周期性定位时，采用触发方式，有请求时，才把库表内容读到内存中
*  而把位置信息回送时，要在内存中长期维持一份库表中的路由，并定时更新
* </p>
* <p>Copyright: 2008 福建福富软件技术股份有限公司 </p>
* <p>Company: 福建福富软件技术股份有限公司</p>
 * @author chenxin
 * @version 1.0 
*/

public class RouteDAO  {
	
	private static Log log = LogFactory.getLog(RouteDAO.class);
	
	public static int time_cyc=10;//路由更新时间间隔，以分钟为单位

     private static Vector<Route> back_routes=new Vector<Route>();
   
     private static HashMap<String, SentRequest> SentRequests=new HashMap<String, SentRequest>();
     
     public static void refreshRoute(){
    	 String sql ="select * from  loc_manage_route where is_valids=1";
  	   //	System.out.println("sql:"+sql);
      	
      	Connection conn = null;
          ResultSet rs = null;
          Statement st =null;
           try{
          	conn = DBPool.getConnection();
  			st = conn.createStatement();
              rs = st.executeQuery(sql.toString());
              if(rs!=null){
             synchronized(back_routes){
            	 back_routes.clear();
              	while (rs.next()) {
             Route tmp_route=new Route();
             tmp_route.setIsdnRange(rs.getString("isdn_range"));
             int sys_type=rs.getInt("sys_type");
             int sys_id =rs.getInt("sys_id");
             int ServerId=SysUtil.makeSystemId(sys_type,sys_id);
             tmp_route.setServerID(Integer.toHexString(ServerId));
//             System.out.println(tmp_route.toString());
             back_routes.add(tmp_route);
              }
              }
              }
       } catch (SQLException sqle) {
              System.err.println(sqle);
              log.error("将回送路由表更新至内存时失败");
           
          } finally {
              JdbcUtil.closeResultSet(rs);
              JdbcUtil.closeStat(st);
              JdbcUtil.closeConn(conn);
          }
          
     }
     
     
     /**
     * 取得位置信息后，回送时选择路由.
     * 在内存中保存路由表，每5min更新一次
     * @param isdn 单个号码
     * @return LocInfoMgrId　位置信息管理模块的id，32位
     */
	public  int routeBack( String isdn){
	     for(int i=0;i<back_routes.size();i++){
	    	String isdn_range= back_routes.get(i).getIsdnRange();
	    	if(isdn.startsWith(isdn_range)){
	    		//匹配到了路由
	    		return SysUtil.makeSystemId(SysUtil.LocManage,back_routes.get(i).getServerID());
	    	}
	     }
	       log.error("查找回送路由时发生错误：号码"+isdn+"找不到路由");
           return -1;
      
    }

    /**
     * 标准定位时，取得路由信息.
     * @param List<String> msids 要定位的号码列表
     * @return List<LCS>　LCS对象的列表
     * 先把DB中的路由表取出，建个数组，然后把号码列表中的号码，
     * 一个个拿出比对，符合某条路由，就将此路由mapping成lcs对象
     */
	/*public List<LCS> getLCSforStdLoc( List<String> msids){
		String sql ="select isdn_range,lcs_id from  lcs_route ";
	   //	System.out.println("sql:"+sql);
    	
    	Connection conn = null;
        ResultSet rs = null;
        Statement st =null;
        Vector<Route> route_list=new Vector<Route> ();
        try{
        	conn = DBPool.getConnection();
			st = conn.createStatement();
            rs = st.executeQuery(sql.toString());
            if(rs!=null){
            	while (rs.next()) {
           Route tmp_route=new Route();
//         这里把周期性定位用到的IsdnRange字段，借用来存放路由表的号段
           tmp_route.setIsdnRange(rs.getString("isdn_range"));
           tmp_route.setServerID(rs.getString("lcs_id"));
           route_list.add(tmp_route);
            }
            }
           //调用路由匹配函数，输入号码列表和路由对象列表，输出匹配好的LCS列表
          List<LCS> route_lcs_list=matchRoute(msids,route_list);
          //调用mapping函数，把列表中的LCS，URL，流控信息，SPid，密码等信息填全
          List<LCS> lcs_list=StdLocLcsMaping(route_lcs_list);
          
          return lcs_list;
            
        } catch (SQLException sqle) {
            System.err.println(sqle);
            return null;
        } finally {
            JdbcUtil.closeResultSet(rs);
            JdbcUtil.closeStat(st);
            JdbcUtil.closeConn(conn);
        }
  
      
    }
*/
    /**
     * 周期性定位时，取得路由信息.
     * @param IsdnRange 号段
     * @return List<LCS>　LCS对象的列表
     */
	public List<LCS> getLCSforCycLoc(Iterator<String> IsdnRange){
		String sql ="select isdn_range,lcs_id from  lcs_route ";//where isdn_range=" + IsdnRange;
  
   	
    	Connection conn = null;
        ResultSet rs = null;
        Statement st =null;
        LinkedList<LCS> lcsList = null;
        Vector<String> ranges=new Vector<String>();
        Vector<String> lcsIds=new Vector<String>();
        try{
        	conn = DBPool.getConnection();
			st = conn.createStatement();
            rs = st.executeQuery(sql.toString());
            while (rs!=null&&rs.next()) {
            	ranges.add(rs.getString("isdn_range"));
            	lcsIds.add(rs.getString("lcs_id"));
            }
          } catch (SQLException sqle) {
	            log.error("取得路由信息时出错"+sqle);
            return null;
        } finally {
            JdbcUtil.closeResultSet(rs);
            JdbcUtil.closeStat(st);
            JdbcUtil.closeConn(conn);
        }
        int len=0;
        String input_range;
        String route_range;
        String matched_rt_range;//存放最后匹配到的路由号段
//      每次取出一个要定位的号段
        while(IsdnRange.hasNext()){
        	input_range=IsdnRange.next();
        	//每次取出一个路由的号段，进行匹配
        	for(int i=0;i<ranges.size();i++){
        		route_range=ranges.get(i);
        		if(route_range.indexOf(input_range)!=-1){
        			//在匹配到的路由号段中，挑出长度最长的
        			if(route_range.length()>len){
        				matched_rt_range=route_range;
        				len=route_range.length();
        				lcsList= insertLcs(lcsList,lcsIds.get(i),input_range);
        			}
        		}
        	}
        }
        //目前的lcsList中，只有lcsid和要定位的号段，通过读取配置文件，把其他信息补全
        return  maping(lcsList,"CycLocUrl");
    
      
    }
	/**
	 * 输入要定位的号段和其所属的lcs服务器，如果lcs存在于列表中，则把此号段加入lcs，
	 * 否则新建个lcs，并把此号段加入lcs
	 * @param lcs_id  lcs的服务器id
	 * @param input_range 要定位的号段
	 */
	  public LinkedList<LCS> insertLcs(LinkedList<LCS>lcsList,String lcs_id,String input_range){
		  int is_in=0;
		  for(int i=0;i<lcsList.size();i++){
			  if(lcsList.get(i).getLcsId().equals(lcs_id)){
				  //说明列表中，已有此lcs，则加入此号段
				  lcsList.get(i).addIsdnGroup(input_range);
				  is_in=1;
				  return lcsList;
			  }
				  
		  }
		  if(is_in==0){
			  LCS tmpLcs=new LCS();
			  tmpLcs.addIsdnGroup(input_range);
			  lcsList.add(tmpLcs);
		  }
		  return lcsList;
	  }
	/**
     * 匹配数据记录中的登录信息，返回登录信息类对象
    */
	    /**