databaseconnectionpool.java.svn-base

监控整个SP系统的SMS信息通道的发送情况并且生成日志。 支持权限判断。

package com.infobank.superchannel.util;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Collection;
import java.util.Hashtable;
import java.util.Properties;
import java.util.ResourceBundle;
import java.util.concurrent.atomic.AtomicReference;

import org.apache.commons.configuration.Configuration;
import org.apache.commons.dbcp.BasicDataSource;
import org.apache.commons.dbcp.BasicDataSourceFactory;

import com.infobank.superchannel.daemon.GenericDaemon;

/**
 * @author Liw
 * @version 连接池 modified by Xiaoguang Sun
 */
public class DatabaseConnectionPool {
  private static final String DATASOURCE_DEFAULT="default";
    private static AtomicReference<BasicDataSource> defaultDataSource = new AtomicReference<BasicDataSource>(null);
    private static Hashtable<String,BasicDataSource> dataSource=new Hashtable<String,BasicDataSource>();

  private DatabaseConnectionPool(){
  }
  
  private static DatabaseConnectionPool instance=new DatabaseConnectionPool();

  public static DatabaseConnectionPool getInstance(){
    return instance;
  }
  
  private BasicDataSource getDataSource(String name){
        String driver;
        String url;
    String user;
    String passwd;
    String maxActive;         //最大连接数量
    String logAbandoned;        //是否在自动恢复超时连接时打印连接的超时错误
    String removeAbandoned;       //是否自动回收超时连接
    String removeAbandonedTimeout;  //超时时间，以秒为单位
    String maxWait;           //超时等待时间以毫秒为党委 6000毫秒/1000 等于60秒
    String initialSize;       //初始化连接数目
    String minIdle;         //最小空闲连接数目
    String maxIdle;         //最大空闲连接数目

    DaemonConfiguration config=DaemonConfiguration.getInstance();
    StringBuilder sb=new StringBuilder();
    sb.append("/daemon/datasource[@name='");
    sb.append(name);
    sb.append("']/");

    String basePath=sb.toString();

    sb=new StringBuilder();
    sb.append(basePath);
    sb.append("url");
    url=config.getString(sb.toString());

    sb=new StringBuilder();
    sb.append(basePath);
    sb.append("user");
    user=config.getString(sb.toString());

    sb=new StringBuilder();
    sb.append(basePath);
    sb.append("password");
    passwd=config.getString(sb.toString());

    sb=new StringBuilder();
    sb.append(basePath);
    sb.append("driver");
    driver=config.getString(sb.toString());

    sb=new StringBuilder();
    sb.append(basePath);
    sb.append("initialSize");
    initialSize = config.getString(sb.toString());

    sb=new StringBuilder();
    sb.append(basePath);
    sb.append("maxIdle");
    maxIdle = config.getString(sb.toString());

    sb=new StringBuilder();
    sb.append(basePath);
    sb.append("minIdle");
    minIdle = config.getString(sb.toString()); 

    sb=new StringBuilder();
    sb.append(basePath);
    sb.append("maxActive");
    maxActive = config.getString(sb.toString());

    sb=new StringBuilder();
    sb.append(basePath);
    sb.append("logAbandoned");
    logAbandoned = config.getString(sb.toString());

    sb=new StringBuilder();
    sb.append(basePath);
    sb.append("removeAbandoned");
    removeAbandoned = config.getString(sb.toString());

    sb=new StringBuilder();
    sb.append(basePath);
    sb.append("removeAbandonedTimeout");
    removeAbandonedTimeout = config.getString(sb.toString());

    sb=new StringBuilder();
    sb.append(basePath);
    sb.append("maxWait");
    maxWait = config.getString(sb.toString());
    
    System.out.println("配置信息读取成功");
    System.out.println("  配置信息正在初始化");
    System.out.println("  url:"+url);
    System.out.println("  user:"+user);
    System.out.println("  password:"+passwd);
    System.out.println("  maxActive:"+maxActive);
    System.out.println("  logAbandoned:"+logAbandoned);
    System.out.println("  removeAbandoned:"+removeAbandoned);
    System.out.println("  removeAbandonedTimeout:"+removeAbandonedTimeout);
    System.out.println("  maxWait:"+maxWait);

        try {
            Properties connProperties = new Properties();
            connProperties.setProperty("driverClassName", driver);
            connProperties.setProperty("url", url);
            connProperties.setProperty("password", passwd);
            connProperties.setProperty("username", user);
            connProperties.setProperty("maxActive", maxActive);
            connProperties.setProperty("maxIdle", maxIdle);
            connProperties.setProperty("minIdle", minIdle);
            connProperties.setProperty("maxWait", maxWait);
            connProperties.setProperty("removeAbandoned", removeAbandoned);
            connProperties.setProperty("removeAbandonedTimeout", removeAbandonedTimeout);//超时时间
            connProperties.setProperty("testOnBorrow", "true");
            connProperties.setProperty("logAbandoned", logAbandoned);

            return (BasicDataSource) BasicDataSourceFactory.createDataSource(connProperties);
        } catch (Exception e) {
          e.printStackTrace();
            System.out.println("创建连接池"+name+"失败");
            return null;
        }
  }
  
  public static boolean init(GenericDaemon daemon){
    if(defaultDataSource.get()!=null){
      throw new RuntimeException("DatabaseConnectionPool has been initialized once already");
    }
    
    BasicDataSource ds=instance.getDataSource(DATASOURCE_DEFAULT);

        if(ds==null){
          System.out.println("创建default连接池失败");
          return false;
        }
        
        defaultDataSource.set(ds);
        dataSource.put(DATASOURCE_DEFAULT,ds);
    return true;
  }
  
  private Connection getConnection(BasicDataSource ds){
    try{
      return ds.getConnection();      
    }
    catch(SQLException ex){
      return null;
    }
  }
  
  public Connection getConnection(String dsName){
    BasicDataSource ds=dataSource.get(dsName);
    if(ds==null){
      ds=getDataSource(dsName);
      if(ds==null){
        return null;
      }
      dataSource.put(dsName, ds);
    }
    return getConnection(ds);
  }
  
  public Connection getConnection(){
      BasicDataSource ds=defaultDataSource.get();
      if(ds==null)
        return null;
      return getConnection(ds);
  }
  
  public static boolean fini(GenericDaemon daemon){
    try{
      defaultDataSource.get().close();
    }
    catch(SQLException ex){
    }
    
    defaultDataSource.set(null);
    Collection<BasicDataSource> allDS=dataSource.values();
    for(BasicDataSource ds:allDS){
      try{
        ds.close();
      }
      catch(SQLException ex){
      }
    }
    
    dataSource.clear();
    
    return true;
  }
}