JDBC封装增删改查操作完整详解版_利用反射封装jdbc

对增删改查的封装，只需要把一个对象当做参数转入方法即可，这样就可以随时在有需要的时候调用到工具封装类的增删改查方法了~

前面我们已经有工具类对JDBC增删改查通用方法进行了封装，数据库配置信息从配置文件中获取步骤可以回顾：https://blog.csdn.net/qq_51444577/article/details/118278234

/** 
封装工具类 
*/
public class BaseUtil {


    /**
    数据库配置信息从配置文件中获取
   连接数据库方法
   */
 public static Connection linked() {
        //加载数据库信息配置
        Properties pro=new Properties();
        InputStream is=BaseUtil.class.getClassLoader().getResourceAsStream("Data.properties");
        Connection conn=null;
        try {
            //从输入流中读取属性列表
            pro.load(is);
            //加载驱动
            Class.forName(pro.getProperty("driver"));
            //建立数据库连接
            conn= DriverManager.getConnection(pro.getProperty("url"),pro.getProperty("username"),pro.getProperty("password"));
        }catch (Exception e){
            e.printStackTrace();
        }
        return conn;
    }


    /*
    关闭数据库方法
     */
    public static void close(ResultSet rs, PreparedStatement stem, Connection conn){
        try {
            if(null!=rs)rs.close();
        }catch (Exception e){
            e.printStackTrace();
        }

        try {
            if(null!=stem)stem.close();
        }catch (Exception e){
            e.printStackTrace();
        }

        try {
            if(null!=conn)conn.close();
        }catch ( Exception e){
            e.printStackTrace();
        }
    }


    /**
     *  //增、删、改的操作，Object...param表示此参数可填可不填，是任意的
     */
    public int exceuteUpdate(String preparedSql,Object ... param){
        Connection conn=BaseUtil.linked();
        PreparedStatement pre=null;
        int num=0;
        try {
            pre = conn.prepareStatement(preparedSql);
            if (null != param){
                for (int i=0;i<param.length;i++){
                    //为预编译sql设置参数
                    pre.setObject(i+1,param[i]);
                }
            }
            num=pre.executeUpdate();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            BaseUtil.close(null,pre,conn);
        }
        return num;
    }


    /**
     * 新增表中所有列数据方法
     * @param obj
     * @return
     */
    public  boolean add(Object obj){
        //获得连接
        Connection conn= BaseUtil.linked();
        PreparedStatement ps=null;

        //getClass()获取传进来的对象的Java类（全限定类名 如：cn.daling.jdbc.Demo）
        Class cls=obj.getClass();

        //getSimpleName()获取到类名值，类名=表名
        String tableName=cls.getSimpleName();

        //拼接sql语句，开头
        String sql=String.format("insert into %s(",tableName);

        //得到这个类的所有属性(属性领域)
        Field[] fields=cls.getDeclaredFields();
        //循环属性
        for (int i = 0; i < fields.length; i++) {
            //取出当前下标属性
            Field field=fields[i];

       //设置访问权限，默认为false只能对public修饰的操作，设置true可对private修饰的操作         
            field.setAccessible(true);

            //getName()获取属性名字
            String fieldName=field.getName();
            sql+=fieldName+",";
        }
        //去掉最后一个的属性后面接的逗号
        sql=sql.substring(0, sql.length()-1);

        //继续拼接value值部分占位符
        sql += ") values (";
        for (int i = 0; i < fields.length; i++) {
            sql+="?,";
        }
        sql = sql.substring(0,sql.length()-1);
        sql += ")";

        try{
            //获取执行对象
            ps=conn.prepareStatement(sql);

            //给sql语句参数赋值
            for (int i = 0; i < fields.length; i++) {
                Field field=fields[i]; //取出当前下标属性
                field.setAccessible(true); //打开访问权限,设置true可对private修饰的操作
                Object fieldVal=field.get(obj);//从传进来的对象obj中取出当前字段的值
                ps.setObject((i+1),fieldVal);
            }
            //执行sql
            return ps.executeUpdate()>0;
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //关闭连接
            BaseUtil.close(null,ps,conn);
        }
        System.out.println(sql);
        return false;
    }


    /**
     *默认第一个属性为主键，根据主键删除方法
     * @param obj
     * @return
     */
    public static boolean delByPrimaryKey(Object obj){
        Connection conn= BaseUtil.linked();
        PreparedStatement ps=null;
        Class cls=obj.getClass();  //获取传进来的对象的Java类
        String tableName=cls.getSimpleName(); //获取到类名值
        StringBuffer sb=new StringBuffer("delete from ");
        sb.append(tableName).append(" where ");
        Field [] field=cls.getDeclaredFields(); //获取这个类的属性领域
        field[0].setAccessible(true); //设置第一个属性的可访问性
        sb.append(field[0].getName()).append("=?");//获取第一个属性的属性名构造删除sql
        String sql= sb.toString();
        try {
            ps=conn.prepareStatement(sql);
            field[0].setAccessible(true);
            ps.setObject(1,field[0].get(obj));//从传进来的对象obj中取出第一属性字段的值
            return ps.executeUpdate()>0;
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            BaseUtil.close(null,ps,conn);
        }
        System.out.println(sb.toString());
        return false;
    }


    /**
     * 默认第一个属性为主键，根据主键对指定列(在调用时给哪列赋值就修改哪列值)进行修改
     * @param obj
     * @return
     */
    public static boolean updateByprimaryKey(Object obj) {
        Connection conn = BaseUtil.linked();
        PreparedStatement ps = null;
        Class cls = obj.getClass(); //获取传进来的对象的Java类
        String tableName = cls.getSimpleName();  //获取到类名值
        Field [] fields=cls.getDeclaredFields();  //获取这个类的属性领域
        try {
            String sql = String.format("update %S set ",tableName);
            for (int i = 1; i < fields.length; i++) {
                Field field = fields[i]; 
                field.setAccessible(true); //打开访问权限,设置true可对private修饰的操作
                Object fieldVal=field.get(obj); //从传进来的对象obj中取出当前字段的值

 //如果可以获取到所传进来对象的当前字段值，说明当前字段以赋值，获取当前属性的属性名构造修改sql语句
                if(null!=fieldVal){ 
                    sql+=field.getName()+"=?,";
                }
            } 

           //去掉所拼接的sql最后一个逗号
            sql=sql.substring(0,sql.length()-1);
            fields[0].setAccessible(true); //设置第一个属性的可访问性

            //从传进来的对象obj中取出第一属性字段的值
            sql+=" where "+fields[0].getName()+"="+fields[0].get(obj); 
            ps=conn.prepareStatement(sql);

            int j=0;
            for (int i = 1; i <fields.length ; i++) { //循环所有属性
                Field field = fields[i];
                field.setAccessible(true);
                Object fieldVal=field.get(obj); //从传进来的对象obj中取出当前字段的值
                if(null!=fieldVal){  
 //如果可以获取到所传进来对象的当前字段值，说明当前字段以赋值，获取当前属性的属性值作为所获参数列的值
                    j++;
                    ps.setObject(j,fieldVal);
                }
            }
            return ps.executeUpdate()>0;
        }catch(Exception e){
            e.printStackTrace();
        } finally{
            BaseUtil.close(null,ps,conn);
        }
        return false;
    }


//查询操作不需要传入一个对象，只需要一个类的Class就可以
    /**
     * 查询指定表所有数据
     * @param cls
     * @param <E>
     * @return
     */
    public static <E> List<E> findAll(Class<E> cls){
        List<E> list=new ArrayList<E>(); //通过反射获取类名对应表名构造SQL语句
        Connection conn=BaseUtil.linked(); //存储查询结果
        PreparedStatement ps=null;
        ResultSet rs=null;
        Field[] field = cls.getDeclaredFields(); //通过反射获取所有属性         
        String sql=String.format("select * from %s",cls.getSimpleName());
        try {
            ps=conn.prepareStatement(sql);
            rs=ps.executeQuery();
            while (rs.next()){
                E obj= cls.newInstance(); //通过反射构造一个E类型的实例
                for (int i = 0; i < field.length; i++) {
                    field[i].setAccessible(true); //设置属性的可访问性(可以访问私有属性)

                  //通过属性名获取结果集中的值赋值到实例对象中
                    field[i].set(obj,rs.getObject(field[i].getName()));
                }
                list.add(obj); //将实例对象添加到list集合
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            BaseUtil.close(rs,ps,conn);
        }
        return list;
    }


    /**
     * 默认第一个属性为主键，根据主键查询单条数据
     * @param obj
     * @return
     */
     public static Object findByprimaryKey(Object obj){
     Class cls=obj.getClass();
     String tableName=cls.getSimpleName();
     Field[] field = cls.getDeclaredFields();

     Connection conn=BaseUtil.linked();
     PreparedStatement ps=null;
     ResultSet rs=null;
     try {
     field[0].setAccessible(true);
     String sql=String.format("select * from %s where %s=?",tableName,field[0].getName());
     ps=conn.prepareStatement(sql);
     ps.setObject(1,field[0].get(obj));
     rs=ps.executeQuery();
     if (rs.next()){
     Object a= cls.newInstance();
     for (int i = 0; i < field.length; i++) {
     field[i].setAccessible(true);
     field[i].set(a,rs.getObject(field[i].getName()));
     }
     return a;
     }
     } catch (Exception e) {
     e.printStackTrace();
     } finally {
     BaseUtil.close(rs,ps,conn);
     }
     return null;
     }
}