JDBCTemplate、Druid连接池

一、JDBC

       1.概念:Java DataBase Connectivity  Java 数据库连接， Java语言操作数据库

          * JDBC本质：其实是官方（sun公司）定义的一套操作所有关系型数据库的规则，即接口。各个数据库厂商去实现这套接口，提供数据库驱动jar包。我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类。

       2.快速入门         

//1. 导入驱动jar包
        //2.注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //3.获取数据库连接对象
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db3", "root", "root");
        //4.定义sql语句  
        String sql = "update account set balance = ? where id = ?";
        //5.获取执行sql的对象 Statement
      PreparedStatement pst =con.prepareStatement(sql);
       pst.setDouble(1, 500);
    pst.setDouble(2, 1000);
        //6.执行sql
        int count = stmt.executeUpdate(sql);
        //7.处理结果
        System.out.println(count);
        //8.释放资源
        stmt.close();
        conn.close();

         3.详解各个对象：

            3.1. DriverManager：驱动管理对象

                 功能：

                           1.注册驱动：告诉程序该使用哪一个数据库驱动jar

                            2.获取数据库连接；

             3.2. Connection：数据库连接对象

                 功能：1. 获取执行sql 的对象

                                * Statement createStatement()

                               * PreparedStatement prepareStatement(String sql)

                            2.管理事务

                                 * 开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，即开启事务

                                         * 在执行sql之前开启事务

                                * 提交事务：commit() 

                                           * 当所有sql都执行完提交事务

　　　　　　　　   * 回滚事务：rollback()

                                           * 在catch中回滚事务

二、数据库连接池

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

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

       3.实现： 标准接口：DataSource   javax.sql包下的；

                  方法： 获取连接：getConnection()；

        4.连接池技术

           4.1.c3p0: 数据库连接技术

              步骤：

                 1. 导入jar包 (两个) c3p0-0.9.5.2.jar mchange-commons-java-0.2.12.jar ，
                     * 不要忘记导入数据库驱动jar包
                 2. 定义配置文件：
                      * 名称： c3p0.properties 或者 c3p0-config.xml
                     * 路径：直接将文件放在src目录下即可。

                 3. 创建核心对象 数据库连接池对象 ComboPooledDataSource
                 4. 获取连接： getConnection         

public class C3_P0utils {
private static ComboPooledDataSource dataSource = new ComboPooledDataSource("oracle");
 
 public static DataSource getDataSource() {
     return dataSource;
 }
 
 public static Connection getConnection() {
     try {
         
         return dataSource.getConnection();
         
    } catch (SQLException e) {
        throw new RuntimeException();
    }
 } 
}

<!--c3p0-config配置文件-->

<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>

  <default-config>
    <property name="driverClass">com.mysql.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mysql:///mbase</property>
    <property name="user">root</property>
    <property name="password">123</property>
    <property name="initialPoolSize">5</property>
    <property name="maxPoolSize">20</property>
  </default-config>


</c3p0-config>

            4.2.Druid:数据库连接技术，阿里巴巴提供

               步骤：

                   1. 导入jar包 druid-1.0.9.jar

                   2. 定义配置文件：
                      * 是properties形式的
                      * 可以叫任意名称，可以放在任意目录下
                   3. 加载配置文件。Properties
                  4. 获取数据库连接池对象：通过工厂来来获取 DruidDataSourceFactory
                  5. 获取连接：getConnection

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;
            }
        
        }

//druid.properties文件
driverClass=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mbase
username=root
password=123

三、DButils

  例：    

//1.创建按核心类QueryRunner
        QueryRunner qr = new QueryRunner(C3_P0utils.getDataSource());

//增加
String sql="insert into sort values(null,?,?,?)";
        //3.为占位符设置值
        Object[] params = {"超萌二哈",190,"拆家拆家"};
        //4.执行添加操作
        int row=qr.update(sql, params);

//修改

String sql="update sort set sname=? where id=?";
        Object[] param= {"二哈",19};
        int row =qr.update(sql,param);

//删除
String sql ="delete from sort where id=?";
        int row = qr.update(sql,20);
//查询
  //1.将结果集的每一行数据封装成JavaBean对象 ： BeanListHandler
List<Users> users=qr.query(sql, new BeanListHandler<Users>(Users.class));
  //2.将结果集的一行数据封装成JavaBean对象：BeanHandler
 Users users=qr.query(sql,new BeanHandler<Users>(Users.class), param);
  //3.查询所有个数：ScalarHandler
 Long count=(Long) qr.query(sql, new ScalarHandler<Object>());
//4.MapListHandler
List<Map<String,Object>> list=qr.query(sql, new MapListHandler());
//5.将某列的值封装到List集合中
String sql="select * from product where pname like ? limit 0,8";
        List<Object> query = qr.query(sql, new ColumnListHandler("pname"), "%"+word+"%");

 四、JdbcTemplate

       1.Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发

        * 步骤：

            1. 导入jar包
           2. 创建JdbcTemplate对象。依赖于数据源DataSource
               * JdbcTemplate template = new JdbcTemplate(ds);

           3. 调用JdbcTemplate的方法来完成CRUD的操作

         　　 * update():执行DML语句。增、删、改语句

          　　* queryForMap():查询结果将结果集封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个map集合

          　　     * 注意：这个方法查询的结果集长度只能是1

          　　* queryForList():查询结果将结果集封装为list集合

                    * 注意：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中

                  * query():查询结果，将结果封装为JavaBean对象

                      * query的参数：RowMapper

                        * 一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装

                        * new BeanPropertyRowMapper<类型>(类型.class)

                   * queryForObject：查询结果，将结果封装为对象

                      * 一般用于聚合函数的查询

例：

  //1. 获取JDBCTemplate对象
private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
 
//添加一条记录
int count = template.update(sql, 1015, "郭靖", 10);

//删除刚才添加的记录
int count = template.update(sql, 1015);

//查询id为1001的记录，将其封装为Map集合
 Map<String, Object> map = template.queryForMap(sql, 1001,1002);

// 查询所有记录，将其封装为List
 List<Map<String, Object>> list = template.queryForList(select * from emp);

//查询总记录数
 Long total = template.queryForObject(sql, Long.class);

  //查询所有记录，将其封装为Emp对象的List集合
      List<Emp> list = template.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));