分享一个jpa的where条件生成工具类

最新推荐文章于 2024-01-02 01:58:51 发布
最新推荐文章于 2024-01-02 01:58:51 发布
阅读量742 收藏
点赞数
分类专栏： 后台 文章标签： java 后端 jpa
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/yaoji8151/article/details/106024646
版权

jpa中自己拼接where条件写一大堆Predicate和CriteriaBuilder进行拼接写一大堆if-else 会有大量代码冗余，于是出现了帮助类来解决where条件生成的代码

jpa的where条件生成帮助类为两个：
Query用来指定使用什么方式查询；QueryHelp用来生成条件语句。

Query 类：

package com.starcity.utils;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import com.starcity.annotation.Query;
import lombok.extern.slf4j.Slf4j;
import org.hibernate.query.criteria.internal.ValueHandlerFactory;

import javax.persistence.criteria.*;
import java.lang.reflect.Field;
import java.util.*;
import java.util.stream.Collectors;

import static java.util.stream.Collectors.joining;

/**
 * @author WeiMaoMao
 * @date
 */
@Slf4j
@SuppressWarnings({"unchecked", "all"})
public class QueryHelp {

    public static <R, Q> Predicate getPredicate(Root<R> root, Q query, CriteriaBuilder cb) {
        List<Predicate> list = new ArrayList<>();

        if (query == null) {
            return cb.and(list.toArray(new Predicate[0]));
        }
        try {
            List<Field> fields = getAllFields(query.getClass(), new ArrayList<>());
            for (Field field : fields) {
                boolean accessible = field.isAccessible();
                field.setAccessible(true);
                Query q = field.getAnnotation(Query.class);
                if (q != null) {
                    String propName = q.propName();
                    String joinName = q.joinName();
                    String blurry = q.blurry();
                    String attributeName = isBlank(propName) ? field.getName() : propName;
                    Class<?> fieldType = field.getType();
                    Object val = field.get(query);
                    if (ObjectUtil.isNull(val) || "".equals(val)) {
                        continue;
                    }
                    Join join = null;
                    // 模糊多字段
                    if (ObjectUtil.isNotEmpty(blurry)) {
                        String[] blurrys = blurry.split(",");
                        List<Predicate> orPredicate = new ArrayList<>();
                        for (String s : blurrys) {
                            orPredicate.add(cb.like(root.get(s)
                                    .as(String.class), "%" + val.toString() + "%"));
                        }
                        Predicate[] p = new Predicate[orPredicate.size()];
                        list.add(cb.or(orPredicate.toArray(p)));
                        continue;
                    }
                    if (ObjectUtil.isNotEmpty(joinName)) {
                        String[] joinNames = joinName.split(">");
                        for (String name : joinNames) {
                            switch (q.join()) {
                                case LEFT:
                                    if (ObjectUtil.isNotNull(join)) {
                                        join = join.join(name, JoinType.LEFT);
                                    } else {
                                        join = root.join(name, JoinType.LEFT);
                                    }
                                    break;
                                case RIGHT:
                                    if (ObjectUtil.isNotNull(join)) {
                                        join = join.join(name, JoinType.RIGHT);
                                    } else {
                                        join = root.join(name, JoinType.RIGHT);
                                    }
                                    break;
                                default:
                                    break;
                            }
                        }
                    }
                    switch (q.type()) {
                        case EQUAL:
                            list.add(cb.equal(getExpression(attributeName, join, root)
                                    .as((Class<? extends Comparable>) fieldType), val));
                            break;
                        case GREATER_THAN:
                            list.add(cb.greaterThanOrEqualTo(getExpression(attributeName, join, root)
                                    .as((Class<? extends Comparable>) fieldType), (Comparable) val));
                            break;
                        case LESS_THAN:
                            list.add(cb.lessThanOrEqualTo(getExpression(attributeName, join, root)
                                    .as((Class<? extends Comparable>) fieldType), (Comparable) val));
                            break;
                        case LESS_THAN_NQ:
                            list.add(cb.lessThan(getExpression(attributeName, join, root)
                                    .as((Class<? extends Comparable>) fieldType), (Comparable) val));
                            break;
                        case INNER_LIKE:
                            list.add(cb.like(getExpression(attributeName, join, root)
                                    .as(String.class), "%" + val.toString() + "%"));
                            break;
                        case LEFT_LIKE:
                            list.add(cb.like(getExpression(attributeName, join, root)
                                    .as(String.class), "%" + val.toString()));
                            break;
                        case RIGHT_LIKE:
                            list.add(cb.like(getExpression(attributeName, join, root)
                                    .as(String.class), val.toString() + "%"));
                            break;
                        case IN:
                            if (CollUtil.isNotEmpty((Collection<Long>) val)) {
                                list.add(getExpression(attributeName, join, root).in((Collection<Long>) val));
                            }
                            break;
                        case NOT_EQUAL:
                            list.add(cb.notEqual(getExpression(attributeName, join, root), val));
                            break;
                        case NOT_NULL:
                            list.add(cb.isNotNull(getExpression(attributeName, join, root)));
                            break;
                        case NULL:
                            if((boolean)val){
                                list.add(cb.isNull(getExpression(attributeName, join, root)));
                            }
                            break;
                        case BETWEEN:
                            List<Object> between = new ArrayList<>((List<Object>) val);
                            list.add(cb.between(getExpression(attributeName, join, root).as((Class<? extends Comparable>) between.get(0).getClass()),
                                    (Comparable) between.get(0), (Comparable) between.get(1)));
                            break;
                        default:
                            break;
                    }
                }
                field.setAccessible(accessible);
            }
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
        int size = list.size();
        return cb.and(list.toArray(new Predicate[size]));
    }

    @SuppressWarnings("unchecked")
    private static <T, R> Expression<T> getExpression(String attributeName, Join join, Root<R> root) {
        if (ObjectUtil.isNotEmpty(join)) {
            return join.get(attributeName);
        } else {
            return root.get(attributeName);
        }
    }

    private static boolean isBlank(final CharSequence cs) {
        int strLen;
        if (cs == null || (strLen = cs.length()) == 0) {
            return true;
        }
        for (int i = 0; i < strLen; i++) {
            if (!Character.isWhitespace(cs.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    private static List<Field> getAllFields(Class clazz, List<Field> fields) {
        if (clazz != null) {
            fields.addAll(Arrays.asList(clazz.getDeclaredFields()));
            getAllFields(clazz.getSuperclass(), fields);
        }
        return fields;
    }


    public static <Q> StringBuffer buildSqlWhere(Q query, StringBuffer sql) {

        if (query == null) {
            return sql;
        }
        try {
            List<Field> fields = getAllFields(query.getClass(), new ArrayList<>());
            for (Field field : fields) {
                boolean accessible = field.isAccessible();
                field.setAccessible(true);
                Query q = field.getAnnotation(Query.class);
                if (q != null) {
                    String propName = q.propName();
                    String joinName = q.joinName();
                    String blurry = q.blurry();
                    String attributeName = isBlank(propName) ? field.getName() : propName;
                    Class<?> fieldType = field.getType();
                    Object val = field.get(query);
                    if (ObjectUtil.isNull(val) || "".equals(val)) {
                        continue;
                    }
                    // 模糊多字段
                    if (ObjectUtil.isNotEmpty(blurry)) {
                        String[] blurrys = blurry.split(",");
                        sql.append(" and (");
                        for (int i = 0; i < blurrys.length; i++) {
                            if (i != 0 && i < blurrys.length) {
                                sql.append(" or ");
                            }
                            sql.append(" " + blurrys[i] + " like '%" + val.toString() + "%'");
                        }
                        sql.append(")");
                        continue;
                    }
                    if (ObjectUtil.isNotEmpty(joinName)) {
                        String[] joinNames = joinName.split(">");
                        for (String name : joinNames) {
                            switch (q.join()) {
                                case LEFT:
                                    sql.append(" left join " + name);
                                    break;
                                case RIGHT:
                                    sql.append(" right join " + name);
                                    break;
                                default:
                                    break;
                            }
                        }
                    }
                    switch (q.type()) {
                        case EQUAL:
                            checkStringAndNum(fieldType, sql, "=", attributeName, val);
                            break;
                        case GREATER_THAN:
                            checkStringAndNum(fieldType, sql, ">=", attributeName, val);
                            break;
                        case LESS_THAN:
                            checkStringAndNum(fieldType, sql, "<=", attributeName, val);
                            break;
                        case LESS_THAN_NQ:
                            checkStringAndNum(fieldType, sql, "<", attributeName, val);
                            break;
                        case INNER_LIKE:
                            sql.append(" and " + attributeName + " like '%" + val.toString() + "%' ");
                            break;
                        case LEFT_LIKE:
                            sql.append(" and " + attributeName + " like '%" + val.toString() + "' ");
                            break;
                        case RIGHT_LIKE:
                            sql.append(" and " + attributeName + " like '" + val.toString() + "%' ");
                            break;
                        case IN:
                            if (CollUtil.isNotEmpty((Collection<Object>) val)) {
                                Collection<Object> list = (Collection<Object>) val;
                                Object o = list.stream().findFirst().orElse(null);
                                if (ValueHandlerFactory.isNumeric(o.getClass())) {
                                    Collection<Number> numberList = (Collection<Number>) val;
                                    sql.append(" and " + attributeName + " in (" + list.stream().map(item->item+"").collect(joining(",")) + ")");
                                } else {
                                    Collection<String> strList = (Collection<String>) val;
                                    sql.append(" and " + attributeName + " in ('" + strList.stream().collect(Collectors.joining("','")) + "')");
                                }
                            }
                            break;
                        case NOT_EQUAL:
                            checkStringAndNum(fieldType, sql, "!=", attributeName, val);
                            break;
                        case NOT_NULL:
                            sql.append(" and " + attributeName + " IS NOT NULL ");
                            break;
                        case NULL:
                            if((boolean)val){
                                sql.append(" and " + attributeName + " IS NULL ");
                            }
                            break;
                        case BETWEEN:
                            List<Object> between = new ArrayList<>((List<Object>) val);
                            if (ValueHandlerFactory.isNumeric(fieldType)) {
                                sql.append(" and " + attributeName + " BETWEEN " + between.get(0) + " AND " + between.get(1));
                                break;
                            }
                            sql.append(" and " + attributeName + " BETWEEN '" + between.get(0) + "' AND '" + between.get(1) + "' ");
                            break;
                        default:
                            break;
                    }
                }
                field.setAccessible(accessible);
            }
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
        return sql;
    }


    /**
     * 仅仅构建where的部分
     * @param query
     * @param sql
     * @param <Q>
     * @return
     */
    public static <Q> StringBuffer buildSqlOnlyWhere(Q query) {
        StringBuffer sql=new StringBuffer();

        if (query == null) {
            return sql;
        }
        try {
            List<Field> fields = getAllFields(query.getClass(), new ArrayList<>());
            for (Field field : fields) {
                boolean accessible = field.isAccessible();
                field.setAccessible(true);
                Query q = field.getAnnotation(Query.class);
                if (q != null) {
                    String propName = q.propName();
                    String joinName = q.joinName();
                    String blurry = q.blurry();
                    String attributeName = isBlank(propName) ? field.getName() : propName;
                    Class<?> fieldType = field.getType();
                    Object val = field.get(query);
                    if (ObjectUtil.isNull(val) || "".equals(val)) {
                        continue;
                    }
                    // 模糊多字段
                    if (ObjectUtil.isNotEmpty(blurry)) {
                        String[] blurrys = blurry.split(",");
                        sql.append(" and (");
                        for (int i = 0; i < blurrys.length; i++) {
                            if (i != 0 && i < blurrys.length) {
                                sql.append(" or ");
                            }
                            sql.append(" " + blurrys[i] + " like '%" + val.toString() + "%'");
                        }
                        sql.append(")");
                        continue;
                    }
                    if (ObjectUtil.isNotEmpty(joinName)) {
                        String[] joinNames = joinName.split(">");
                        for (String name : joinNames) {
                            switch (q.join()) {
                                case LEFT:
                                    sql.append(" left join " + name);
                                    break;
                                case RIGHT:
                                    sql.append(" right join " + name);
                                    break;
                                default:
                                    break;
                            }
                        }
                    }
                    switch (q.type()) {
                        case EQUAL:
                            checkStringAndNum(fieldType, sql, "=", attributeName, val);
                            break;
                        case GREATER_THAN:
                            checkStringAndNum(fieldType, sql, ">=", attributeName, val);
                            break;
                        case LESS_THAN:
                            checkStringAndNum(fieldType, sql, "<=", attributeName, val);
                            break;
                        case LESS_THAN_NQ:
                            checkStringAndNum(fieldType, sql, "<", attributeName, val);
                            break;
                        case INNER_LIKE:
                            sql.append(" and " + attributeName + " like '%" + val.toString() + "%' ");
                            break;
                        case LEFT_LIKE:
                            sql.append(" and " + attributeName + " like '%" + val.toString() + "' ");
                            break;
                        case RIGHT_LIKE:
                            sql.append(" and " + attributeName + " like '" + val.toString() + "%' ");
                            break;
                        case IN:
                            if (CollUtil.isNotEmpty((Collection<String>) val)) {
                                if (ValueHandlerFactory.isNumeric(fieldType)) {
                                    sql.append(" and " + attributeName + " in (" + ((Collection<String>) val).stream().collect(joining(",")) + ")");
                                } else {
                                    sql.append(" and " + attributeName + " in ('" + ((Collection<String>) val).stream().collect(joining("','")) + "')");
                                }
                            }
                            break;
                        case NOT_EQUAL:
                            checkStringAndNum(fieldType, sql, "!=", attributeName, val);
                            break;
                        case NOT_NULL:
                            sql.append(" and " + attributeName + " IS NOT NULL ");
                            break;
                        case NULL:
                            if((boolean)val){
                                sql.append(" and " + attributeName + " IS NULL ");
                            }
                            break;
                        case BETWEEN:
                            List<Object> between = new ArrayList<>((List<Object>) val);
                            if (ValueHandlerFactory.isNumeric(fieldType)) {
                                sql.append(" and " + attributeName + " BETWEEN " + between.get(0) + " AND " + between.get(1));
                                break;
                            }
                            sql.append(" and " + attributeName + " BETWEEN '" + between.get(0) + "' AND '" + between.get(1) + "' ");
                            break;
                        default:
                            break;
                    }
                }
                field.setAccessible(accessible);
            }
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
        return sql;
    }
    /**
     * 判断字段类型并加入引号
     *
     * @param fieldType     字段类型
     * @param sql           总体sql
     * @param type          = >= <=
     * @param attributeName 字段名称
     * @param val           字段值
     */
    private static void checkStringAndNum(Class<?> fieldType, StringBuffer sql, String type, String attributeName, Object val) {
        if (attributeName.equals("enabled")) {
            System.out.println(ValueHandlerFactory.isBoolean(val));
        }
        //如果是数字类型
        if (ValueHandlerFactory.isNumeric(fieldType)) {
            sql.append(" and " + attributeName + " " + type + " " + val);
        }//如果是boolean
        else if (ValueHandlerFactory.isBoolean(val)) {
            sql.append(" and " + attributeName + " " + type + " " + ((Boolean) val ? 1 : 0) + "");
        }//字符
        else {
            sql.append(" and " + attributeName + " " + type + " '" + val + "' ");
        }
    }

}

QueryHelp上面有三个方法：
第一个方法是jpa自身调用时引用
第二个方法是使用entityManager.createNativeQuery调用
第三个方法是只生成where条件，用于自己拼接

举例说明：
第一种：
在这里插入图片描述在这里插入图片描述
第二种：
在这里插入图片描述
在这里插入图片描述
第三种不出示例喽。

spring-boot：使用JPA访问数据源（二）实现where条件，order by查询
zhibin的程序日记
02-13 3956
上一篇文章：spring-boot：使用JPA访问数据源（一） 一、使用where条件 上一篇我们使用JPA进行了数据源的访问，默认JPA已经实现了好几个接口可以调用。但是，在实际的业务中，查询语句不可避免地需要使用where、order by等语句。 我们用商品数据来做例子，添加一个价格字段price，按价格范围查询，看看怎么来实现。 方式一：通过方法名称来实现 public int...
使用JPA自动生成数据库实体类
qq_40308101的博客
07-26 2020
2、修改GeneratePOJOs.groovy文件配置。选择存放实体类的目录，点击确定。3、选择要生成实体类的表右键。4、自动生成的实体类如下。1、添加maven依赖。
SpringDataJPA 动态查询，JpaSpecificationExecutor 快速条件构造工具类
qq_41664621的博客
12-06 685
版权声明：本文为博主原创文章转载请附上原文出处链接。
JPA 中使用@Where
风之贝拉的博客
12-21 8220
说明：表customer和表res_prop是一对多的关系， 映射关系是res_prop的res_id对应customer的id,res_prop的rescode对应‘Customer’问题：对customer 分页查询，其显示条数与总条数total不一致。 修改之前的代码：customer对应的实体Customer import javax.persistence.Column; import
JPA动态拼接where条件
热门推荐
心寒的博客
06-28 1万+
在开发中，经常会涉及到动态拼接sql，以下就是JPA使用三元运算符的方式拼接条件案例： @Query(value = "select * from user a where if(?1 !='',id=?1 ,1=1 ) ",nativeQuery = true) public List<User> findPersonById(String id); 写了一个简单的根据id查找用户的案例，首先不输入id，则返回所有数据，如下： 如果输入id则只返回对应的用户：
JPA - @Where注解 - 添加条件查询
Maggieq8324的博客
08-17 4395
目录前言具体实现 前言 这里介绍@Where注解给Entity统一添加条件查询。 具体实现 Product.java @Entity @Getter @Setter @Where(clause = "delete_time is null") public class Product { @Id private int id; private String title; private Date createTime; private Date deleteT
【IntelliJ IDEA工具】spring boot使用JPA自动生成实体类（数据库表逆向工程自动生成带注释的实体类）
Tastill的博客
09-15 1532
1、maven依赖： <!-- JPA，用于自动生成表结构 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> &
SpringBoot+JPA+Freemarker 生成动态SQL
09-21
结合SpringBoot和JPA，我们可以创建一个服务，该服务使用JPA的Repository接口与数据库进行交互，并通过Freemarker生成动态SQL。具体步骤如下： 1. **设置项目**：创建一个SpringBoot项目，添加Spring Data JPA和...
使用idea插件生成jpa实体类（基于lombok）
qq_20012311的博客
01-13 1514
使用idea插件生成jpa实体类（基于lombok） 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.打开视图 2.新建mysql数据源，配置数据库信息 3.编写逆向工程的脚本文件Generate POJOs.groovy 总结 前言 使用idea插件生成jpa实体类 提示：以下是本篇文章正文内容，下面案例可供参考 一、使用步骤 1.打开视图 view -> Tool Windows -> Database .
JPA的一个例子
03-06
Java Persistence API（JPA）是Java平台上的一个标准，用于管理和持久化对象。它简化了在关系数据库中存储和检索Java对象的过程，使得开发人员可以专注于业务逻辑而不是数据库交互的细节。本实例将通过分析提供的...
sqlCondition where条件生成器 主要用于表格筛选
weixin_34274029的博客
11-27 1182
2019独角兽企业重金招聘Python工程师标准>>> ...
java sqlcondition,sqlCondition where条件生成器 主要用于表格筛选
weixin_31141099的博客
03-13 900
packagecom.yiyikefu.sqlconditionkit;importjava.util.ArrayList;importjava.util.HashMap;importjava.util.List;importjava.util.Map;importjava.util.Set;/****Title:SqlCondition.java*Description:sq...
JPA 关联表添加关联条件@Where、@WhereJoinTable()
你当像鸟飞往你的山~~
11-27 5462
JPA 关联表添加关联条件，当我其中一个表的数据状态发送改变，不是业务上所需要的，这时实体查询还是会带出关联数据，所以我们需要处理这部分数据；第一种方式：删除中间表对应数据；第二种添加关联条件，按条件带出有效数据 代码示例 用户实体 @Entity @Table(name = "pmi_t_user") @org.hibernate.annotations.Table(applie...
jpa使用@Where注解来实现统一加条件
enthan809882的博客
10-31 1万+
JpaRepository已经封装好了许多方法，例如：findAll，但是实际中我们往往要加入一些条件，例如del_flag= 0 ，难道要改JpaRepository的源码么，当然不： 在实体类中使用@Where即可。 @Entity @Where(clause="del_Flag = 0 ") public class Category { } 那么打印的sql为： 可以发现自动加上查询条...
JPA 使用@Where 注解实现全局过滤
ideal-lingyun
01-02 761
JPA 使用@Where 注解实现全局过滤
JPA使用Specification动态where条件查询
胃病的不良少彦
09-18 4386
1. 想要的效果SQL select * from XXX where column_1 ='字段1的值' and column_2 ='字段2的值' and (column_3= '字段3的值' or column_3 ='字段3的第二个值') and LOCATE('字段4的值', column_4)>0 2.Specification 查询 ...
JPA多属性排序以及JPAwhere多条件动态查询
HD243608836的博客
03-02 2707
PageRequest pageable = PageRequest.of(page, limit,new Sort(Direction.DESC,"XXX").and(new Sort(Direction.DESC,"XXX"))); 1. 动态Where条件查询 注意如果有动态where，而且没有一项确定的值，需要加where 1=1 如果不为空查询，为空不查询 @Query(...
JPA使用
爱吃鱼油
07-24 1150
dao Interface继承Repository接口 可以直接继承Repository也可以继承下面的子接口 CrudRepository  (Spring Data提供) 继承Repository，提供增删改查方法，可以直接调用。 PagingAndSortingRepository (Spring Data提供) 继承CrudRepository，增加了分页查询和排序两个方法
Java 多条件查询语句组合工具类
Aicken_mocking的博客
05-25 782
package util; import java.sql.Date; public class Expression { StringBuffer exp = new StringBuffer(); int count = 0; boolean leftbra = false; // 代表左边的括号 boolean orderflag = false; // 排序出现标志 boolean between = false;// 代表between and里between出现的标志 /**
代码生成工具类java
最新发布
01-12
### Java 代码生成工具概述 在Java开发领域，代码生成工具能够显著提升开发效率并确保代码质量的一致性。这些工具通过自动生成常见的代码结构和逻辑，减少了手动编写重复代码的需求。 #### JHipster JHipster 是一种流行的全栈式开发平台，它不仅支持前端技术的选择（如 Angular, React 或 Vue.js），还提供了丰富的后端服务生成功能。对于 Spring Boot 和微服务架构的支持尤为突出[^1]。 #### MyBatis Generator 专门针对数据库操作层的代码生成解决方案之一就是 MyBatis Generator (MBG)，它可以依据现有的数据库表结构来自动生成相应的 DAO 接口及其实现类、Model 类等基础组件，极大地方便了开发者快速搭建数据访问层。 #### OpenAPI Generator 当涉及到 RESTful API 的设计与实现时，OpenAPI Generator 成为了理想之选。该工具可以从定义好的 OpenAPI 规范文件中提取信息，并据此创建客户端 SDKs 及服务器 stubs，在前后端分离项目里特别有用处。 #### Spring Roo 作为早期出现的一个命令行驱动型 IDE 插件形式存在的 Rapid Application Development 工具——Spring Roo，则更侧重于简化企业级应用的整体构建过程。尽管其活跃度有所下降但仍保留了一定的应用场景价值。 #### Lombok 虽然严格意义上不属于传统意义上的“代码生成”，但 Project Lombok 提供了一些编译期注解处理器的功能，可以在不改变源码的情况下向程序注入额外的方法体或字段声明等内容，从而达到减少样板代码的目的。 #### 自动化全能型生成器 存在一些综合性的代码生成工具，这类工具可以根据不同的输入格式（JSON、SQL语句或是已有的实体类）自动推断目标语言特性，并批量生产出带有基本 CRUD 功能的完整业务对象模型及相关持久化方法[^2]。 #### ORM框架兼容的高级定制化生成器 某些特定场合下可能需要更加灵活可控的方式来进行代码合成工作，这时可以选择那些基于模板引擎打造而成的产品。它们允许用户按照个人喜好调整最终产出物的形式样式，同时兼顾主流ORM映射库之间的协作需求，比如 Hibernate/JPA、MyBatis/MyBatis Plus 等[^4]。 ```java // 示例：使用Template Engine生成DAO接口 public interface UserMapper { @Select("SELECT * FROM users WHERE id=#{id}") User selectById(Integer id); } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值