JAVA原生JDBC JDBC-PLUS 1.0.0 JDBC辅助包

浩奕染

已于 2024-03-21 09:14:12 修改

阅读量531

点赞数 10

分类专栏： JDBC JDBC辅助包初学者文章标签： java maven log4j servlet tomcat

于 2024-03-20 12:04:18 首次发布

本文链接：https://blog.csdn.net/qq_56432476/article/details/136872052

版权

JDBC 同时被 3 个专栏收录

1 篇文章 0 订阅

订阅专栏

JDBC辅助包

1 篇文章 0 订阅

订阅专栏

初学者

1 篇文章 0 订阅

订阅专栏

以下是我们原先的JDBC工具包，操作过于繁琐，重点是居然要自己写SQL！太违背程序员偷懒的习惯了！

package org.example.util;


import com.sun.org.slf4j.internal.Logger;
import com.sun.org.slf4j.internal.LoggerFactory;

import java.sql.*;

/**对数据库中表的操作
 * @author 方笔山
 * @date 2023-12-4 10 : 04
 */
public class BaseUtil {
    private static final Logger log = LoggerFactory.getLogger(BaseUtil.class);
    private static final String DRIVER = "com.mysql.cj.jdbc.Driver";
    private static final String URL = "jdbc:mysql://127.0.0.1:3306/sys?serverTimezone=GMT%2b8&useSSL=false&max_connections=150";
    private static final String USERNAME = "root";
    private static final String PASSWORD = "123456";

    private Connection conn = null;
    private PreparedStatement prs = null;

    public void getConnection() {
        try {
            Class.forName(DRIVER);
            conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            log.error("驱动没有找到，请确认是否导入驱动包.", e);
        } catch (SQLException e) {
            e.printStackTrace();
            log.error("连接数据库失败，请确认是否数据库已经打开，或者数据库连接地址是否正确.");
        }
    }

    /**
     * 删除、新增
     * @param sql     insert into student(name,age) values(?,?)
     * @param objects ...动态参数
     * @return int 返回账号Id
     */
    public int executeUpdate(String sql, Object... objects) throws SQLException {
        try {
            getConnection();
            prs = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            for (int i = 0; i < objects.length; i++) {
                prs.setObject(i + 1, objects[i]);
            }
            System.out.println(prs);
            prs.executeUpdate();
            ResultSet rs = prs.getGeneratedKeys();
            if (rs.next()) {
                // 返回插入的 ID
                return rs.getInt(1);
            } else {
                System.out.println("获取插入的 ID 失败");
            }
        } catch (SQLSyntaxErrorException e) {
            e.printStackTrace();
            throw new SQLException("SQL语法错误", e);
        } catch (SQLException e) {
            e.printStackTrace();
            log.error("SQL执行失败",e);
        } finally {
            this.close(null);
        }
        return 0;
    }

    /**
     * 查询、修改
     * @param sql SQL语句
     * @param objects 参数
     * @return 返回ResultSet
     */
    public ResultSet executeQuery(String sql, Object... objects) throws SQLException {
        try {
            getConnection();
            prs = conn.prepareStatement(sql);
            for (int i = 0; i < objects.length; i++) {
                prs.setObject(i + 1, objects[i]);
            }
            System.out.println(prs);
            return prs.executeQuery();
        } catch (SQLSyntaxErrorException e) {
            e.printStackTrace();
            throw new SQLException("SQL语法错误", e);
        } catch (SQLException e) {
            e.printStackTrace();
            log.error("SQL执行失败",e);
        }
        // 默认返回值，如果以上代码都没有返回结果集，则返回 null
        return null;
    }

    /**
     * 关闭资源
     * @param rs 关闭ResultSet的对象
     */
    public void close(ResultSet rs) {
        try {
            if (rs != null) {
                rs.close();
            }
            if (prs != null) {
                prs.close();
            }
            if (conn != null) {
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
            log.error("数据库关闭失败",e);
        }
    }

}

通过以下代码改进之后写Dao层不需要写SQL和繁琐的大量查询，包括少量业务判断。

注意：org.example.note.是我自己的工程路径下的XX注解，需要自己修改的地方

package org.example.util;


import org.example.entity.Page;

import java.lang.annotation.Annotation;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import java.lang.reflect.Field;
import java.util.Map;

/**
 * @author 方笔山
 * @date 2024-3-7 上午 11:06
 * BaseUtil辅助包
 */
public class BaseReflection extends BaseUtil {
    /**
     * 删除
     * @param object 实体类
     * @param condition 条件 String条件成员变量 Object条件内容
     * @return Int
     * @param <T> 实体类
     */
    public <T> Integer delete(Class<T> object, Map<String, Object> condition){
        StringBuilder sql = new StringBuilder("DELETE FROM ");
        String masterTableName = getObjectName(object);
        sql.append(masterTableName).append(" WHERE 1 = 1  ");
        //参数
        ArrayList<Object> params = new ArrayList<>();
        condition.forEach((entityName,entityValue)->{
            sql.append("and ")
                    .append(getFieldName(object,entityName))
                    .append(" <=> ?");

            params.add(entityValue);
        });
        try {
            return super.executeUpdate(sql.toString(), params.toArray());
        } catch (SQLException e) {
            throw new RuntimeException("SQL语句错误 : "+e);
        }
    }
    /**
     * 修改
     * @param object 实体类
     * @param entity Map<String,Object> String:实体类成员变量 Object:值 修改的值
     * @param condition Map<String,Object> String:实体类成员 Object:值 条件
     * @return 修改Id
     * @param <T> 实体类
     */
    public <T> Integer update(Class<T> object, Map<String, Object> entity, Map<String, Object> condition) {
        StringBuilder sql = new StringBuilder("UPDATE ");
        String masterTableName = getObjectName(object);
        sql.append(masterTableName).append(" set ");

        //参数
        ArrayList<Object> params = new ArrayList<>();
        entity.forEach((entityName, entityValue) -> {
            Integer maxLength = getMaxLength(object, entityName);
            Integer minLength = getMinLength(object, entityName);
            if (entityValue instanceof Integer) {
                if (maxLength < (Integer) entityValue && maxLength!= -1) {
                    throw new RuntimeException("超过限定最大值");
                }
                if (minLength > (Integer) entityValue && maxLength!= -1) {
                    throw new RuntimeException("超过限定最小值");
                }
            }
            if (entityValue instanceof String) {

                if (maxLength < ((String) entityValue).length() && maxLength!= -1) {
                    throw new RuntimeException("超过限定最大值");
                }
                if (minLength > ((String) entityValue).length() && maxLength!= -1) {
                    throw new RuntimeException("超过限定最小值");
                }
            }
            if (entityValue == null && getNotNull(object, entityName)) {
                throw new RuntimeException("不能为空");
            }

            if (entityValue == null) {
                String defaultValue = getDefaultValue(object, entityName);
                System.out.println(defaultValue);
                if (defaultValue!= null) {
                    params.add(defaultValue);
                } else {
                    params.add(null);
                }

            } else {
                List<String> type = getType(object, entityName);
                if (type!= null) {
                    long count = type.stream().filter(e ->!e.equals(entityValue)).count();
                    System.out.println(count);
                    if (count >= type.size() && type.size()!= 0) {
                        throw new RuntimeException("超过选项!");
                    }
                }
                params.add(entityValue);
            }
            sql.append(getFieldName(object, entityName)).append(" =? ").append(",");
        });
        sql.deleteCharAt(sql.length() - 1);
        sql.append(" where 1 = 1 ");
        condition.forEach((entityName, entityValue) -> {
            System.out.println(entityName + entityValue);
            sql.append("and ")
                    .append(getFieldName(object, entityName))
                    .append(" <=> ").append(entityValue);
        });
        System.out.println(sql);
        try {
            return super.executeUpdate(sql.toString(), params.toArray());
        } catch (SQLException e) {
            throw new RuntimeException("SQL语句错误 : " + e);
        }
    }
    /**
     * 新增
     * @param object 实体类
     * @param entity Map<String,Object> String:实体类成员变量 Object:值
     * @return 新增Id
     * @param <T> 实体类
     */
    public <T> Integer insert(Class<T> object, Map<String, Object> entity) {
        StringBuilder sql = new StringBuilder("INSERT INTO ");
        String masterTableName = getObjectName(object);
        sql.append(masterTableName).append(" (");
        entity.forEach((entityName, entityValue) -> {
            Integer maxLength = getMaxLength(object, entityName);
            Integer minLength = getMinLength(object, entityName);
            if (entityValue instanceof Integer) {
                if (maxLength < (Integer) entityValue && maxLength != -1) {
                    throw new RuntimeException("超过限定最大值");
                }
                if (minLength > (Integer) entityValue && maxLength != -1) {
                    throw new RuntimeException("超过限定最小值");
                }
            }
            if (entityValue instanceof String) {

                if (maxLength < ((String) entityValue).length() && maxLength != -1) {
                    throw new RuntimeException("超过限定最大值");
                }
                if (minLength > ((String) entityValue).length() && maxLength != -1) {
                    throw new RuntimeException("超过限定最小值");
                }
            }
            if (entityValue == null && getNotNull(object,entityName)){
                throw new RuntimeException("不能为空");
            }

            sql.append(getFieldName(object, entityName)).append(" ,");
        });
        sql.deleteCharAt(sql.length() - 1);
        sql.append(") values (");
        //参数
        ArrayList<Object> params = new ArrayList<>();
        entity.forEach((entityName, entityValue) -> {
            sql.append(" ? ").append(" ,");
            if (entityValue == null){
                String defaultValue = getDefaultValue(object, entityName);
                System.out.println(defaultValue);
                if (defaultValue != null){
                    params.add(defaultValue);
                }else{
                    params.add(null);
                }

            }else{
                List<String> type = getType(object, entityName);
                if (type != null) {
                    long count = type.stream().filter(e -> !e.equals(entityValue)).count();
                    System.out.println(count);
                    if (count >= type.size() && type.size() != 0){
                        throw new RuntimeException("超过选项!");
                    }
                }
                params.add(entityValue);
            }
        });
        System.out.println(params);
        sql.deleteCharAt(sql.length() - 1);
        sql.append(") ");
        try {
            return super.executeUpdate(sql.toString(), params.toArray());
        } catch (SQLException e) {
            throw new RuntimeException("SQL语句错误 : "+e);
        }
    }

    /**
     * 查询
     *
     * @param object    实体类
     * @param selectSet 需要查询实体类字段名称、SQL不填写则默认查询全部
     *                  查询参数或SQL默认查询全部
     * @param parameter String填入需要查询实体类字段 Object条件
     *                  条件查询（需要在obscureSelect为true才会进行模糊查询）
     * @param sort      排序查询 String实体类字段 Boolean是否升序 true升序 false降序
     * @param page      分页查询 只需要填入两个值 1.页码 2.分页页数
     * @param link      链表
     *                  Map<String,Map<String,String>> 第一个值左链接、右链接SQL
     *                  第二个值Map<String,String> String: 实体类名称 String:条件成员变量
     * @return 返回Page结果集
     * @throws SQLException 抛出错误
     */
    public <T> Page<T> select(Class<T> object,
                              List<String> selectSet,
                              Map<String, Object> parameter,
                              Map<String, Boolean> sort,
                              Map<String, Map<String, String>> link,
                              List<Integer> page)
            throws SQLException {
        //查询SQL
        StringBuilder sql = new StringBuilder("select  ");
        //参数
        ArrayList<Object> params = new ArrayList<>();
        //是否自己设置查询字段
        if (selectSet != null && selectSet.size() > 1) {
            selectSet.forEach(e -> {
                String isLinker = ".";
                if (e.contains(isLinker)) {
                    sql.append(e.split("\\.")[0])
                            .append(".")
                            .append(getFieldName(object, e.split("\\.")[1]))
                            .append(",");
                } else {
                    sql.append(getFieldName(object, e)).append(",");
                }
            });
            sql.deleteCharAt(sql.length() - 1);
            //是否是属于SQL查询集
        } else if (selectSet != null
                && !containsMemberVariable(object, selectSet.get(0))) {
            sql.append(selectSet.get(0));
        } else {
            //默认查询所有
            sql.append("*");
        }

        sql.append(" from ");
        //添加需要查询的表名
        String masterTableName = getObjectName(object);
        sql.append(masterTableName);
        //结果集
        ResultSet rs;
        //返回结果集
        Page<T> pageData = new Page<>();
        //自定义结果集查询
        if (selectSet != null
                && !containsMemberVariable(object, selectSet.get(0))
                && selectSet.size() == 1) {
            rs = super.executeQuery(sql.toString());
            if (rs.next()) {
                //自定义结果集
                Integer customResultSets = rs.getInt(1);
                pageData.setCustomObject(customResultSets);
                return pageData;
            }
        } else {
            //链表
            if (link != null) {
                link.forEach((linker, map) -> {
                    sql.append(" ")
                            .append(linker)
                            .append(" join ");
                    map.forEach((entityName, fieldName) -> {
                        try {
                            String tableName = getObjectName(
                                    Class.forName("org.example.entity."
                                            + entityName));
                            System.out.println(tableName);
                            char linkedInitials = tableName.charAt(0);
                            sql.append(tableName)
                                    .append(" ")
                                    .append(linkedInitials)
                                    .append(" on ")
                                    .append(linkedInitials)
                                    .append(".")
                                    .append(fieldName)
                                    .append(" <=> ")
                                    .append(masterTableName)
                                    .append(".")
                                    .append(fieldName)
                                    .append(" ");
                        } catch (ClassNotFoundException e) {
                            throw new RuntimeException("链表不存在 : " + e);
                        }
                    });
                });
            }

            //
            sql.append(" where 1 = 1 ");
            //循环添加条件判断
            if (parameter != null) {
                parameter.forEach((k, v) -> {
                    //根据实体类成员变量获取基数据库字段
                    String fieldName = getFieldName(object, k);
                    //判断是否可以模糊查询
                    if (getFieldObscureSelect(object, k)) {
                        sql.append("and ").append(fieldName).append(" like ? ");
                        params.add("%" + v + "%");
                    } else {
                        //<=>在不确定传过来的值类型需要使用安全等于
                        sql.append("and ").append(fieldName).append(" <=> ? ");
                        params.add(v);
                    }
                });
            }
            //循环条件排序
            if (sort != null) {
                sql.append(" ORDER BY ");
                sort.forEach((k, v) -> {
                    //根据实体类成员变量获取基数据库字段
                    String fieldName = getFieldName(object, k);
                    if (v) {
                        //升序
                        sql.append(fieldName).append(" ASC ");
                    } else {
                        //倒叙
                        sql.append(fieldName).append(" DESC ");
                    }
                });
            }
            //分页参数
            int pageDataSize = 2;
            //分页
            if (page != null && page.size() == pageDataSize) {

                sql.append(" LIMIT ?,?");
                //页码
                int pageNumber = page.get(0) - 1;
                //每页数量
                int pageSize = page.get(1);
                params.add(pageNumber);
                params.add(pageSize);

                pageData.setPageNumber(pageNumber);
                pageData.setPageSize(pageSize);

            }

            // 执行SQL
            rs = super.executeQuery(sql.toString(), params.toArray());
            //获取所有实体类字段
            List<String> objectNameAll = getObjectNameAll(object);
            //返回
            ArrayList<T> objectList = new ArrayList<>();
            while (rs.next()) {
                //实体类
                T instance;
                try {
                    // 使用反射创建实体类对象
                    instance = object.getDeclaredConstructor().newInstance();
                } catch (Exception e) {
                    throw new SQLException("无法创建对象实例", e);
                }
                if (selectSet != null && containsMemberVariable(object, selectSet.get(0))) {
                    //返回结果集 普通查询 单表查询
                    getField(object, false, selectSet, rs, instance);
                } else if (selectSet != null && !containsMemberVariable(object, selectSet.get(0))) {
                    //返回结果集 链表查询
                    getField(object, true, selectSet, rs, instance);
                } else {
                    //返回结果集 单结果集查询
                    getField(object, false, objectNameAll, rs, instance);
                }
                //将结果集添加到集合里
                objectList.add(instance);
            }
            //添加到Page
            pageData.setData(objectList);
        }

        //释放资源
        close(rs);
        return pageData;
    }


    /***
     * 获取全部结果集
     * @param object 结果集实体类
     * @param objectName 查询参数
     * @param isLinker 是否链表查询
     * @param rs 结果集
     * @param instance 实体类对象
     * @return 结果集
     */
    public static <T> String getField(Class<T> object,
                                      Boolean isLinker,
                                      List<String> objectName,
                                      ResultSet rs,
                                      T instance) {
        for (String fieldName : objectName) {
            //是否是链表查询
            if (isLinker) {
                try {
                    String entityFieldName = "\\.";
                    String mysqlFieldName = getFieldName(object,
                            fieldName.split(entityFieldName)[1]);
                    Object value = rs.getObject(fieldName.split(entityFieldName)[0]
                            + "." + mysqlFieldName);
                    Field field = object.getDeclaredField(
                            fieldName.split(entityFieldName)[1]);
                    field.setAccessible(true);
                    field.set(instance, value);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            } else {
                // 获取指定实体类字段名称查找对应的数据库字段名
                String dbFieldName = getFieldName(object, fieldName);
                try {
                    // 获取实体类成员变量
                    Field field = object.getDeclaredField(fieldName);
                    field.setAccessible(true);
                    // 根据注解name获取数据库中的数据
                    Object value = rs.getObject(dbFieldName);
                    field.set(instance, value);
                } catch (Exception ex) {
                    throw new RuntimeException("数据库字段名称错误!", ex);
                }
            }

        }
        return null;
    }

    /**
     * 通过反射根据字段注解的name属性找到对应的字段名称
     *
     * @param object    实体类的Class对象
     * @param fieldName 注解中的name属性
     * @return 匹配字段的名称，如果未找到则返回null
     */
    public static String getFieldNameByAnnotationName(Class<?> object, String fieldName) {
        // 遍历类的所有字段
        for (Field field : object.getDeclaredFields()) {
            // 检查字段上是否有@Field或@FieldId注解
            if (field.isAnnotationPresent(org.example.note.Field.class)) {
                org.example.note.Field annotation = field.getAnnotation(org.example.note.Field.class);
                // 获取注解的name属性值
                if (annotation.name().equals(fieldName)) {
                    return field.getName();
                    // 返回字段的名称
                }
            } else if (field.isAnnotationPresent(org.example.note.FieldId.class)) {
                org.example.note.FieldId annotation = field.getAnnotation(org.example.note.FieldId.class);
                // 获取注解的name属性值
                if (annotation.name().equals(fieldName)) {
                    return field.getName();
                    // 返回字段的名称
                }
            }
        }
        // 如果没有找到匹配的字段，返回null
        return null;
    }

    /**
     * 根据成员变量获取对应的FieldId或Field的name属性值
     *
     * @param object    实体类对象
     * @param fieldName 成员变量名
     * @return FieldId或Field的name属性值，或者null（如果未找到任何符合条件的注解）
     */
    public static <T> String getFieldName(Class<T> object, String fieldName) {
        try {
            Field field = object.getDeclaredField(fieldName);
            // 获取FieldId注解
            org.example.note.FieldId fieldIdAnnotation = field.getAnnotation(org.example.note.FieldId.class);
            if (fieldIdAnnotation != null) {
                //获取name属性
                return fieldIdAnnotation.name();
            }
            // 获取Field注解
            org.example.note.Field fieldAnnotation = field.getAnnotation(org.example.note.Field.class);
            if (fieldAnnotation != null) {
                //获取name属性
                return fieldAnnotation.name();
            }
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }

        return null;
    }

    /**
     * 根据成员变量对应的Field的obscureSelect属性值
     *
     * @param object    实体类对象
     * @param fieldName 成员变量名
     * @return Field的obscureSelect属性值，或者false（如果未找到Field注解）
     */
    public static <T> boolean getFieldObscureSelect(Class<T> object, String fieldName) {
        try {
            Field field = object.getDeclaredField(fieldName);
            // 获取Field注解
            org.example.note.Field fieldAnnotation =
                    field.getAnnotation(org.example.note.Field.class);
            if (fieldAnnotation != null) {
                //获取obscureSelect属性
                return fieldAnnotation.obscureSelect();
            }
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }

        return false;
    }

    /**
     * 获取表名
     *
     * @param object 实体类
     * @param <T>    实体类
     * @return 返回表名称
     */
    public <T> String getObjectName(Class<T> object) {
        // 检查实体类上是否有TableName注解
        if (object.isAnnotationPresent(org.example.note.TableName.class)) {
            // 获取TableName注解
            Annotation tableNameAnnotation = object.getAnnotation(org.example.note.TableName.class);
            // 强制转换为TableName注解类型
            org.example.note.TableName tableName =
                    (org.example.note.TableName) tableNameAnnotation;
            // 获取并返回name属性的值
            return tableName.name();
        } else {
            throw new RuntimeException("没有TableName注解: " +
                    object.getName());
        }
    }

    /**
     * 获取实体类所有字段
     *
     * @param object 实体类
     * @param <T>    类型参数
     * @return 字段名列表
     */
    public <T> List<String> getObjectFieldNameAll(Class<T> object) {
        List<String> fieldNames = new ArrayList<>();
        Field[] fields = object.getDeclaredFields();

        for (Field field : fields) {
            Annotation[] annotations = field.getAnnotations();
            for (Annotation annotation : annotations) {
                if (annotation instanceof org.example.note.FieldId) {
                    String annotationName = ((org.example.note.FieldId) annotation).name();
                    fieldNames.add(annotationName);
                    break;
                } else if (annotation instanceof org.example.note.Field) {
                    String annotationName = ((org.example.note.Field) annotation).name();
                    fieldNames.add(annotationName);
                    break;
                }
            }
        }

        return fieldNames;
    }

    /**
     * 获取实体类所有成员变量
     *
     * @param object 实体类
     * @param <T>    类型参数
     * @return 字段名列表
     */
    public <T> List<String> getObjectNameAll(Class<T> object) {
        List<String> fieldNames = new ArrayList<>();
        Field[] fields = object.getDeclaredFields();

        for (Field field : fields) {
            field.setAccessible(true);
            fieldNames.add(field.getName());
        }
        return fieldNames;
    }

    /**
     * 获取实体类指定字段的注解名称
     *
     * @param object          实体类
     * @param fieldName       需要获取的字段名
     * @param annotationClass 获取的字段是属于FieldId还是Field注解
     * @param <T>             实体类
     * @return 字段名
     */
    public <T> String getFieldName(Class<T> object, String fieldName, Class<? extends Annotation> annotationClass) {
        try {
            Field field = object.getDeclaredField(fieldName);
            Annotation annotation = field.getAnnotation(annotationClass);

            if (annotation != null) {
                if (annotation instanceof org.example.note.FieldId) {
                    return ((org.example.note.FieldId) annotation).name();
                } else if (annotation instanceof org.example.note.Field) {
                    return ((org.example.note.Field) annotation).name();
                }
            }
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }

        return null;
    }

    /**
     * 判断该字符串是否存在于实体类
     *
     * @param object             实体类
     * @param memberVariableName 成员变量
     * @return true存在 false不存在
     */
    public static boolean containsMemberVariable(Class<?> object, String memberVariableName) {
        for (Field field : object.getDeclaredFields()) {
            field.setAccessible(true);
            if (field.getName().equals(memberVariableName)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 获取最大限定值
     *
     * @param object    实体类
     * @param fieldName 成员变量
     * @param <T>       实体类
     * @return 最大限定值
     */
    public static <T> Integer getMaxLength(Class<T> object, String fieldName) {
        try {
            // 获取指定字段
            Field field = object.getDeclaredField(fieldName);

            // 检查字段上是否有Field注解
            if (field.isAnnotationPresent(org.example.note.Field.class)) {
                // 获取Field注解
                org.example.note.Field annotation = field.getAnnotation(org.example.note.Field.class);

                // 获取maxLength属性的值
                return annotation.maxLength();
            }
        } catch (NoSuchFieldException e) {
            // 字段不存在时抛出异常或返回null
            e.printStackTrace();
        }

        // 如果没有Field注解或字段不存在，返回null或空字符串
        return null;
    }

    /**
     * 获取最小限定值
     *
     * @param object    实体类
     * @param fieldName 成员变量
     * @param <T>       实体类
     * @return 最小限定值
     */
    public static <T> Integer getMinLength(Class<T> object, String fieldName) {
        try {
            // 获取指定字段
            Field field = object.getDeclaredField(fieldName);

            // 检查字段上是否有Field注解
            if (field.isAnnotationPresent(org.example.note.Field.class)) {
                // 获取Field注解
                org.example.note.Field annotation = field.getAnnotation(org.example.note.Field.class);

                // 获取maxLength属性的值
                return annotation.minLength();
            }
        } catch (NoSuchFieldException e) {
            // 字段不存在时抛出异常或返回null
            e.printStackTrace();
        }

        // 如果没有Field注解或字段不存在，返回null或空字符串
        return null;
    }

    /**
     * 获取默认值
     *
     * @param object    实体类
     * @param fieldName 成员变量
     * @param <T>       实体类
     * @return 默认值
     */
    public static <T> String getDefaultValue(Class<T> object, String fieldName) {
        try {
            // 获取指定字段
            Field field = object.getDeclaredField(fieldName);

            // 检查字段上是否有Field注解
            if (field.isAnnotationPresent(org.example.note.Field.class)) {
                // 获取Field注解
                org.example.note.Field annotation = field.getAnnotation(org.example.note.Field.class);

                // 获取maxLength属性的值
                return annotation.defaultValue();
            }
        } catch (NoSuchFieldException e) {
            // 字段不存在时抛出异常或返回null
            e.printStackTrace();
        }

        // 如果没有Field注解或字段不存在，返回null或空字符串
        return null;
    }
    /**
     * 获取是否为空
     *
     * @param object    实体类
     * @param fieldName 成员变量
     * @param <T>       实体类
     * @return 是否为空
     */
    public static <T> Boolean getNotNull(Class<T> object, String fieldName) {
        try {
            // 获取指定字段
            Field field = object.getDeclaredField(fieldName);

            // 检查字段上是否有Field注解
            if (field.isAnnotationPresent(org.example.note.Field.class)) {
                // 获取Field注解
                org.example.note.Field annotation = field.getAnnotation(org.example.note.Field.class);

                // 获取maxLength属性的值
                return annotation.notNull();
            }
        } catch (NoSuchFieldException e) {
            // 字段不存在时抛出异常或返回null
            e.printStackTrace();
        }

        // 如果没有Field注解或字段不存在，返回null或空字符串
        return false;
    }
    /**
     * 获取固定值选择
     *
     * @param object    实体类
     * @param fieldName 成员变量
     * @param <T>       实体类
     * @return 固定值选择
     */
    public static <T> List<String> getType(Class<T> object, String fieldName) {
        try {
            // 获取指定字段
            Field field = object.getDeclaredField(fieldName);

            // 检查字段上是否有Field注解
            if (field.isAnnotationPresent(org.example.note.Field.class)) {
                // 获取Field注解
                org.example.note.Field annotation = field.getAnnotation(org.example.note.Field.class);

                // 获取maxLength属性的值
                return Arrays.asList(annotation.type());
            }
        } catch (NoSuchFieldException e) {
            // 字段不存在时抛出异常或返回null
            e.printStackTrace();
        }

        // 如果没有Field注解或字段不存在，返回null或空字符串
        return null;
    }
}

以下是注解包：

普通字段

package org.example.note;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 普通字段
 * @author 方笔山
 * @date 2024-3-7
 */
// 保持运行时可见
//只能在成员变量使用
// ElementType.METHOD成员方法
// ElementType.FIELD成员变量
// ElementType.TYPE限制该注解只能用于类、接口或enum声明
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Field {
    /**
     * 字段名称
     */
    String name();

    /**
     * 默认值
     */
    String defaultValue() default "";

    /**
     * 是否非空 true不能为空 false可以为空
     */
    boolean notNull() default false;
    //是否模糊查询 true模糊查询 false不模糊查询
    boolean obscureSelect() default false;
    //最大长度限制 默认-1不限制
    int maxLength() default -1;
    //最小长度限制 默认-1不限制
    int minLength() default  -1;
    //固定值选择
    String[] type();

}

标记主键ID注解

package org.example.note;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 主键ID
 * @author fbs
 * @date 2024-3-7 上午 10:54
 */
// 保持运行时可见
@Retention(RetentionPolicy.RUNTIME)
//只能在成员变量使用
// ElementType.METHOD成员方法
// ElementType.FIELD成员变量
// ElementType.TYPE限制该注解只能用于类、接口或enum声明
@Target(ElementType.FIELD)
public @interface FieldId {
    //是否自增 true可以自增 false不可以自增
    boolean autoIncrease() default true;
    //字段名称
    String name();

}

链表

package org.example.note;

/**链表
 * @author 康文程
 * @date 2024-3-20 上午 11:36
 */
public @interface JoinTable {
    //从表名称
    String name();

}

表名称

package org.example.note;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 表名称
 * @author kwc13
 * @date 2024-3-7 上午 10:54
 */
// 保持运行时可见
@Retention(RetentionPolicy.RUNTIME)
//只能在成员变量使用
// ElementType.METHOD成员方法
// ElementType.FIELD成员变量
// ElementType.TYPE限制该注解只能用于类、接口或enum声明
@Target(ElementType.TYPE)
public @interface TableName {
    //表名称名称
    String name();
}

只需要给实体类标记上以上注解即可完成查询，修改，新增，删除操作。

如下是示例：

package org.example.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.example.note.Field;
import org.example.note.FieldId;
import org.example.note.JoinTable;
import org.example.note.TableName;

/**图书
 * @author 方笔山
 * @date 2024-3-7 上午 10:52
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName(name="book")
public class Book {
    /**
     * 字段主键autoIncrease是否自增 name字段名称
     */
    @FieldId(autoIncrease = false,name = "id")
    private Integer id;
    @Field(name="btype",defaultValue="原创",maxLength = 5,minLength = 2,
            type = {"原创","轻小说","穿越","历史","架空历史"})
    private String type;
    @Field(name="name",notNull=true,obscureSelect = true,maxLength = 12,minLength = 1,type = {})
    private String name;
    @Field(name="description",maxLength = 100,type = {})
    private String description;
    /**
     * 链表
     */
    @JoinTable(name="demo")
    Demo demo;
}

注意链表字段不要重复