中小微型开发架构实战之2 jdbc

小灰灰 2022-11-01 13:59 101阅读 0赞

# JDBC #

## 什么是JDBC ##

维基百科的简介：
    Java 数据库连接，（Java Database Connectivity，简称JDBC）是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口，提供了诸如查询和更新数据库中数据的方法。
    JDBC也是Sun Microsystems的商标。JDBC是面向关系型数据库的。
    简单地说，就是用于执行SQL语句的一类JavaAPI，通过JDBC使得我们可以直接使用Java编程来对关系数据库进行操作。
    通过封装，可以使开发人员使用纯Java API完成SQL的执行。

**JDBC 规范定义接口，具体的实现由各大数据库厂商来实现。**

## JDBC优势 ##

1.  程序员如果想开发访问数据库的项目，只需要使用java api中的java.sql包下的几个类即可，不用关心各大数据库厂商的具体实现方式
2.  同一套java代码，只需要更改数据库连接属性，数据库厂商驱动，即可切换到另一个数据库

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI4MDY3ODc_size_16_color_FFFFFF_t_70_pic_center]

## 建库建表 ##

# unsigned 将数据类型无符号化。例如 bigint 原本区间 (-2 147 483 648，2 147 483 647) unsigned之后是 (0，4 294 967 295)
    CREATE TABLE `biz_tags` (
      `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
      `name` varchar(50) NOT NULL COMMENT '书签名',
      `description` varchar(100) DEFAULT NULL COMMENT '描述',
      `create_time` datetime DEFAULT current_timestamp() COMMENT '添加时间',
      `update_time` datetime DEFAULT current_timestamp() COMMENT '更新时间',
      PRIMARY KEY (`id`) USING BTREE
    ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8
    ;
    CREATE TABLE `biz_article_tags` (
      `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
      `tag_id` bigint(20) unsigned NOT NULL COMMENT '标签表主键',
      `article_id` bigint(20) unsigned NOT NULL COMMENT '文章ID',
      `create_time` datetime DEFAULT current_timestamp() COMMENT '添加时间',
      `update_time` datetime DEFAULT current_timestamp() COMMENT '更新时间',
      PRIMARY KEY (`id`) USING BTREE
    ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8
    ;

## 导包 ##

数据库使用的是mariadb，这里引入mariadb专有的驱动

<dependency>
        <groupId>org.mariadb.jdbc</groupId>
        <artifactId>mariadb-java-client</artifactId>
        <version>2.7.2</version>
    </dependency>
    
     <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>

## 数据库接入核心代码 ##

import javax.sql.DataSource;
    import java.io.IOException;
    import java.io.InputStream;
    import java.sql.*;
    import java.util.Properties;
    
    public class DbHelper extends BaseHelper{ 
        private static DbHelper dbHelper = new DbHelper();
        private static final String USERNAME_KEY = "username";
        private static String USERNAME = "";
        private static final String PASSWORD_KEY = "password";
        private static String PASSWORD = "";
        private static final String URL_KEY = "url.mariadb";
        private static String URL = "";
        private static final String DRIVER_KEY = "driver.mariadb";
        private static String DRIVER = "";
    
        static { 
            Properties prop = new Properties();
            InputStream inputStream = DbHelper.class.getResourceAsStream("/jdbc.properties");
            if (null == inputStream) { 
                throw new RuntimeException("未找到数据库配置文件，jdbc.properties");
            }
            try { 
                prop.load(inputStream);
            } catch (IOException e) { 
                e.printStackTrace();
            }
            if(prop.containsKey(USERNAME_KEY)){ 
                USERNAME = prop.get(USERNAME_KEY).toString();
            }
            if(prop.containsKey(PASSWORD_KEY)){ 
                PASSWORD = prop.get(PASSWORD_KEY).toString();
            }
            if(prop.containsKey(URL_KEY)){ 
                URL = prop.get(URL_KEY).toString();
            }
            if(prop.containsKey(DRIVER_KEY)){ 
                DRIVER = prop.get(DRIVER_KEY).toString();
            }
            System.out.println(USERNAME);
            System.out.println(PASSWORD);
            System.out.println(URL);
            System.out.println(DRIVER);
        }
    
        @Override
        protected DataSource dataSource() { 
            return null;
        }
    
        @Override
        public Connection getConnection() { 
            Connection conn = null;
            try { 
                Class.forName(DRIVER);
            } catch (ClassNotFoundException e) { 
                e.printStackTrace();
            }
            try { 
                conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);
            } catch (SQLException e) { 
                e.printStackTrace();
            }
            return conn;
        }
    
        public static DbHelper getInstance(){ 
            return dbHelper;
        }
    }

数据库连接公共重构代码，如下：

import javax.sql.DataSource;
    import java.sql.Connection;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.sql.Statement;
    
    /** * @author heshiyuan * @date 2021/2/23 16:33 */
    public abstract class BaseHelper { 
        private DataSource dataSource;
    
        /** * 获取数据源 * @return */
        protected abstract DataSource dataSource();
    
        public Connection getConnection(){ 
            if(null == dataSource){ 
                dataSource = dataSource();
                if(null == dataSource){ 
                    throw new IllegalArgumentException("数据源加载失败");
                }
            }
            try { 
                return dataSource.getConnection();
            } catch (SQLException e) { 
                e.printStackTrace();
            }
            throw new IllegalArgumentException("连接池获取连接失败");
        }
    
        /** * 释放连接回连接池 * @param conn * @param stmt * @param rs */
        public void release(Connection conn, Statement stmt, ResultSet rs) { 
            if (rs != null) { 
                try { 
                    rs.close();
                } catch (Exception e) { 
                    e.printStackTrace();
                }
                rs = null;
            }
            if (stmt != null) { 
                try { 
                    stmt.close();
                } catch (Exception e) { 
                    e.printStackTrace();
                }
                stmt = null;
            }
            if (conn != null) { 
                try { 
                    conn.close();
                } catch (Exception e) { 
                    e.printStackTrace();
                }
                conn = null;
            }
        }
    }

src/main/resources/jdbc.properties

username=root
    password=root@mariadb
    driver.mariadb=org.mariadb.jdbc.Driver
    driver.mysql=com.mysql.jdbc.Driver
    url.mariadb=jdbc:mariadb://localhost:3306/dblog
    url.mysql=jdbc:mysql://localhost:3306/dblog

## crud代码 ##

import org.hsy.java.jdbc.entity.Tag;
    import org.hsy.java.jdbc.utils.BaseHelper;
    
    import java.sql.*;
    import java.util.ArrayList;
    import java.util.List;
    
    /** * @author heshiyuan * @date 2021/2/22 11:44 */
    public class TagDao { 
    
        BaseHelper baseHelper;
        Connection connection;
        public TagDao(BaseHelper baseHelper) { 
            this.baseHelper = baseHelper;
            connection = baseHelper.getConnection();
        }
        // 本方法模拟了事务的回滚案例
        public int testTransaction(Tag tag) { 
            Savepoint savepoint1=null, savepoint2=null, savepoint3 = null;
            PreparedStatement ps = null;
            PreparedStatement ps2 = null;
            try { 
                connection.setAutoCommit(false);
                savepoint1 = connection.setSavepoint();
                ps = connection.prepareStatement(
                        "update biz_tags set description = ?, update_time = now() where id = ?");
                ps.setString(1, "2222");
                ps.setLong(2, tag.getId());
                ps.executeUpdate();
                savepoint2 = connection.setSavepoint();
                ps2 = connection.prepareStatement(
                        "update biz_article_tags set update_time = now() where tag_id = ?");
                ps2.setLong(1, tag.getId());
                ps2.executeUpdate();
                savepoint3 = connection.setSavepoint();
                int i = 2/0;
                connection.commit();
                return 1;
            } catch (Exception e) { 
                e.printStackTrace();
                try { 
                    connection.rollback(savepoint2);
                    connection.commit();
                } catch (SQLException ex) { 
                    ex.printStackTrace();
                }
            }finally { 
                baseHelper.release(connection, ps, null);
            }
            return 0;
        }
        /** * 增加一条记录 * @param tag * @return */
        public int insert(Tag tag) { 
            PreparedStatement ps = null;
            try { 
                ps = connection.prepareStatement(
                        "INSERT INTO biz_tags (id, name, description, create_time, update_time) " +
                                "VALUES ("+tag.getId()+", '"+tag.getName()+"', '"+tag.getDescription()+"', now(), now());");
                return ps.executeUpdate();
            } catch (SQLException e) { 
                e.printStackTrace();
            } finally { 
                baseHelper.release(connection, ps, null);
            }
            return 0;
        }
    
        public int delete(Long id){ 
            PreparedStatement preparedStatement = null;
            try { 
                preparedStatement = connection.prepareStatement("delete from biz_tags where id = ?");
                preparedStatement.setLong(1, id);
                return preparedStatement.executeUpdate();
            } catch (SQLException e) { 
                e.printStackTrace();
            } finally { 
                baseHelper.release(connection, preparedStatement, null);
            }
            return 0;
        }
    
        /** * 修改一条记录 * @param tag * @return */
        public int update(Tag tag){ 
            PreparedStatement ps = null;
            try { 
                ps = connection.prepareStatement(
                        "update biz_tags set name = ?, description = ?, update_time = now() where id = ?");
                ps.setString(1, tag.getName());
                ps.setString(2, tag.getDescription());
                ps.setLong(3, tag.getId());
                return ps.executeUpdate();
            } catch (SQLException e) { 
                e.printStackTrace();
            } finally { 
                baseHelper.release(connection, ps, null);
            }
            return 0;
        }
        public Tag findOne(Long id){ 
            PreparedStatement ps = null;
            ResultSet resultSet = null;
            try { 
                ps = connection.prepareStatement(
                        "select * from biz_tags where id = ?");
                ps.setLong(1, id);
                resultSet = ps.executeQuery();
                if(resultSet.next()){ 
                    return convertTag(resultSet);
                }
            } catch (SQLException e) { 
                e.printStackTrace();
            } finally { 
                baseHelper.release(connection, ps, resultSet);
            }
            return null;
        }
    
        private Tag convertTag(ResultSet resultSet) throws SQLException { 
            Tag tag = new Tag();
            tag.setId(resultSet.getLong("id"));
            tag.setName(resultSet.getString("name"));
            tag.setDescription(resultSet.getString("description"));
            tag.setCreateTime(resultSet.getDate("create_time"));
            tag.setUpdateTime(resultSet.getDate("update_time"));
            return tag;
        }
    
        public List<Tag> findList(Tag tag){ 
            PreparedStatement ps = null;
            ResultSet resultSet = null;
            try { 
                ps = connection.prepareStatement(
                        "select * from biz_tags");
                resultSet = ps.executeQuery();
                List<Tag> returnList = new ArrayList<>();
                while (resultSet.next()){ 
                    returnList.add(convertTag(resultSet));
                }
                return returnList;
            } catch (SQLException e) { 
                e.printStackTrace();
            } finally { 
                baseHelper.release(connection, ps, resultSet);
            }
            return new ArrayList<>();
        }

## 测试类代码 ##

import org.hsy.java.jdbc.entity.Tag;
    import org.hsy.java.jdbc.utils.C3p0Helper;
    import org.hsy.java.jdbc.utils.DbHelper;
    import org.hsy.java.jdbc.utils.DbcpHelper;
    import org.junit.Assert;
    import org.junit.Test;
    
    /** * @author heshiyuan * @date 2021/2/22 14:44 */
    public class TagDaoTest { 
        TagDao tagDao = new TagDao(DbHelper.getInstance());
    
        @Test
        public void insert() { 
            Tag tag = new Tag();
            tag.setId(100L);
            tag.setName("临时测试insert");
            tag.setDescription("我是描述呀insert");
            Assert.assertEquals(1, tagDao.insert(tag));
        }
        @Test
        public void delete() { 
            Assert.assertEquals(1, tagDao.delete(100L));
        }
        @Test
        public void update() { 
            Tag tag = new Tag();
            tag.setId(100L);
            tag.setName("临时测试update");
            tag.setDescription("我是描述呀update");
            Assert.assertEquals(1, tagDao.update(tag));
        }
        @Test
        public void findOne() { 
            Assert.assertEquals(java.util.Optional.of(100L).get(), tagDao.findOne(100L).getId());
        }
        @Test
        public void findList() { 
            System.out.println(tagDao.findList(new Tag()));
        }
    
        @Test
        public void testTransaction(){ 
            Tag tag = new Tag();
            tag.setId(100L);
            tagDao.testTransaction(tag);
        }

## 分析 ##

上述源码中涉及到几个重要的类，单独分析一下。

### DriverManager ###

1.  管理和注册数据库驱动（public static void registerDriver(java.sql.Driver driver)  
    throws SQLException）
2.  建立数据库连接（public static Connection getConnection(String url,  
    String user, String password) throws SQLException ）

### Connection ###

是一个接口，具体由数据库厂商实现。

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Statement createStatement() throws SQLException;</td> 
   <td>创建一个Statement对象，发送sql请求</td> 
  </tr> 
  <tr> 
   <td>PreparedStatement prepareStatement(String sql) throws SQLException;</td> 
   <td>预编译一条待执行的sql，效率比Statement高。</td> 
  </tr> 
  <tr> 
   <td>CallableStatement prepareCall(String sql) throws SQLException;</td> 
   <td>调用存储过程。</td> 
  </tr> 
  <tr> 
   <td>String nativeSQL(String sql) throws SQLException;</td> 
   <td>执行数据库本地sql</td> 
  </tr> 
  <tr> 
   <td>void setAutoCommit(boolean autoCommit) throws SQLException;</td> 
   <td>设置事务是否自动提交</td> 
  </tr> 
  <tr> 
   <td>void commit() throws SQLException;</td> 
   <td>提交当前事务</td> 
  </tr> 
  <tr> 
   <td>void rollback() throws SQLException;</td> 
   <td>回滚当前事务</td> 
  </tr> 
  <tr> 
   <td>void rollback(Savepoint savepoint) throws SQLException;</td> 
   <td>回滚事务到某一个点</td> 
  </tr> 
  <tr> 
   <td>void close() throws SQLException;</td> 
   <td>关闭当前数据库连接</td> 
  </tr> 
  <tr> 
   <td>DatabaseMetaData getMetaData() throws SQLException;</td> 
   <td>获取数据库字段的元数据，数据类型，长度等等</td> 
  </tr> 
  <tr> 
   <td>void setTransactionIsolation(int level) throws SQLException;</td> 
   <td>设置数据库的事务级别</td> 
  </tr> 
  <tr> 
   <td>Savepoint setSavepoint(String name) throws SQLException;</td> 
   <td>在当前事务中设置事务保存点，方便控制事务的回滚位置</td> 
  </tr> 
 </tbody> 
</table>

### PreparedStatement ###

数据库的执行动作类。  
**使用 占位符“？”可以有效防止sql注入事件的发生。**

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ResultSet executeQuery() throws SQLException;</td> 
   <td>执行一条查询操作</td> 
  </tr> 
  <tr> 
   <td>int executeUpdate() throws SQLException;</td> 
   <td>执行一条更新操作</td> 
  </tr> 
  <tr> 
   <td>void setInt(int parameterIndex, int x) throws SQLException;</td> 
   <td>替换sql中的“？”，parameterIndex the first parameter is 1, the second is 2, …</td> 
  </tr> 
  <tr> 
   <td>void setString(int parameterIndex, String x) throws SQLException;</td> 
   <td>替换sql中的“？”字符串类型，parameterIndex the first parameter is 1, the second is 2, …</td> 
  </tr> 
  <tr> 
   <td>default long executeLargeUpdate() throws SQLException</td> 
   <td>执行insert，update，delete，ddl等</td> 
  </tr> 
 </tbody> 
</table>

### ResultSet ###

sql执行的结果集

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>boolean next() throws SQLException;</td> 
   <td>判断游标下一个对应点有无数据</td> 
  </tr> 
  <tr> 
   <td>void close() throws SQLException;</td> 
   <td>释放结果集</td> 
  </tr> 
  <tr> 
   <td>int getInt(String columnLabel) throws SQLException;</td> 
   <td>获取对应列名的int数据类型值</td> 
  </tr> 
  <tr> 
   <td>String getString(String columnLabel) throws SQLException;</td> 
   <td>获取对应列名的varchar数据类型值</td> 
  </tr> 
 </tbody> 
</table>

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI4MDY3ODc_size_16_color_FFFFFF_t_70_pic_center 1]

## 释放资源 ##

1.  需要释放的对象：ResultSet 结果集，Statement 语句，Connection 连接
2.  释放原则：先开的后关，后开的先关。ResultSet > Statement > Connection
3.  放在哪个代码块中：finally 块

# 连接池 #

## 必要性 ##

1.  建立数据库连接
2.  数据库操作
3.  短信数据库连接

这种模式开发，存在的问题

上面使用DbHelper操作数据库，连接使用 DriverManager 来获取Connection，每次向数据库建立连接的时候都要将 Connection 加载到内存中，再验证用户名和密码(从数据库获取连接耗时0.05s～1s的时间)。

操作数据库的时候，就向数据库获取一个Connection，执行完成后再断开连接。

这样的方式将会消耗大量的资源和时间。数据库的连接资源并没有得到很好的重复利用。

若是一个微型项目（qps：1000+），频繁的进行数据库连接操作将占用很多的系统资源，严重的甚至会造成服务器的崩溃。

对于每一次数据库连接，使用完后都得断开。否则，如果程序出现异常而未能关闭，将会导致数据库系统中的内存泄漏，最终将导致重启项目，或者重启数据库。

这种开发不能控制被创建的连接对象数，系统资源会被毫无顾及的分配出去，如连接过多，也可能导致内存泄漏，服务器崩溃。

因此，数据库连接池就凸显出他的价值。

## 连接池 ##

数据库连接池的基本思想就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕之后再放回去。

数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是重新建立一个。

1.  能够定制池子的connection总数（防止内存泄漏，防止系统资源占用过大）
2.  资源重用，能够重复使用数据库连接（加快数据库处理速度）
3.  快速响应数据库操作

## 开源连接池技术框架 ##

*  c3p0
 *  dbcp
 *  druid

## DBCP ##

DBCP(DataBase connection pool)数据库连接池是 apache上的一个Java连接池项目。  
DBCP通过连接池预先同数据库建立一些连接放在内存中(即连接池中)，应用程序需要建立数据库连接时直接从池中申请一个连接使用，用完后由连接池回收该连接，从而达到连接复用，减少资源消耗的目的。

### 依赖 ###

*  commons-dbcp-1.4.jar（第一代dbcp技术，最后更新于2010-2-7）
 *  commons-pool-1.6.jar(内置于commons-dbcp)

### 配置文件 ###

src/main/resources/dbcp.properties

username=root
    password=root@mariadb
    driverClassName=org.mariadb.jdbc.Driver
    url=jdbc:mariadb://localhost:3306/dblog?useUnicode=true&characterEncoding=utf-8
    
    # 初始化连接
    dataSource.initialSize=10
    # 最大空闲连接
    dataSource.maxIdle=10
    # 最小空闲连接
    dataSource.minIdle=10
    # 最大连接数量
    dataSource.maxActive=10
    # 是否在自动回收超时连接的时候打印连接的超时错误
    dataSource.logAbandoned=true
    # 是否自动回收超时连接
    dataSource.removeAbandoned=true
    # 超时时间(以秒数为单位)
    # 设置超时时间有一个要注意的地方，超时时间=现在的时间-程序中创建Connection的时间，如果 maxActive比较大，比如超过100，
    # 那么removeAbandonedTimeout可以设置长一点比如180，也就是三分钟无响应的连接进行回收，当然应用的不同设置长度也不同。
    dataSource.removeAbandonedTimeout=180
    # 超时等待时间以毫秒为单位
    # maxWait代表当Connection用尽了，多久之后进行回收丢失连接
    dataSource.maxWait=1000

### 数据库连接配置 ###

import org.apache.commons.dbcp.BasicDataSourceFactory;
    
    import javax.sql.DataSource;
    import java.io.InputStream;
    import java.util.Properties;
    
    /** * @author heshiyuan */
    public class DbcpHelper extends BaseHelper{ 
        private static DbcpHelper dbcpHelper = new DbcpHelper();
        private static DataSource dataSource = null;
        static { 
            Properties prop = new Properties();
            InputStream inputStream = DbcpHelper.class.getResourceAsStream("/dbcp.properties");
            if (null == inputStream) { 
                throw new RuntimeException("未找到数据库配置文件，dbcp.properties");
            }
            try { 
                prop.load(inputStream);
                dataSource = BasicDataSourceFactory.createDataSource(prop);
                inputStream.close();
            } catch (Exception e) { 
                e.printStackTrace();
            }
        }
    
        @Override
        protected DataSource dataSource() { 
            return dataSource;
        }
    
        public static DbcpHelper getInstance(){ 
            return dbcpHelper;
        }
    }

### 测试类 ###

import org.hsy.java.jdbc.entity.Tag;
    import org.hsy.java.jdbc.utils.DbcpHelper;
    import org.junit.Assert;
    import org.junit.Test;
    
    import java.util.logging.Logger;
    
    /** * @author heshiyuan * @date 2021/2/22 14:44 */
    public class DbcpTest { 
        Logger logger = Logger.getLogger(DbcpTest.class.getName());
        TagDao tagDao = new TagDao(DbcpHelper.getInstance());
    
        @Test
        public void insert() { 
            Tag tag = new Tag();
            tag.setId(100L);
            tag.setName("临时测试insert");
            tag.setDescription("我是描述呀insert");
            Assert.assertEquals(1, tagDao.insert(tag));
        }
        @Test
        public void delete() { 
            Assert.assertEquals(1, tagDao.delete(100L));
        }
        @Test
        public void update() { 
            Tag tag = new Tag();
            tag.setId(100L);
            tag.setName("临时测试update");
            tag.setDescription("我是描述呀update");
            Assert.assertEquals(1, tagDao.update(tag));
        }
        @Test
        public void findOne() { 
            Assert.assertEquals(java.util.Optional.of(100L).get(), tagDao.findOne(100L).getId());
        }
        @Test
        public void findList() { 
            logger.info(tagDao.findList(new Tag()).toString());
        }
    
        @Test
        public void testTransaction(){ 
            Tag tag = new Tag();
            tag.setId(100L);
            tagDao.testTransaction(tag);
        }
    }

以上也可实现对数据库的crud操作。

## C3P0 ##

C3P0是一个开源的JDBC连接池，它实现了数据源与JNDI绑定，支持JDBC3规范和实现了JDBC2的标准扩展说明的Connection和Statement池的DataSources对象。

即将用于连接数据库的连接整合在一起形成一个随取随用的数据库连接池（Connection pool）。

### 包引入 ###

*  c3p0-0.9.1.2.jar

### 配置文件 ###

src/main/resources/c3p0-config.xml

<c3p0-config>
        <default-config>
            
            
            
            <property name="initialPoolSize">10</property>
            <property name="minPoolSize">10</property>
            
            <property name="acquireIncrement">0</property>
            
            <property name="maxPoolSize">10</property>
            
            <property name="maxIdleTime">30</property>
    
            
            <property name="acquireRetryAttempts">30</property>
    
            
            <property name="acquireRetryDelay">1000</property>
    
            
            <property name="autoCommitOnClose">false</property>
    
            
            
    
            
            <property name="breakAfterAcquireFailure">false</property>
    
            
            
    
            
            
    
            
            <property name="factoryClassLocation">null</property>
    
            
            <property name="forceIgnoreUnresolvedTransactions">false</property>
    
            
            <property name="idleConnectionTestPeriod">60</property>
    
            
            <property name="maxStatements">100</property>
    
            
            
    
            
            <property name="numHelperThreads">3</property>
    
            
           
    
            
            <property name="propertyCycle">300</property>
    
            
            <property name="testConnectionOnCheckout">false</property>
    
            
            <property name="testConnectionOnCheckin">false</property>
    
            
            <property name="usesTraditionalReflectiveProxies">false</property>
        </default-config>
    
        
        <named-config name="mariadb">
            <property name="driverClass">org.mariadb.jdbc.Driver</property>
            <property name="jdbcUrl">jdbc:mariadb://localhost:3306/dblog</property>
            <property name="user">root</property>
            <property name="password">root@mariadb</property>
            <property name="initialPoolSize">10</property>
            <property name="maxIdleTime">10</property>
            <property name="maxPoolSize">10</property>
            <property name="minPoolSize">10</property>
            <property name="maxStatements">100</property>
        </named-config>
    </c3p0-config>

### 数据库连接操作 ###

import com.mchange.v2.c3p0.ComboPooledDataSource;
    import javax.sql.DataSource;
    /** * @author heshiyuan */
    public class C3p0Helper extends BaseHelper{ 
        private static DataSource dataSource = new ComboPooledDataSource("mariadb");
        private static C3p0Helper c3p0Helper = new C3p0Helper();
    
        /** * 获取实例 * @return */
        public static C3p0Helper getInstance(){ 
            return c3p0Helper;
        }
    
        @Override
        protected DataSource dataSource() { 
            return dataSource;
        }
    }

### 测试类 ###

import org.hsy.java.jdbc.entity.Tag;
    import org.hsy.java.jdbc.utils.C3p0Helper;
    import org.junit.Assert;
    import org.junit.Test;
    
    import java.util.logging.Logger;
    
    /** * @author heshiyuan * @date 2021/2/22 14:44 */
    public class C3P0Test { 
        Logger logger = Logger.getLogger(C3P0Test.class.getName());
        TagDao tagDao = new TagDao(C3p0Helper.getInstance());
    
        @Test
        public void insert() { 
            Tag tag = new Tag();
            tag.setId(100L);
            tag.setName("临时测试insert");
            tag.setDescription("我是描述呀insert");
            Assert.assertEquals(1, tagDao.insert(tag));
        }
        @Test
        public void delete() { 
            Assert.assertEquals(1, tagDao.delete(100L));
        }
        @Test
        public void update() { 
            Tag tag = new Tag();
            tag.setId(100L);
            tag.setName("临时测试update");
            tag.setDescription("我是描述呀update");
            Assert.assertEquals(1, tagDao.update(tag));
        }
        @Test
        public void findOne() { 
            Assert.assertEquals(java.util.Optional.of(100L).get(), tagDao.findOne(100L).getId());
        }
        @Test
        public void findList() { 
            logger.info(tagDao.findList(new Tag()).toString());
        }
    
        @Test
        public void testTransaction(){ 
            Tag tag = new Tag();
            tag.setId(100L);
            tagDao.testTransaction(tag);
        }
    }

以上实现了数据库的增加(Create)、检索(Retrieve)、更新(Update)和删除(Delete)操作

# 性能大PK #

## case ##

观察jdbc， dbcp， c3p0耗时性能（此处只关注时间复杂度，忽略空间复杂度，忽略jvm消耗系统资源情况）  
硬件：  
\* MacBook Pro (Retina, 13-inch, Early 2015)  
\* cpu 3.1 GHz Dual-Core Intel Core i7  
\* memory 16 GB 1867 MHz DDR3

软件：  
\* 连接池最大连接数10  
\* 连接池最小连接数10  
\* 连接池初始化连接数10  
\* 最大空闲时间,30秒内未使用则连接被丢弃  
\* maxStatements=100

case 1. 单线程对数据库insert批量（1000， 2000， 3000）数据，每条数据insert前获取一次数据库连接  
期望：T(jdbc) 远大于 T(dbcp) 近似于 T(c3p0)  
实际：

1000条数据：3次
        T(jdbc) = 4.349s 4.204s 5.43s
        T(dbcp) = 2.391s, 2.131s, 2.375s
        T(c3p0) = 2.570, 2.499s, 2.509s
        T(jdbc) >> T(c3p0) > T(dbcp)
        2000条数据：3次
        T(jdbc) = 7.321s 6.563s 8.406s
        T(dbcp) = 4.299s 4.188s 3.486s
        T(c3p0) = 3.991s 4.134s 4.420s
        T(jdbc) >> T(dbcp) > T(c3p0) 
        3000条数据：3次
        T(jdbc) = 9.498s 9.791s 8.513s
        T(dbcp) = 4.913s 5.001s 4.5s
        T(c3p0) = 5.9s 5.617s 5.107s
        T(jdbc) >> T(c3p0) > T(dbcp)

实操多线程方案时遇到以下问题：

1.  每个线程单独操作一条insert时，jdbc直接报错，无法创建太多线程（数据库不支持1000个connection）
2.  线程内操作dbcp，c3p0时无法生效，datasouce获取不到

综上本次不考虑多线程方案（理论上多线程时 dbcp，c3p0性能更优于jdbc）

## 实操 ##

### dbcp，c3p0连接池调参，保证参数一致 ###

### 测试代码 ###

// 测试代码类似，区别在于不通数据源实例
    TagDao tagDao = new TagDao(DbHelper.getInstance());
    IntStream.range(1, 3001).forEach(i -> { 
        Tag tag = new Tag();
        tag.setName("insert" + i);
        tag.setDescription("我是描述 insert" + i);
        logger.info("threadId = "+Thread.currentThread().getId()+", 第 "+i+" 次，result = " + tagDao.insert(tag));
    });

## 分析 ##

综上实测，三次测试中jdbc均耗时最长（意料之中），dbcp两次性能优于c3p0，分别是1000条，3000条数据。

## 结论 ##

使用连接池效果明显强于原生jdbc。

## 畅言 ##

在整个开发过程中，查看了jdbc，dbcp，c3p0源码。  
就源码可读性看，jdbc > dbcp > c3p0.

c3p0有很多注释的脏代码没有删除，影响阅读效果，而且代码不够简洁。

jdbc是java与关系型数据库的桥梁，中小微型的项目使用jdbc+连接池完全够用，由于jdbc是手写代码，拥有很强的扩展性。

多数据源，读写分离，事务控制也比较简单。缺点是需要编写大量代码。

可以利用java反射机制，针对PreparedStatement，ResultSet做简易的封装。

# 源码 #

[java-jdbc][]

# 参考文献 #

[JDBC - 使用C3p0数据源和dbcp数据源][JDBC - _C3p0_dbcp]

[详解C3P0（数据库连接池）][C3P0]

[数据库连接池性能比对][Link 1]

***分享是快乐的，也记录了个人成长历程以及知识备份，可能自身认知不足之处在所难免，不想误人子弟，如有错误大家指正，共同探讨进步。  
本文版权归作者所有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出, 如有问题， 可邮件（shiyuan4work@126.com）咨询。***

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI4MDY3ODc_size_16_color_FFFFFF_t_70_pic_center]: /images/20221024/d0327fd325ba44caa86907ab4a7abf5d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI4MDY3ODc_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221024/1597c9e272134b32a7bdc03c73f367b3.png
[java-jdbc]: https://github.com/shiyuan2he/java/tree/master/java-jdbc
[JDBC - _C3p0_dbcp]: https://janus.blog.csdn.net/article/details/53737437?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-5.control&dist_request_id=6f4bdbfd-4f68-4aba-9d98-94d517f21de9&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-5.control
[C3P0]: https://www.cnblogs.com/SUN99bk/p/12181493.html
[Link 1]: https://blog.csdn.net/hetaohappy/article/details/50462486?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.control&dist_request_id=ceb19c5e-511b-4ec0-bb2a-cd97552eedf9&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.control