www.pudn.com > mobileMms.rar > ConnectionPool.java

/**File Name:ConnectionPool.java 
 * Company:  中国移动集团公司 
 * Date  :   2004-1-9 
 * */ 
 
package com.cmcc.mm7.vasp.common; 
 
import java.util.*; 
import java.util.HashMap; 
import com.cmcc.mm7.vasp.conf.*; 
import com.cmcc.mm7.vasp.common.ConnectionWrap; 
 
public class ConnectionPool implements Runnable 
{ 
  //public static List ClientList; 
  public List ClientList; 
  private static boolean isCreate; 
  public HashMap hashmap; 
  private long time; 
  private int IPCount; 
  private MM7Config Mm7Config; 
  private String NonceCount; 
  private int ServerMaxSize; 
  private String KeepAlive; 
  private static final ConnectionPool m_instance = new ConnectionPool(); 
 
  public ConnectionPool() 
  { 
    hashmap = new HashMap(); 
    isCreate = false; 
    ClientList = null; 
    IPCount = 0; 
    Mm7Config = null; 
    NonceCount = "00000001"; 
    ServerMaxSize = 0; 
    KeepAlive = "off"; 
  } 
  public static ConnectionPool getInstance() 
  { 
    return m_instance; 
  } 
  public void setConfig(MM7Config mm7config) 
  { 
    Mm7Config = mm7config; 
    if(ClientList == null) 
      init(); 
    if(!isCreate) 
    { 
      Thread thread = new Thread(this); 
      thread.run(); 
      isCreate = true; 
    } 
  } 
  //主要是为了实现MMSCIP的平均分配而设置的顺序。 
  public void setIPCount(int count) 
  { 
    IPCount = count; 
  } 
  //得到当前应该分配给第几个MMSCIP。 
  public int getIPCount() 
  { 
    return(IPCount); 
  } 
  public void setNonceCount(String nc) 
  { 
    NonceCount = nc; 
  } 
  public String getNonceCount() 
  { 
    return NonceCount; 
  } 
  public void setInitNonceCount() 
  { 
    setNonceCount("00000001"); 
  } 
  public MM7Config getConfig() 
  { 
    return Mm7Config; 
  } 
  private void setServerMaxSize(int size) 
  { 
    ServerMaxSize = size; 
  } 
  public int getServerMaxSize() 
  { 
    return ServerMaxSize; 
  } 
  private void setKeepAlive(String conn) 
  { 
    KeepAlive = conn; 
  } 
  public String getKeepAlive() 
  { 
    return KeepAlive; 
  } 
 
  // 从配置文件中获得一些基本信息 
  private void init() 
  { 
    hashmap.clear(); 
    MM7ConfigManager confManager = new MM7ConfigManager(); 
    String name = Mm7Config.getConnConfigName(); 
    if(!name.equals("")) 
    { 
      confManager.load(name); 
      hashmap = confManager.hashmap; 
      if(!hashmap.isEmpty()) 
      { 
        this.setKeepAlive((String)hashmap.get("KeepAlive")); 
        this.setServerMaxSize(Integer.parseInt((String)hashmap.get("ServerMaxKeepAlive"))); 
      } 
    } 
    if(this.getKeepAlive().equals("on")) 
    { 
      /**若支持长连接，则建最小长连接数，若不支持，则建一条短连接*/ 
      addURL(Integer.parseInt( (String) hashmap.get("MinKeepAliveRequests"))); 
    } 
  } 
  //获得空闲的连接 
  public synchronized ConnectionWrap getConnWrap() 
  { 
    if(ClientList == null) 
    { 
      addURL(1); 
      ConnectionWrap connWrap; 
      if(ClientList.isEmpty()) 
      { 
        return null; 
      } 
      else 
      { 
          connWrap = (ConnectionWrap) ClientList.get(0); 
          connWrap.setFree(false); 
          connWrap.setConnectIndex(0); 
          return connWrap; 
      } 
    } 
    else 
    { 
        //寻找空闲的连接 
        for (int i = 0; i < ClientList.size(); i++) { 
          ConnectionWrap conn = (ConnectionWrap) ClientList.get(i); 
          if (conn != null && conn.getFree()) { 
            conn.setFree(false); 
            conn.setConnectIndex(i); 
            conn.start = System.currentTimeMillis(); 
            return conn; 
          } 
          else if(conn == null){ 
            continue; 
          } 
        } 
        //没有空闲连接的话，若size小于最大连接数，则建step步长的连接。 
        int MaxCount = Integer.parseInt( (String) hashmap.get( 
            "MaxKeepAliveRequests")); 
        if (ClientList.size() < MaxCount) { 
          int step = Integer.parseInt((String) hashmap.get("step")); 
          /**判断目前已有连接加入要新建的连接是否超过最大连接数，若不超，则建setp个连接，否则 
           * 新建（最大连接数－现有连接数）个连接。 
           * */ 
          if (ClientList.size() + step <= MaxCount) 
            addURL(step); 
          else 
            addURL(MaxCount - ClientList.size()); 
          if(ClientList.isEmpty()==true) 
          { 
            //addURL(step); 
            return null; 
          } 
          else 
          { 
            ConnectionWrap conn = (ConnectionWrap) ClientList.get(ClientList.size() - 
                step); 
            conn.setFree(false); 
            conn.setConnectIndex(ClientList.size() - step); 
            return conn; 
          } 
        } 
        //建一条短连接 
        else { 
          try { 
            ConnectionWrap conn = new ConnectionWrap(Mm7Config); 
            if(conn.BuidLink()) 
              return conn; 
            else 
              return null; 
          } 
          catch (Exception e) { 
            System.err.println(e); 
            return null; 
          } 
        } 
    } 
  } 
 
  //增加count个新的URL连接 
  public void addURL(int count) 
  { 
    //System.out.println("addURL"+count); 
    if(ClientList == null) 
      ClientList = new ArrayList(count); 
    try{ 
      for(int i=0;i 0) { 
            time = System.currentTimeMillis() - conn.start; 
            if (time >= timeout) 
              conn.setFree(true); 
          } 
        } 
      } 
    } 
  } 
}