一个很神奇的【JPAUtil.class】

已于 2022-11-29 18:00:00 修改
阅读量540 收藏
点赞数 1
分类专栏： SpringBoot JPA 文章标签： java jpa
于 2022-11-14 18:40:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40109075/article/details/127852594
版权

背景描述：

这个是前几个月突发奇想去构建的一个关于JPA查询的工具类，具体包含了几个注解，一个Base查询类，和一个工具类。

真正使用的时候，需要将base类进行继承并扩展，那么接下来上代码。

第一部分，三个注解：

第一个注解@JPASort，该注解用于标识字段，被标识的字段必须填充filedName属性来确定排序使用的字段，且该字段需要是boolean类型。（后面会有示例）

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

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface JPASort {
    String filedName();
}

第二个注解@JPASpecification，该注解用于标识字段，被标识的字段必须填充filedName属性。用于指明是区间查询、单体查询、条件查询等

例：通过接口入参tttOP（OPEnum在后面的Base类中）来标识ttt应该使用什么样的条件进行查询，有大于小于这些范围查询，有前模糊，后模糊，模糊查询，有区间等（可继续扩展）。

 例：创建时间的区间查询如下↓↓↓ 

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

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface JPASpecification {
    String filedName();
    /**
     * 是否仅支持equal条件，默认不使用，如果此属性为true，则不考虑其他匹配条件
     */
    boolean onlyEq() default false;
    /**
     * filedName 对应的 QueryCriteria
     */
    String queryCriteria() default "";
    /**
     * 是否是区间的开头
     */
    boolean startOfSection() default false;
    /**
     * 是否是区间的尾部
     */
    boolean endOfSection() default false;
}

第三个注解，@JPAExampleMatcher，该注解用于标识字段，被标识的字段必须填充filedName属性。使用Example查询，在后面有示例。

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

/**
 * 灵活匹配只支持String类型，其他类型只支持精准匹配，所以只有String类型需要使用该注解
 */
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface JPAExampleMatcher {
    String filedName();
    boolean eq() default false;
    boolean fuzzyQuery() default false;
    boolean startsWith() default false;
    boolean endsWith() default false;
    boolean ignoreFiled() default false;
}

第二部分，base类：

该类内部只有一个OPEnum枚举，不包含其他内容。

import java.util.HashMap;
import java.util.Map;

/**
 * 继承该类，指明子类是一个查询条件
 */
public class BaseCriteria {

    public enum OPEnum {
        EQ(1, "等于"),
        NEQ(2,"不等于"),
        GT(3, "大于"),
        GT_OR_EQ(4,"大于等于"),
        LT(5,"小于"),
        LT_OR_EQ(6,"小于等于"),
        START(7,"模糊查询-以...开始"),
        END(8,"模糊查询-以...结束"),
        CONTAINS(9,"模糊查询-包含"),
        BETWEEN(10, "区间"),
        ;

        private final int code;
        private final String description;

        OPEnum(int code, String description) {
            this.code = code;
            this.description = description;
        }

        public String description() {
            return this.description;
        }

        public int getCode() {
            return code;
        }

        public static String getMsgByCodeInt(int codeInt) {
            for (OPEnum e : OPEnum.values()) {
                if (e.getCode() == codeInt) {
                    return e.description;
                }
            }
            throw new IllegalArgumentException("未定义的code码:" + codeInt);
        }

        private static final Map<Integer, OPEnum> OP_ENUM_MAP = new HashMap<>();

        static {
            for (OPEnum a : OPEnum.values()) {
                OP_ENUM_MAP.put(a.getCode(), a);
            }
        }

        /**
         * 通过code获取OPEnum
         *
         * @param code code
         * @return OPEnum
         */
        public static OPEnum getEnumByCode(Integer code) {
            return OP_ENUM_MAP.get(code);
        }

    }

}

第三部分，util:

import cn.hutool.core.util.ArrayUtil;
import JPAExampleMatcher;
import JPASort;
import JPASpecification;
import BaseCriteria;
import lombok.Data;
import lombok.experimental.Accessors;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.ExampleMatcher;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.util.ReflectionUtils;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Objects;

@Slf4j
public class JPAUtils {

    /**
     * 通过BaseCriteria中的排序条件组装「排序对象」，如果没有排序条件，则返回无排序设置的Sort
     *
     * @param criteria 查询条件
     * @return 排序对象
     * @throws IllegalAccessException 非法访问异常(此处为获取)
     */
    public static Sort sortFromCriteria(BaseCriteria criteria) throws IllegalAccessException {
        if (criteria == null) {
            return Sort.unsorted();
        }
        Class<? extends BaseCriteria> criteriaClass = criteria.getClass();
        Field[] fields = criteriaClass.getDeclaredFields();
        List<Sort.Order> orderList = new ArrayList<>();
        for (Field field : fields) {
            ReflectionUtils.makeAccessible(field);
            // 对标注了JPASort注解的字段且字段值不为null的，进行Order拼装
            if (field.isAnnotationPresent(JPASort.class) && Objects.nonNull(field.get(criteria))) {
                JPASort jpaSort = field.getAnnotation(JPASort.class);
                boolean desc = (Boolean) field.get(criteria);
                Sort.Order order = desc ? Sort.Order.desc(jpaSort.filedName()) : Sort.Order.asc(jpaSort.filedName());
                orderList.add(order);
            }
        }
        if (orderList.size() > 0) {
            return Sort.by(orderList);
        }
        return Sort.unsorted();
    }


    /**
     * 通过BaseCriteria中example部分的字段标注的注解 @JPAExampleMatcher 组装ExampleMatcher
     * 注意：灵活匹配只针对于String类型，其余类型只能精确匹配，所以完全动态的查询ExampleMatcher并不支持
     *
     * @param criteria 查询条件
     * @return ExampleMatcher
     */
    public static ExampleMatcher exampleMatcherFromCriteria(BaseCriteria criteria) {
        ExampleMatcher matcher = ExampleMatcher.matching().withIgnoreCase();
        if (criteria == null) {
            return matcher;
        }
        Class<? extends BaseCriteria> criteriaClass = criteria.getClass();
        Field[] fields = criteriaClass.getDeclaredFields();
        for (Field field : fields) {
            // 对标注了JPAExampleMatcher注解的字段，进行matcher拼装
            if (field.isAnnotationPresent(JPAExampleMatcher.class)) {
                JPAExampleMatcher jpaExampleMatcher = field.getAnnotation(JPAExampleMatcher.class);
                // 根据标注的不同查询条件，进行匹配规则
                if (jpaExampleMatcher.fuzzyQuery()) {
                    matcher = matcher.withMatcher(jpaExampleMatcher.filedName(), ExampleMatcher.GenericPropertyMatcher::contains); // 模糊匹配
                }
                if (jpaExampleMatcher.startsWith()) {
                    matcher = matcher.withMatcher(jpaExampleMatcher.filedName(), ExampleMatcher.GenericPropertyMatcher::startsWith); // 开头匹配
                }
                if (jpaExampleMatcher.endsWith()) {
                    matcher = matcher.withMatcher(jpaExampleMatcher.filedName(), ExampleMatcher.GenericPropertyMatcher::endsWith); // 末尾匹配
                }
                if (jpaExampleMatcher.eq()) {
                    matcher = matcher.withMatcher(jpaExampleMatcher.filedName(), ExampleMatcher.GenericPropertyMatcher::exact); // 精确匹配
                }
                if (jpaExampleMatcher.ignoreFiled()) {
                    matcher = matcher.withIgnorePaths(jpaExampleMatcher.filedName()); // 忽略哪些字段不作为匹配规则
                }
            }
        }
        return matcher;
    }

    /**
     * 返回最基本的Specification
     */
    public static <T> Specification<T> defaultSpec(Class<T> clazz) {
        return (root, query, criteriaBuilder) -> criteriaBuilder.conjunction();
    }

    /**
     * 返回BaseCriteria对应拥有JPASpecification注解的非空字段的 fieldName:QueryCriteriaDTO 的键值对集合
     *
     * @param criteria 查询条件
     * @return 键值对集合
     * @throws IllegalAccessException 非法访问异常(此处为获取)
     */
    public static HashMap<String, QueryCriteriaDTO> opDTOFromCriteria(BaseCriteria criteria) throws IllegalAccessException {
        HashMap<String, QueryCriteriaDTO> result = new HashMap<>(16);
        Class<? extends BaseCriteria> criteriaClass = criteria.getClass();
        Field[] fields = criteriaClass.getDeclaredFields();
        for (Field field : fields) {
            ReflectionUtils.makeAccessible(field);
            if (field.isAnnotationPresent(JPASpecification.class) && Objects.nonNull(field.get(criteria))) {
                JPASpecification jpaSpecification = field.getAnnotation(JPASpecification.class);
                Object value = field.get(criteria);
                QueryCriteriaDTO dto;
                // 如果是区间
                if (jpaSpecification.startOfSection()) {
                    dto = result.containsKey(jpaSpecification.filedName()) ? result.get(jpaSpecification.filedName()) : new QueryCriteriaDTO()
                            .setSingle(false)
                            .setFieldName(jpaSpecification.filedName())
                            .setStartValue(value.toString())
                            .setStartJpaSpecification(jpaSpecification);
                } else if (jpaSpecification.endOfSection()) {
                    dto = result.containsKey(jpaSpecification.filedName()) ? result.get(jpaSpecification.filedName()) : new QueryCriteriaDTO()
                            .setSingle(false)
                            .setFieldName(jpaSpecification.filedName())
                            .setEndValue(value.toString())
                            .setEndJpaSpecification(jpaSpecification);
                } else {
                    // 如果是单体
                    dto = new QueryCriteriaDTO()
                            .setSingle(true)
                            .setSingleJpaSpecification(jpaSpecification)
                            .setFieldName(jpaSpecification.filedName())
                            .setFieldValue(value.toString());
                }
                // 放入
                result.put(jpaSpecification.filedName(), dto);
            }
        }
        return result;
    }

    public static void putFieldToOpMap(HashMap<BaseCriteria.OPEnum, List<QueryCriteriaDTO>> opMap, QueryCriteriaDTO dto, BaseCriteria.OPEnum op) {
        List<QueryCriteriaDTO> list;
        if (opMap.containsKey(op)) {
            list = opMap.get(op);
        } else {
            list = new ArrayList<>();
        }
        list.add(dto);
        opMap.put(op, list);
    }

    /**
     * ①通过JPASpecificationFromCriteria()方法获取非空字段的->dbo的fieldName:JPASpecification注解的键值对集合<br/>
     * ②
     *
     * @param criteria      查询条件
     * @param criteriaClass BaseCriteria对应的子类的class
     * @return 键值对集合
     * @throws IllegalAccessException 非法访问异常(此处为获取)
     */
    public static <K> HashMap<BaseCriteria.OPEnum, List<QueryCriteriaDTO>> fieldsFromCriteria(BaseCriteria criteria, Class<K> criteriaClass) throws IllegalAccessException {
        // 操作集合
        HashMap<BaseCriteria.OPEnum, List<QueryCriteriaDTO>> opMap = new HashMap<>(8);
        //
        HashMap<String, QueryCriteriaDTO> fieldJPASpecMap = opDTOFromCriteria(criteria);
        for (String fieldName : fieldJPASpecMap.keySet()) {
            QueryCriteriaDTO queryCriteriaDTO = fieldJPASpecMap.get(fieldName);
            // 单体
            if (queryCriteriaDTO.getSingle()) {
                // 只能是EQ的,放入EQ操作中后，开始下一个字段
                if (queryCriteriaDTO.getSingleJpaSpecification().onlyEq()) {
                    putFieldToOpMap(opMap, queryCriteriaDTO, BaseCriteria.OPEnum.EQ);
                    continue;
                }
                // 其他操作：
                // 在请求DTO中该字段对应的查询条件字段名
                String queryCriteria = queryCriteriaDTO.getSingleJpaSpecification().queryCriteria();
                // 根据此字段名获得字段的值
                Field field = ReflectionUtils.findField(criteriaClass, queryCriteria);
                assert field != null;
                ReflectionUtils.makeAccessible(field);
                Object op = ReflectionUtils.getField(field, criteria);
                if (op instanceof BaseCriteria.OPEnum) {
                    putFieldToOpMap(opMap, queryCriteriaDTO, (BaseCriteria.OPEnum) op);
                }
            } else {
                // 区间BETWEEN操作
                if (Objects.nonNull(queryCriteriaDTO.getStartValue()) && Objects.nonNull(queryCriteriaDTO.getEndValue())) {
                    putFieldToOpMap(opMap, queryCriteriaDTO, BaseCriteria.OPEnum.BETWEEN);
                }
                // 其他非单体操作(如果有，在此处进行添加 ↓↓↓)

            }
        }
        return opMap;
    }


    public static <T, K> Specification<T> specFromCriteria(Class<T> clazz, BaseCriteria criteria, Class<K> criteriaClass) throws IllegalAccessException {
        HashMap<BaseCriteria.OPEnum, List<QueryCriteriaDTO>> opMap = fieldsFromCriteria(criteria, criteriaClass);
        return (Root<T> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) -> {
            //
            List<Predicate> predicateList = new ArrayList<>();
            // 根据opMap组装Predicate然后返回
            for (BaseCriteria.OPEnum op : opMap.keySet()) {
                // 每一种操作组装成一个 Predicate
                predicateList.add(buildPredicate(opMap, op, root, query, criteriaBuilder));
            }
            if (predicateList.size() > 0) {
                return criteriaBuilder.and(ArrayUtil.toArray(predicateList, Predicate.class));
            }
            return criteriaBuilder.conjunction();
        };
    }

    private static <T> Predicate buildPredicate(HashMap<BaseCriteria.OPEnum, List<QueryCriteriaDTO>> opMap, BaseCriteria.OPEnum op, Root<T> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) {
        List<QueryCriteriaDTO> dtoList = opMap.get(op);
        List<Predicate> predicateList = new ArrayList<>();
        for (QueryCriteriaDTO criteriaDTO : dtoList) {
            Predicate predicate;
            switch (op) {
                case EQ:
                    predicateList.add(criteriaBuilder.equal(root.get(criteriaDTO.getFieldName()), criteriaDTO.getFieldValue()));
                    break;
                case NEQ:
                    predicateList.add(criteriaBuilder.notEqual(root.get(criteriaDTO.getFieldName()), criteriaDTO.getFieldValue()));
                    break;
                case GT:
                    predicateList.add(criteriaBuilder.greaterThan(root.get(criteriaDTO.getFieldName()), criteriaDTO.getFieldValue()));
                    break;
                case GT_OR_EQ:
                    predicateList.add(criteriaBuilder.greaterThanOrEqualTo(root.get(criteriaDTO.getFieldName()), criteriaDTO.getFieldValue()));
                    break;
                case LT:
                    predicateList.add(criteriaBuilder.lessThan(root.get(criteriaDTO.getFieldName()), criteriaDTO.getFieldValue()));
                    break;
                case LT_OR_EQ:
                    predicateList.add(criteriaBuilder.lessThanOrEqualTo(root.get(criteriaDTO.getFieldName()), criteriaDTO.getFieldValue()));
                    break;
                case START:
                    predicateList.add(criteriaBuilder.like(root.get(criteriaDTO.getFieldName()), criteriaDTO.getFieldValue() + "%"));
                    break;
                case END:
                    predicateList.add(criteriaBuilder.like(root.get(criteriaDTO.getFieldName()), "%" + criteriaDTO.getFieldValue()));
                    break;
                case CONTAINS:
                    predicateList.add(criteriaBuilder.like(root.get(criteriaDTO.getFieldName()), "%" + criteriaDTO.getFieldValue() + "%"));
                    break;
                case BETWEEN:
                    predicateList.add(criteriaBuilder.between(root.get(criteriaDTO.getFieldName()), criteriaDTO.getStartValue(), criteriaDTO.getEndValue()));
                    break;
                default:
                    log.warn("暂不支持的操作类型" + op.description());
                    break;
            }
        }
        return criteriaBuilder.and(ArrayUtil.toArray(predicateList, Predicate.class));
    }

    @Data
    @Accessors(chain = true)
    public static class QueryCriteriaDTO {
        private String fieldName;
        // 单体查询条件使用fieldValue
        private String fieldValue;
        // 区别是单体还是区间:true->单体；false->区间
        private Boolean single;
        private JPASpecification singleJpaSpecification;
        // 区间查询条件使用startValue和endValue
        private String startValue;
        private String endValue;
        private JPASpecification startJpaSpecification;
        private JPASpecification endJpaSpecification;
    }


}

第四部分，使用：

首先我们需要有一个继承了base类的查询类,其中Example部分对应dbo中的字段：

@Data
@EqualsAndHashCode(callSuper = true)
public class CriteriaTest extends BaseCriteria {

    /**
     * Sort部分：用于order by指定字段，此处可以任意保留0-n个，一般建议0-2个排序条件即可
     * （该部分内容非必须，但是一旦指定，默认true是desc，false是asc）
     */
    @JPASort(filedName = "createTime")
    private Boolean createTimeDesc;
    @JPASort(filedName = "updateTime")
    private Boolean updateTimeDesc;
    @JPASort(filedName = "status")
    private Boolean statusDesc;

    /**
     * Example部分：通过属性值组装example进行查询
     * 通过 @JPAExampleMatcher 标注进行组装匹配规则（灵活匹配只支持字符串类型，其余类型只支持精准匹配）
     * 下面的id表示必须精准匹配，ttt和descript可以是灵活匹配，根据是否输入该查询条件进行匹配
     */
    @JPAExampleMatcher(filedName = "id", eq = true)
    private String id;
    @JPAExampleMatcher(filedName = "ttt", fuzzyQuery = true)
    private String ttt;
    private Integer status;
    private Date createTime;
    private Date updateTime;
    @JPAExampleMatcher(filedName = "descript", fuzzyQuery = true)
    private String descript;
}

然后是我们的test：

    @Test
    @Rollback
    void exampleTest() {
        CriteriaTest criteria = new CriteriaTest();
        criteria.setTtt("1");
        ExampleMatcher exampleMatcher = JPAUtils.exampleMatcherFromCriteria(criteria);
        Example<Ttt> example = Example.of(new Ttt().setTtt(criteria.getTtt()), exampleMatcher);
        List<Ttt> list = tttRepo.findAll(example);
        list.forEach(System.out::println);
    }

因为数据库里面只有一条数据，最后test输出的结果【toString()】是：

Ttt(ttt=ff4b6ca5cb8246218cdccab89f02d24c, status=1, createTime=2022-11-11 14:16:51.895, updateTime=2022-11-11 14:16:51.895, descript=init)

更多查询相关的使用，如分页查询、动态查询可以自己摸索哦~

也许不许耶
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
JPAUtils:一套工具，可以更轻松地使用条件查询
05-19
JPAUtils 一组utils使使用条件查询更加轻松。
Hibernate 教程（五）[Criteria使用]
God_Father_kao的博客
12-25 586
Criteria Criteria 只支持查询，而且很难用，反正挺恶心的。我是这么觉得，别碰我。 但是Hibernate推荐这么做，我搞不懂 Criteria 查询数据 package query.Criteria; import java.util.Arrays; import java.util.List; import javax.persistence.Tuple; import ja...
JpaUtils 工具类
最新发布
小恶魔的博客
08-14 284
可以实现少量代码即完成一次查询，并且在业务发生修改时，相比。，存储过程等常用的操作方法，并结合前端列表的数据格式，静态工具类对数据库操作的常用功能进行完整的封装，并对。前台传过来的字段，并非主实体属性的时候，需要通过。务，进行了封装，使开发时无需再引入额外代码。，满足大多数业务场景，如果且存在。和事务，减少开发的重复代码量。子类，高级查询，分页，排序等均。，最快一行代码就能实现一次查询。进行排序或者高级查询时，通过。获取分页信息，列表查询时，，并扩展了如下一些方法，数据库表有相同主键则。
JPA学习（二） 创建JPAUtil 和 简单的增删改查
GinChou的萌新博客
10-14 1057
前章：https://blog.csdn.net/qq_28198181/article/details/102550503 这一节简单的记录一下 创建一个JPAUti类和增删改查的方法 依赖在上一章； 目录 1.创建JPAUTIL 2.创建增删改查方法 1.创建JPAUTIL 创建JPAUtil是用来通过这个方法得到一个单例的entityManagerFactory publi...
JPA-Specification常用条件查询构造方式
职业炮灰的博客
09-25 3179
使用JAP的JpaSpecificationExecutor常用条件查询方式
spring-data-jpa之Specification使用exists和not exists
coderyjz的博客
05-27 6298
写在前面 spring-data-jpa是spring对hibernate框架的封装，如果你一开始熟悉的是mybatis，那么转到jpa可能会让你有些不适应。jpa的简单查询确实非常非常方便，但是对于复杂查询来说，jpa确实有点“复杂”。当然，你可以写原生sql，但是那样就违背了jpa操作对象、避免操作sql的出发点了。好，废话不多说，进入正题吧。 遇到的问题 原先是针对单表的列表查询操作，非常简单，所以就用了Specification来做： return (root, query, cri.
DB.class.php mysql 连接数据库代码
01-06
DB.class.php mysql 连接数据库代码DB.class.php mysql 连接数据库代码DB.class.php mysql 连接数据库代码
Snoopy.class.rar_Snoopy.class.php
09-22
php网络源码，提供php网络服务，很方便使用
UserApi.class.php
06-24
UserApi.class.php
如何在eclipse中查看.class文件的步骤
10-19
如何在eclipse中查看引用现成的.class文件的步骤，以便于详细了解引用文件的实现方法。
SpringData框架中的JPA工具类
10-02
SpringData框架中使用的JPA工具类.模板代码,解决实体管理器工厂的浪费资源和耗时问题.第一次访问getEntityManager方法：经过静态代码块创建一个factory对象，再调用方法创建一个EntityManager对象,第二次方法getEntityManager方法：直接通过一个已经创建好的factory对象，创建EntityManager对象
OauthApi.class (2).php
06-24
OauthApi.class (2).php
Spring Data JPA进阶（三）：Specification查询
热门推荐
程铭程铭你快成名的博客
06-24 1万+
Spring Data JPA支持非常丰富的查询方式，本文主要介绍Specification查询。 JPA 2 规范引进了criteria查询API。Spring Data JPA对此提供了支持。如果你想使用这个功能，只需要继承JpaSpecificationExecutor接口。这个接口已经实现了基本的查询方法（findOne，findAll，count等）。 public interface ...
JPA复杂查询条件构造(两种写法)
weixin_46054799的博客
11-23 1091
private Specification<Users> getSpecification(){ return (Specification<Users>)(root, query, criteriaBuilder)->{ List<Predicate> predicates = new ArrayList<>(); Predicate gtId = criteriaBuilder...
JPAUtil
Thinking的专栏
12-01 1567
import java.util.List; import java.util.Map; import javax.persistence.Query; import net.sf.json.JSONArray; import net.sf.json.JSONObject; import org.hibernate.SQLQuery; import org.hibernate.transfo
一篇文章带你搞定如何抽取 JpaUtil 工具类
南淮北安的博客
07-11 1153
文章目录一、为什么要抽取 JpaUtil 工具类二、JpaUtil 工具类三、测试工具类 一、为什么要抽取 JpaUtil 工具类 前面我们已经学习了：一篇文章带你搞定 JPA 中的 API 对象 知道由于EntityManagerFactory 是一个线程安全的对象（即多个线程访问同一个EntityManagerFactory 对象不会有线程安全问题），并且EntityManagerFactory 的创建极其浪费资源，所以在使用JPA编程时，我们可以对EntityManagerFactory 的创建进行优
02 JPAUtil工具类
仙贝儿
09-17 294
JPAUtil工具类 1、创建一个工具类 package com.mars.util; import javax.persistence.EntityManager; import javax.persistence.EntityManagerFactory; import javax.persistence.Persistence; /* 解决实体管理器工厂的浪费资源和耗时问题 ...
Spring Data JPA 从入门到精通~Criteria概念的简单介绍
小强快跑~~
01-08 1787
（1）Root<T> root 代表了可以查询和操作的实体对象的根，如果将实体对象比喻成表名，那 root 里面就是这张表里面的字段，这不过是 JPQL 的实体字段而已。通过里面的 Path<Y> get(String attributeName)，来获得我们想操作的字段。 （2）CriteriaQuery<?> query 代表一个 specific 的顶层查询对象，它包含着查询的各个部分，比如 select 、from、where、group by、orde
【审批工作流camunda教程】（一）：创建camunda项目=＞部署流程定义=＞创建流程实例=＞走完流程实例
Te_zzx_amo的博客
01-18 1万+
教程（一）学习前提： ①了解bpmn2.0基础知识中的：startEvent，endEvent，Task； ②会使用IDEA,以及Maven（JAVA）； 1、首先，保存下方这个最简单的xml文件为：【simpleTest.bpmn20.xml】 <?xml version="1.0" encoding="UTF-8"?> <bpmn:definitions xmlns:bpmn="http://www.omg.org/spec/BPMN/20100524/MODEL" xmln
一个类.class是什么意思
06-01
在Java中，`.class`是一个后缀名，用于表示一个Java类的字节码文件。当一个Java类被编译后，会生成一个对应的`.class`文件，该文件包含了该类的所有信息，包括类名、字段、方法、访问修饰符等等。 在Java程序中，`....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值