Introduction to JDBC (IV) - use of Druid connection pool

1.Druid Connection pool （ a key ）
Connection pool ：
summary ： Put multiple connection objects in the pool in advance , When a user uses a connection object , Take it out of the pool ; When it is used up, it is recycled to the pool
benefits ： Reduce the number of connection objects created and destroyed , Improved performance
principle ：（ Reuse mechanism ）
Put... In the set 10 A connection object
If a user uses a connection object , Get... From the collection , And delete the objects in the collection
If the execution is complete , call close, Recycle resources ( Connect objects , Add back to the collection , Reuse for another user )

Druid Connection pool : It is provided by Alibaba , Recognized as the best performance connection pool product ; Other -c3p0,dbcp

Use steps ：
1. Import Druid The connection pool jar package
2. To write Druid Configuration file for db.properties;( Be careful ：key Fix , Value can be changed )
3. Load profile , Acquisition data source , To get the connection object
4.close It has become recycling （ There are rewrites in the connection pool ）

---------------db.properties To configure ---------------

# connections setting up 
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mydb1
username=root
password=123
#<!--  Initialize connection  -->
initialSize=10
# Maximum number of connections 
maxActive=50
#<!--  Minimum free connection  -->
minIdle=5
#<!--  Timeout wait time in milliseconds  60000 millisecond /1000 be equal to 60 second  -->
maxWait=5000

------------DBUtils Connection pool tool class -------------

public class DBUtils {
    
    private static DataSource dataSource;
    private static Properties p = new Properties();
    // Static code block ： Load only once 
    static{
    
        // Reflection object calls getResourceAsStream
        // from src Get... From the directory db.properties Resources for 
        try {
    
            InputStream is = DBUtils.class.getResourceAsStream("/db.properties");
            p.load(is);  // Load connection pool configuration 
            // According to the incoming configuration , Acquisition data source , The data source contains the operation of connection pool 
            dataSource = DruidDataSourceFactory.createDataSource(p);
        } catch (Exception e) {
    
            e.printStackTrace();
        }
    }

    public static DataSource getDataSource(){
    
        return dataSource;  // Acquisition data source 
    }

    public static Connection getConnection(){
    
        Connection conn = null;
        try {
     // Get the connection object from the connection pool 
           conn = dataSource.getConnection();
        } catch (SQLException e) {
    
            e.printStackTrace();
        }
        return conn;
    }
}

2.DaoUtils The third party of jar
DaoUtils The third party jar Package introduction
Internal implementation ： And we wrote it ourselves DaoUtils It's similar , Provides , We don't have to write it ourselves
A third party jar Division level made crud Other than sql Encapsulation of statements ; for example ： polymerization , Link query
step ：
1. Import dbutils Of jar package （DaoUtils The implementation of the ）
2. adopt QueryRunner call update and query Method to add, delete, modify and query

public class PersonDaoImpl {
    
    // Use QueryRunner Realize the function of adding, deleting, modifying and checking 
    private QueryRunner queryRunner = new QueryRunner(DBUtils.getDataSource());

    public int insert(Person p) {
    
        String sql = "insert into person(name,age,bornDate,email,address) values(?,?,?,?,?)";
        try {
    
            return queryRunner.update(sql,p.getName(),p.getAge(),p.getBornDate(),p.getEmail(),p.getAddress());
        } catch (SQLException e) {
    
            e.printStackTrace();
        }
        return 0;
    }

    public int update(Person p) {
    
        String sql = "update person set name=?,age=? where id=?";
        try {
    
            return queryRunner.update(sql,p.getName(),p.getAge(),p.getId());
        } catch (SQLException e) {
    
            e.printStackTrace();
        }
        return 0;
    }

    public int delete(int id) {
    
       String sql = "delete from person where id=?";
        try {
    
            return queryRunner.update(sql,id);
        } catch (SQLException e) {
    
            e.printStackTrace();
        }
        return 0;
    }

    public Person selectById(int id) {
    
        String sql = "select * from person where id=?";
        try {
    
           return queryRunner.query(sql, new BeanHandler<>(Person.class), id);
        } catch (SQLException e) {
    
            e.printStackTrace();
        }
        return null;
    }

    public List<Person> selectAll() {
    
        String sql = "select * from person";
        try {
    
            return queryRunner.query(sql,new BeanListHandler<>(Person.class));
        } catch (SQLException e) {
    
            e.printStackTrace();
        }
        return null;
    }