JDBC学习--2

1、数据库连接池

1、之前写JDBC代码，每次都要连接数据库，注册驱动，最后又释放资源，太过于麻烦；所以就有了数据库连接池

2、概念：简单来说就是一个容器(集合)，存放数据库连接的容器；

当系统初始化好之后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，会从容器中获取连接对象，用户访问完了之后又将连接对象归还给容器；

3、优点

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

4、连接池的简单实现

1. 标准接口：DataSource Javax.sql包下的

方法： 获取连接：getConnectioon
			归还连接：如果连接对象Connection是从连接池中获取的，那么调用
			Connection.close()方法，则不会再关闭连接了，而是归还连接

2. 一般我们自己不去实现这个接口，由数据库厂商来实现；

1、C3P0技术：一种数据库连接池技术；
2、Druid：数据库连接池(由阿里巴巴提供)

5、C3P0的使用

1. 步骤：

1、导入jar包：c3p0-0.9.5.2.jar    mchange-commons-java-0.2.12.jar  
						（还有一个数据库驱动jar包不要忘记）
2、定义配置文件
		1、c3p0.properties  或者  c3p0-config.xml     
		 (必须叫这两个名字，只有叫这两个名字才能以后在使用的时候自己去寻找这两个文件)
		 2、路径：直接将文件放在src目录下即可。
3、创建核心对象，数据库连接池对象  ComboPooledDataSource
4、获取连接  ：getConnection
5、接口 DataSource：定义引用获取连接池的链接数据库对象，然后这个对象再返回Connection对象
			连接池实现 - 生成自动参与连接池的 Connection 对象。
		 

6、Druid数据库连接池

1. 步骤

1、导入jar包  druid-1.0.9.jar
2、定义配置文件
	特点：
			1、是properties形成的
			2、可以叫任意名称，可以防止在任意的目录下，需要手动加载(c3p0自动加载的)
3、加载配置文件  druid.properties
Properties properties = new Properties();
            properties.load(new FileReader(
                    "D:\\Github\\JavaSE2019\\
                    chatroom_websocket\\src\\main\\resources\\
                    datasource.properties"));
3、获取数据库连接池对象：通过工厂类来获取  DruidDataSourceFactory
dataSource = (DruidDataSource) DruidDataSourceFactory.createDataSource(properties);
4、获取链接 getConnection
 return dataSource.getConnection();

2. 定义工具类

1、定义一个JDBCUtils
2、提供静态代码块来加载配置文件，初始化连接池对象
3、提供方法
		1、获取连接方法：通过数据库连接池来获取连接
		2、释放资源
		3、获取连接池的方法

3. Druid代码示例以及练习

2、Spring JDBC：JDBC Template

1、Spring框架对JDBC的简单封装，提供了一个JDBC Template对象简化JDBC的开发

2、步骤

1、导入jar包
2、创建一个对象JDBC Template，但是这个对象创建的时候需要依赖于数据源DataSource
		*JdbcTemplate template = new JdbcTemplate(ds)
3、调用JdbcTemplate的方法来完成CRUD的操作
		*update() : DML语句
		*queryForMap() : 查询结果，将结果集封装成map集合
						 这个结果集的长度只能是1；也就是说只能返回一个map对象；
		*queryForList() : 查询结果，将结果集封装成list集合
				将每一条记录封装成一条map集合，再将每一条map集合封装到List集合中
		*query() : 查询结果，将结果集封装成Javabean对象
					返回的是一个一个的对象
				一般使用BeanPropertyRowMapper实现类，可以完成数据到JavaBean的自动封装
				new BeanPropertyRowMapper<类型>(类型.class)
		*queryForObject() : 查询结果，将结果封装成对象，一般用于聚合函数的查询

4. 练习

需求：
		1、修改1号数据的salary为10000
		2、添加一条记录
		3、删除刚才添加的记录
		4、查询id为1的记录，将其封装为map集合
		5、查询所有记录，将其封装成List集合
		6、查询所有记录，封装成Emp对象的List集合
		7、查询总记录数，

练习代码链接：

package com.bit.jdbcTemplate;
import com.bit.domain.Emp;
import com.bit.utils.jdbc_utils;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

/**
 * @author Dangxuchao
 * @Title: JdbcTemplate_Test2
 * @ProjectName JDBC
 * @Description: JDBC下半部分
 */
public class JdbcTemplate_Test2 {
    //将会有七个方法
    //Junit单元测试，可以让方法独立执行

    //获取jdbcTemplate对象
    private JdbcTemplate template = new JdbcTemplate(jdbc_utils.getDs());

    /*
    * 	1、修改1号数据的salary为10000
    * */
    @Test  //这个注解的意思就是可以独立运行
    public void test1(){
        //定义sql
        String sql = "update emp set salary = 66666 where id = 1001";
        //执行sql
        int count = template.update(sql);
        System.out.println(count);

    }

    /*
    * 2、添加一条记录
    * */
    @Test  //这个注解的意思就是可以独立运行
    public void test2(){
        //定义sql
        String sql = 
        		"insert into emp (id,ename,dept_id) values (?,?,?)";//防止sql注入
        //执行sql
        int count = template.update(sql,1030,"牛牛",40);
        System.out.println(count);
    }

    /*
    * 	3、删除刚才添加的记录
    * */
    @Test  //这个注解的意思就是可以独立运行
    public void test3(){
        //定义sql
        String sql = "delete from emp where id=?";//防止sql注入
        //执行sql
        int count = template.update(sql,1030);
        System.out.println(count);

    }

    /*
    * 4、查询id为1的记录，将其封装为map集合
    * */
    @Test
    public void test4(){
        String sql = "select * from emp where id = ?";
        //String sql = "select * from emp where id = ? or id = ?";
        //将字段的值和字段的名称封装成了一个map集合，keu='id',value=1001;
        //注意，这个方法查询的结果集长度只能是1，只能返回一个对象
        Map map = template.queryForMap(sql,1001);
        System.out.println(map);
    }

    /*
    * 5、查询所有记录，将其封装成List集合
    * */
    @Test
    public void test5(){
        String sql = "select * from emp";
        List> list = template.queryForList(sql);
        for (Map map:list){
            System.out.println(map);
        }
    }

    /*
    * 	6、查询所有记录，封装成Emp对象的List集合
    * */

    @Test
    public void test6(){
        String sql = "select * from emp";
        //query() : 查询结果，将结果集封装成Javabean对象
        //		    返回的是一个一个的对象
        List list = template.query(sql, new RowMapper() {
            @Override
            public Emp mapRow(ResultSet rs, int i) throws SQLException {
                //此方法每调用一次就会返回一个对象
                Emp emp = new Emp();
                emp.setId(rs.getInt("id"));
                emp.setEname(rs.getString("ename"));
                emp.setJob_id(rs.getInt("job_id"));
                emp.setMgr(rs.getInt("mgr"));
                emp.setJoindate(rs.getDate("joindate"));
                emp.setSalary(rs.getDouble("salary"));
                emp.setBonus(rs.getDouble("bonus"));
                emp.setDept_id(rs.getInt("dept_id"));

                return emp;
            }
        });

         for (Emp emp:list){
             System.out.println(emp);
         }
    }


    @Test
    public void test6_2(){
        String sql = "select * from emp";
        //query() : 查询结果，将结果集封装成Javabean对象
        //		    返回的是一个一个的对象
        List list = template.query(
        						sql,new BeanPropertyRowMapper(Emp.class));
        for (Emp emp:list){
            System.out.println(emp);
        }
    }

    /*
    * 		7、查询总记录数，
    * */

    @Test
    public void test7(){
        String sql = "select count(id) from emp";
        Long total = template.queryForObject(sql,Long.class);
        System.out.println(total);


    }

}

json:字符串

谷歌退出的字符串系列化类