zoukankan      html  css  js  c++  java

  • java的几种连接池

    连接池的管理用了了享元模式，这里对连接池进行简单设计。

    一、设计思路

         1.连接池配置属性DBbean：里面存放可以配置的一些属性

         2.连接池接口IConnectionPool：里面定义一些基本的获取连接的一些方法

         3.接口实现ConnectionPool：对上面操作进行实现，并加入一些其他方法

         4.连接池管理ConnectionPoolManager：管理所有的不同的连接池，所有的连接都能通过这里进行获得连接

         5.另外还有几个测试类，和连接信息模拟的类，这里就不进行xml 和配置文件信息的读取了

    Java代码  收藏代码
    1. package pool;  
    2. /** 
    3.  * 这是外部可以配置的连接池属性 
    4.  * 可以允许外部配置，拥有默认值 
    5.  * @author Ran 
    6.  * 
    7.  */  
    8. public class DBbean {  
    9.     // 连接池属性  
    10.     private String driverName;  
    11.     private String url;  
    12.     private String userName;  
    13.     private String password;  
    14.     // 连接池名字  
    15.     private String poolName;  
    16.     private int minConnections = 1; // 空闲池，最小连接数  
    17.     private int maxConnections = 10; // 空闲池，最大连接数  
    18.       
    19.     private int initConnections = 5;// 初始化连接数  
    20.       
    21.     private long connTimeOut = 1000;// 重复获得连接的频率  
    22.       
    23.     private int maxActiveConnections = 100;// 最大允许的连接数，和数据库对应  
    24.       
    25.     private long connectionTimeOut = 1000*60*20;// 连接超时时间，默认20分钟  
    26.       
    27.     private boolean isCurrentConnection = true; // 是否获得当前连接，默认true  
    28.       
    29.     private boolean isCheakPool = true; // 是否定时检查连接池  
    30.     private long lazyCheck = 1000*60*60;// 延迟多少时间后开始 检查  
    31.     private long periodCheck = 1000*60*60;// 检查频率  
    32.       
    33.       
    34.       
    35.     public DBbean(String driverName, String url, String userName,  
    36.             String password, String poolName) {  
    37.         super();  
    38.         this.driverName = driverName;  
    39.         this.url = url;  
    40.         this.userName = userName;  
    41.         this.password = password;  
    42.         this.poolName = poolName;  
    43.     }  
    44.     public DBbean() {  
    45.     }  
    46.     public String getDriverName() {  
    47.         if(driverName == null){  
    48.             driverName = this.getDriverName()+"_"+this.getUrl();  
    49.         }  
    50.         return driverName;  
    51.     }  
    52.     public void setDriverName(String driverName) {  
    53.         this.driverName = driverName;  
    54.     }  
    55.     public String getUrl() {  
    56.         return url;  
    57.     }  
    58.     public void setUrl(String url) {  
    59.         this.url = url;  
    60.     }  
    61.     public String getUserName() {  
    62.         return userName;  
    63.     }  
    64.     public void setUserName(String userName) {  
    65.         this.userName = userName;  
    66.     }  
    67.     public String getPassword() {  
    68.         return password;  
    69.     }  
    70.     public void setPassword(String password) {  
    71.         this.password = password;  
    72.     }  
    73.     public String getPoolName() {  
    74.         return poolName;  
    75.     }  
    76.     public void setPoolName(String poolName) {  
    77.         this.poolName = poolName;  
    78.     }  
    79.     public int getMinConnections() {  
    80.         return minConnections;  
    81.     }  
    82.     public void setMinConnections(int minConnections) {  
    83.         this.minConnections = minConnections;  
    84.     }  
    85.     public int getMaxConnections() {  
    86.         return maxConnections;  
    87.     }  
    88.     public void setMaxConnections(int maxConnections) {  
    89.         this.maxConnections = maxConnections;  
    90.     }  
    91.     public int getInitConnections() {  
    92.         return initConnections;  
    93.     }  
    94.     public void setInitConnections(int initConnections) {  
    95.         this.initConnections = initConnections;  
    96.     }  
    97.   
    98.     public int getMaxActiveConnections() {  
    99.         return maxActiveConnections;  
    100.     }  
    101.     public void setMaxActiveConnections(int maxActiveConnections) {  
    102.         this.maxActiveConnections = maxActiveConnections;  
    103.     }  
    104.     public long getConnTimeOut() {  
    105.         return connTimeOut;  
    106.     }  
    107.     public void setConnTimeOut(long connTimeOut) {  
    108.         this.connTimeOut = connTimeOut;  
    109.     }  
    110.     public long getConnectionTimeOut() {  
    111.         return connectionTimeOut;  
    112.     }  
    113.     public void setConnectionTimeOut(long connectionTimeOut) {  
    114.         this.connectionTimeOut = connectionTimeOut;  
    115.     }  
    116.     public boolean isCurrentConnection() {  
    117.         return isCurrentConnection;  
    118.     }  
    119.     public void setCurrentConnection(boolean isCurrentConnection) {  
    120.         this.isCurrentConnection = isCurrentConnection;  
    121.     }  
    122.     public long getLazyCheck() {  
    123.         return lazyCheck;  
    124.     }  
    125.     public void setLazyCheck(long lazyCheck) {  
    126.         this.lazyCheck = lazyCheck;  
    127.     }  
    128.     public long getPeriodCheck() {  
    129.         return periodCheck;  
    130.     }  
    131.     public void setPeriodCheck(long periodCheck) {  
    132.         this.periodCheck = periodCheck;  
    133.     }  
    134.     public boolean isCheakPool() {  
    135.         return isCheakPool;  
    136.     }  
    137.     public void setCheakPool(boolean isCheakPool) {  
    138.         this.isCheakPool = isCheakPool;  
    139.     }  
    140.       
    141.       
    142.       
    143. }  
    package pool;
/**
 * 这是外部可以配置的连接池属性
 * 可以允许外部配置，拥有默认值
 * @author Ran
 *
 */
public class DBbean {
	// 连接池属性
	private String driverName;
	private String url;
	private String userName;
	private String password;
	// 连接池名字
	private String poolName;
	private int minConnections = 1; // 空闲池，最小连接数
	private int maxConnections = 10; // 空闲池，最大连接数
	
	private int initConnections = 5;// 初始化连接数
	
	private long connTimeOut = 1000;// 重复获得连接的频率
	
	private int maxActiveConnections = 100;// 最大允许的连接数，和数据库对应
	
	private long connectionTimeOut = 1000*60*20;// 连接超时时间，默认20分钟
	
	private boolean isCurrentConnection = true; // 是否获得当前连接，默认true
	
	private boolean isCheakPool = true; // 是否定时检查连接池
	private long lazyCheck = 1000*60*60;// 延迟多少时间后开始 检查
	private long periodCheck = 1000*60*60;// 检查频率
	
	
	
	public DBbean(String driverName, String url, String userName,
			String password, String poolName) {
		super();
		this.driverName = driverName;
		this.url = url;
		this.userName = userName;
		this.password = password;
		this.poolName = poolName;
	}
	public DBbean() {
	}
	public String getDriverName() {
		if(driverName == null){
			driverName = this.getDriverName()+"_"+this.getUrl();
		}
		return driverName;
	}
	public void setDriverName(String driverName) {
		this.driverName = driverName;
	}
	public String getUrl() {
		return url;
	}
	public void setUrl(String url) {
		this.url = url;
	}
	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public String getPoolName() {
		return poolName;
	}
	public void setPoolName(String poolName) {
		this.poolName = poolName;
	}
	public int getMinConnections() {
		return minConnections;
	}
	public void setMinConnections(int minConnections) {
		this.minConnections = minConnections;
	}
	public int getMaxConnections() {
		return maxConnections;
	}
	public void setMaxConnections(int maxConnections) {
		this.maxConnections = maxConnections;
	}
	public int getInitConnections() {
		return initConnections;
	}
	public void setInitConnections(int initConnections) {
		this.initConnections = initConnections;
	}

	public int getMaxActiveConnections() {
		return maxActiveConnections;
	}
	public void setMaxActiveConnections(int maxActiveConnections) {
		this.maxActiveConnections = maxActiveConnections;
	}
	public long getConnTimeOut() {
		return connTimeOut;
	}
	public void setConnTimeOut(long connTimeOut) {
		this.connTimeOut = connTimeOut;
	}
	public long getConnectionTimeOut() {
		return connectionTimeOut;
	}
	public void setConnectionTimeOut(long connectionTimeOut) {
		this.connectionTimeOut = connectionTimeOut;
	}
	public boolean isCurrentConnection() {
		return isCurrentConnection;
	}
	public void setCurrentConnection(boolean isCurrentConnection) {
		this.isCurrentConnection = isCurrentConnection;
	}
	public long getLazyCheck() {
		return lazyCheck;
	}
	public void setLazyCheck(long lazyCheck) {
		this.lazyCheck = lazyCheck;
	}
	public long getPeriodCheck() {
		return periodCheck;
	}
	public void setPeriodCheck(long periodCheck) {
		this.periodCheck = periodCheck;
	}
	public boolean isCheakPool() {
		return isCheakPool;
	}
	public void setCheakPool(boolean isCheakPool) {
		this.isCheakPool = isCheakPool;
	}
	
	
	
}
    Java代码  收藏代码
    1. package pool;  
    2.   
    3. import java.sql.Connection;  
    4. import java.sql.SQLException;  
    5.   
    6. public interface IConnectionPool {  
    7.     // 获得连接  
    8.     public Connection  getConnection();  
    9.     // 获得当前连接  
    10.     public Connection getCurrentConnecton();  
    11.     // 回收连接  
    12.     public void releaseConn(Connection conn) throws SQLException;  
    13.     // 销毁清空  
    14.     public void destroy();  
    15.     // 连接池是活动状态  
    16.     public boolean isActive();  
    17.     // 定时器，检查连接池  
    18.     public void cheackPool();  
    19. }  
    package pool;

import java.sql.Connection;
import java.sql.SQLException;

public interface IConnectionPool {
	// 获得连接
	public Connection  getConnection();
	// 获得当前连接
	public Connection getCurrentConnecton();
	// 回收连接
	public void releaseConn(Connection conn) throws SQLException;
	// 销毁清空
	public void destroy();
	// 连接池是活动状态
	public boolean isActive();
	// 定时器，检查连接池
	public void cheackPool();
}
    Java代码  收藏代码
    1. package pool;  
    2.   
    3. import java.sql.Connection;  
    4. import java.sql.DriverManager;  
    5. import java.sql.SQLException;  
    6. import java.util.List;  
    7. import java.util.Timer;  
    8. import java.util.TimerTask;  
    9. import java.util.Vector;  
    10.   
    11. public class ConnectionPool implements IConnectionPool {  
    12.     // 连接池配置属性  
    13.     private DBbean dbBean;  
    14.     private boolean isActive = false; // 连接池活动状态  
    15.     private int contActive = 0;// 记录创建的总的连接数  
    16.       
    17.     // 空闲连接  
    18.     private List<Connection> freeConnection = new Vector<Connection>();  
    19.     // 活动连接  
    20.     private List<Connection> activeConnection = new Vector<Connection>();  
    21.     // 将线程和连接绑定，保证事务能统一执行  
    22.     private static ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();  
    23.       
    24.     public ConnectionPool(DBbean dbBean) {  
    25.         super();  
    26.         this.dbBean = dbBean;  
    27.         init();  
    28.         cheackPool();  
    29.     }  
    30.   
    31.     // 初始化  
    32.     public void init() {  
    33.         try {  
    34.             Class.forName(dbBean.getDriverName());  
    35.             for (int i = 0; i < dbBean.getInitConnections(); i++) {  
    36.                 Connection conn;  
    37.                 conn = newConnection();  
    38.                 // 初始化最小连接数  
    39.                 if (conn != null) {  
    40.                     freeConnection.add(conn);  
    41.                     contActive++;  
    42.                 }  
    43.             }  
    44.             isActive = true;  
    45.         } catch (ClassNotFoundException e) {  
    46.             e.printStackTrace();  
    47.         } catch (SQLException e) {  
    48.             e.printStackTrace();  
    49.         }  
    50.     }  
    51.       
    52.     // 获得当前连接  
    53.     public Connection getCurrentConnecton(){  
    54.         // 默认线程里面取  
    55.         Connection conn = threadLocal.get();  
    56.         if(!isValid(conn)){  
    57.             conn = getConnection();  
    58.         }  
    59.         return conn;  
    60.     }  
    61.   
    62.     // 获得连接  
    63.     public synchronized Connection getConnection() {  
    64.         Connection conn = null;  
    65.         try {  
    66.             // 判断是否超过最大连接数限制  
    67.             if(contActive < this.dbBean.getMaxActiveConnections()){  
    68.                 if (freeConnection.size() > 0) {  
    69.                     conn = freeConnection.get(0);  
    70.                     if (conn != null) {  
    71.                         threadLocal.set(conn);  
    72.                     }  
    73.                     freeConnection.remove(0);  
    74.                 } else {  
    75.                     conn = newConnection();  
    76.                 }  
    77.                   
    78.             }else{  
    79.                 // 继续获得连接,直到从新获得连接  
    80.                 wait(this.dbBean.getConnTimeOut());  
    81.                 conn = getConnection();  
    82.             }  
    83.             if (isValid(conn)) {  
    84.                 activeConnection.add(conn);  
    85.                 contActive ++;  
    86.             }  
    87.         } catch (SQLException e) {  
    88.             e.printStackTrace();  
    89.         } catch (ClassNotFoundException e) {  
    90.             e.printStackTrace();  
    91.         } catch (InterruptedException e) {  
    92.             e.printStackTrace();  
    93.         }  
    94.         return conn;  
    95.     }  
    96.   
    97.     // 获得新连接  
    98.     private synchronized Connection newConnection()  
    99.             throws ClassNotFoundException, SQLException {  
    100.         Connection conn = null;  
    101.         if (dbBean != null) {  
    102.             Class.forName(dbBean.getDriverName());  
    103.             conn = DriverManager.getConnection(dbBean.getUrl(),  
    104.                     dbBean.getUserName(), dbBean.getPassword());  
    105.         }  
    106.         return conn;  
    107.     }  
    108.   
    109.     // 释放连接  
    110.     public synchronized void releaseConn(Connection conn) throws SQLException {  
    111.         if (isValid(conn)&& !(freeConnection.size() > dbBean.getMaxConnections())) {  
    112.             freeConnection.add(conn);  
    113.             activeConnection.remove(conn);  
    114.             contActive --;  
    115.             threadLocal.remove();  
    116.             // 唤醒所有正待等待的线程，去抢连接  
    117.             notifyAll();  
    118.         }  
    119.     }  
    120.   
    121.     // 判断连接是否可用  
    122.     private boolean isValid(Connection conn) {  
    123.         try {  
    124.             if (conn == null || conn.isClosed()) {  
    125.                 return false;  
    126.             }  
    127.         } catch (SQLException e) {  
    128.             e.printStackTrace();  
    129.         }  
    130.         return true;  
    131.     }  
    132.   
    133.     // 销毁连接池  
    134.     public synchronized void destroy() {  
    135.         for (Connection conn : freeConnection) {  
    136.             try {  
    137.                 if (isValid(conn)) {  
    138.                     conn.close();  
    139.                 }  
    140.             } catch (SQLException e) {  
    141.                 e.printStackTrace();  
    142.             }  
    143.         }  
    144.         for (Connection conn : activeConnection) {  
    145.             try {  
    146.                 if (isValid(conn)) {  
    147.                     conn.close();  
    148.                 }  
    149.             } catch (SQLException e) {  
    150.                 e.printStackTrace();  
    151.             }  
    152.         }  
    153.         isActive = false;  
    154.         contActive = 0;  
    155.     }  
    156.   
    157.     // 连接池状态  
    158.     @Override  
    159.     public boolean isActive() {  
    160.         return isActive;  
    161.     }  
    162.       
    163.     // 定时检查连接池情况  
    164.     @Override  
    165.     public void cheackPool() {  
    166.         if(dbBean.isCheakPool()){  
    167.             new Timer().schedule(new TimerTask() {  
    168.             @Override  
    169.             public void run() {  
    170.             // 1.对线程里面的连接状态  
    171.             // 2.连接池最小 最大连接数  
    172.             // 3.其他状态进行检查，因为这里还需要写几个线程管理的类，暂时就不添加了  
    173.             System.out.println("空线池连接数："+freeConnection.size());  
    174.             System.out.println("活动连接数：："+activeConnection.size());  
    175.             System.out.println("总的连接数："+contActive);  
    176.                 }  
    177.             },dbBean.getLazyCheck(),dbBean.getPeriodCheck());  
    178.         }  
    179.     }  
    180. }  
    package pool;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;
import java.util.Vector;

public class ConnectionPool implements IConnectionPool {
	// 连接池配置属性
	private DBbean dbBean;
	private boolean isActive = false; // 连接池活动状态
	private int contActive = 0;// 记录创建的总的连接数
	
	// 空闲连接
	private List<Connection> freeConnection = new Vector<Connection>();
	// 活动连接
	private List<Connection> activeConnection = new Vector<Connection>();
	// 将线程和连接绑定，保证事务能统一执行
	private static ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();
	
	public ConnectionPool(DBbean dbBean) {
		super();
		this.dbBean = dbBean;
		init();
		cheackPool();
	}

	// 初始化
	public void init() {
		try {
			Class.forName(dbBean.getDriverName());
			for (int i = 0; i < dbBean.getInitConnections(); i++) {
				Connection conn;
				conn = newConnection();
				// 初始化最小连接数
				if (conn != null) {
					freeConnection.add(conn);
					contActive++;
				}
			}
			isActive = true;
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	// 获得当前连接
	public Connection getCurrentConnecton(){
		// 默认线程里面取
		Connection conn = threadLocal.get();
		if(!isValid(conn)){
			conn = getConnection();
		}
		return conn;
	}

	// 获得连接
	public synchronized Connection getConnection() {
		Connection conn = null;
		try {
			// 判断是否超过最大连接数限制
			if(contActive < this.dbBean.getMaxActiveConnections()){
				if (freeConnection.size() > 0) {
					conn = freeConnection.get(0);
					if (conn != null) {
						threadLocal.set(conn);
					}
					freeConnection.remove(0);
				} else {
					conn = newConnection();
				}
				
			}else{
				// 继续获得连接,直到从新获得连接
				wait(this.dbBean.getConnTimeOut());
				conn = getConnection();
			}
			if (isValid(conn)) {
				activeConnection.add(conn);
				contActive ++;
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		return conn;
	}

	// 获得新连接
	private synchronized Connection newConnection()
			throws ClassNotFoundException, SQLException {
		Connection conn = null;
		if (dbBean != null) {
			Class.forName(dbBean.getDriverName());
			conn = DriverManager.getConnection(dbBean.getUrl(),
					dbBean.getUserName(), dbBean.getPassword());
		}
		return conn;
	}

	// 释放连接
	public synchronized void releaseConn(Connection conn) throws SQLException {
		if (isValid(conn)&& !(freeConnection.size() > dbBean.getMaxConnections())) {
			freeConnection.add(conn);
			activeConnection.remove(conn);
			contActive --;
			threadLocal.remove();
			// 唤醒所有正待等待的线程，去抢连接
			notifyAll();
		}
	}

	// 判断连接是否可用
	private boolean isValid(Connection conn) {
		try {
			if (conn == null || conn.isClosed()) {
				return false;
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return true;
	}

	// 销毁连接池
	public synchronized void destroy() {
		for (Connection conn : freeConnection) {
			try {
				if (isValid(conn)) {
					conn.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		for (Connection conn : activeConnection) {
			try {
				if (isValid(conn)) {
					conn.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		isActive = false;
		contActive = 0;
	}

	// 连接池状态
	@Override
	public boolean isActive() {
		return isActive;
	}
	
	// 定时检查连接池情况
	@Override
	public void cheackPool() {
		if(dbBean.isCheakPool()){
			new Timer().schedule(new TimerTask() {
			@Override
			public void run() {
			// 1.对线程里面的连接状态
			// 2.连接池最小 最大连接数
			// 3.其他状态进行检查，因为这里还需要写几个线程管理的类，暂时就不添加了
			System.out.println("空线池连接数："+freeConnection.size());
			System.out.println("活动连接数：："+activeConnection.size());
			System.out.println("总的连接数："+contActive);
				}
			},dbBean.getLazyCheck(),dbBean.getPeriodCheck());
		}
	}
}
    Java代码  收藏代码
    1. package pool;  
    2.   
    3. import java.sql.Connection;  
    4. import java.sql.SQLException;  
    5. import java.util.Hashtable;  
    6. /** 
    7.  * 连接管理类 
    8.  * @author Ran 
    9.  * 
    10.  */  
    11. public class ConnectionPoolManager {  
    12.       
    13.       
    14.     // 连接池存放  
    15.     public Hashtable<String,IConnectionPool> pools = new Hashtable<String, IConnectionPool>();  
    16.       
    17.     // 初始化  
    18.     private ConnectionPoolManager(){  
    19.         init();  
    20.     }  
    21.     // 单例实现  
    22.     public static ConnectionPoolManager getInstance(){  
    23.         return Singtonle.instance;  
    24.     }  
    25.     private static class Singtonle {  
    26.         private static ConnectionPoolManager instance =  new ConnectionPoolManager();  
    27.     }  
    28.       
    29.       
    30.     // 初始化所有的连接池  
    31.     public void init(){  
    32.         for(int i =0;i<DBInitInfo.beans.size();i++){  
    33.             DBbean bean = DBInitInfo.beans.get(i);  
    34.             ConnectionPool pool = new ConnectionPool(bean);  
    35.             if(pool != null){  
    36.                 pools.put(bean.getPoolName(), pool);  
    37.                 System.out.println("Info:Init connection successed ->" +bean.getPoolName());  
    38.             }  
    39.         }  
    40.     }  
    41.       
    42.     // 获得连接,根据连接池名字 获得连接  
    43.     public Connection  getConnection(String poolName){  
    44.         Connection conn = null;  
    45.         if(pools.size()>0 && pools.containsKey(poolName)){  
    46.             conn = getPool(poolName).getConnection();  
    47.         }else{  
    48.             System.out.println("Error:Can't find this connecion pool ->"+poolName);  
    49.         }  
    50.         return conn;  
    51.     }  
    52.       
    53.     // 关闭，回收连接  
    54.     public void close(String poolName,Connection conn){  
    55.             IConnectionPool pool = getPool(poolName);  
    56.             try {  
    57.                 if(pool != null){  
    58.                     pool.releaseConn(conn);  
    59.                 }  
    60.             } catch (SQLException e) {  
    61.                 System.out.println("连接池已经销毁");  
    62.                 e.printStackTrace();  
    63.             }  
    64.     }  
    65.       
    66.     // 清空连接池  
    67.     public void destroy(String poolName){  
    68.         IConnectionPool pool = getPool(poolName);  
    69.         if(pool != null){  
    70.             pool.destroy();  
    71.         }  
    72.     }  
    73.       
    74.     // 获得连接池  
    75.     public IConnectionPool getPool(String poolName){  
    76.         IConnectionPool pool = null;  
    77.         if(pools.size() > 0){  
    78.              pool = pools.get(poolName);  
    79.         }  
    80.         return pool;  
    81.     }  
    82. }  
    package pool;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.Hashtable;
/**
 * 连接管理类
 * @author Ran
 *
 */
public class ConnectionPoolManager {
	
	
	// 连接池存放
	public Hashtable<String,IConnectionPool> pools = new Hashtable<String, IConnectionPool>();
	
	// 初始化
	private ConnectionPoolManager(){
		init();
	}
	// 单例实现
	public static ConnectionPoolManager getInstance(){
		return Singtonle.instance;
	}
	private static class Singtonle {
		private static ConnectionPoolManager instance =  new ConnectionPoolManager();
	}
	
	
	// 初始化所有的连接池
	public void init(){
		for(int i =0;i<DBInitInfo.beans.size();i++){
			DBbean bean = DBInitInfo.beans.get(i);
			ConnectionPool pool = new ConnectionPool(bean);
			if(pool != null){
				pools.put(bean.getPoolName(), pool);
				System.out.println("Info:Init connection successed ->" +bean.getPoolName());
			}
		}
	}
	
	// 获得连接,根据连接池名字 获得连接
	public Connection  getConnection(String poolName){
		Connection conn = null;
		if(pools.size()>0 && pools.containsKey(poolName)){
			conn = getPool(poolName).getConnection();
		}else{
			System.out.println("Error:Can't find this connecion pool ->"+poolName);
		}
		return conn;
	}
	
	// 关闭，回收连接
	public void close(String poolName,Connection conn){
			IConnectionPool pool = getPool(poolName);
			try {
				if(pool != null){
					pool.releaseConn(conn);
				}
			} catch (SQLException e) {
				System.out.println("连接池已经销毁");
				e.printStackTrace();
			}
	}
	
	// 清空连接池
	public void destroy(String poolName){
		IConnectionPool pool = getPool(poolName);
		if(pool != null){
			pool.destroy();
		}
	}
	
	// 获得连接池
	public IConnectionPool getPool(String poolName){
		IConnectionPool pool = null;
		if(pools.size() > 0){
			 pool = pools.get(poolName);
		}
		return pool;
	}
}
    Java代码  收藏代码
    1. package pool;  
    2.   
    3. import java.util.ArrayList;  
    4. import java.util.List;  
    5. /** 
    6.  * 初始化，模拟加载所有的配置文件 
    7.  * @author Ran 
    8.  * 
    9.  */  
    10. public class DBInitInfo {  
    11.     public  static List<DBbean>  beans = null;  
    12.     static{  
    13.         beans = new ArrayList<DBbean>();  
    14.         // 这里数据 可以从xml 等配置文件进行获取  
    15.         // 为了测试，这里我直接写死  
    16.         DBbean beanOracle = new DBbean();  
    17.         beanOracle.setDriverName("oracle.jdbc.driver.OracleDriver");  
    18.         beanOracle.setUrl("jdbc:oracle:thin:@7MEXGLUY95W1Y56:1521:orcl");  
    19.         beanOracle.setUserName("mmsoa");  
    20.         beanOracle.setPassword("password1234");  
    21.           
    22.         beanOracle.setMinConnections(5);  
    23.         beanOracle.setMaxConnections(100);  
    24.           
    25.         beanOracle.setPoolName("testPool");  
    26.         beans.add(beanOracle);  
    27.     }  
    28. }  
    package pool;

import java.util.ArrayList;
import java.util.List;
/**
 * 初始化，模拟加载所有的配置文件
 * @author Ran
 *
 */
public class DBInitInfo {
	public  static List<DBbean>  beans = null;
	static{
		beans = new ArrayList<DBbean>();
		// 这里数据 可以从xml 等配置文件进行获取
		// 为了测试，这里我直接写死
		DBbean beanOracle = new DBbean();
		beanOracle.setDriverName("oracle.jdbc.driver.OracleDriver");
		beanOracle.setUrl("jdbc:oracle:thin:@7MEXGLUY95W1Y56:1521:orcl");
		beanOracle.setUserName("mmsoa");
		beanOracle.setPassword("password1234");
		
		beanOracle.setMinConnections(5);
		beanOracle.setMaxConnections(100);
		
		beanOracle.setPoolName("testPool");
		beans.add(beanOracle);
	}
}

        测试：

       

    Java代码  收藏代码
    1. package pool;  
    2.   
    3. import java.sql.Connection;  
    4. /** 
    5.  * 模拟线程启动，去获得连接 
    6.  * @author Ran 
    7.  * 
    8.  */  
    9. public class ThreadConnection implements Runnable{  
    10.     private IConnectionPool pool;  
    11.     @Override  
    12.     public void run() {  
    13.         pool = ConnectionPoolManager.getInstance().getPool("testPool");  
    14.     }  
    15.       
    16.     public Connection getConnection(){  
    17.         Connection conn = null;  
    18.         if(pool != null && pool.isActive()){  
    19.             conn = pool.getConnection();  
    20.         }  
    21.         return conn;  
    22.     }  
    23.       
    24.     public Connection getCurrentConnection(){  
    25.         Connection conn = null;  
    26.         if(pool != null && pool.isActive()){  
    27.             conn = pool.getCurrentConnecton();  
    28.         }  
    29.         return conn;  
    30.     }  
    31. }  
    package pool;

import java.sql.Connection;
/**
 * 模拟线程启动，去获得连接
 * @author Ran
 *
 */
public class ThreadConnection implements Runnable{
	private IConnectionPool pool;
	@Override
	public void run() {
		pool = ConnectionPoolManager.getInstance().getPool("testPool");
	}
	
	public Connection getConnection(){
		Connection conn = null;
		if(pool != null && pool.isActive()){
			conn = pool.getConnection();
		}
		return conn;
	}
	
	public Connection getCurrentConnection(){
		Connection conn = null;
		if(pool != null && pool.isActive()){
			conn = pool.getCurrentConnecton();
		}
		return conn;
	}
}
    Java代码  收藏代码
    1. package pool;  
    2.   
    3.   
    4.   
    5. public class Client {  
    6.     public static void main(String[] args) throws InterruptedException {  
    7.         // 初始化连接池  
    8.         Thread t = init();  
    9.         t.start();  
    10.         t.join();  
    11.           
    12.         ThreadConnection a = new ThreadConnection();  
    13.         ThreadConnection b = new ThreadConnection();  
    14.         ThreadConnection c = new ThreadConnection();  
    15.         Thread t1 = new Thread(a);  
    16.         Thread t2 = new Thread(b);  
    17.         Thread t3 = new Thread(c);  
    18.           
    19.           
    20.         // 设置优先级，先让初始化执行，模拟 线程池 先启动  
    21.         // 这里仅仅表面控制了，因为即使t 线程先启动，也不能保证pool 初始化完成，为了简单模拟，这里先这样写了  
    22.         t1.setPriority(10);  
    23.         t2.setPriority(10);  
    24.         t3.setPriority(10);  
    25.         t1.start();  
    26.         t2.start();  
    27.         t3.start();  
    28.           
    29.         System.out.println("线程A-> "+a.getConnection());  
    30.         System.out.println("线程B-> "+b.getConnection());  
    31.         System.out.println("线程C-> "+c.getConnection());  
    32.     }  
    33.   
    34.     // 初始化  
    35.     public static Thread init() {  
    36.         Thread t = new Thread(new Runnable() {  
    37.             @Override  
    38.             public void run() {  
    39.                 IConnectionPool  pool = initPool();  
    40.                 while(pool == null || !pool.isActive()){  
    41.                     pool = initPool();  
    42.                 }  
    43.             }  
    44.         });  
    45.         return t;  
    46.     }  
    47.       
    48.     public static IConnectionPool initPool(){  
    49.         return ConnectionPoolManager.getInstance().getPool("testPool");  
    50.     }  
    51.   
    52. }  
    package pool;



public class Client {
	public static void main(String[] args) throws InterruptedException {
		// 初始化连接池
		Thread t = init();
		t.start();
		t.join();
		
		ThreadConnection a = new ThreadConnection();
		ThreadConnection b = new ThreadConnection();
		ThreadConnection c = new ThreadConnection();
		Thread t1 = new Thread(a);
		Thread t2 = new Thread(b);
		Thread t3 = new Thread(c);
		
		
		// 设置优先级，先让初始化执行，模拟 线程池 先启动
		// 这里仅仅表面控制了，因为即使t 线程先启动，也不能保证pool 初始化完成，为了简单模拟，这里先这样写了
		t1.setPriority(10);
		t2.setPriority(10);
		t3.setPriority(10);
		t1.start();
		t2.start();
		t3.start();
		
		System.out.println("线程A-> "+a.getConnection());
		System.out.println("线程B-> "+b.getConnection());
		System.out.println("线程C-> "+c.getConnection());
	}

	// 初始化
	public static Thread init() {
		Thread t = new Thread(new Runnable() {
			@Override
			public void run() {
				IConnectionPool  pool = initPool();
				while(pool == null || !pool.isActive()){
					pool = initPool();
				}
			}
		});
		return t;
	}
	
	public static IConnectionPool initPool(){
		return ConnectionPoolManager.getInstance().getPool("testPool");
	}

}

    小结 ：

              1.连接池诞生原因是，如果每次都从数据库获得连接，时间比较长，因此我们提前做建立一些连接，放在连接池里面，每次都从里面取

              2.上面仅仅写了连接池基本原理，关于多线程下连接池的管理没写，后面对多线程操作熟练了添加吧
  • 相关阅读:
    栈
    队列
    数据结构简介
    标准模板库
    类模板
    函数模板
    srvctl error
    FLASH BACK
    RAC 设置archive log模式
    CHAPTER 1 Architectural Overview of Oracle Database 11g
  • 原文地址：https://www.cnblogs.com/jiangyi666/p/5686786.html
Copyright © 2011-2022 走看看