在学习数据源连接池之前我们先来了解一个一种模式。
DAO模式：（使我们在编程时经常用到的一种编程模式）数据访问对象，它是标准的JavaEE设计模式的一种。
使用DAO模式可以把底层的数据访问操作和上层的业务逻辑分开。
一个DAO模式我们用三个组件来实现：
1、DAO接口
2、DAO接口的具体实现类
3、DAO工厂类

对于在JDBC的应用中DAO接口主要是用于声明我要实现的CURD操作：
我在这里做了一个Employee实例针对其进行增删查改，基于MySQL数据库
1、实现DAO接口，声明我要实现的方法：

package dao;

import entity.Employee;
import entity.Page;

import java.util.List;

public interface EmpDao {
//插入
void save(Employee emp);
//修改
void update(Employee emp);
//删除
void delete(int id);
//根据条件查询某一条
Employee findone(int id);
//查询所有记录
List<Employee> findAll();
//模糊查询
List<Employee> findByName(String name);
//统计总记录数
long count();
//分页查询
Page<Employee> findAll(int number,int size);
}

有了接口我们接下来就需要DAO实现类来实现我们具体的操作：

public class EmpDaoMySQLImpl implements EmpDao {

//这里质检单罗列了增删查改的功能
private static DataSource ds=DBUtils.getDateSource();
@Override
public void save(Employee emp) {
    QueryRunner qr=new QueryRunner(ds);
    String sql="INSERT INTO employee(name,joinTime,gender,job,salary) VALUES(?,?,?,?,?)";
    try {
        qr.update(sql,emp.getName(),emp.getJoinTime(),emp.getGender(),emp.getJob(),emp.getSalary());
    } catch (SQLException e) {
        e.printStackTrace();
    }


}

@Override
public void update(Employee emp) {
    Connection conn=null;
    conn=DBUtils.getConnection();

    QueryRunner qr=new QueryRunner();
    String sql="UPDATE employee SET name=?,joinTime=?,gender=?,job=?,salary=? WHERE id=?";
    try {
        qr.update(conn,sql,emp.getName(),emp.getJoinTime(),emp.getGender(),emp.getJob(),emp.getSalary(), emp.getId());
    } catch (SQLException e) {
        e.printStackTrace();
    }finally {
        DBUtils.close(conn);
    }
}

@Override
public void delete(int id) {
    Connection conn=null;
    conn=DBUtils.getConnection();

    QueryRunner qr=new QueryRunner();
    String sql="DELETE FROM employee WHERE id=?";
    try {
        qr.update(conn,sql,id);
    } catch (SQLException e) {
        e.printStackTrace();
    }finally {
        DBUtils.close(conn);
    }
}

@Override
public Employee findone(int id) {
    Connection conn=null;
    Employee ee=null;
    conn=DBUtils.getConnection();
    QueryRunner qr=new QueryRunner();
    String sql="SELECT id,name,joinTime,gender,job,salary From employee WHERE id="+id;
    try {
        //BeanHandler将结果集的第一行数据，封装成JavaBean对象
        ee=qr.query(conn,sql,new BeanHandler<Employee>(Employee.class));
    } catch (SQLException e) {
        e.printStackTrace();
    }finally {
        DBUtils.close(conn);
    }
    return ee;
  }
}

最后一步就是通过DAO工厂类来产生具体的DAO实现类实例，以为针对不同的数据库我们可能会有不同的增删查改及其他功能操作，为了后期的修改方便，我们把要实现的类放在一个properties文件里面，通过Properties来加载具体的实现类即可。

public class DaoFactory {
  //dao工厂

private static Properties prop=new Properties();
static {
    try {
        prop.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("config.properties"));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

//获取实例
public static Object getInstance(String key){
    String name=prop.getProperty(key);
    Object obj=null;
    try {
        obj=Class.forName(name).newInstance();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    return obj;
  }
}

就这样我们的DAO模式就已经实现，这样在我们执行的时候

  public class TestDruid {
  public static void main(String[] args) {
    //我们直接通过工厂类来来获取具体实现类来执行操作
    EmpDao ed= (EmpDao) DaoFactory.getInstance("Empdao");
    //新增数据
    ed.save(new Employee(1,"嘿嘿",new Date(),"男","就是玩",2300));
}

那么接下来是要说说我们的数据源连接池的问题了，这个问题的缘由是由于当我们的项目有很大的访问量是，每个用户的访问都需要新建连接进行连接，我们的连接时间是最为耗时的，为了防止同时多个客户同时操作数据库，我们就准备了一个连接池，把我们的连接提前创建直接放在我们的池子里，当用的时候直接获取使用就会大大提高我们的效率。

数据源：数据源，作为DriverManager工具类的 替代项，是用亍获取数据库连接的首选方式。 其设置了我们确定数据的基本配置参数以及驱动。

#mysql config
driverClass=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mytest?serverTimezone=UTC
username=root
password=root
#druid配置初始化大小、最小、最大
druid.initialSize=1
druid.minIdle=1
druid.maxActive=20
#配置获取连接等待超时的时间
druid.maxWait=60000
#配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
druid.timeBetweenEvictionRunsMillis=60000
# 配置一个连接在池中最小生存的时间，单位是毫秒
druid.minEvictableIdleTimeMillis=300000
druid.validationQuery=SELECT 'x’ druid.testWhileIdle=true
druid.testOnBorrow=false
druid.testOnReturn=false
#配置监控统计拦截的filters
druid.filters=stat
maxOpenPreparedStatements=20
removeAbandoned=true
removeAbandonedTimeout=1800
logAbandoned=true

然后我们引用了Alibaba的druid.jar包，其效率是目前最快的。

public class DBUtils {
//通过druid数据库连接池来获取连接

private static Properties prop = new Properties();
private static DataSource ds = null;

static {
    try {
        prop.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("druid.properties"));
        ds = DruidDataSourceFactory.createDataSource(prop);
    } catch (IOException e) {
        System.out.println("未找到配置文件");
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }
  }
 //需要从连接池获取 通过DataSource
public static Connection getConnection(){
    Connection conn=null;
    try {
        conn=ds.getConnection();
    } catch (SQLException e) {
        e.printStackTrace();
    }

    return conn;
}

public static DataSource getDateSource(){
    return ds;
}
}

这样基本的原理及使用流程就实现了。