数据库连接池和DBUtils使用-蒲公英云

DAO模式、连接池和DBUtils应用

回顾

1、批处理
     Statement
         addBatch(Sql);
         executeBath();
         clearBath();
     PreparedStatement 
         addBatch();
         executeBath();
         clearBath();
2、事务
    把一组操作当成整体，不能分割，全部执行成功，都不执行。
    A 原子性: 不能分割
    C 一致性：事务执行前和执行后数据保持一致
    I 隔离性: 事务与事务之间的隔离 
    D 持久性：事务提交，数据就永久保存，不能再更改。
3.事务隔离性    
    read uncommitted 读取未提交的   (脏读)
    read comitted  读取提交的   (不可重复读)
    repeatable read 重复读    (幻读、虚读) mysql 通过并发机制解决
    serializable  串读   共享锁  效率低
4、jdbc操作事务
     0  导入驱动包
    1 注册驱动
    2 获取连接
        //开启事务   connection.setAutoCommit(false);//start transaction;
    3 创建命令
    4 执行命令处理结果
        //提交     connection.commit(); //commit;
        //异常     connection.rollback();//rollback;
                  connection.commit();
    5 释放资源
5 保存点  SavePoint

今日内容

1、数据库工具类封装
2、DAO模式
3、使用DBCP连接池
4、使用C3P0连接池
5、使用Druid连接池
6、DbUtils的使用

教学目标

1、掌握工具类的封装
2、掌握DAO设计模式
3、了解DBCP连接池
4、掌握C3P0连接池的使用
5、掌握Druid连接池的使用
6、掌握DbUtils的使用

第一节工具类封装、DAO模式和自定义连接池

1.1 工具类封装

案例实现：实现emp表的查询、添加、删除、修改

1.1.1 封装DbUtils

由于多个地方都需要使用数据库连接和释放，所以把功能封装到工具类中DbUtils

四个功能：1注册驱动 2 获取连接 3 释放资源 4 执行命令

public class DbUtils {
    private static String driver;
    private static String url;
    private static String user;
    private static String password;
    static{
        try {
            driver="com.mysql.jdbc.Driver";
               url="jdbc:mysql://localhost:3306/school";
               user="root";
               password="root";
            //加载驱动
            Class.forName(driver);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    /**
     * 获取连接
     * @return
     * @throws SQLException
     */
    public static Connection getConnection() throws SQLException{
        return DriverManager.getConnection(url,user,password);
    }
    /**
     * 释放资源
     * @param rs
     * @param stat
     * @param conn
     */
    public static void release(ResultSet rs,Statement stat,Connection conn){
        if(rs!=null){
            try {
                rs.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        if(stat!=null){
            try {
                stat.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        if(conn!=null){
            try {
                conn.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    /**
     * 根据参数执行sql语句  Insert Delete Update
     * @param sql
     * @param params
     * @return
     */
    public static int executeUpdate(String sql, Object...params){
        Connection conn=null;
        PreparedStatement pstat=null;
        try {
            //1创建连接
            conn=getConnection();
            //2创建命令对象
            pstat=conn.prepareStatement(sql);
            //3设置参数
            for (int i = 0; i < params.length; i++) {
                pstat.setObject(i+1, params[i]);
            }
            //4执行
            int result=pstat.executeUpdate();
            return result;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }finally {
            release(null, pstat, conn);
        }
    }
}

1.1.2优化DbUtils工具类：把数据库连接信息封装到Properties文件中

Properties properties=new Properties();
            InputStream is=DbUtils.class.getClassLoader().getResourceAsStream("database.properties");
            properties.load(is);
            //初始化参数
            driver=properties.getProperty("driver");
            url=properties.getProperty("url");
            user=properties.getProperty("user");
            password=properties.getProperty("password");

1.2 DAO设计模式

DAO(Database Access Object 数据库访问对象)

为了降低耦合性，提出了DAO封装数据库操作的设计模式。

它可以实现业务逻辑与数据库访问相分离。相对来说，数据库是比较稳定的，其中DAO组件依赖于数据库系统，提供数据库访问的接口。

隔离了不同的数据库实现。

DAO模式的组成部分

1 DAO接口（主要添加修改更新删除方法）

2 DAO实现类

3 实体类（domain、beans、entity、pojo、model）

--作用：用在数据访问代码和业务逻辑代码之间通过实体类来传输数据

--实体类特征：

◦属性一般使用private修饰

◦提供public修饰的getter/setter方法

◦实体类提供无参构造方法，根据业务提供有参构造

◦实现java.io.Serializable接口，支持序列化机制

4 数据库连接和关闭工具类

设计的包名 :

domain 存放实体类

utils 存放工具类

dao 存放接口

dao.impl 存放实现类

使用DAO设计模式实现emp表的查询、添加、删除、修改

Employee类

/**
 * 员工类
 * 实体类
 * @author wgy
 *
 */
public class Employee implements Serializable {
    /**
     * 
     */
    private static final long serialVersionUID = 373910607014836778L;
    private int empno;
    private String ename;
    private String job;
    private int mgr;
    private Date hiredate;
    private double sal;
    private double comm;
    private int deptno;
    public Employee() {
        // TODO Auto-generated constructor stub
    }
    public Employee(int empno, String ename, String job, int mgr, Date hiredate, double sal, double comm, int deptno) {
        super();
        this.empno = empno;
        this.ename = ename;
        this.job = job;
        this.mgr = mgr;
        this.hiredate = hiredate;
        this.sal = sal;
        this.comm = comm;
        this.deptno = deptno;
    }
    public int getEmpno() {
        return empno;
    }
    public void setEmpno(int empno) {
        this.empno = empno;
    }
    public String getEname() {
        return ename;
    }
    public void setEname(String ename) {
        this.ename = ename;
    }
    public String getJob() {
        return job;
    }
    public void setJob(String job) {
        this.job = job;
    }
    public int getMgr() {
        return mgr;
    }
    public void setMgr(int mgr) {
        this.mgr = mgr;
    }
    public Date getHiredate() {
        return hiredate;
    }
    public void setHiredate(Date hiredate) {
        this.hiredate = hiredate;
    }
    public double getSal() {
        return sal;
    }
    public void setSal(double sal) {
        this.sal = sal;
    }
    public double getComm() {
        return comm;
    }
    public void setComm(double comm) {
        this.comm = comm;
    }
    public int getDeptno() {
        return deptno;
    }
    public void setDeptno(int deptno) {
        this.deptno = deptno;
    }
    @Override
    public String toString() {
        return "Employee [empno=" + empno + ", ename=" + ename + ", job=" + job + ", mgr=" + mgr + ", hiredate="
                + hiredate + ", sal=" + sal + ", comm=" + comm + ", deptno=" + deptno + "]";
    }
}

接口：

public interface EmployeeDao {
     //1查询
     List<Employee> findAll();
     //2更新
     void update(Employee e);
     //3删除
     void delete(int empno);
     //4添加
     void add(Employee e);
}

实现类

public class EmployeeDaoImpl implements EmployeeDao{
    @Override
    public List<Employee> findAll() {
        ArrayList<Employee> employees=new ArrayList<Employee>();
        //1获取连接
        Connection conn=null;
        PreparedStatement pstat=null;
        ResultSet rs=null;
        try {
            conn=DbUtils.getConnection();
            pstat=conn.prepareStatement("select * from emp;");
            rs=pstat.executeQuery();
            while(rs.next()){
                int empno=rs.getInt("empno");
                String ename=rs.getString("ename");
                String job=rs.getString("job");
                int mgr=rs.getInt("mgr");
                Date date=rs.getDate("hiredate");
                double sal=rs.getDouble("sal");
                double comm=rs.getDouble("comm");
                int deptno=rs.getInt("deptno");
                Employee employee=new Employee(empno, ename, job, mgr, date, sal, comm, deptno);
                employees.add(employee);
            }
            return employees;
        } catch (Exception e) {
            throw new RuntimeException("查询emp失败");
        } finally {
            DbUtils.closeAll(rs, pstat, conn);
        }
    }
    @Override
    public void update(Employee e) {
        Object[] params={
    e.getEname(),e.getJob(),e.getMgr(),e.getHiredate(),e.getSal(),e.getComm(),e.getDeptno(),e.getEmpno()};
        DbUtils.executeUpdate("update emp set ename=?,job=?,mgr=?,hiredate=?,sal=?,comm=?,deptno=? where empno=?", params);
    }
    @Override
    public void delete(int empno) {
        DbUtils.executeUpdate("delete from emp where empno=?", empno);
    }
    @Override
    public void add(Employee e) {
        Object[] params={
    e.getEmpno(),e.getEname(),e.getJob(),e.getMgr(),e.getHiredate(),e.getSal(),e.getComm(),e.getDeptno()};
        DbUtils.executeUpdate("insert into emp values(?,?,?,?,?,?,?,?)", params);
    }
}

1.3 自定义实现连接池

为什么要使用连接池：

用户每次请求都需要向数据库获得链接，而数据库创建连接通常需要消耗相对较大的资源，创建时间也较长。假设网站一天10万访问量，数据库服务器就需要创建10万次连接，极大的浪费数据库的资源，并且极易造成数据库服务器内存溢出、拓机。

Java为连接池实现提供了一个规范(接口),规范的写法,我们需要实现DataSource接口!

/**
 * 连接池
 * @author wgy
 *
 */
public class MyDbPool implements DataSource{
    //创建集合 并且线程安全
    public static List<Connection>  connctions=Collections.synchronizedList(new LinkedList<Connection>()) ;
    static{
        try {
            InputStream is=MyDbPool.class.getClassLoader().getResourceAsStream("database.properties");
            Properties properties=new Properties();
            properties.load(is);
            String driver=properties.getProperty("driver");
            String url=properties.getProperty("url");
            String user=properties.getProperty("user");
            String password=properties.getProperty("password");
            //1加载驱动
            Class.forName(driver);
            for(int i=0;i<5;i++){
                Connection connection=DriverManager.getConnection(url, user, password);
                connctions.add(connection);
                System.out.println(i+"....."+connection.hashCode());
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    @Override
    public Connection getConnection() throws SQLException {
        // TODO Auto-generated method stub
        Connection connection=connctions.remove(0);
        System.out.println("获取一个连接.."+connection.hashCode());
        System.out.println("池中还剩"+connctions.size());
        return connection;
    }
    @Override
    public Connection getConnection(String username, String password) throws SQLException {
        // TODO Auto-generated method stub
        return null;
    }
    /**
     * 把连接再放入池中
     * @param conn
     */
    public void release(Connection conn){
        connctions.add(conn);
        System.out.println("放入了一个连接"+conn.hashCode());
        System.out.println("池中还剩"+connctions.size());
    }
    @Override
    public PrintWriter getLogWriter() throws SQLException {
        // TODO Auto-generated method stub
        return null;
    }
    @Override
    public void setLogWriter(PrintWriter out) throws SQLException {
        // TODO Auto-generated method stub
    }
    @Override
    public void setLoginTimeout(int seconds) throws SQLException {
        // TODO Auto-generated method stub
    }
    @Override
    public int getLoginTimeout() throws SQLException {
        // TODO Auto-generated method stub
        return 0;
    }
    @Override
    public Logger getParentLogger() throws SQLFeatureNotSupportedException {
        // TODO Auto-generated method stub
        return null;
    }
    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        // TODO Auto-generated method stub
        return null;
    }
    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        // TODO Auto-generated method stub
        return false;
    }
}

第二节 DBCP连接池

DBCP(DataBase connection pool),[数据库连接池]。是 apache 上的一个 java 连接池项目，也是 tomcat 使用的连接池组件。单独使用dbcp需要2个包：commons-dbcp.jar,commons-pool.jar由于建立数据库连接是一个非常耗时的行为，所以通过连接池预先同数据库建立一些连接，放在内存中，应用程序需要建立数据库连接时直接到连接池中申请一个就行，用完后再放回去。

#####2.1 DBCP连接池的使用

2.1.1 创建项目

创建JavaWeb项目

2.1.2 导入相应jar包

mysql驱动包

commons-dbcp.jar

commons-pool.jar

commons-logging.jar 日志支持

2.1.3 硬编码使用DBCP

所谓的硬编码方式就是在代码中添加配置

@Test
public void testHard() throws SQLException{
        //TODO 硬编码 使用DBCP连接池子
        BasicDataSource source = new BasicDataSource();
        //设置连接的信息  
        source.setDriverClassName("com.mysql.jdbc.Driver");
        source.setUrl("jdbc:mysql://localhost:3306/day2");
        source.setUsername("root");
        source.setPassword("111");
        Connection connection = source.getConnection();
        String sql = "select * from student";
        Statement createStatement = connection.createStatement();
        ResultSet executeQuery = createStatement.executeQuery(sql);
        while (executeQuery.next()) {
            System.out.println(executeQuery.getString(2));
        }
        connection.close(); //回收
    }

2.1.4 软编码使用DBCP

所谓的软编码,就是在项目中添加配置文件,这样就不需要每次代码中添加配合!

项目中添加配置

文件名称: dbcp.properties

文件位置: src下

#连接设置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/school
username=root
password=root
#<!-- 初始化连接 -->
initialSize=10
#最大连接数量
maxTotal=50
#<!-- 最大空闲连接 -->
maxIdle=20
#<!-- 最小空闲连接 -->
minIdle=5
#<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->
maxWaitMillis=5000

代码实现

@Test

public void testSoft() throws Exception{
    Properties properties = new  Properties();
    //配置文件添加到properties对象中  javase
    properties.load(new FileInputStream("src/info.properties"));
    //生成连接池子  需要配置文件
    DataSource source = BasicDataSourceFactory.createDataSource(properties);
    Connection connection = source.getConnection();
    String sql = "select * from student";
    Statement createStatement = connection.createStatement();
    ResultSet executeQuery = createStatement.executeQuery(sql);
    while (executeQuery.next()) {
        System.out.println(executeQuery.getString(2));
    }
    connection.close(); //回收
}

第三节 C3P0连接池

C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate，Spring等。

c3p0与dbcp区别
     1.
        dbcp没有自动回收空闲连接的功能
        c3p0有自动回收空闲连接功能
     2. 
         dbcp需要手动加载配置文件
        c3p0自动加载

3.1 使用步骤

3.1.1 创建项目

3.1.2 导入jar包

c3p0-0.9.1.2.jar

mchange-commons-java-0.2.11.jar

mysql驱动包

3.1.3.添加配置文件

c3p0是在外部添加配置文件,工具直接进行应用,因为直接引用,所以要求固定的命名和文件位置

文件位置: src

文件命名:c3p0-config.xml/c3p0.properties

<c3p0-config>
    <!-- 默认配置，如果没有指定则使用这个配置 -->
    <default-config>
        <!-- 基本配置 -->
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/school</property>
        <property name="user">root</property>
        <property name="password">root</property>
        <!--扩展配置-->
        <!-- 连接超过10秒报错-->
        <property name="checkoutTimeout">10000</property>
        <!--30秒检查空闲连接 -->
        <property name="idleConnectionTestPeriod">30</property>
        <!-- 初始大小 -->
        <property name="initialPoolSize">10</property>
        <!-- 每次增长的个数 -->
        <property name="acquireIncrement">5</property>
         <!-- 30秒不适用丢弃-->
        <property name="maxIdleTime">20</property>
        <property name="maxPoolSize">50</property>
        <property name="minPoolSize">5</property>
    </default-config> 
    <!-- 命名的配置 -->
    <named-config name="bj1805">
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/day2</property>
        <property name="user">root</property>
        <property name="password">111</property>
        <!-- 如果池中数据连接不够时一次增长多少个 -->
        <property name="acquireIncrement">5</property>
        <property name="initialPoolSize">20</property>
        <property name="minPoolSize">10</property>
        <property name="maxPoolSize">40</property>
    </named-config>
</c3p0-config>

c3p0.properties

c3p0.driverClass=com.mysql.jdbc.Driver
c3p0.jdbcUrl=jdbc:mysql://localhost:3306/school
c3p0.user=root
c3p0.password=root
c3p0.acquireIncrement=5
c3p0.initialPoolSize=20
c3p0.minPoolSize=10
c3p0.maxPoolSize=40

注意:

1: c3p0的配置文件内部可以包含命名配置文件和默认配置文件!默认是选择默认配置!如果需要切换命名配置可以在创建c3p0连接池的时候填入命名即可!

2:如果xml配置文件和属性文件都存在时，xml优先级高于属性文件

3.1.4 c3p0进行数据库操作

public class TestC3p0 {
    public static void main(String[] args) throws Exception {
          //创建ComboPooledDataSource对象使用默认配置
        ComboPooledDataSource  dataSource = new ComboPooledDataSource();
        //1.创建C3P0连接池子
        Connection connection = dataSource.getConnection();
        Statement createStatement = connection.createStatement();
        String sql = "select * from student;";
        ResultSet resultSet = createStatement.executeQuery(sql);
        while (resultSet.next()) {
            System.out.println(resultSet.getString(1));
        }
        resultSet.close();
          createStatement.close();
          connection.close();
    }    
}

第四节 Druid连接池

Druid 是目前比较流行的高性能的，分布式列存储的OLAP框架(具体来说是MOLAP)。它有如下几个特点：
一. 亚秒级查询
     druid提供了快速的聚合能力以及亚秒级的OLAP查询能力，多租户的设计，是面向用户分析应用的理想方式。
二.实时数据注入
     druid支持流数据的注入，并提供了数据的事件驱动，保证在实时和离线环境下事件的实效性和统一性
三.可扩展的PB级存储
     druid集群可以很方便的扩容到PB的数据量，每秒百万级别的数据注入。即便在加大数据规模的情况下，也能保证时其效性
四.多环境部署
     druid既可以运行在商业的硬件上，也可以运行在云上。它可以从多种数据系统中注入数据，包括hadoop，spark，kafka，storm和samza等
五.丰富的社区
     druid拥有丰富的社区，供大家学习

4.1 使用步骤

配置文件 database.properties:

#连接设置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/school
username=root
password=root
#<!-- 初始化连接 -->
initialSize=10
#最大连接数量
maxActive=50
#<!-- 最小空闲连接 -->
minIdle=5
#<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->
maxWait=5000

4.1.1 导入jar包

druid-1.1.5.jar

4.1.2 编写工具类

/**
 * 阿里的数据库连接池
 * 性能最好的
 * Druid
 * */
public class DbUtils {
    //声明连接池对象
    private static DruidDataSource ds;
    static{
        //实例化配置对象
        Properties properties=new Properties();
        try {
            //加载配置文件内容
              properties.load(DbUtils.class.getResourceAsStream("database.properties"));
              ds = (DruidDataSource)DruidDataSourceFactory.createDataSource(properties);    
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    //获取连接对象
    public static Connection getConnection() {
        try {
            return ds.getConnection();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }    
}

4.1.3 测试

package com.qf.utils;
import java.sql.Connection;
public class Test {
    public static void main(String[] args) throws Exception {
        for(int i=0;i<100;i++) {
            Connection connection=DbUtils.getConnection();
            if(connection!=null) {
                System.out.println("连接成功"+i+"..."+connection.hashCode()+connection.toString());
            }
            connection.close();
        }
    }
}

第五节 DBUtils使用

Commons DbUtils是Apache组织提供的一个对JDBC进行简单封装的开源工具类库，使用它能够简化JDBC应用程序的开发，同时也不会影响程序的性能。

5.1 DBUtils简介

DBUtils是java编程中的数据库操作实用工具，小巧简单实用，

1.对于数据表的读操作，可以把结果转换成List，Array，Set等java集合，便于程序员操作。

2.对于数据表的写操作，也变得很简单（只需写sql语句）。

DBUtils包括主要类

DbUtils类：启动类

ResultSetHandler接口：转换类型接口

--ArrayHandler类：实现类，把记录转化成数组

--ArrayListHandler类：把记录转化成数组，并放入集合中

--ColumnListHandler类：取某一列的数据。封装到List中。

--ScalarHandler类：适合获取一行一列数据。

--BeanHandler类：实现类,把记录转成对象。

--BeanListHandler类：实现类，把记录转化成List，使记录为JavaBean类型的对象

QueryRunner类：执行SQL语句的类

5.2 DBUtils工具类封装

5.2.1 项目准备

创建项目
导入jar包工具类配置文件
commons-dbutils-1.6.jar
druid-1.1.5.jar
DruidUtils.java工具类
database.properties配置文件

5.2.2 实现代码

public class ResultHanlder {
    @Test
    public void testArrayHander() throws SQLException {
        // ArrayHandler:适合取1条记录。把该条记录的每列值封装到一个数组中Object[]
        QueryRunner runner = new QueryRunner(DruidUtils.getDataSource());
        Object[] query = runner.query("select * from school where empno = ?", new ArrayHandler(), 1234);
        for (Object object : query) {
            System.out.println(object);
        }
    }
    @Test
    public void testArrayListHander() throws SQLException {
        // ArrayHandler:适合取1条记录。把该条记录的每列值封装到一个数组中Object[]
        QueryRunner runner = new QueryRunner(DruidUtils.getDataSource());
        List<Object[]> query = runner.query("select * from emp ", new ArrayListHandler());
        for (Object[] objects : query) {
            for (Object object : objects) {
                System.out.println(object);
            }
        }
    }
    @Test
    public void testColumnListHander() throws SQLException {
        // ColumnListHandler:取某一列的数据。封装到List中。
        QueryRunner runner = new QueryRunner(DruidUtils.getDataSource());
        List<Object> query = runner.query("select * from emp ", new ColumnListHandler<Object>(2));
        for (Object objects : query) {
            System.out.println(objects);
        }
    }
    @Test
    public void testScalarHandler() throws SQLException {
        // ScalarHandler:适合取单行单列数据
        QueryRunner runner = new QueryRunner(DruidUtils.getDataSource());
        Object query = runner.query("select count(*) from emp ", new ScalarHandler());
        System.out.println(query);
    }
    @Test
    public void testBeanHandler() throws SQLException {
        // BeanHandler:适合取单行单列数据
        QueryRunner runner = new QueryRunner(DruidUtils.getDataSource());
        Employee query = runner.query("select * from emp where empno=1234 ", new BeanHandler<Employee>(Employee.class));
        System.out.println(query.toString());
    }
  @Test
    public void testBeanListHandler() throws SQLException {
        // BeanHandler:适合取多行多列数据
        QueryRunner runner = new QueryRunner(DruidUtils.getDataSource());
        List<Employee> query2 = runner.query("select * from emp", new BeanListHandler<Employee>(Employee.class));
        for (Employee employee : query2) {
            System.out.println(employee);
        }
    }
}

总结

1 封装工具类

2 Dao设计模式：把数据访问代码抽离出来。降低代码的耦合性和提高扩展性。

dao接口

dao实现

实体类

数据库工具类

3 连接池

dbcp

c3p0

druid重点

4 Dbutils工具

作业题

1、使用数据库连接池和DbUtils改造之前的案例

面试题

1、描述数据库连接池的优缺点

DAO模式、连接池和DBUtils应用

回顾

今日内容

教学目标

第一节 工具类封装、DAO模式和自定义连接池

1.1 工具类封装

1.2 DAO设计模式

1.3 自定义实现连接池

第二节 DBCP连接池

2.1.1 创建项目

2.1.2 导入相应jar包

2.1.3 硬编码使用DBCP

2.1.4 软编码使用DBCP

第三节 C3P0连接池

3.1 使用步骤

3.1.1 创建项目

3.1.2 导入jar包

3.1.3.添加配置文件

3.1.4 c3p0进行数据库操作

第四节 Druid连接池

4.1 使用步骤

4.1.1 导入jar包

4.1.2 编写工具类

4.1.3 测试

第五节 DBUtils使用

5.1 DBUtils简介

5.2 DBUtils工具类封装

5.2.1 项目准备

5.2.2 实现代码

总结

作业题

面试题

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

随便看看

教程文章

热评文章

1江湖小白之一起学Python （二）爬取数据的保存

2Java Shiro：简化身份验证和授权的安全框架

3Java中try()catch{}的使用方法

4Swagger注解-@ApiModel 和 @ApiModelProperty

5windows下强制杀死tomcat进程

6uni-app 条形码(一维码)/二维码生成实现

标签列表

第一节工具类封装、DAO模式和自定义连接池