JDBC工具包使用

数据库结构图：

第一种组合 ：

　　只有官方驱动 mysql-connector-java-5.1.13-bin.jar

包结构：

代码：简单实现增删改查可以自己做一个配置文件工具包，见上一篇文章

package com.jdbc.onlyconnector;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Scanner;

import org.junit.Test;

public class ConnectorTest {
    @Test
    public void test01() throws ClassNotFoundException, SQLException {
        //jdbc四大参数,driver的全限命名,url,user,password
        String driverClassName = "com.mysql.jdbc.Driver";
        String url = "Jdbc:mysql://localhost:3306/db2";
        String user = "root";
        String password ="123";
        /*    
         * public class Driver implements java.sql.Driver 
         *     获取到Driver的对象（创建驱动）,com.mysql.jdbc.Driver类的内部有一个静态代码块,当类被加载时就会调用
         * java.sql.DriverManager.registerDriver(new Driver())这个方法
         *     该驱动实现了java内部的Driver接口,通过多态传递给驱动管理，进行底层连接
         */
        Class.forName(driverClassName);
        /*
         *     通过传递另外三大参数和数据库取得连接,并且返回一个Connection    对象,
         * Connection对象的数据库能够提供描述其表、所支持的 SQL 语法、存储过程、此连接功能等等的信息
         *     Connection类主要用到的方法  commit 提交上一次修改;   rollback  回滚到数据库（不修改）
         *     getAutoCommit() true为自动提交,false为手动事务,默认true
         *     createStatement() 创建一个 Statement 对象来将 SQL 语句发送到数据库,返回值就是一个Statement 对象
         *  prepareStatement(String sql) 创建一个 PreparedStatement 对象来将参数化的 SQL 语句发送到数据库。
         *      注意:prepareStatement extends Statement  两个都是接口  Connection也是接口
         */
        Connection connection = DriverManager.getConnection(url, user, password);
//        /*
//         *     第一种 ：开始
//         *      调用    createStatement() 方法返回一个Statement对象 
//         *     Statement类用于执行静态 SQL 语句并返回它所生成结果的对象。
//         *     Statement类主要用到的方法 
//         *     boolean execute(String sql)执行给定的 SQL 语句，该语句可能返回多个结果。
//         *     ResultSet executeQuery(String sql) 执行给定的 SQL 语句，该语句返回单个 ResultSet 对象 ;(查数据库)
//         *     int executeUpdate(String sql) 执行给定 SQL 语句，
//         *     该语句可能为 INSERT、UPDATE 或 DELETE 语句，或者不返回任何内容的 SQL 语句（如 DDL 语句）; （改数据库）
//         */
//            Statement statement = connection.createStatement();
//        /*
//         *     增 数据insert
//         */
//            String zeng = "insert into emp(eid , ename ,did) values (4,'小猪',1)";
//            //返回值是表中受影响的行数
//            int empZeng = statement.executeUpdate(zeng); //返回值是1 代表1行收到影响
//        /*
//         *      删 数据 delete
//         */
//            String shan = "delete from emp where eid = 4";
//            int empShan = statement.executeUpdate(shan);
//        /*
//         *         改  数据update
//         */
//            String gai = "UPDATE emp SET ename = '小红'  WHERE eid = 3 ";
//            int empGai = statement.executeUpdate(gai);
//        /*
//         *      重点：查 数据  select
//         */
//            String cha = "select * from emp";
//            /*
//             *     返回值是ResultSet类的对象，表示数据库结果集的数据表，通常通过执行查询数据库的语句生成。
//             *     ResultSet类常用方法 
//             *      boolean next()  将光标从当前位置向前移一行。 （和迭代器差不多）
//             *     int getInt(int columnIndex) 获取索引列的int类型的值  columnIndex 第一列等于1
//             *     String getString(int columnIndex)
//             *     Object getObject(int columnIndex)
//             *     Object getObject(String columnLabel) 获取此 ResultSet对象中当前行中指定列的值
//             *     （columnLabel 指定的列标签。如果未指定 SQL AS 子句，则标签是列名称 ）
//             *     String getString(String columnLabel) 获取此 ResultSet 对象的当前行中指定列的值。
//             *     int getInt(String columnLabel)
//             * 
//             */
//            ResultSet empCha = statement.executeQuery(cha);
//            if(empCha!=null) {
//                while(empCha.next()) {
//                    System.out.println(empCha.getInt(1));
//                    System.out.println(empCha.getString("ename"));
//                    System.out.println(empCha.getObject(3));
//                }
//            }
///*
//  输出结果：
//1
//张三
//1
//2
//李四
//2
//3
//小红
//1
// */
            /*
             *     第二种 使用preparedStatement
             */
        /*
         *      查数据更加方便 好处:
         *  1.使用占位符而不是语句拼接,可以防止注入攻击;
         *  2.语句预编译,执行效率高;
         */
        String sql = "select * from emp where eid =?";
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要查找的员工id");
        int eid =sc.nextInt();
        PreparedStatement ps = connection.prepareStatement(sql);
    //setInt(int parameterIndex, int x) parameterIndex占位符下标，第一个是1  x代表占位符的值
        ps.setInt(1, eid); 
        //执行语句
        ResultSet rs = ps.executeQuery();
        if(!rs.wasNull()) {
            while(rs.next()) {
                System.out.println(rs.getObject(1));
                System.out.println(rs.getObject(2));
                System.out.println(rs.getObject(3));
            }
        }
/*
执行结果：
请输入要查找的员工id
1
1
张三
1
 */
        
    }
}

第二种组合 ：

　　官方驱动 　　mysql-connector-java-5.1.13-bin.jar

　　C3p0连接池 和它的关联包  以及它的配置文件　　

　　　　c3p0-0.9.2-pre1.jar   mchange-commons-0.2.jar  c3p0-config.xml（配置文件放在src目录下）

　　

包结构

代码：

<?xml version="1.0" encoding="UTF-8" ?>
<c3p0-config>
    <default-config> 
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/db2</property>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="user">root</property>
        <property name="password">123</property>
        
        <property name="acquireIncrement">3</property>
        <property name="initialPoolSize">2</property>
        <property name="minPoolSize">2</property>
        <property name="maxPoolSize">20</property>
    </default-config>
</c3p0-config>

package com.jdbc.usec3p0utils;

import java.sql.Connection;
import java.sql.SQLException;

import com.mchange.v2.c3p0.ComboPooledDataSource;
/*
 * 通过c3p0jar包封装一个工具类，c3p0中有一个连接池类，通过创建连接池来获取到一个dateSource对象，通过调用这个
 * 对象的getConnection方法获取一个connection连接对象，这就是这个工具类的作用
 * 
 * 对c3p0的理解 ，就是通过c3p0-config.xml配置文件,管理对数据库的连接，实现随时取用，提高效率
 * 
 */
public class C3p0Utils {
    //C3P0连接池提供的核心类: 数据源（就是一个名词，作用是可以调用他的方法给我们一个连接对象）
    private static ComboPooledDataSource dataSource=new ComboPooledDataSource();
    
    //获取数据源
    public static ComboPooledDataSource getDataSoruce() {
        return dataSource;    
    }
    //从连接池中取用一个连接
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();
    }
    
}

package com.jdbc.usec3p0utils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import org.junit.Test;

public class C3p0Test {
    @Test
    public void selectByC3p0Utile() throws SQLException {
        /*
         * 使用    c3p0工具包获取到一个连接对象，在进行数据库的操作
         */
        C3p0Utils  c3p0Utils = new C3p0Utils();
        Connection connection = c3p0Utils.getConnection();
        //进行数据库操作
        String sql = "select * from emp";
        PreparedStatement ps = connection.prepareStatement(sql);
        ResultSet rs = ps.executeQuery();
        //输出查询结果
        if(!rs.wasNull()) {
            while(rs.next()) {
                System.out.println(rs.getObject(1));
                System.out.println(rs.getObject(2));
                System.out.println(rs.getObject(3));
            }
        }
/*
 执行结果
 1
张三
1
2
李四
2
3
小红
1*/
    }
}

第三种组合：

　1.官方驱动 　　mysql-connector-java-5.1.13-bin.jar

　2.C3p0连接池 和它的关联包  以及它的配置文件　　

　　　　c3p0-0.9.2-pre1.jar   mchange-commons-0.2.jar  c3p0-config.xml（配置文件放在src目录下）

　3.commons-dbutils-1.4.jar

Dbutils：主要是封装了JDBC的代码，简化dao层的操作。

Dbutils作用：帮助java程序员，开发Dao层代码的简单框架。

         　　　框架的作用：帮助程序员，提高程序的开发效率。

    　　　　 出生：Dbutils是由Apache公司提供。

 为什么需要Dbutils ？

     在使用Dbutils 之前，我们Dao层使用的技术是JDBC，那么分析一下JDBC的弊端：

          （1）数据库链接对象、sql语句操作对象，封装结果集对象，这三大对象会重复定义

          （2）封装数据的代码重复，而且操作复杂，代码量大

          （3）释放资源的代码重复

               结果：（1）程序员在开发的时候，有大量的重复劳动。（2）开发的周期长，效率低

包结构：

 

代码 ：将数据库数据转化成员工对象

<?xml version="1.0" encoding="UTF-8" ?>
<c3p0-config>
    <default-config> 
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/db2</property>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="user">root</property>
        <property name="password">123</property>
        
        <property name="acquireIncrement">3</property>
        <property name="initialPoolSize">2</property>
        <property name="minPoolSize">2</property>
        <property name="maxPoolSize">20</property>
    </default-config>
</c3p0-config>

package com.jdbc.usec3p0utils;

import java.sql.Connection;
import java.sql.SQLException;

import com.mchange.v2.c3p0.ComboPooledDataSource;
/*
 * 通过c3p0jar包封装一个工具类，c3p0中有一个连接池类，通过创建连接池来获取到一个dateSource对象，通过调用这个
 * 对象的getConnection方法获取一个connection连接对象，这就是这个工具类的作用
 * 
 * 对c3p0的理解 ，就是通过c3p0-config.xml配置文件,管理对数据库的连接，实现随时取用，提高效率
 * 
 */
public class C3p0Utils {
    //C3P0连接池提供的核心类: 数据源（就是一个名词，作用是可以调用他的方法给我们一个连接对象）
    private static ComboPooledDataSource dataSource=new ComboPooledDataSource();
    
    //获取数据源
    public static ComboPooledDataSource getDataSoruce() {
        return dataSource;    
    }
    //从连接池中取用一个连接
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();
    }
    
}

package com.jdbc.entity;

public class Employee {
    /*
     * 创建对象时必须用数据库的字段作为属性，因为dbutils内部将查询结果转化成对象是
     * 通过我们Employee类的get和set方法来赋值的，所以必须对上号
     * 创建对象最重要的两点      对应的get和set方法       无参构造
     */
    private int eid;   //员工编号
     private String ename;   //员工姓名
    private int did;        //员工部门编号
    public Employee() {
    }
    public int getEid() {
        return eid;
    }
    public void setEid(int eid) {
        this.eid = eid;
    }
    public String getEname() {
        return ename;
    }
    public void setEname(String ename) {
        this.ename = ename;
    }
    public int getDid() {
        return did;
    }
    public void setDid(int did) {
        this.did = did;
    }
    @Override
    public String toString() {
        return "Employee [eid=" + eid + ", ename=" + ename + ", did=" + did + "]";
    }
    
    
    
}

package com.jdbc.dbutils;

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

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.junit.Test;

import com.jdbc.entity.Employee;
import com.jdbc.usec3p0utils.C3p0Utils;

public class UseDbUtils {
    @Test
    public void dmlByDbutils() {
        /*
         * 使用c3p0连接池获取连接,但是有了Dbutils就省去了我们的连接和关闭工作
         *  org.apache.commons.dbutils.QueryRunner 该类常用方法
         *      public QueryRunner();无参构造，在之后调用qu
         *   public QueryRunner(DataSource ds);传一个数据源  c3p0工具包中连接池的数据源
         *   
         */
        //第一种  有参构造 传数据源
        QueryRunner qr = new QueryRunner(C3p0Utils.getDataSoruce());
        /*
         *     增
         */
        String sql = "insert into emp(eid,ename,did) values (?,?,?)";
        try {
//            int update = qr.update(sql,4,"张飞",2);// 返回值是被影响的行数
//            System.out.println(update);
//            或者
            Object[] objs = {4,"张飞",2};
            int update = qr.update(sql,objs);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        
        //第二种  无参构造  
        QueryRunner qr2 = new QueryRunner();
        /*
         *        删
         */
        String sql2  = "delete from emp where did = ?"; //删除张飞这个员工
        try {
            int update2 = qr2.update(C3p0Utils.getConnection(),sql2, 3);
            System.out.println(update2);
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }
    /*
     *     重点 将数据转化成对象
     */
    /*    //获取一个对象  使用public BeanHandler(Class type);
     *     public transient Object query(String sql, ResultSetHandler rsh, Object params[]);
     *     ResultSetHandler是BeanHandler它爸爸  Object params[]代表占位符？的具体值
     */
    @Test   
    public void getEmpBeanByDbUtilsBeanHandler() throws SQLException {

        QueryRunner qr = new QueryRunner(C3p0Utils.getDataSoruce());
        String sql = "select * from emp where eid = ?";
        Employee emp = qr.query(sql, new BeanHandler<Employee>(Employee.class),1);
        System.out.println(emp); //执行结果  Employee [eid=1, ename=张三, did=1]
    }
    /*
     * //获取一组对象  使用BeanListHandler
     */
    @Test  
    public void getgetEmpsBeanByDbUtilsBeanListHandler() throws SQLException {
        QueryRunner qr = new QueryRunner(C3p0Utils.getDataSoruce());
        String sql = "select * from emp";
        List<Employee> emps = qr.query(sql, new BeanListHandler<Employee>(Employee.class));
        System.out.println(emps); 
//执行结果 [Employee [eid=1, ename=张三, did=1], Employee [eid=3, ename=小红, did=1], Employee [eid=4, ename=张飞, did=2]]
    }
    /*
     *     获取对象，不用BeanHandler装对象  而用MapHandler输出对象值
     *     （注意，它输出的是一个对象，但是却不是一个Employee对象）
     *       这是为连表查询做准备
     * class MapHandler implements ResultSetHandler
     *     键是字段   值是实数据
     */
    @Test   
    public void getEmpValuesByDbUtilsMapHandler() throws SQLException {

        QueryRunner qr = new QueryRunner(C3p0Utils.getDataSoruce());
        String sql = "select * from emp where eid = ?";
            Map<String, Object> empValues = qr.query(sql, new MapHandler(),1);
            System.out.println(empValues); //并没有将值转换成一个员工对象
//            执行结果： {eid=1, ename=张三, did=1}
    }
    /*
     *     不用BeanListHandler ,而是MapListHandler
     */
    @Test   
    public void getEmpsValuesByDbUtilsMapListHandler() throws SQLException {
        QueryRunner qr = new QueryRunner(C3p0Utils.getDataSoruce());
        String sql = "select * from emp";
            List<Map<String, Object>> empsValues = qr.query(sql, new MapListHandler());
            System.out.println(empsValues); //并没有将值转换成员工对象
//执行结果[{eid=1, ename=张三, did=1}, {eid=3, ename=小红, did=1}, {eid=4, ename=张飞, did=2}]        
}
}

第四种组合：用于数据库中的连表

　1.官方驱动 　　mysql-connector-java-5.1.13-bin.jar

　2.C3p0连接池 和它的关联包  以及它的配置文件　　

　　　　c3p0-0.9.2-pre1.jar   mchange-commons-0.2.jar  c3p0-config.xml（配置文件放在src目录下）

　3.commons-dbutils-1.4.jar   Dbutils：主要是封装了JDBC的代码，简化dao层的操作。

　4.自定义工具包 和它的关联包　　　　chinasofti-tools.jar（调用了beanutils的方法）    commons-beanutils-1.8.3.jar   commons-logging-1.1.1.jar

 

　包结构：　　　

 

 

代码：

<?xml version="1.0" encoding="UTF-8" ?>
<c3p0-config>
    <default-config> 
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/db2</property>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="user">root</property>
        <property name="password">123</property>
        
        <property name="acquireIncrement">3</property>
        <property name="initialPoolSize">2</property>
        <property name="minPoolSize">2</property>
        <property name="maxPoolSize">20</property>
    </default-config>
</c

package com.jdbc.usec3p0utils;

import java.sql.Connection;
import java.sql.SQLException;

import com.mchange.v2.c3p0.ComboPooledDataSource;
/*
 * 通过c3p0jar包封装一个工具类，c3p0中有一个连接池类，通过创建连接池来获取到一个dateSource对象，通过调用这个
 * 对象的getConnection方法获取一个connection连接对象，这就是这个工具类的作用
 * 
 * 对c3p0的理解 ，就是通过c3p0-config.xml配置文件,管理对数据库的连接，实现随时取用，提高效率
 * 
 */
public class C3p0Utils {
    //C3P0连接池提供的核心类: 数据源（就是一个名词，作用是可以调用他的方法给我们一个连接对象）
    private static ComboPooledDataSource dataSource=new ComboPooledDataSource();
    
    //获取数据源
    public static ComboPooledDataSource getDataSoruce() {
        return dataSource;    
    }
    //从连接池中取用一个连接
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();
    }
    
}

package com.jdbc.entity;
/*
 *     由于有主外键，两个员工类封装的属性不一样，所以重新定义一个员工类
 */
public class EmployeeW {
    private int eid;
    private String ename;
    /*
     *     部门是主键  员工是外键  一个员工只有一个部门,
     *     一个部门可以有多个员工
     */
    private Department  dep;//我们想得到部门名称而不是 部门id，所以定义了一个部门属性
    public EmployeeW() {
    }
    public int getEid() {
        return eid;
    }
    public void setEid(int eid) {
        this.eid = eid;
    }
    public String getEname() {
        return ename;
    }
    public void setEname(String ename) {
        this.ename = ename;
    }
    public Department getDep() {
        return dep;
    }
    public void setDep(Department dep) {
        this.dep = dep;
    }
    @Override
    public String toString() {
        return "EmployeeW [eid=" + eid + ", ename=" + ename + ", dep=" + dep + "]";
    }
    
}

package com.jdbc.entity;

import java.util.List;

public class Department {
    private int did;
    private String dname;
    private List<EmployeeW> emps;
    public Department() {
    }
    public int getDid() {
        return did;
    }
    public void setDid(int did) {
        this.did = did;
    }
    public String getDname() {
        return dname;
    }
    public void setDname(String dname) {
        this.dname = dname;
    }
    public List<EmployeeW> getEmps() {
        return emps;
    }
    public void setEmp(List<EmployeeW> emps) {
        this.emps = emps;
    }
    @Override
    public String toString() {
        return "Department [did=" + did + ", dname=" + dname + ", emps=" + emps + "]";
    }
    
    
}

package com.jdbc.dbutils;

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

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.junit.Test;

import com.chinasofti.commons.CommonUtils;
import com.chinasofti.jdbc.TxQueryRunner;
import com.jdbc.entity.Department;
import com.jdbc.entity.EmployeeW;



public class UseDbUtilsAndChinaSoft {
    /*
     *     第一种 ：query(sql, new MapHandler(),1);    
     *     第二种 ：qr.query(sql, new BeanHandler<EmployeeW>(EmployeeW.class),1);
     */
    @Test
    public void getEmp() throws SQLException{
        //使用封装好的TxQueryRunner省去获取数据源的步骤
        QueryRunner qr = new TxQueryRunner();
        //连表
        String sql = "select * from emp e,dep d where e.did = d.did and e.eid =? ";
        Map<String, Object> map = qr.query(sql, new MapHandler(),1);
////        或者直接获取员工对象和部门对象org.apache.commons.dbutils.handlers.BeanHandler
//         EmployeeW emp = qr.query(sql, new BeanHandler<EmployeeW>(EmployeeW.class),1);
//        Department dep = qr.query(sql, new BeanHandler<Department>(Department.class),1);
//        emp.setDep(dep);
//        System.out.println(emp);
////        执行结果 
////        EmployeeW [eid=1, ename=张三, dep=Department [did=1, dname=财务部, emps=null]]
        /*
         *     自定义的ChinaSoft jar包中封装一个将map转化成给定对象的方法
         *     toBean方法内部调用了beanUtils的BeanUtils.populate(bean, map);
         */
        EmployeeW empbean = CommonUtils.toBean(map,EmployeeW.class);//得到一个员工对象
        Department depbean = CommonUtils.toBean(map, Department.class);//得到一个部门对象
//        把部门对象作为属性赋给员工
        empbean.setDep(depbean);
        System.out.println(empbean);//得到员工的信息
//输出结果
//        EmployeeW [eid=1, ename=张三, dep=Department [did=1, dname=财务部, emps=null]]
//            
    }
    /*
     *         获取部门信息，部门中有多少人
     */
    @Test
    public void getDep() throws SQLException{
        //使用封装好的TxQueryRunner省去获取数据源的步骤
        QueryRunner qr = new TxQueryRunner();
        String sql = "select * from dep where did =? ";
        //得到一个部门对象  用map或者bean
        Map<String, Object> map = qr.query(sql, new MapHandler(),1);
        Department depbean = CommonUtils.toBean(map, Department.class);
        String sql2  ="select * from emp where did =?";
        //得到所有员工集合 直接转成list集合,如果用maplist还要遍历list集合再把每个map转化成员工对象太麻烦
        List<EmployeeW> emps = qr.query(sql2, new BeanListHandler<EmployeeW>(EmployeeW.class),1);
        depbean.setEmp(emps);
        System.out.println(depbean);
//        执行结果
//    Department [did=1, dname=财务部, emps=[EmployeeW [eid=1, ename=张三, dep=null], EmployeeW [eid=3, ename=小红, dep=null]]]
        
        
        
        

            
    }
    
}