手撕数据库连接池

1.有开源的数据库连接池，你为啥不用？

这个不是因为闲的没事干，先说下需求背景

我们有一个数据源管理模块，配置的数据源连接，用户名，密码等信息

在数据源管理模块配置好之后，去另一个模块选择数据源，获取每个数据源下库表结构以及字段

之前是每次都会创建一个新的连接，那这肯定会比较慢，反复打开和关闭连接，耗费时间

但是我们平时用的Druid连接池，我研究了一下，似乎没办法我说的这种业务

1.因为Druid虽然支持多数据源，但一般都是支持两个，三个数据源进行切换。

但是我们业务可能达到上百个数据源连接

2.而且Druid是需要在yml文件中，提前配置好你需要哪几个数据库，把连接信息写上

但我们可能自由的修改新增删除，无法在项目启动的时候就知道我有哪些数据源需要操作

2.思路

这种应该是有开源框架的，但是我没找到，就花了一天时间写了一个

1.项目启动的时候，我会加载数据源模块的数据，

以jdbcurl+username为key

用concurrentHashMap为每个数据源创建一个连接

2.实体结构

2.1先创建一个实体ConnEntity，里边仨属性，一个conn，一个当前conn被几个人使用，一个现在conn是否在被使用状态

2.2再创建一个实体ConnCacheEntity，这个就是连接池Map的value

里边俩属性一个是connList，一个是当前访问数

当前访问数是说当前jdbcurl+username为key的情况下有多少个人使用

2.3连接池map

concurrentHashMap

key=jdbcurl+username

value=ConnCacheEntity

3.思想

连接池就是为了连接可以复用，不需要每次都去创建一个新的连接，在释放的时候不是真正的关闭连接，而是把链接还给池子

在知道连接池思想的前提下，再去说手撕数据库连接池这件事

4.获得连接

* 通过url username 从内存中获取连接 或者新建连接 放到内存中并且返回
* 通过key 取连接信息 没有的话就新建立一个连接返回，有的话就当前使用数最少的那个返回
* 当前存在可用连接  算出目前访问数和已有连接的比例  <=标准比例 则返回一个现在使用数量最小的连接  >标准比例  创建一个连接  与第一个步骤相同
* 我现在的设计是一个conn可以同时被五个人访问，所以现在如果发现有6个人 那就要新创建一个连接返回了
* 而且不管是返回哪个连接，都要设置这个连接被使用标识为true,被使用次数+1，而且key对应的使用人数+1
* 使用连接之后 需要在finally方法中把当前连接数-1 如果当前连接数-1之后为0  则 当前连接使用标识为false
* 使用连接之后 还要根据url+username组成的key 把当前对应的访问数-1

5.释放连接

释放连接中有些操作就是和获得连接时候相反了

* 如果当前连接被使用的人数为0 则使用标识设置为false
* 同数据库连接池 酌情关闭连接
* 因为五个人用一个连接  所以 人数/连接数=0.2 是目前标准
* 如果目前  人数*0.2=目前应有的连接数
* 如果实际连接数>目前应有连接数 就把目前没有被用到的连接关闭，并且移除数组
* 连接数至少要留一个
* 如果实际连接数>目前应有连接数 算出差了几个 就把目前没有被用到的连接关闭，并且移除数组
* 当前是把连接还给池子  所以池子的访问数量-1
* 当前conn的连接数量-1

6.注意点
mysql 连接空闲8小时会自动断开连接 所以返回连接之前需要检测 如果当前连接关闭 就再建一个连接返回
发现这一点之后，我不光修改了getConn方法，还加了个定时，每天八点，看哪个连接关了，就新建一个连接

3.项目启动时候初始化连接池

@Component
@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
@RequiredArgsConstructor
public class CommandLineRunnerImpl implements CommandLineRunner {

    SysDataSourceService sysDataSourceService;
    @Override
    public void run(String... args){
        this.createDBConn();
    }

    /**
     * 程序启动时，对于数据源表中 success状态的 建立连接
     */
    private void createDBConn(){
        List<SysDataSource> list = sysDataSourceService.list(new LambdaQueryWrapper<SysDataSource>().eq(SysDataSource::getTestStatus, LinkTestStatus.SUCCESS.name()));
        if(CollectionUtils.isEmpty(list)){
            return;
        }
        list.forEach(source -> ConnFactory.getConn(source.getLinkInfo(),source.getUsername(),source.getPassword()));
    }

}

4.缓存实体

@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class ConnCacheEntity {

    List<ConnEntity> connEntityList;

    /**
     * 当前访问数
     * key为url+username
     * 记录当前url+username下的访问数
     * 每次get时 +1 用完 -1
     */
    int linkCount;

    /**
     * url username password用于连接关闭的情况下  再次建立连接时使用
     */
    String url;

    String user;

    String password;
}

@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class ConnEntity {

    /**
     * 连接对象
     */
    Connection conn;

    /**
     * 当前连接是否正在被使用
     * 每次getConn时 给当前使用对象赋值为true  使用之后 赋值为false
     */
    boolean use;

    /**
     * 使用数量
     * 每次getConn时 +1  使用之后 -1
     */
    int useCount;

    /**
     * 用于连接测试时展示具体失败原因
     */
    SQLException e;
}

5.创建和销毁时公用属性

    /**
     * key是url_username
     * value是对应的连接信息
     * 相当于数据库连接池
     */
    public static Map<String, ConnCacheEntity> connMap = new ConcurrentHashMap<>();

    /**
     * 访问数与现在内存中已经建立的数据库连接数的比例
     * 5个人 用一个连接
     */
    private static final BigDecimal LINK_DIVIDE_CONN = BigDecimal.valueOf(5);

    /**
     * 5个人用一个连接 1:5=0.2
     */
    private static final BigDecimal CONN_DIVIDE_LINK = BigDecimal.valueOf(0.2);
    /**
     * 每个数据源，最大能打开的连接数
     */
    private static final int MAX_LINK = 10;

    /**
     * key的组成方式 url_username
     *
     * @param url
     * @param user
     * @return
     */
    private static String getKey(String url, String user) {
        return url.concat(Constant.UNDERLINE).concat(user);
    }

6.创建连接

    /**
     * 获得数据库连接
     * 通过url username 从内存中获取连接 或者新建连接 放到内存中并且返回
     * 使用连接之后 需要在finally方法中把当前连接数-1 如果当前连接数-1之后为0  则 当前连接使用标识为false
     * 使用连接之后 还要根据url+username组成的key 把当前对应的访问数-1
     *
     * @param url
     * @param user
     * @param password
     * @return
     */
    public static ConnEntity getConn(String url, String user, String password) {
        if (StringUtils.isEmpty(url) || StringUtils.isEmpty(user)) {
            SQLException sqlException = new SQLException("连接信息有误，请检查用户名端口号等信息");
            return ConnEntity.builder().e(sqlException).build();
        }
        //拼接Key
        String key = getKey(url, user);
        //通过key 取连接信息 没有的话就新建立一个连接返回，有的话就当前使用数最少的那个返回
        ConnCacheEntity connCacheEntity = connMap.get(key);
        if (Objects.isNull(connCacheEntity) || CollectionUtils.isEmpty(connCacheEntity.getConnEntityList())) {
            //如果对象不为空但是对应的可用连接数为空
            try {
                Connection conn = DriverManager.getConnection(url, user, password);
                //因为新建的 即将返回  所以 当前连接正在使用 使用数量为1
                ConnEntity connEntity = ConnEntity.builder().conn(conn).use(true).useCount(1).build();
                //因为新建的 设置当前访问数为1
                List<ConnEntity> connEntities = new ArrayList<>();
                connEntities.add(connEntity);
                connCacheEntity = ConnCacheEntity.builder().connEntityList(connEntities).linkCount(1).url(url).user(user).password(password).build();
                connMap.put(key, connCacheEntity);
                return connEntity;
            } catch (SQLException e) {
                log.error(e.getMessage());
                return ConnEntity.builder().e(e).build();
            }
        } else {
            //当前连接数+1
            connCacheEntity.setLinkCount(connCacheEntity.getLinkCount() + 1);
            //当前存在可用连接  算出目前访问数和已有连接的比例  <=标准比例 则返回一个现在使用数量最小的连接  >标准比例  创建一个连接  与第一个步骤相同
            //或者是当前连接已经达到上限 就不创建新的连接了 就把目前占用最少的那个conn返回
            int linkCount = connCacheEntity.getLinkCount();
            int size = connCacheEntity.getConnEntityList().size();
            BigDecimal divide = new BigDecimal(linkCount).divide(new BigDecimal(size));
            if (divide.compareTo(LINK_DIVIDE_CONN) <= 0 || size >= MAX_LINK) {
                connCacheEntity.getConnEntityList().sort(Comparator.comparing(ConnEntity::getUseCount));
                //正序 第一个是最小值 赋值 当前正在被使用 并且 使用数+1
                ConnEntity connEntity = connCacheEntity.getConnEntityList().get(0);
                //mysql 连接空闲8小时会自动断开连接 所以返回连接之前需要检测 如果当前连接关闭 就再建一个连接返回
                try {
                    if(connEntity.getConn().isClosed()){
                        Connection conn = DriverManager.getConnection(url, user, password);
                        connEntity.setConn(conn);
                    }
                } catch (SQLException e) {
                    throw new RuntimeException(e);
                }
                connEntity.setUse(true);
                connEntity.setUseCount(connEntity.getUseCount() + 1);
                return connEntity;
            } else {
                try {
                    Connection conn = DriverManager.getConnection(url, user, password);
                    //因为新建的 即将返回  所以 当前连接正在使用 使用数量为1
                    ConnEntity connEntity = ConnEntity.builder().conn(conn).use(true).useCount(1).build();
                    connCacheEntity.getConnEntityList().add(connEntity);
                    //新的连接加入到list中并返回
                    return connEntity;
                } catch (SQLException e) {
                    log.error(e.getMessage());
                    return ConnEntity.builder().e(e).build();
                }
            }
        }
    }

7.销毁连接

  /**
     * 关闭数据库连接
     * 如果当前连接被使用的人数为0 则使用标识设置为null
     * 同数据库连接池 酌情关闭连接
     * 因为五个人用一个连接  所以 人数/连接数=0.2 是目前标准
     * 如果目前  人数*0.2=目前应有的连接数
     * 如果实际连接数>目前应有连接数 就把目前没有被用到的连接关闭，并且移除数组
     *
     * @param connEntity
     * @param url
     * @param user
     */
    public static void  closeConn(ConnEntity connEntity, String url, String user) {
        if (Objects.isNull(connEntity) || StringUtils.isEmpty(url) || StringUtils.isEmpty(user)) {
            return;
        }
        //拼接Key
        String key = getKey(url, user);
        //当前是把连接还给池子  所以池子的访问数量-1
        ConnCacheEntity connCache = connMap.get(key);
        connCache.setLinkCount(connCache.getLinkCount() - 1);
        //当前conn的连接数量-1
        int useCount = connEntity.getUseCount();
        if (useCount > 0) {
            connEntity.setUseCount(connEntity.getUseCount() - 1);
        }
        //如果当前连接被使用的人数为0 则使用标识设置为null
        if (connEntity.getUseCount() == 0) {
            connEntity.setUse(false);
        }
        //人数*0.2=目前应有的连接数   如果实际连接数>目前应有连接数 就把目前没有被用到的连接关闭，并且移除数组
        BigDecimal multiply = new BigDecimal(connCache.getLinkCount()).multiply(CONN_DIVIDE_LINK);
        //向上取整  防止2*0.2=0.4<1 然后把最后一个连接关闭的这种情况发生
        int roundedNumber = multiply.setScale(0, RoundingMode.UP).intValue();
        //实际连接数
        int size = connCache.getConnEntityList().size();
        //连接数至少要留一个
        if (size > roundedNumber && size > 1) {
            //如果实际连接数>目前应有连接数 算出差了几个 就把目前没有被用到的连接关闭，并且移除数组
            int subtract = size - roundedNumber;
            List<ConnEntity> removes = new ArrayList<>();
            for (ConnEntity entity : connCache.getConnEntityList()) {
                if (!entity.isUse() && subtract > 0) {
                    try {
                        entity.getConn().close();
                        removes.add(entity);
                        subtract--;
                    } catch (SQLException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
            connCache.getConnEntityList().removeAll(removes);
        }
    }

8.使用方式

用我提供的静态方法获取conn

还是要在finally中去调用我提供的关闭连接的方法

但是不要自己去conn.close();而是调用静态方法由我来决定是否关闭

    private static List<ColumnBO> getColumnNames(ConnectQueryBO connectQueryBO) {
        // 调用方法并计时
        long startTime = System.currentTimeMillis();
        ConnEntity conn1 = null;
        List<ColumnBO> list = new ArrayList<>();
        Statement stmt = null;
        ResultSet resultSet = null;
        try {
            // conn = DriverManager.getConnection(connectQueryBO.getUrl(), connectQueryBO.getUser(), connectQueryBO.getPassword());
            conn1 = ConnFactory.getConn(connectQueryBO.getUrl(), connectQueryBO.getUser(), connectQueryBO.getPassword());
            Connection conn = conn1.getConn();
            stmt = conn.createStatement();
            resultSet = stmt.executeQuery(connectQueryBO.getQuerySql());
            //有dba权限情况下才会执行这部
            while (resultSet.next()) {//如果对象中有数据，就会循环打印出来
                String columName = resultSet.getString(COLUMN_NAME);
                String dataType = resultSet.getString(DATA_TYPE);
                list.add(ColumnBO.builder().columnName(columName).dataType(dataType).build());
            }
        } catch (SQLException e) {
            //select TABLE_NAME from all_tables WHERE owner="+dbName 这个语句可能没有权限执行
            log.error(e.getMessage());
        } finally {
            //finally中关闭连接
            ConnFactory.closeConn(conn1, connectQueryBO.getUrl(), connectQueryBO.getUser());
            try {
                if (Objects.nonNull(stmt)) {
                    stmt.close();
                }
                if (Objects.nonNull(resultSet)) {
                    resultSet.close();
                }
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        // 计算执行时间
        long endTime = System.currentTimeMillis();
        long executionTime = endTime - startTime;
        // 打印执行时间
        System.out.println("getColumnNames方法执行时间：" + executionTime + "毫秒");
        return list.stream().distinct().collect(Collectors.toList());
    }

9.定时检验已关闭的连接

这个是踩了坑才想起来加的

No operations allowed after connection closed

mysql如果连接空闲了8小时，会自动关闭

@Configuration
@EnableScheduling
public class ConnCheck {

    /**
     * 每天早上八点，把已经关闭的连接，重新打开
     * 因为mysql的数据库连接空闲8小时会自动断开
     * 在这里提前重新打开，可以加快效率
     */
    @Scheduled(cron = "0 0 8 * * ?")
    public void check() {
        for (Map.Entry<String, ConnCacheEntity> entry : ConnFactory.connMap.entrySet()) {
            ConnCacheEntity entity = entry.getValue();
            if (Objects.isNull(entity)) {
                continue;
            }
            List<ConnEntity> connEntityList = entity.getConnEntityList();
            if (CollectionUtils.isEmpty(connEntityList)) {
                continue;
            }
            connEntityList.forEach(connEntity -> {
                try {
                    boolean closed = connEntity.getConn().isClosed();
                    //如果连接已经关闭 就重新打开
                    if (closed) {
                        Connection conn = DriverManager.getConnection(entity.getUrl(), entity.getUser(), entity.getPassword());
                        connEntity.setConn(conn);
                    }
                } catch (SQLException e) {
                    throw new RuntimeException(e);
                }
            });
        }
    }

}