JDBC-Data Acess Object

//BaseDAO.java
package DAO;
import Instrument.GetConnection;
import User.CetStu;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;

/**
 * @description 一个基类里面，封装了针对不同数据表的通用操作，子类继承基类，
 * @author Vodka
 * @date 2021/07//18:01
 */

public  class  BaseDAO <T> {
//    因为是针对具体某个表的具体操作，不需要利用反射动态获取表的相应类，可以在继承时直接声明T的类，泛型方法也要改回泛型类的泛型
    private Class<T> TClass  = null;

    //1.{...}构造块，只有类建造一个对象，构造代码块就执行一次
    //2.static{...}静态构造块，建立一个对象，就只执行一次
    //3.构造块的代码放在基类里，这样不同子类继承只需要声明T的类型，不用重复写构造块，减少冗余
 {
     /*
* -Type是所有数据类型的公共高级接口，所有已知子接口：GenericArrayType, ParameterizedType, TypeVariable<D>, WildcardType
  所有已知实现类：Class
  * -注意区分Type与Class的区别，这里的Class是Type的一种，而像数组、枚举等"类型"是相对于Class来说的。
* -Type[]    getActualTypeArguments()  返回表示此类型实际类型参数的 Type 对象的数组。
*-简单来说就是：获得参数化类型中<>里的类型参数的类型。
*   因为可能有多个类型参数，例如Map<K, V>，所以返回的是一个Type[]数组。
*-注意：无论<>中有几层<>嵌套，这个方法仅仅脱去最外层的<>，
*   之后剩下的内容就作为这个方法的返回值，所以其返回值类型不一定。
*
* */
      //getGenericSuperclass()，作用是获取父类及其泛型，例子：Person<Teacher,Doctor>
     // getSuperclass(),区别是获取父类，但没有泛型参数类型 ， 例子： Person<>
     //这里的this不是BaseDAO, 是具体子类，通过具体子类获取父类的泛型参数类型数组
     Type GSC = this.getClass().getGenericSuperclass();
     //获取参数化类型中<>里的类型参数的类型数组
     Type[] TypeArgs = ((ParameterizedType)GSC).getActualTypeArguments();
    //这里只有一个泛型参数，所有只需要泛型参数数组的第一个元素即可，要类型转换
     TClass = (Class<T>) TypeArgs[0];
 }

    //考虑事务特性的增删改操作，version 2.0
    public  int UpdateTwo(Connection conn, String sql, Object...args) {
        PreparedStatement ps = null;
        int ExecuteRS = 0;
        try {
            //预编译
            ps = conn.prepareStatement(sql);
            for (int index = 0; index < args.length; index++) {
                ps.setObject(index + 1, args[index]);   //这里要注意两个变量下标起始值的不同
            }
            //执行sql语句
            /*
             *   对于ps.execute()：
             *      1.如果执行的是查询操作，查询成功就返回true
             *      2.如果执行的是增删改，失败就返回false
             *   对于ps.executeUpdate():
             *      1.执行增删改成功，就返回DML操作的行数，失败就什么都不返回
             *
             * */
            ExecuteRS = ps.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                //数据库的连接关闭交由函数外部的代码控制，这样可以保证一个事务完整性，一次连接贯穿一次事务
                GetConnection.Close(null, ps);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return ExecuteRS;
    }

    //查询函数，返回查询结果
    public List<T> TableSearch( String sql, Object... arg) {

        //这里利用反射的Class，用来动态获取具体的表的相应的类，再根据反射获得的类来创建相应的对象
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet resultSet = null;
        ArrayList<T> TList = null;
        try {

            conn = GetConnection.getConnection();
            ps = conn.prepareStatement(sql);
            //填充查询语句中的占位符
            for (int index = 0; index < arg.length; ++index) {
                ps.setObject(index + 1, arg[index]);
            }

            //执行查询操作,使用Result的实例对象来接收查询结果集
            resultSet = ps.executeQuery();
            //从结果集中获取数据库相应表的元数据（即数据类型)，以及（元数据的个数）表的列数
            ResultSetMetaData rsmd = resultSet.getMetaData();
            int ColumnNums = rsmd.getColumnCount();
            TList = new ArrayList<>();

            //遍历结果集
            while (resultSet.next()) {
                //利用泛型类直接创建的对象，代替反射的动态获取相应类再创建实例对象
                T temp = TClass.getDeclaredConstructor().newInstance();
                //遍历每一列，获取数据
                for (int index = 0; index < ColumnNums; ++index) {
                    //通过ResultSet获取每一列的值
                    Object ColumnValue = resultSet.getObject(index + 1);
                    //通过rsmd，获取相应的列名,getColumnLabel()该方法既能获取列名，也可以获取列的别名
                    String ColumnLabel = rsmd.getColumnLabel(index + 1);
                    //通过列名获取其在相应类中的属性域
                    Field field = temp.getClass().getDeclaredField(ColumnLabel);
                    field.setAccessible(true);  // 当要修改不是public的属性时，要设置为truee
                    field.set(temp, ColumnValue);
                }
                //添加到表的集合对象中
                TList.add(temp);

            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                GetConnection.CloseResource(conn, ps, resultSet);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        //返回包含所有查询对象的集合
        return TList;
    }

    //针对只返回一行查询结果的情况，如sql聚集函数的结果
    public <E> E GetOneValue(E data, Connection conn, String sql, Object...args){
        PreparedStatement ps = null;
        ResultSet rs = null;
        try{
            ps = conn.prepareStatement(sql);
            for( int index = 0 ; index < args.length; ++index){
                ps.setObject(index+1,args[index]);
            }
            rs = ps.executeQuery();
            if(rs.next()){
                return (E) rs.getObject(1); //转换成E类型的数据结果，并返回
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //当前连接不关闭，交由外部开启连接的程序关闭，这样可以避免一个事务的全部操作尚未结束，就关闭了连接的问题
            try {
                GetConnection.CloseResource(null,ps,rs);
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        return null;
    }
}

//CET表的接口
package DAO;
import User.CetStu;
import java.sql.Connection;
import java.util.Date;
import java.util.List;

/**
 * @author Vodka
 * @date 2021/07//18:11
 * @description 此接口用于规针对于CET表的通用操作
 */
public interface CET {
//      将cet对象添加到数据库中
   void InCET(Connection conn, CetStu cet);

//      根据FlowId删除记录
    void DeleteById(Connection conn,int FlowId );

    //根据内存中的cet对象，去修改表中的数据
    void update(Connection conn,CetStu cet);

//    根据FlowId 查询对应的CetStu对象
    CetStu QueryStu(Connection conn,int FlowId);

//    查询表中所有记录的集合
    List<CetStu> QueryAll(Connection conn);

//    返回数据表中总数据条数
    long NumOfTable(Connection conn);

//    返回学生中最大年龄
    Date MaxBirth(Connection conn);
}




//CETDAO.java
package Bean;
import DAO.*;
import User.*;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Date;
import java.util.List;

/**
 * @description CET表的通用操作类，继承BaseDAO,实现CET的接口，面向接口编程(继承基类的方法，重写接口的方法)
 * @author Vodka
 * @date 2021/07//15:50
 */

//继承基类的时候，要声明基类泛型类的类型
public class CetDAO extends BaseDAO<CetStu> implements CET{
    @Override
    public void InCET(Connection conn, CetStu cet) {
        String sql ;
        sql = "Insert into cet ( Species, IDCard, ExamCard, StudentName, Location, Grade , InTime ) " +
                "values(?,?,?,?,?,?,?)";
        UpdateTwo(conn,sql,cet.getSpecies(),cet.getIDCard(),cet.getExamCard(),cet.getStudentName(),
                  cet.getLocation(),cet.getGrade(),cet.getInTime());
    }

    @Override
    public void DeleteById(Connection conn, int FlowId) {
         String sql = "Delete from cet where FlowId = ?";
         UpdateTwo(conn,sql,FlowId);
    }

    @Override
    public void update(Connection conn, CetStu cet) {
         String sql = "Update cet set Species = ? , IDCard = ? , ExamCard = ? , " +
                 "StudentName, = ?  Location = ? , Grade  = ? , InTime = ? where FlowId = ?";
         UpdateTwo(conn,sql,cet.getSpecies(),cet.getIDCard(),cet.getExamCard(),cet.getStudentName(),
                 cet.getLocation(),cet.getGrade(),cet.getInTime(),cet.getFLowId());
    }

    @Override
    public CetStu QueryStu(Connection conn, int FlowId) {
        String sql = "select * from cet where FlowId = ?";
       return (CetStu) TableSearch(sql,FlowId);
    }

    @Override
    public List<CetStu> QueryAll(Connection conn) {
       String sql = "select * from cet ";
       return TableSearch(sql);
    }

    @Override
    public long NumOfTable(Connection conn) {
        String sql = "select count(*) from cet";
        long i = 0;
        return GetOneValue(i,conn,sql);
    }

    @Override
    public Date MaxBirth(Connection conn) {
        String sql = "select Max(InTime) from cet";
        Date d = null;
        return GetOneValue(d,conn,sql);
    }
}


//CetStu.java  CET表的相应类
private String IDCard;
    private String ExamCard;
    private String StudentName;
    private String Location;

    public CetStu(){
        super();
    }

    public CetStu( int species, int grade, Timestamp inTime, String IDCard, String examCard, String studentName, String location) {

        Species = species;
        Grade = grade;
        InTime = inTime;
        this.IDCard = IDCard;
        ExamCard = examCard;
        StudentName = studentName;
        Location = location;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        CetStu cetStu = (CetStu) o;
        return FLowId == cetStu.FLowId &&
                Species == cetStu.Species &&
                Grade == cetStu.Grade &&
                Objects.equals(InTime, cetStu.InTime) &&
                Objects.equals(IDCard, cetStu.IDCard) &&
                Objects.equals(ExamCard, cetStu.ExamCard) &&
                Objects.equals(StudentName, cetStu.StudentName) &&
                Objects.equals(Location, cetStu.Location);
    }

    @Override
    public int hashCode() {
        return Objects.hash(FLowId, Species, Grade, InTime, IDCard, ExamCard, StudentName, Location);
    }

    public void setFLowId(int FLowId) {
        this.FLowId = FLowId;
    }

    public void setSpecies(int species) {
        Species = species;
    }

    public void setGrade(int grade) {
        Grade = grade;
    }

    public void setInTime(Timestamp inTime) {
        InTime = inTime;
    }

    public void setIDCard(String IDCard) {
        this.IDCard = IDCard;
    }

    public void setExamCard(String examCard) {
        ExamCard = examCard;
    }

    public void setStudentName(String studentName) {
        StudentName = studentName;
    }

    public void setLocation(String location) {
        Location = location;
    }

    public int getFLowId() {
        return FLowId;
    }

    public int getSpecies() {
        return Species;
    }

    public int getGrade() {
        return Grade;
    }

    public Timestamp getInTime() {
        return InTime;
    }

    public String getIDCard() {
        return IDCard;
    }

    public String getExamCard() {
        return ExamCard;
    }

    public String getStudentName() {
        return StudentName;
    }

    public String getLocation() {
        return Location;
    }

    @Override
    public String toString() {
        return "CetStu{ " +
                "FLowId=" + FLowId +
                ", Species=" + Species +
                ", Grade=" + Grade +
                ", InTime=" + InTime +
                ", IDCard='" + IDCard + '\'' +
                ", ExamCard='" + ExamCard + '\'' +
                ", StudentName='" + StudentName + '\'' +
                ", Location='" + Location + '\'' +
                '}';
    }
}



//CET测试类，测试相应方法
import java.util.List;
/**
 * @author Vodka
 * @date 2021/07//16:31
 */
public class CetDAOTest {
    //创建一个Cet通用操作类的对象
    private  CetDAO CDAO = new CetDAO();
    //测试最大年龄
    @Test
   public void testOne(){
        Connection conn = null;
        try {
            conn = GetConnection.getConnection();
            Date date = CDAO.MaxBirth(conn);
            System.out.println(date);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                GetConnection.Close(conn,null);
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

   }

    //测试获取全部数据
    @Test
    public void testTwo(){
        Connection conn = null;
        try {
            conn = GetConnection.getConnection();
            List<CetStu> AllStu= CDAO.QueryAll(conn);
            for(CetStu cs : AllStu){
                System.out.println(cs);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }try {
            GetConnection.Close(conn,null);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    //测试插入单个数据
    @Test
    public  void testThree(){
        Connection conn = null;
        try {
            conn = GetConnection.getConnection();
            CetStu cs = new CetStu(4,561, new Timestamp(new Date().getTime()),
                    "4564","119010","时君博","广东省深圳市");
            CDAO.InCET(conn,cs);
        }catch (Exception e){
            e.printStackTrace();
        } finally {
            try {
                GetConnection.Close(conn,null);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}