数据库连接池技术、Spring JDBC

多点赞、多评论、谢支持~

数据库连接池

1.基本理解：
其实就是一个容器集合，存放数据库连接的容器。
当系统初始化好之后，容器被创建，容器会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，将连接对象还给容器。

2.使用数据库连接池的好处：节约资源、访问效率高

3.实现：
（1）有标准的接口 DataSource 存放于javax.sql包下。具体方法有：

获取连接：Connection getConnection()
归还连接:Connection.close() 如果连接对象是从数据库连接池中取的，那么调用该方法，就不会关闭连接，而是归还连接。

（2）一般情况下，会有专门的数据库厂商来进行实现

• C3P0：数据库连接池技术
• Druid：数据库连接池实现技术，由阿里巴巴提供

4.C3P0：数据库连接池技术
使用步骤如下：
（1）导入jar包，需要导入两个
c3p0-0.9.5.2.jar
mchange-commons-java-0.2.12.jar
（2）定义配置文件：

名称：c3p0.properties 或者 c3p0-config.xml
存放位置：一般我们直接存放在src目录下

（3）创建核心对象（数据库连接池对象）ComboPooledDataSource，会直接加载配置文件
（4）获取连接：getConnection

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

5.Druid:数据库连接池实现技术，由阿里巴巴提供
实现步骤：
（1）导入jar包 druid-1.0.9.jar
（2）定义配置文件

必须使用properties形式的
可以存放在任意位置，可以叫任意名称

（3）不会直接加载配置文件，所以需要我们手动加载 Properties
（4）获取数据库连接池对象，通过工厂类来获取 DruidDataSourceFactory
（5）获取连接 getConnection

//加载配置文件
	 Properties pro=new Properties();
	 InputStream rs =Demo1.class.getClassLoader().getResourceAsStream("druid.properties");
	 pro.load(rs);
 //获取连接池对象
   DataSource ds= DruidDataSourceFactory.createDataSource(pro);
 //获取连接
   Connection con = ds.getConnection();

（6）定义一个工具类，包含以下方法：

• 获取连接的方法，通过数据库连接池
• 释放资源
• 获取连接池的方法

/*定义工具类：
* 1.提供静态代码块加载配置文件，初始化连接池对象
* 2.提供方法：
*    获取连接的方法，通过数据库连接池
*    释放资源
*    获取连接池*/
public class DruidUtils {
    //定义一个成员变量
    private static DataSource ds;
    static {
        try {
            //加载配置文件
            Properties pro=new Properties();
            pro.load(DruidUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
            //初始化连接池对象
           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 DataSource getDataSource(){
        return ds;
    }
    //释放资源
    public static void close(ResultSet rs, PreparedStatement psmt,Connection con){
        if(rs!=null){
            try {
                rs.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(psmt!=null){
            try {
                psmt.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(con!=null){
            try {
                con.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
    public static void close( PreparedStatement psmt,Connection con){
        close(null,psmt,con);
    }

}

Spring JDBC

Spring框架对JDBC的简单封装。提供了一个JDBCTemplate来简化JDBC
实现步骤：

• 导入jar包
• 创建JDBCTemplate对象，依赖于数据源DataSource
  JdbcTemplate template= new JdbcTemplate(DataSource ds)
• 调用 JdbcTemplate 的方法来完成CRUD操作

方法：
（1）update():执行DML操作，增删改语句
（2）queryForMap():查询结果放在Map结合中，将列作为key，值作为value

该方法只能存储一条记录

（3）queryForList():将结果集封装在list集合中，将每一条记录封装为Map集合，再将Map集合装载到List集合中
（4）query():查询结果，将结果封装为JavaBean对象

query的参数是RowMapper
使用BeanPropertyRowMapper实现类，来完成数据到JavaBean的自动封装
new BeanPropertyRowMapper<类型>(类型.class)

（5）queryForObject():查询结果，将结果封装为对象。一般使用在聚合函数中

/*练习：
		* 需求：
			1. 修改1号数据的 age 为 20
			2. 添加一条记录
			3. 删除刚才添加的记录
			4. 查询id为1的记录，将其封装为Map集合
			5. 查询所有记录，将其封装为List
			6. 查询所有记录，将其封装为Emp对象的List集合
			7. 查询总记录数*/
public class TemplateDemo2 {
    //创建JdbcTemplate对象
    static JdbcTemplate template=new JdbcTemplate(DruidUtils.getDataSource());
    @Test
    public  void test1(){
        //修改1号数据的 age 为 20
        String sql="update user set age=20 where id=?";
        int i = template.update(sql, "1");
        System.out.println(i);
    }
    @Test
    public  void test2(){
        //添加一条数据
        String sql="insert into user values (?,?,?)";
        int i = template.update(sql, "3", "王五", 19);
        System.out.println(i);

    }
    @Test
    public  void test3(){
        //删除记录
        String sql="delete from user where id=?";
        int i = template.update(sql, "3");
        System.out.println(i);
    }
    @Test
    public  void test4(){
        //查询id为1的记录，将其封装为Map集合
        String sql="select * from user where id=?";
        Map<String, Object> map = template.queryForMap(sql, "1");
        System.out.println(map);
    }
    @Test
    public  void test5(){
        //查询所有记录，将其封装为List
        String sql="select * from user";
        List<Map<String, Object>> list = template.queryForList(sql);
        System.out.println(list);
    }
    @Test
    public  void test6(){
        //查询所有记录，将其封装为User对象的List集合
        String sql="select * from user";
        List<User> list = template.query(sql, new RowMapper<User>() {
            @Override
            public User mapRow(ResultSet rs, int i) throws SQLException {
                User user = new User();
                String id = rs.getString("id");
                String name = rs.getString("name");
                int age = rs.getInt("age");

                user.setId(id);
                user.setName(name);
                user.setAge(age);

                return user;
            }
        });
        for (User user : list) {
            System.out.println(user);
        }

    }
    @Test
    public  void test6_2(){
        //查询所有记录，将其封装为User对象的List集合
        String sql="select * from user";
        List<User> list = template.query(sql, new BeanPropertyRowMapper<User>(User.class));
        System.out.println(list);
    }
    @Test
    public  void test7(){
        //查询总记录数
        String sql="select count(id) from user";
        Long i = template.queryForObject(sql, long.class);
        System.out.println(i);
    }
}

多点赞、多评论、谢支持~