jdbc封装一个父类减少代码重复

1. 回顾

1. jdbc--查询功能。
2. sql注入的安全问题解决方案.
   (1)加载驱动:Class.forName("mysql驱动名称");
   (2)获取连接对象:Connection conn=DriverManager.getConnection(url,u,pass);
   (3)获取执行sql语句的对象:
      PreparedStatement ps=conn.prepareStatement(sql);//预编译sql
   (4)为占位符赋值
      ps.setXXX(index,value); //index:表示占位符的索引。value:表示占位符的值
   (5)执行sql语句。
       ps.executeUpdate();//执行增删改的sql
       ResultSet rs=ps.executeQuery();//执行查询的sql
   (6)遍历ResultSet中的内容.
       while(rs.next()){ //判断指针是否可以移动，如果可以移动则移动到下一行记录
            rs.getXXX("列名"); //获取当前行的指定列的值。
       }

2. 正文

1. 把查询的结果封装到相应的实体上。
2. 把对每一张表的操作封装到相应的类上。
3. 抽象操作类的公共父类。

3.把查询的结果封装到相应的实体上。

注意: 我们这里把查询的结果直接输出到控制台了，而实际开发中，我们需要把查询的结果展示到浏览器网页上，效果如下

 如何把查询的结果封装起来。

1. 把数据库中每张表封装成一个类---简称实体类。
2. 把表中的列封装成实体类中的属性。
3. 表中的每条记录封装成实体类的对象。
4. 表中多条记录封装成集合ArrayList。

public class User {
    private int id;
    private String name;
    private String password;

    public User() {
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public User(int id, String name, String password) {
        this.id = id;
        this.name = name;
        this.password = password;
    }
}

@Test

    public void testSelect() throws Exception {
        Class.forName("com.mysql.cj.jdbc.Driver");
        String url = "jdbc:mysql://localhost:3306/mydb?serverTimezone=Asia/Shanghai";
        String user = "root";
        String password = "root";
        Connection connection = DriverManager.getConnection(url, user, password);
        String sql = "select * from tb_dept"; //因为这里没有占位符 所以可以不用为占位符赋值
        PreparedStatement ps= connection.prepareStatement(sql);
        ResultSet rs = ps.executeQuery();
​
        List<Dept> list = new ArrayList<>(); //集合存放数据库表中所有记录
        while (rs.next()){
            int id = rs.getInt("id");
            String name = rs.getString("name");
            //创建一个实体类对象 存储表中的一条记录。
            Dept d = new Dept();
            d.setId(id);
            d.setName(name);
​
            list.add(d);
        }
        System.out.println(list); //正常再开发中应该把该对象list返回给前端。
    }

    @Test
    public void testSelectOne() throws Exception{
        Class.forName("com.mysql.cj.jdbc.Driver");
        String url = "jdbc:mysql://localhost:3306/mydb?serverTimezone=Asia/Shanghai";
        String user = "root";
        String password = "root";
        Connection connection = DriverManager.getConnection(url, user, password);
        String sql = "select * from tb_dept where id=?"; //这里根据id查询的结果一定是一条记录。因为id是主键。
        PreparedStatement ps= connection.prepareStatement(sql);
        ps.setInt(1,9);
​
        ResultSet rs = ps.executeQuery();
        Dept d=null;//声明部门实体类对象。
        while (rs.next()){
            d =  new Dept(); //因为进入该语句表示从数据库中查询到相应的记录了。
            int id = rs.getInt("id");
            String name = rs.getString("name");
            d.setId(id);
            d.setName(name);
        }
​
        System.out.println(d); //以后可以把d返回给前端调用者
​
    }

如果查询的结果为多条记录使用ArrayList存储多条记录而每一条还是用实体类对象。

如果查询的结果确定为一条，直接使用实体类。

4. 把对每一张表的操作封装到相应的类上。

思考: 我们如果把所有表的操作都写在一个类中，那么该类的代码会变得越来越容重，对应后期维护也不方便，真正再企业开发时我们会对每张表得操作都封装一个对应得操作类。

后缀都是Dao -----Data access Object 数据访问对象层

tb_dept 对应一个操作类 DeptDao该操作类中包含所有对tb_dept表得增删改查得操作。

tb_student 对应一个操作 StudentDao


package com.ykq.dao;
​
import com.ykq.entity.Dept;
​
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
​
/**
 * @program: jdbc03
 * @description:
 * @author: 闫克起2
 * @create: 2022-05-06 14:56
 * //专门对tb_dept表操作得类。
 **/
public class DeptDao {
​        
    private String driverName="com.mysql.cj.jdbc.Driver";
    private String url="jdbc:mysql://localhost:3306/mydb?serverTimezone=Asia/Shanghai";
    private String user="root";
    private String password="root";
​
    //根据id查询部门信息
    public Dept findOne(int id) throws Exception{
        Class.forName(driverName);
        Connection connection = DriverManager.getConnection(url, user, password);
        String sql = "select * from tb_dept where id=?"; //这里根据id查询的结果一定是一条记录。因为id是主键。
        PreparedStatement ps= connection.prepareStatement(sql);
        ps.setInt(1,id);
​
        ResultSet rs = ps.executeQuery();
        Dept d=null;//声明部门实体类对象。
        while (rs.next()){
            d =  new Dept(); //因为进入该语句表示从数据库中查询到相应的记录了。
            d.setId(rs.getInt("id"));
            d.setName(rs.getString("name"));
        }
        return d;
    }
​
    //查询操作--查询所有
    public List<Dept> findAll() throws Exception{
        List<Dept> list=new ArrayList<>();
        Class.forName(driverName);
        Connection connection = DriverManager.getConnection(url,user,password);
        String sql= "select * from tb_dept";
        PreparedStatement ps=connection.prepareStatement(sql);
        ResultSet rs = ps.executeQuery();
​
        while (rs.next()){
            //创建一个实体类对象 存储表中的一条记录。
            Dept d = new Dept();
            d.setId(rs.getInt("id"));
            d.setName(rs.getString("name"));
            list.add(d);
        }
        return list;
    }
​
    //增加操作--要不要传递参数
    public void insertDept(Dept dept) throws Exception{ //把前端输入得部门信息封装到相应得实体类。
        Class.forName(driverName);
        Connection connection = DriverManager.getConnection(url,user,password);
        String sql = "insert into tb_dept values(null,?)";
        PreparedStatement ps = connection.prepareStatement(sql);
        ps.setObject(1,dept.getName());
        ps.executeUpdate();
    }
​
    //删除操作--根据id删除
    public void delete(int id)throws Exception{
        Class.forName(driverName);
        Connection connection = DriverManager.getConnection(url,user,password);
        String sql = "delete from tb_dept where id=?";
        PreparedStatement ps = connection.prepareStatement(sql);
        ps.setObject(1,id);
        ps.executeUpdate();
    }
}

5. 使用try-catch-finally来处理异常

 //查询操作--查询所有
    public List<Dept> findAll() {
        List<Dept> list = new ArrayList<>();
        try {
            Class.forName(driverName);
            connection = DriverManager.getConnection(url, user, password);
            String sql = "select * from tb_dept";
            ps = connection.prepareStatement(sql);
            rs = ps.executeQuery();
            while (rs.next()) {
                //创建一个实体类对象 存储表中的一条记录。
                Dept d = new Dept();
                d.setId(rs.getInt("id"));
                d.setName(rs.getString("name"));
                list.add(d);
            }
        } catch (Exception exception) {
            exception.printStackTrace();
        } finally {
            try {
                if(rs!=null){
                     rs.close();
                }
                if(ps!=null){
                     ps.close();
                }
                if(connection!=null){
                     connection.close();
                }
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        return list;
    }

6.抽取一个dao的公共的父类。

        为什么要抽取父类。

因为我们对每一张表都封装了一个操作类，那么再数据库中有很多表，那么我们就会有很多操作类，这些操作类都有一些公共的代码，为了减少代码的冗余，我们就抽取了一个父类。

package com.ykq.dao;
​
import java.sql.*;
​
/**
 * @program: jdbc03
 * @description:
 * @author: 闫克起2
 * @create: 2022-05-07 14:08
 * 该类就是一个父类。该类中包含子类中一些公共的属性和方法。
 **/
public class BaseDao {
    //公共属性
    private String driverName = "com.mysql.cj.jdbc.Driver";
    private String url = "jdbc:mysql://localhost:3306/mydb?serverTimezone=Asia/Shanghai";
    private String user = "root";
    private String password = "root";
    protected PreparedStatement ps = null;  //protected同包以及不同包下的子类都可以使用该修饰符修饰的成员
    protected Connection connection = null;
    protected ResultSet rs = null;
​
    //获取连接对象。
    public Connection getConn() throws Exception { //这里要处理异常还是抛出异常。
        Class.forName(driverName);
        connection = DriverManager.getConnection(url, user, password);
        return connection;
    }
    //关闭资源的方法。
    public void closeAll(){
        try {
            if(rs!=null){ //判断是否为空
                rs.close();
            }
            if(ps!=null){
                ps.close();
            }
            if(connection!=null){
                connection.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
​

 为添加 删除 修改抽取公共的方法。

父类的代码

//抽取一个增删改 公共方法
    public void edit(String sql,Object... params){
        try {
            connection = getConn();
            //意外
            ps = connection.prepareStatement(sql);
            //为占位符赋值
            for(int i=0;i<params.length;i++){
                ps.setObject(i+1, params[i]);
            }
            ps.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeAll();
        }
    }
 

 

子类的代码

 //增加操作--要不要传递参数
    public void insertDept(Dept dept) { //把前端输入得部门信息封装到相应得实体类。
        String sql = "insert into tb_dept values(null,?,?)";
        edit(sql,dept.getName(),dept.getAddress());
    }
​
    //删除操作--根据id删除
    public void delete(int id) {
        String sql = "delete from tb_dept where id=?";
        edit(sql,id);
    }
 

测试类的代码

 EmpDao empDao=new EmpDao();
    @Test
    public void add(){
        Emp emp=new Emp();
        emp.setName("第三方");
        emp.setAddress("df");
        empDao.add(emp);
    }
    @Test
    public void remove(){
        empDao.remove(22);
    }
    @Test
    public void update(){
        Emp emp=new Emp();
        emp.setName("电风扇");
        emp.setAddress("电饭锅 ");
        emp.setId(18);
        empDao.update(emp);
    }
    @Test
    public void query(){
        List<Emp> list= empDao.query();
        for (Emp e:list) {
            System.out.println(e);
        }

    }