Java数据库之JDBC高级使用

DAO模式

Data Access Object(数据存取对象),位于业务逻辑和持久化数据之间,实现对持久化数据的访问。

DAO模式的组成部分有DAO接口,DAO实现类,实体类的包名：entity、models、pojo、vo,数据库封装工具类

DBUtil

DBUtils是Apache组织提供的一个对JDBC进行简单封装的开源工具类库，使用它能够简化JDBC应用程序的开发，同时也不会影响程序的性能

JDBC高级使用-加入DBUtils

导入ojdbc.jar和commons-dbutils.jar

DBUtils的三大核心功能

QueryRunner类中提供对sql语句操作的API.(增,删,改,查),

ResultSetHandler接口，用于定义select操作后，怎样封装结果集

DbUtils类，它就是一个工具类,定义了关闭资源与事务处理的方法,有一个close方法,可以释放资源

在项目下的src目录下,创建abc.properties文件,并输入

a=oracle.jdbc.driver.OracleDriver
b=jdbc:oracle:thin:@localhost:1521:orcl
c=raoweijia
d=123

在项目下的src目录下,创建tools目录,然后在此目录下创建DB.class(DbUtils类),并输入

  package tools;

  import java.io.IOException;
  import java.io.InputStream;
  import java.sql.*;
  import java.util.Properties;

  public class DB {
    public Connection conn = null;
    public PreparedStatement ps = null;
    public ResultSet rs = null;

    static String driver = null;
    static String url = null;
    static String name = null;
    static String pwd = null;

    //在调用方法之前，就将四个变量赋值
    //在一个类中，静态代码块具有最高的执行优先级（当类加载时）
    static {
        //1.读取abc.properties配置文件（加载到jvm中）
        //解决：将配置文件读取到jvm中，并以流的形式返回 （配置文件中所有的数据放在流中）
        InputStream is = DB.class.getClassLoader().getResourceAsStream("abc.properties");
        //2.创建解析对象（专门解读 .properties文件的类）
        Properties pp = new Properties();
        try {
            //3.将流中的数据加载到pp对象中
            pp.load(is);
            //4.从pp对象中获得参数值
            driver = pp.getProperty("a");
            url = pp.getProperty("b");
            name = pp.getProperty("c");
            pwd = pp.getProperty("d");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void getConn() {
        try {
            Class.forName(driver);
            conn = DriverManager.getConnection(url, name, pwd);
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }
    }

    public void close() {
        try {
            if (rs != null) {
                rs.close();
            }
            if (ps != null) {
                ps.close();
            }
            if (conn != null) {
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

在项目下的src目录下,创建models目录,然后在此目录下创建Student.class(与数据库的表对应),并输入

package models;

public class Student {
  //成员变量==列
  private String id;
  private String name;
  private String grade;
  private int age;

  public Student(String id, String name, int age, String grade) {
      this.id = id;
      this.name = name;
      this.grade = grade;
      this.age = age;
  }

  public Student() {
  }

  public String getId() {
      return id;
  }
  public void setId(String id) {
      this.id = id;
  }

  public String getName() {
      return name;
  }
  public void setName(String name) {
      this.name = name;
  }

  public String getGrade() {
      return grade;
  }
  public void setGrade(String grade) {
      this.grade = grade;
  }

  public int getAge() {
      return age;
  }
  public void setAge(int age) {
      this.age = age;
  }

  @Override
  public String toString() {
      return "Student{" +
              "id='" + id + '\'' +
              ", name='" + name + '\'' +
              ", grade='" + grade + '\'' +
              ", age=" + age +
              '}';
  }
}

在项目下的src目录下,创建dao目录,然后在此目录下创建StudentDao接口,并输入

package dao;

import models.Student;
import java.util.List;
import java.util.Map;

public interface StudentDao {

    //使用基础的jdbc查询全部科目
    List<Student> getAllStudent_jdbc();

    //使用jdbc+dbutils
    // 使用BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。
    List<Student> getAllStudent_dbutil();

    //使用BeanHandler：将结果集中的第一行数据封装到一个对应的JavaBean实例中。
    Student getAllStudentFirst_dbutil(String str);

    //ArrayHandler：把结果集中的第一行数据转成对象数组。
    Object[] getAllStudentFirstToObject_dbutil(String str);

    //ArrayListHandler：把结果集中的每一行数据都转成一个对象数组，再存放到List中。
    List<Object[]> getAllStudentToObject_dbutil(String str);

    //MapHandler：将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值。
    Map<String, Object> getAllStudentFirstToMap_dbutil(String str);

    // MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后再存放到List。
    List<Map<String, Object>> getAllStudentToMap_dbutil(String str);

    // ScalarHandler：将结果集中第一条记录的其中某一列的数据存成Object。
    Object getAllStudentFirstOneColumnToObject(String str);

    //ColumnListHandler：将结果集中某一列的数据存放到List中。
    List<Object> getAllStudentOneColumnToObject(String str);

    //KeyedHandler：将结果集中的每一行数据都封装到一个Map里，然后再根据指定的key把每个Map再存放到一个Map里。
    Map<Object, Map<String, Object>> getAllStudentToMapToMap(String str);

    //采用dbutil增加数据
    int insert_dbutil(Student stu);

    //采用dbutil删除数据
    int delete_dbutil(String id);

    //采用dbutil修改数据
    int update_dbutil(String id,String name,int age);
}

进入项目下的src/dao,然后在此目录下创建StudentDaoImpl.class继承DB.class实现StudentDao接口,并输入

package dao.impl;

import dao.StudentDao;
import models.Student;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.*;
import tools.DB;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class StudentDaoImpl extends DB implements StudentDao {
    //使用基础的jdbc查询全部科目
    @Override
    public List<Student> getAllStudent_jdbc() {
        List<Student> list = new ArrayList<Student>();
        String sql = "select * from student";
        getConn();
        try {
            ps = conn.prepareStatement(sql);
            rs = ps.executeQuery();
            while (rs.next()) {
                Student s = new Student();
                s.setId(rs.getString(1));
                s.setName(rs.getString(2));
                s.setAge(rs.getInt(3));
                s.setGrade(rs.getString(4));
                list.add(s);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            close();
        }
        return list;
    }

    //使用jdbc+dbutils
    // 使用BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。
    @Override
    public List<Student> getAllStudent_dbutil() {
        List<Student> list = null;
        String sql = "select * from student";
        QueryRunner q = new QueryRunner();
        getConn();
        try {
            list = q.query(conn, sql,new BeanListHandler<Student>(Student.class));
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            try {
                DbUtils.close(conn);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return list;
    }

    //使用BeanHandler：将结果集中的第一行数据封装到一个对应的JavaBean实例中。
    @Override
    public Student getAllStudentFirst_dbutil(String str){
        Student stu =new Student();
        String sql = "select * from student where id like ?";
        QueryRunner q = new QueryRunner();
        getConn();
        try {
            stu = q.query(conn, sql,new BeanHandler<Student>(Student.class),str);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            try {
                DbUtils.close(conn);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return stu;
    }

    //ArrayHandler：把结果集中的第一行数据转成对象数组。
    @Override
    public Object[] getAllStudentFirstToObject_dbutil(String str){
        Object[] stu =null;
        String sql = "select * from student where id like ?";
        QueryRunner q = new QueryRunner();
        getConn();
        try {
            stu = q.query(conn, sql,new ArrayHandler(),str);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            try {
                DbUtils.close(conn);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return stu;
    }

    //ArrayListHandler：把结果集中的每一行数据都转成一个对象数组，再存放到List中。
    @Override
    public List<Object[]> getAllStudentToObject_dbutil(String str){
        List<Object[]> stu =null;
        String sql = "select * from student where id like ?";
        QueryRunner q = new QueryRunner();
        getConn();
        try {
            stu = q.query(conn, sql,new ArrayListHandler(),str);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            try {
                DbUtils.close(conn);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return stu;
    }

    //MapHandler：将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值。
    @Override
    public Map<String, Object> getAllStudentFirstToMap_dbutil(String str){
        Map<String, Object> stu =null;
        String sql = "select * from student where id like ?";
        QueryRunner q = new QueryRunner();
        getConn();
        try {
            stu = q.query(conn, sql,new MapHandler(),str);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            try {
                DbUtils.close(conn);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return stu;
    }

    // MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后再存放到List。
    @Override
    public List<Map<String, Object>> getAllStudentToMap_dbutil(String str){
        List<Map<String, Object>> stu =null;
        String sql = "select * from student where id like ?";
        QueryRunner q = new QueryRunner();
        getConn();
        try {
            stu = q.query(conn, sql,new MapListHandler(),str);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            try {
                DbUtils.close(conn);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return stu;
    }

    // ScalarHandler：将结果集中第一条记录的其中某一列的数据存成Object。
    @Override
    public Object getAllStudentFirstOneColumnToObject(String str){
        Object stu = new Object();
        String sql = "select * from student where id like ?";
        QueryRunner q = new QueryRunner();
        getConn();
        try {
            stu = q.query(conn, sql,new ScalarHandler("name"),str);//可以指定第几列或列名，默认是第一列
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            try {
                DbUtils.close(conn);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return stu;
    }

    //ColumnListHandler：将结果集中某一列的数据存放到List中。
    @Override
    public List<Object> getAllStudentOneColumnToObject(String str){
        List<Object> stu = null;
        String sql = "select * from student where id like ?";
        QueryRunner q = new QueryRunner();
        getConn();
        try {
            stu = q.query(conn,sql, new ColumnListHandler<>(2),str); //可以指定第几列或列名，默认是第一列
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            try {
                DbUtils.close(conn);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return stu;
    }

    //KeyedHandler：将结果集中的每一行数据都封装到一个Map里，然后再根据指定的key把每个Map再存放到一个Map里。
    @Override
    public Map<Object, Map<String, Object>> getAllStudentToMapToMap(String str){
        Map<Object, Map<String, Object>> stu = null;
        String sql = "select * from student where id like ?";
        QueryRunner q = new QueryRunner();
        getConn();
        try {
            stu = q.query(conn,sql, new KeyedHandler<>(2),str); //可以指定第几列或列名当作key，默认是第一列
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            try {
                DbUtils.close(conn);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        return stu;
    }

    //采用dbutil增加数据
    @Override
    public int insert_dbutil(Student stu){
        String sql = "insert into student values (?,?,?,?)";
        int aba = -1;
        QueryRunner q = new QueryRunner();
        getConn();
        try {
            aba = q.update(conn, sql,stu.getId(),stu.getName(),stu.getAge(),stu.getGrade());
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            try {
                DbUtils.close(conn);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return aba;
    }

    //采用dbutil删除数据
    @Override
    public  int delete_dbutil(String id){
        String sql = "delete from student where id = ?";
        int aba = -1;
        QueryRunner q = new QueryRunner();
        getConn();
        try {
            aba = q.update(conn, sql,id);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            try {
                DbUtils.close(conn);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return aba;
    }

    //采用dbutil修改数据
    @Override
    public int update_dbutil(String id,String name,int age){
        String sql = "update student set name=?,age=? where id = ?";
        int aba = -1;
        QueryRunner q = new QueryRunner();
        getConn();
        try {
            aba = q.update(conn, sql,name,age,id);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            try {
                DbUtils.close(conn);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return aba;
    }
}

进入项目下的src目录,创建test目录,然后在此目录下创建Test.class,并输入

package test;

import dao.StudentDao;
import dao.impl.StudentDaoImpl;
import models.Student;
import java.util.List;
import java.util.Map;

public class Test {
    public static void main(String[] args) {
        StudentDao sd = new StudentDaoImpl();

        //使用基础的jdbc查询全部科目
        List<Student> list = sd.getAllStudent_jdbc();
        list.forEach( stu -> System.out.println( stu ) );
        System.out.println("-----------------------------------------------");

        //使用jdbc+dbutils
        // 使用BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。
        List<Student> list1 = sd.getAllStudent_dbutil();
        list1.forEach( stu -> System.out.println( stu ) );

        //采用dbutil增加数据
        /*Student stu = new Student("1004","xsad",10,"6");
        int a = sd.insert_dbutil(stu);
        System.out.println(a);*/
        System.out.println("-----------------------------------------------");

        //使用BeanHandler：将结果集中的第一行数据封装到一个对应的JavaBean实例中。
        /*Student stu = new Student();
        stu = sd.getAllStudentFirst_dbutil("10%");
        System.out.println(stu);*/

        //ArrayHandler：把结果集中的第一行数据转成对象数组。
        /*Object[] obj = sd.getAllStudentFirstToObject_dbutil("10%");
        System.out.println(Arrays.toString(obj));*/

        //ArrayListHandler：把结果集中的每一行数据都转成一个对象数组，再存放到List中。
        /*List<Object[]> obj = sd.getAllStudentToObject_dbutil("10%");
        obj.forEach( stu -> System.out.println(Arrays.toString(stu)));
        System.out.println(Arrays.deepToString(obj.toArray()));*/

        //MapHandler：将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值。
        /*Map<String, Object> mp = sd.getAllStudentFirstToMap_dbutil("10%");
        System.out.println(mp);*/

        // MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后再存放到List。
        /*List<Map<String, Object>> mp = sd.getAllStudentToMap_dbutil("10%");
        mp.forEach( stu -> System.out.println( stu ) );*/

        // ScalarHandler：将结果集中第一条记录的其中某一列的数据存成Object。
        /*Object obj1 = sd.getAllStudentFirstOneColumnToObject("10%");
        System.out.println(obj1);*/

        //ColumnListHandler：将结果集中某一列的数据存放到List中。
        List<Object> obj1 = sd.getAllStudentOneColumnToObject("10%");
        System.out.println(obj1);

        //KeyedHandler：将结果集中的每一行数据都封装到一个Map里，然后再根据指定的key把每个Map再存放到一个Map里。
        Map<Object, Map<String, Object>> mtm = sd.getAllStudentToMapToMap("10%");
        System.out.println(mtm);

        //采用dbutil增加数据
        /*int b = sd.delete_dbutil("1004");
        System.out.println(b);*/

        //采用dbutil增加数据
        /*int c = sd.update_dbutil("1002","dsdd0",11);
        System.out.println(c);*/
        System.out.println("-----------------------------------------------");
    }
}

QueryRunner类对数据库的操作

ResultSetHandler接口的各个子类

ArrayHandler：把结果集中的第一行数据转成对象数组。

ArrayListHandler：把结果集中的每一行数据都转成一个对象数组，再存放到List中。

BeanHandler：将结果集中的第一行数据封装到一个对应的JavaBean实例中。

BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。

ColumnListHandler：将结果集中某一列的数据存放到List中。

KeyedHandler：将结果集中的每一行数据都封装到一个Map里，然后再根据指定的key把每个Map再存放到一个Map里。

MapHandler：将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值。

MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后再存放到List。

ScalarHandler：将结果集中某一条记录的其中某一列的数据存成Object。