自己封装dbc连接池，支持并发，多数据源

最新推荐文章于 2023-02-13 00:41:32 发布

李修睿

最新推荐文章于 2023-02-13 00:41:32 发布

阅读量906

点赞数

文章标签：连接池 jdbc 事务

本文链接：https://blog.csdn.net/liwang2016384/article/details/86652445

版权

ConnectionManager.java

package com.shuidi.common.mypool;

import org.apache.log4j.Logger;

import com.shuidi.common.myException.MyException;
import com.shuidi.common.spring.BeanFactory;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
/**
* jdbc连接管理类
* @Author 李修睿
* @Param
* @return
* 2018-08-15 下午 4:06
**/
public enum ConnectionManager {
/**
* 使用枚举单例对象
* @Author 李修睿
* @Param
* @return
* 2018-08-15 下午 4:07
**/
MANAGER;
private final Logger log = Logger.getLogger(ConnectionManager.class);

/**
* 加载的驱动器名称集合
*/
private Set<String> drivers = new HashSet<String>();

/**
* 数据库连接池字典
* 为每个数据库创建一个连接池（可配置多个数据库）
*/
private ConcurrentHashMap<String, IConnectionPool> pools = new ConcurrentHashMap<String, IConnectionPool>();

private ConnectionManager() {
// createPools();
}

/**
* 装载JDBC驱动程序，并创建连接池
* @throws ClassNotFoundException
*/
private synchronized IConnectionPool createPools(String poolname) throws ClassNotFoundException{
if(pools.containsKey(poolname)){
return pools.get(poolname);
}
   DataSource db= (DataSource) BeanFactory.getBean(poolname);
   db.setDbName(poolname);
if (db.getUrl() == null) {
log.error(poolname+"数据库的连接字符串为空，请检查配置文件");
//抛出一个异常，说明数据库为空
return null;
}
if (db.getDriverName() == null) {
log.error(poolname+"数据库的driver驱动为空，请检查配置文件");
return null;
}

if (db.getUsername() == null) {
log.error(poolname+"数据库的用户名设置为空，请检查配置文件");
return null;
}
if (db.getPassword() == null) {
log.error(poolname+"数据库的密码设置为空，请检查配置文件");
return null;
}

//验证最小连接数配置正确性
if (db.getMinConnections() <1) {
log.error(poolname+"数据库的最小连接数配置不正确，设置为默认值5");
db.setMinConnections(5);
}

//验证初始连接数配置正确性
if (db.getInitConnections() <db.getMinConnections()) {
log.error(poolname+"数据库的初始连接数配置不正确，设置为最小连接数"+db.getMinConnections());
db.setInitConnections(db.getMinConnections());
}

//验证最大连接数配置正确性
if (db.getMaxConnections() <db.getInitConnections()) {
log.error(poolname+"数据库的最大连接数配置不正确，设置为初始连接数"+db.getInitConnections());
db.setInitConnections(db.getInitConnections());
}

//验证conninterval配置正确性
if (db.getConninterval() <1) {
log.error(poolname+"数据库的等待时间配置不正确，设置为默认值500毫秒");
db.setConninterval(500);
}
//验证timeout配置正确性
if (db.getTimeout() <0) {
log.error(poolname+"数据库的超时重连配置不正确，设置为默认值2000毫秒");
db.setTimeout(2000);
}

//创建驱动
if(!drivers.contains(db.getDriverName())){
try {
Class.forName(db.getDriverName());
log.info("加载JDBC驱动"+db.getDriverName()+"成功");
drivers.add(db.getDriverName());
} catch (ClassNotFoundException e) {
log.error("未找到JDBC驱动" + db.getDriverName() + "，请引入相关包");
throw e;
}
}
log.warn("初始化连接："+db.getInitConnections());
//创建连接池。这里采用同步方法实现的连接池类ConnectionPool。
//(如果后面我们还有别的实现方式，只需要更改这里就行了。)
IConnectionPool cp = ConnectionPool.createConnectionPool(db);
if (cp.getFreeNum()>0) {
pools.put(poolname, cp);
cp.checkPool();
log.info("创建" + poolname + "数据库连接池成功");
} else {
log.info("创建" + poolname + "数据库连接池失败");
throw new MyException("创建" + poolname + "数据库连接池失败");
}
return cp;
}

/**
* 从指定连接池中获取可用连接
*
* @param poolName 要获取连接的连接池名称
* @throws SQLException
* @return 连接池中的一个可用连接或null
* @throws ClassNotFoundException
*/
public MyConnection getConnection(String poolName) throws SQLException, ClassNotFoundException {
IConnectionPool pool = pools.get(poolName);
if(pool==null){
pool = createPools(poolName);
}

return pool.getCurrentConnection();
}

/**
* 回收指定连接池的连接
*
* @param poolName 连接池名称
* @param conn 要回收的连接
* @throws SQLException
*/
public void closeConnection(String poolName, MyConnection conn) throws SQLException{
IConnectionPool pool = pools.get(poolName);
if (pool != null) {
   if(isAutoCommit(conn.getConnection())){//自动提交状态才释放，非自动提交状态可能是开启了事务管理
       pool.releaseConn(conn);
   }

}else{
log.error("找不到"+poolName+"连接池，无法回收");
throw new MyException("找不到"+poolName+"连接池，无法回收");
}
}

private boolean isAutoCommit(Connection conn) throws SQLException{
   boolean b =false;
   try {
           b = conn.getAutoCommit();
       } catch (SQLException e) {
           log.error("判断连接是否自动提交出错！");
           throw e;
       }
   return b;
}
/**
* 关闭所有连接，撤销驱动器的注册
*/
public void destroy() {
for (Map.Entry<String, IConnectionPool> poolEntry : pools.entrySet()) {
IConnectionPool pool = poolEntry.getValue();
pool.destroy();
}
log.info("已经关闭所有连接");
}
/**
* 关闭resultSet
* @Author 李修睿
* @Param [rs]
* @return void
* 2018-08-03 上午 9:21
**/
public void closeResultSet(ResultSet rs){
   try {
       if(null!=rs){
           rs.close();
       }else{
           log.error("ResultSet是null");
       }
       } catch (SQLException e) {
           log.error("关闭ResultSet出错!");
           throw new MyException("关闭ResultSet出错!");
       }
}

/**
* 关闭statement
* @Author 李修睿
* @Param [stm]
* @return void
* 2018-08-03 上午 9:20
* @throws SQLException
**/
   public void closeStatement(Statement stm) throws SQLException {
       try {
           if(null!=stm){
               stm.close();
           }else{
               log.error("关闭Statement出错!Statement是null");
               throw new MyException("关闭Statement出错!Statement是null");
           }

       } catch (SQLException e) {
           log.error("关闭ResultSet出错!");
           throw e;
       }
   }
}

ConnectionPool.java

package com.shuidi.common.mypool;

import org.apache.log4j.Logger;

import com.shuidi.common.myException.DBException;

import java.sql.*;
import java.util.LinkedList;
import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
* 类说明 :友元类，包内可见，不提供给客户程序直接访问。
*/
class ConnectionPool implements IConnectionPool {

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

/**
* 最长空闲时间，超过就要校验连接是否可用
* @Author 李修睿
* @Param
* @return
* 2018-08-06 下午 1:59
**/
private static final long FREE_TIME = 18000000;
private DataSource propertyBean=null;

/**
* 连接池可用状态
* @Author 李修睿
* @Param
* @return
* 2018-08-06 上午 10:39
**/
private Boolean isActive = true;

/**
* 空闲连接池。由于List读写频繁，使用LinkedList存储比较合适
* @Author 李修睿
* @Param
* @return
* 2018-08-06 上午 10:39
**/
private LinkedList<MyConnection> freeConnections = new LinkedList<>();
/**
* 活动连接池。活动连接数 <= 允许最大连接数(maxConnections)
* @Author 李修睿
* @Param
* @return
* 2018-08-06 上午 10:39
**/
private LinkedList<MyConnection> activeConnections = new LinkedList<>();

/**
* 当前线程获得的连接
* @Author 李修睿
* @Param
* @return
* 2018-08-06 上午 10:39
**/
private ThreadLocal<MyConnection> currentConnection= new ThreadLocal<>();

/**
* 构造方法无法返回null，所以取消掉。在下面增加了CreateConnectionPool静态方法。
* @Author 李修睿
* @Param
* @return
* 2018-08-06 上午 10:40
**/
private ConnectionPool(){
super();
}

public static ConnectionPool createConnectionPool(DataSource propertyBean) {
ConnectionPool connpool=new ConnectionPool();
connpool.propertyBean = propertyBean;

//基本点2、始使化时根据配置中的初始连接数创建指定数量的连接
for (int i = 0; i < connpool.propertyBean.getInitConnections(); i++) {
Connection con = connpool.newConnection();
if (con!=null){
MyConnection conn = new MyConnection(con) ;
connpool.freeConnections.add(conn);
}

}

connpool.isActive = true;
return connpool;
}

/**
* 检测连接是否有效
* @param conn 数据库连接对象
* @return Boolean
*/
private Boolean isValidConnection(Connection conn){
try {
if(conn==null || conn.isClosed()){
return false;
}
} catch (SQLException e) {
log.error("检测连接出错"+e.getMessage(),e);
return false;
}
return true;
}

/**
* 创建一个新的连接
* @return 数据库连接对象
*/
private Connection newConnection(){

Connection conn = null;
try {
if (this.propertyBean != null) {

conn = DriverManager.getConnection(this.propertyBean.getUrl(),
this.propertyBean.getUsername(),
this.propertyBean.getPassword());
}
} catch (SQLException e) {
log.error(this.propertyBean.getDbName()+"创建新连接出错！"+e.getMessage(),e);
throw new DBException("创建新连接出错！",e);
}
return conn;
}

private synchronized MyConnection getConnection() {
MyConnection conn;
if (this.getActiveNum() < this.propertyBean.getMaxConnections()) {
// 分支1：当前使用的连接没有达到最大连接数
// 基本点3、在连接池没有达到最大连接数之前，如果有可用的空闲连接就直接使用空闲连接，如果没有，就创建新的连接。
if (this.getFreeNum() > 0) {
// 分支1.1：如果空闲池中有连接，就从空闲池中直接获取
log.info("分支1.1：如果空闲池中有连接，就从空闲池中直接获取");
conn = this.freeConnections.pollFirst();

//连接闲置久了也会超时，因此空闲池中的有效连接会越来越少，需要另一个进程进行扫描监测，不断保持一定数量的可用连接。
//在下面定义了checkFreepools的TimerTask类，在checkPool()方法中进行调用。

//基本点5、由于数据库连接闲置久了会超时关闭，因此需要连接池采用机制保证每次请求的连接都是有效可用的。

if(this.isValidConnection(conn.getConnection())){
//闲置小于5个小时，不检测能否连接上
   long now = System.currentTimeMillis();
   if((now - conn.getRefreshTime()) < FREE_TIME){
       this.activeConnections.add(conn);
currentConnection.set(conn);
//刷新使用时间
conn.setRefreshTime(now);
   }else{//闲置大于5小时
       if(testConn(conn.getConnection())){
//能连上
           this.activeConnections.add(conn);
currentConnection.set(conn);
           conn.setRefreshTime(now);
       }else{
//连接不上
       Connection con=conn.getConnection();
       try {
                               con.close();
                       } catch (SQLException e) {
                               log.error("关闭连接出错！"+e.getMessage());
                               e.printStackTrace();
                           }
       conn.setConnection(this.newConnection());
       conn.setRefreshTime(now);
       }
   }
}else{
//如果连接不可用
//同步方法是可重入锁
conn = getCurrentConnection();
}

} else {
// 分支1.2：如果空闲池中无可用连接，就创建新的连接
log.info("分支1.2：如果空闲池中无可用连接，就创建新的连接");
conn = new MyConnection(newConnection());
this.activeConnections.add(conn);

}
} else {
// 分支2：当前已到达最大连接数
// 基本点4、当连接池中的活动连接数达到最大连接数，新的请求进入等待状态，直到有连接被释放。
log.info("分支2：当前已到达最大连接数 ");
long startTime = System.currentTimeMillis();

//进入等待状态。等待被notify(),notifyALL()唤醒或者超时自动苏醒
try{
this.wait(this.propertyBean.getConninterval());
}catch(InterruptedException e) {
log.error("线程等待被打断");
}

//若线程超时前被唤醒并成功获取连接，就不会走到return null。
//若线程超时前没有获取连接，则返回null。
//如果timeout设置为0，就无限重连。
if(this.propertyBean.getTimeout()!=0){
if(System.currentTimeMillis() - startTime > this.propertyBean.getTimeout()) {
return null;
}
}
conn = this.getConnection();

}
return conn;
}

@Override
public MyConnection getCurrentConnection() {

   MyConnection conn=currentConnection.get();
   if(null==conn || !isValidConnection(conn.getConnection())){
       conn=this.getConnection();
   }

return conn;
}

@Override
public synchronized void releaseConn(MyConnection conn){

log.info(Thread.currentThread().getName()+"关闭连接：activeConnections.remove:"+conn.getConnection());
this.activeConnections.remove(conn);
this.currentConnection.remove();
//活动连接池删除的连接，相应的加到空闲连接池中
if(isValidConnection(conn.getConnection())){
freeConnections.add(conn);
}else{
freeConnections.add(new MyConnection(this.newConnection()));
}
//唤醒getConnection()中等待的线程
this.notifyAll();
}

@Override
public synchronized void destroy() {
for (MyConnection conn : this.freeConnections) {
try {
if (this.isValidConnection(conn.getConnection())) {
conn.getConnection().close();
//释放掉连接
}
} catch (SQLException e) {
e.printStackTrace();
}
}
for (MyConnection conn : this.activeConnections) {
try {
if (this.isValidConnection(conn.getConnection())) {
   conn.getConnection().close();
   //释放掉连接
}
} catch (SQLException e) {
e.printStackTrace();
}
}
this.isActive = false;
this.freeConnections.clear();
this.activeConnections.clear();
}

@Override
public boolean isActive() {
return this.isActive;
}

@Override
public void checkPool() {

ScheduledExecutorService ses=Executors.newScheduledThreadPool(1);
//功能一：开启一个定时器线程输出状态
ses.scheduleAtFixedRate(new TimerTask() {
@Override
public void run() {
   //当活跃连接数较少时，空余连接数较多时关闭空余连接释放资源
if(getActiveNum()<propertyBean.getInitConnections()){

   if(getFreeNum()>propertyBean.getInitConnections()){
       MyConnection conn= freeConnections.pollLast();
       if(conn!=null){
           try {
                       conn.getConnection().close();

                       log.warn("当前空余连接"+getFreeNum()+"个,删除一个空余连接...");
                       } catch (SQLException e) {
                           e.printStackTrace();
                       }
       }
   }
}
}
}, 5, 5, TimeUnit.SECONDS);

//功能二：开启一个定时器线程，监测并维持空闲池中的最小连接数
//代码已维护，永远不会小于最小
// ses.scheduleAtFixedRate(new checkFreepools(this), 1, 5, TimeUnit.SECONDS);
}

@Override
public synchronized int getActiveNum() {
return this.activeConnections.size();
}

@Override
public synchronized int getFreeNum() {
return this.freeConnections.size();
}

static class checkFreepools extends TimerTask {
private ConnectionPool conpool = null;

public checkFreepools(ConnectionPool cp) {
this.conpool = cp;
}

@Override
public void run() {
if (this.conpool != null && this.conpool.isActive()) {
int poolstotalnum = conpool.getFreeNum()
+ conpool.getActiveNum();
int subnum = conpool.propertyBean.getMinConnections()
- poolstotalnum;

if (subnum > 0) {
log.warn(conpool.propertyBean.getDbName()
+ "扫描并维持空闲池中的最小连接数，需补充" + subnum + "个连接");
for (int i = 0; i < subnum; i++) {
conpool.freeConnections.add(new MyConnection(this.conpool.newConnection()));
}

}
}

}

/**
*
* @Author 李修睿
* @Param
* @return
* 2018-08-06 下午 2:03
**/
   @Override
   public boolean testConn(Connection conn) {
       String sql = "select 1 from dual";
       PreparedStatement pstmt=null;
ResultSet resultSet=null;
       try {
           pstmt = conn.prepareStatement(sql);
resultSet =pstmt.executeQuery();
       } catch (SQLException e) {
           log.error("连接数据库"+this.propertyBean.getDbName()+"失败！"+e.getMessage());
           return false;
       }finally{
try {
if(pstmt!=null) {
pstmt.close();
}
if(resultSet!=null) {
resultSet.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
       return true;
   }

}

DataBaseExecutor.java

package com.shuidi.common.mypool;

import org.apache.log4j.Logger;

import com.shuidi.common.myException.ParamIsNullException;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
* @author Administrator
*/
public class DataBaseExecutor {

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

   /**
   * 查询操作
   * @Author 李修睿
   * @Param [sql, poolName, params]
   * @return java.util.List<java.util.Map<java.lang.String,java.lang.Object>>
   * 2018-08-16 上午 10:08
   * @throws SQLException
   * @throws ClassNotFoundException
   **/
   public static List<Map<String, Object>> executorQuery(String sql, String poolName, Object[] params) throws SQLException, ClassNotFoundException{
       if(sql==null||sql.trim()==""){
           throw new ParamIsNullException("sql");
       }
       if(poolName==null||poolName.trim()==""){
           throw new ParamIsNullException("poolName");
       }
       ResultSet rs=null;
       List<Map<String, Object>> mapList = new ArrayList<>();
       MyConnection conn=null;
       //使用预处理防止sql注入
       PreparedStatement preparedStatement =null;

       try {
           conn = ConnectionManager.MANAGER.getConnection(poolName);
           preparedStatement = conn.getConnection().prepareStatement(sql);
           if (params!=null&&params.length>0) {

               for (int i=0;i<params.length;i++) {preparedStatement.setObject(i + 1, params[i]);}
           }
           rs = preparedStatement.executeQuery();

           while (rs.next()) {
               Map<String,Object> map= new HashMap<>();
               ResultSetMetaData md = rs.getMetaData();
               int size = md.getColumnCount();
               for (int i = 0; i <size; i++) {
                   map.put((md.getColumnLabel(i+1)).toLowerCase(),rs.getObject(i+1));
               }
               mapList.add(map);
           }

       } catch (SQLException e) {
           String s= preparedStatement.toString();
           String rsql = s.substring(s.indexOf(":")+1);
           log.error("执行sql异常："+e.getMessage()+">>sql:"+rsql);
           throw e;
       } finally {
           ConnectionManager.MANAGER.closeResultSet(rs);
           ConnectionManager.MANAGER.closeStatement(preparedStatement);
           ConnectionManager.MANAGER.closeConnection(poolName,conn);
       }
       return mapList;

   }

   /**
   * 、插入、删除、更新操作
   * @Author 李修睿
   * @Param [sql, poolname, params]
   * @return int
   * 2018-08-16 上午 10:08
   * @throws SQLException
   * @throws ClassNotFoundException
   **/
   public static int executorUpdate(String sql, String poolname,Object[] params) throws SQLException, ClassNotFoundException{
       if(sql==null||sql.trim()==""){
           throw new ParamIsNullException("sql");
       }
       if(poolname==null||poolname.trim()==""){
           throw new ParamIsNullException("poolName");
       }
       MyConnection conn=null;
       PreparedStatement preparedStatement =null;

int res =0;
try {

           conn = ConnectionManager.MANAGER.getConnection(poolname);
           preparedStatement = conn.getConnection().prepareStatement(sql);
           if (params!=null&&params.length>0) {
                   for (int i=0;i<params.length;i++) {
                       preparedStatement.setObject(i+1, params[i]);
                   }
           }
           res = preparedStatement.executeUpdate();
           ;

       } catch (SQLException e) {
           String s= preparedStatement.toString();
           String rsql = s.substring(s.indexOf(":")+1);
           log.error("执行sql异常："+e.getMessage()+">>sql:"+rsql);
           throw e;
       } finally{
           ConnectionManager.MANAGER.closeStatement(preparedStatement);
           ConnectionManager.MANAGER.closeConnection(poolname,conn);
       }
       return res;
   }

   /**
   * 批量处理
   * @Author 李修睿
   * @Param [sql, poolname, params]
   * @return int
   * 2018-08-16 上午 10:22
   * @throws SQLException
   * @throws ClassNotFoundException
   **/
   public static int executorBatch(String sql, String poolname,List<Object[]> params) throws SQLException, ClassNotFoundException{
       if(sql==null||sql.trim()==""){
           throw new ParamIsNullException("sql");
       }
       if(poolname==null||poolname.trim()==""){
           throw new ParamIsNullException("poolName");
       }
       MyConnection conn=null;
       PreparedStatement preparedStatement =null;
       int res = 0;
       try {

           conn = ConnectionManager.MANAGER.getConnection(poolname);
           preparedStatement = conn.getConnection().prepareStatement(sql);
           if (params!=null&&params.size()>0) {
               for (Object [] pars:params) {
                   for (int j=0, length =pars.length;j<length;j++) {
                       preparedStatement.setObject(j + 1,pars[j]);
                   }
                   preparedStatement.addBatch();
               }
           }
           int[] result= preparedStatement.executeBatch();
           if(result==null || (result!=null && result.length==0) ){
return res;
           }
           for (int re:result) {
               res+=re;
           }

       } catch (SQLException e) {
           String s= preparedStatement.toString();
           String rsql = s.substring(s.indexOf(":")+1);
           log.error("执行sql异常："+e.getMessage()+">>sql:"+rsql);
           throw e;
       } finally{
           ConnectionManager.MANAGER.closeStatement(preparedStatement);
           ConnectionManager.MANAGER.closeConnection(poolname,conn);
       }
       return res;
   }
}

package com.shuidi.common.mypool;

import org.apache.log4j.Logger;

import com.shuidi.common.myException.ParamIsNullException;

/**
* @author Administrator
*/
public class DataBaseExecutor {

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

       try {
           conn = ConnectionManager.MANAGER.getConnection(poolName);
           preparedStatement = conn.getConnection().prepareStatement(sql);
           if (params!=null&&params.length>0) {

int res =0;
try {

package com.shuidi.common.mypool;
public class DataSource {

private String dbName;
//数据连接驱动
private String driverName;
//数据连接url
private String url;
//数据连接username
private String username;
//数据连接密码
private String password;
//连接池最大连接数
private int maxConnections ;
//连接池最小连接数
private int minConnections;
//连接池初始连接数
private int initConnections;
//重连间隔时间，单位毫秒
private int conninterval ;
//获取连接超时时间，单位毫秒，0永不超时
private int timeout ;

//构造方法
public DataSource(){
super();
}

//下面是getter and setter

/**
* 获取数据库连接节点名称
* @return
*/
public String getDbName() {
return dbName;
}

/**
* 设置数据库连接节点名称
* @param nodeName
*/
public void setDbName(String nodeName) {
this.dbName = nodeName;
}

/**
* 获取数据库驱动
* @return
*/
public String getDriverName() {
return driverName;
}

/**
* 设置数据库驱动
* @param driverName
*/
public void setDriverName(String driverName) {
this.driverName = driverName;
}

/**
* 获取数据库url
* @return
*/
public String getUrl() {
return url;
}

/**
* 设置数据库url
* @param url
*/
public void setUrl(String url) {
this.url = url;
}

/**
* 获取用户名
* @return
*/
public String getUsername() {
return username;
}

/**
* 设置用户名
* @param username
*/
public void setUsername(String username) {
this.username = username;
}

/**
* 获取数据库连接密码
* @return
*/
public String getPassword(){
return password;
}

/**
* 设置数据库连接密码
* @param password
*/
public void setPassword(String password) {
this.password = password;
}

/**
* 获取最大连接数
* @return
*/
public int getMaxConnections() {
return maxConnections;
}

/**
* 设置最大连接数
* @param maxConnections
*/
public void setMaxConnections(int maxConnections) {
this.maxConnections = maxConnections;
}

/**
* 获取最小连接数（也是数据池初始连接数）
* @return
*/
public int getMinConnections() {
return minConnections;
}

/**
* 设置最小连接数（也是数据池初始连接数）
* @param minConnections
*/
public void setMinConnections(int minConnections) {
this.minConnections = minConnections;
}

/**
* 获取初始加接数
* @return
*/
public int getInitConnections() {
return initConnections;
}

/**
* 设置初始连接数
* @param initConnections
*/
public void setInitConnections(int initConnections) {
this.initConnections = initConnections;
}

/**
* 获取重连间隔时间，单位毫秒
* @return
*/
public int getConninterval() {
return conninterval;
}

/**
* 设置重连间隔时间，单位毫秒
* @param conninterval
*/
public void setConninterval(int conninterval) {
this.conninterval = conninterval;
}

/**
* 获取连接超时时间，单位毫秒
* @return
*/
public int getTimeout() {
return timeout;
}

/**
* 设置连接超时时间，单位毫秒，0-无限重连
* @param timeout
*/
public void setTimeout(int timeout) {
this.timeout = timeout;
}

}

IConnectionPool.java

package com.shuidi.common.mypool;
import java.sql.Connection;
import java.sql.SQLException;

public interface IConnectionPool {

/**
* 获得当前线程的连接库连接,如果为空则获取一个空闲的连接，如果等待超时则返回null
* @return 数据库连接对象
*/
public MyConnection getCurrentConnection();

/**
* 释放当前线程数据库连接
* @param conn 数据库连接对象
* @throws SQLException
*/
public void releaseConn(MyConnection conn);

/**
* 销毁清空当前连接池
*/
public void destroy();

/**
* 连接池可用状态
* @return 连接池是否可用
*/
public boolean isActive();

/**
* 定时器，检查连接池
*/
public void checkPool();

/**
* 获取线程池活动连接数
* @return 线程池活动连接数
*/
public int getActiveNum();

/**
* 获取线程池空闲连接数
* @return 线程池空闲连接数
*/
public int getFreeNum();
/**
* 测试连接是否真实可用
* @return
*/
public boolean testConn(Connection conn);
}

MyConnection.java

package com.shuidi.common.mypool;

import java.sql.Connection;

public class MyConnection {

   private Connection connection;//连接
   private long refreshTime;//刷新时间

   public MyConnection(Connection conn){
       this.connection = conn;
       this.refreshTime = System.currentTimeMillis();
   }
   public Connection getConnection() {
       return connection;
   }
   public void setConnection(Connection connection) {
       this.connection = connection;
   }
   public long getRefreshTime() {
       return refreshTime;
   }
   public void setRefreshTime(long refreshTime) {
       this.refreshTime = refreshTime;
   }
}

TransactionAspect.java

package com.shuidi.common.mypool;

import org.apache.log4j.Logger;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;

import com.shuidi.common.myException.UnKonwException;
import com.shuidi.common.myanotation.Transaction;

import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.SQLException;

@Aspect
public class TransactionAspect {
private static final Logger log = Logger.getLogger(TransactionAspect.class);

   /**
   * 定义一个方法, 用于声明切入点表达式. 一般地, 该方法中再不需要添入其他的代码. 使用 @Pointcut 来声明切入点表达式.
   * 后面的其他通知直接使用方法名来引用当前的切入点表达式.
   */
   @Pointcut("@annotation(com.shuidi.common.myanotation.Transaction)")
   public void declareJointPointExpression() {
   }

   // /**
   // * 前置通知
   // * 在 com.atguigu.spring.aop.ArithmeticCalculator
   // * 接口的每一个实现类的每一个方法开始之前执行一段代码
   // * 用通配符*来表示所有
   // */
   @Before("execution(public double
   // com.spring2.lee.aop.impl.ArithmeticCalculator.plus(int, int))")
   // @Before("declareJointPointExpression()")
   // public void beforeMethod(JoinPoint joinPoint) {
   // String methodName = joinPoint.getSignature().getName();
   // Object[] args = joinPoint.getArgs();
   // System.out.println("@Before: before method " + methodName + " begin
   // with:" + Arrays.asList(args));
   // }
   //
   // /**
   // * 后置通知
   // * 在方法执行之后执行的代码. 无论该方法是否出现异常
   // * @param joinPoint
   // */
   //
   // @After("declareJointPointExpression()")
   // public void afterMethod(JoinPoint joinPoint) {
   // String methodName = joinPoint.getSignature().getName();
   // Object[] args = joinPoint.getArgs();
   // System.out.println("@After:after method " + methodName +
   // " end " + Arrays.asList(args));
   // }
   //
   // /**
   // * 返回通知
   // * 在方法法正常结束受执行的代码
   // * 返回通知是可以访问到方法的返回值的!
   // */
   // @AfterReturning(value = "declareJointPointExpression()",
   // returning = "result")
   // public void afterReturning(JoinPoint joinPoint,
   // Object result) {
   // String methodName = joinPoint.getSignature().getName();
   // System.out.println(" @AfterReturning:The method " + methodName +
   // " ends with " + result);
   // }
   //
   // /**
   // * 异常通知
   // * 在目标方法出现异常时会执行的代码.
   // * 可以访问到异常对象; 且可以指定在出现特定异常时在执行通知代码
   // */
   // @AfterThrowing(value = "declareJointPointExpression()", throwing = "e")
   // public void afterThrowing(JoinPoint joinPoint, Exception e) {
   // String methodName = joinPoint.getSignature().getName();
   // System.out.println("@AfterThrowing:The method " + methodName +
   // " occurs excetion:" + e);
   // }

   /**
   * 环绕通知需要携带 ProceedingJoinPoint 类型的参数. 环绕通知类似于动态代理的全过程: ProceedingJoinPoint
   * 类型的参数可以决定是否执行目标方法. 且环绕通知必须有返回值, 返回值即为目标方法的返回值
   * @throws SQLException
   */

@Around("declareJointPointExpression()")
public Object aroundMethod(ProceedingJoinPoint pjd) throws SQLException {

       Object result = null;
       Signature sig = pjd.getSignature();
       MethodSignature msig;
       if (!(sig instanceof MethodSignature)) {
           throw new IllegalArgumentException("该注解只能用于方法");
       }
       msig = (MethodSignature) sig;
       Object target = pjd.getTarget();
       MyConnection myconn =null;
       Connection conn = null;
       String poolname = "";
       String className = "";
       String methodName = "";
       try {
           Method currentMethod = target.getClass().getMethod(msig.getName(), msig.getParameterTypes());

           Transaction permission = currentMethod.getAnnotation(Transaction.class);

           className = target.getClass().getName();
           methodName = currentMethod.getName();
           poolname = permission.value();
           myconn = ConnectionManager.MANAGER.getConnection(poolname);
           conn =myconn.getConnection();

log.warn(className + ":" + methodName + "方法的" + poolname + "连接池启用事务管理");
conn.setAutoCommit(false);

result = pjd.proceed();// 执行方法

           conn.commit();

           log.warn(className + ":" + methodName + "方法的" + poolname + "连接池提交事务");
       } catch (Throwable e) {
           result = null;
           //ConnectionManager.rollbackTransaction(conn);
           try {
               if(conn!=null)
               conn.rollback();
           } catch (SQLException e1) {
               log.error(className + ":" + methodName + "方法的连接池执行事务回滚失败",e);
               throw e1;
           }
           log.error(className + ":" + methodName + "方法的" + poolname + "连接池执行事务失败,事务回滚",e);
           throw new UnKonwException("事务管理异常！"+e.getMessage());
       } finally {
           try {
               if(conn!=null)
               conn.setAutoCommit(true);
           } catch (SQLException e) {
               log.error(className + ":" + methodName + "方法的"+conn+"设置事务自动提交失败",e);
throw e;
           }
           log.warn(className + ":" + methodName + "方法的" + poolname + "事物结束，释放连接..");
           ConnectionManager.MANAGER.closeConnection(poolname, myconn);
       }

return result;
}

}

Transaction.java

package com.shuidi.common.myanotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
* 自定义事务管理注解
* @author 李修睿
* @date 2018年4月23日下午1:58:37
*/
@Retention(RetentionPolicy.RUNTIME)//注解会在class中存在，运行时可通过反射获取
@Target(ElementType.METHOD)//目标是方法
@Documented//文档生成时，该注解将被包含在javadoc中，可去掉
public @interface Transaction {
String value() default "companyadvertisement";
}

李修睿

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
自己封装dbc连接池，支持并发，多数据源

ConnectionManager.javapackage com.shuidi.common.mypool;import org.apache.log4j.Logger;import com.shuidi.common.myException.MyException;import com.shuidi.common.spring.BeanFactory;import java....
复制链接

扫一扫