Java 查询的结果进行封装 实体

1.正文

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

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

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

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

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

    @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存储多条记录而每一条还是用实体类对象。

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

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

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

后缀都是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;

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

4.使用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;
    }

1. 再数据库中每张表封装了一个实体类和一个操作类。
   实体类---与表中列对应得类。
   操作类---对该表进行相应操作得类。--对表得增删改查。

2.异常处理try-catch-finally

   对该表进行操作---封装实体类 和  操作类（添加 删除  修改  查询所有  根据id查询单条记 录）。
包名: com.wmd.entity[实体类包]  com.wmd.dao[操作类包]

5.抽取一个dao的公共类的父类

5.1为什么要抽取父类

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

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

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

父类的代码

//抽取一个增删改 公共方法
    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);
    }