JDBC连接池

数据库连接池
JDBC Template
数据库连接池
概念
数据库连接池是存放数据库连接的容器
当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户访问数据库时，从容器中获取连接对象，用户访问完之后，会将对象归还给容器。

好处
1.节约资源
2.用户访问高效

数据库连接池的实现
1、接口：DataSource java.sql包下
2、由数据库厂商实现
实现技术:
（1）C3P0
(2 ) Druid—由阿里巴巴提供的
3、方法：
（1）获取连接：getConnection()
（2）归还连接：Connection.close() 如果连接对象是从Connection对象中获取的，那么调用Connection.close()对象则是归还连接。

C3P0数据库连接池的使用
步骤如下：
1.导包（2个，一个实现jar，一个依赖jar）
2.定义配置文件（默认扫描）：
(1)名称：c3p0.properties或c3p0-config.xml
模板见文件
(2)路径：直接将文件放在src目录下
3.创建核心对象（数据库连接池对象）： ComboPooledDataSource
4.获取连接：getConnection()

//1.创建数据库连接池对象
DataSource ds = new ComboPooledDataSource();
//2. 获取连接对象
Connection conn = ds.getConnection();

    //3. 打印
    System.out.println(conn);

Druid数据库连接池的使用
步骤如下：
1.导包（1个druid-1.0.9.jar）
2.定义配置文件
特点：
（1）是properties文件
（2）可以叫任意名，放到任意目录下
3.加载配置文件
4.获取数据库连接池对象：通过工厂来获取DruidDataSourceFactory
5.获取连接对象：getConnection()

相关代码：
public static void main(String[] args) throws Exception {
//1.导入jar包
//2.定义配置文件
//3.加载配置文件
Properties pro = new Properties();
InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream(“druid.properties”);
pro.load(is);
//4.获取连接池对象
DataSource ds = DruidDataSourceFactory.createDataSource(pro);
//5.获取连接
Connection conn = ds.getConnection();
System.out.println(conn);

}

抽取工具类：
1.定义JDBCUtils
2.提供静态代码块加载配置文件，初始化连接池对象
3.提供方法：
（1）获取连接的方法：通过数据库连接池获取连接
（2）释放资源的方法
（3）获取连接池的方法
相关代码：

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.IOException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

/**

• Druid连接池的工具类
  */
  public class JDBCUtils {

  //1.定义成员变量 DataSource
  private static DataSource ds ;

  static{
  try {
  //1.加载配置文件
  Properties pro = new Properties();
  pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream(“druid.properties”));
  //2.获取DataSource
  ds = DruidDataSourceFactory.createDataSource(pro);
  } catch (IOException e) {
  e.printStackTrace();
  } catch (Exception e) {
  e.printStackTrace();
  }
  }

  /**

  • 获取连接
    */
    public static Connection getConnection() throws SQLException {
    return ds.getConnection();
    }

  /**

  • 释放资源
    /
    public static void close(Statement stmt,Connection conn){
    / if(stmt != null){
    try {
    stmt.close();
    } catch (SQLException e) {
    e.printStackTrace();
    }
    }

    if(conn != null){
    try {
    conn.close();//归还连接
    } catch (SQLException e) {
    e.printStackTrace();
    }
    }*/

    close(null,stmt,conn);
    }

  public static void close(ResultSet rs , Statement stmt, Connection conn){

   if(rs != null){
       try {
           rs.close();
       } catch (SQLException e) {
           e.printStackTrace();
       }
   }
  
  
   if(stmt != null){
       try {
           stmt.close();
       } catch (SQLException e) {
           e.printStackTrace();
       }
   }
  
   if(conn != null){
       try {
           conn.close();//归还连接
       } catch (SQLException e) {
           e.printStackTrace();
       }
   }
  

  }

  /**

  • 获取连接池方法
    */

  public static DataSource getDataSource(){
  return ds;
  }

}
练习
public static void main(String[] args) {
/*
* 完成添加操作：给account表添加一条记录
*/
Connection conn = null;
PreparedStatement pstmt = null;
try {
//1.获取连接
conn = JDBCUtils.getConnection();
//2.定义sql
String sql = “insert into user values(null,?,?)”;
//3.获取pstmt对象
pstmt = conn.prepareStatement(sql);
//4.给？赋值
pstmt.setString(1,“张三”);
pstmt.setInt(2,30);
//5.执行sql
int count = pstmt.executeUpdate();
System.out.println(count);
} catch (SQLException e) {
e.printStackTrace();
}finally {
//6. 释放资源
JDBCUtils.close(pstmt,conn);
}
JDBC Template
概念：Spring框架对JDBC的封装，提供了JDBCTemplate的对象，简化JDBC的开发

步骤
1.导包（5个Jar包)
2.创建JdbcTemplate对象
JdbcTemplate jt = new JdbcTemplate(ds);
3.使用js里的方法完成CRUD操作

update()执行DML语句（增删改）
queryForMap():查询结果，将结果集封装为Map
注意：key是列名，value是值，将这条结果封装到一个map里，长度只能是1
queryForList():查询结果，将结果集封装为List
注意：将每一条结果封装为一个map集合，再将map集合装载到List集合里
query():查询结果，将结果集封装为JavaBean对象
参数：
RowMapper 一般不直接用而是推荐用实现类
BeanPropertyRowMapper
如List list = template.query(sql,new
BeanPropertyRowMapper(Student.class));
queryForObject():查询结果，将结果集封装为对象
注意：一般用于聚合函数的查询
代码示例：
package jdbctemplet;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.List;

import java.util.Map;

import org.junit.Test;

import
org.springframework.jdbc.core.BeanPropertyRowMapper;

import
org.springframework.jdbc.core.JdbcTemplate;

import org.springframework.jdbc.core.RowMapper;

import com.util.JDBCUtils;

import jdbctemplet.entity.Student;

/*

• 1.增加一条记录 id为13，姓名为李丽丽，javase
  99,javaee 89,math 93,gender ‘女’

• 2.修改李丽丽的javase分数为98

• 3.将李丽丽的成绩信息封装到map里

• 4.将所有学生信息存放到List里

• 5.查询所有学生信息，将其封装为Student对象的List集合

• 6.查询总记录数

*/

public class JDBCTemplet {

private JdbcTemplate template = new 

JdbcTemplate(JDBCUtils.getDataSource());

public static void main(String[] args) {

    JdbcTemplate template = new 

JdbcTemplate(JDBCUtils.getDataSource());

    String sql = "update stu set name=? 

where id=1";

    int count = template.update(sql, "张三");

    System.out.println(count);

    

    

}

/**

 * 1.增加一条记录 id为13，姓名为李丽丽，<u>javase</u> 

99,javaee 89,math 93,gender ‘女’

 */

@Test

public void testAdd(){

    String sql = "insert into 

student(id,name,javase,javaee,math,gender)
values(?,?,?,?,?,?)";

    int <u>count</u> = template.update(sql, 13,"李丽丽",99,89,93,"女");

}

/**

 * 2.修改李丽丽的<u>javase</u>分数为98

 */

@Test

public void testUpdate(){

    String sql = "update student set javase 

= ? where name =‘李丽丽’";

    int count = template.update(sql, 98);

    System.out.println(count);

}

/**

 * 4.将所有学生信息存放到List里

 */

@Test

public void testQueryMap(){

    String sql = "select * from student";

    List<Map<String, Object>> list = 

template.queryForList(sql);

    for(<u>Map</u> map:list){

    System.out.println(map);

    }

}

/**

 * 5.查询所有学生信息，将其封装为Student对象的List集合

 */

@Test

public void testQuery(){

    String sql = "select * from student";

    List<Student> list = 

template.query(sql,new RowMapper(){

        @Override

        public Student mapRow(ResultSet rs, 

int i) throws SQLException {

            Student stu = new Student();

            int id = rs.getInt("id");

            String name = 

rs.getString(“name”);

            double javase = 

rs.getDouble(“javase”);

            double javaee = 

rs.getDouble(“javaee”);

            double math = 

rs.getDouble(“math”);

            String gender = 

rs.getString(“gender”);

            stu.setId(id);

            stu.setName(name);

            stu.setJavase(javase);

            stu.setJavaee(javaee);

            stu.setMath(math);

            stu.setGender(gender);

            return stu;

        }

        

    });

            for(Student s:list){

                System.out.println(s);

            }

}

/**

 * 5.查询所有学生信息，将其封装为Student对象的List集合

 */

@Test

public void testQuery2(){

    String sql = "select * from student";

    List<Student> list = 

template.query(sql,new
BeanPropertyRowMapper(Student.class));

    for(Student stu:list){

        System.out.println(stu);

    }

}

/*

 * 6.查询总记录数

 */

@Test

public void testQueryForObject(){

    String sql ="select count(id) from 

student";

    Long count = 

template.queryForObject(sql,Long.class);

    System.out.println(count);

}     

}