经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Spring Boot » 查看文章
Spring-Data-Jpa使用总结
来源：cnblogs　　作者：逸竹小站　　时间：2019/10/17 10:38:34　　对本文有异议

参考资源列表

  1. 官方文档：https://docs.spring.io/spring-data/jpa/docs/2.1.5.RELEASE/reference/html/
  2. 《Spring Data JPA入门到精通》

前言

JPA是Java Persistence API的简称，是Spring在Hibernate的基础上进行的二次封装框架，为了更好更方便的融入Spring大家庭，同时也提供了一些Hibernate没有的特性，与其他ORM框架一起构成SpringData，统一封装了ORM层，使开发人员使用起来更加方便快捷。

备注：本文所有代码都是基于SpringBoot 2.1.5版本

JPA的使用

基本单表操作的使用

对于操作单表来说，jpa提供了非常方便使用的封装，我们只需要按规范编写Repository接口同时继承JpaRepository就可以享用jpa基本功能了。代码如下：

User实体:

  1. package com.yizhu.entity;
  3. import lombok.Builder;
  4. import lombok.Data;
  5. import lombok.ToString;
  7. import javax.persistence.*;
  8. import java.io.Serializable;
  9. import java.util.List;
  10. import java.util.Set;
  12. @Entity
  13. @Table(name = "t_user")
  14. @Data
  15. @Builder
  16. public class User implements Serializable {
  18.     private static final long serialVersionUID = 1L;
  20.     @Id
  21.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  22.     private Long id;
  24.     private String name;
  26.     private String password;
  28.     private Integer age;
  30.     private Integer sex;
  31. }

repository接口：

  1. package com.yizhu.repository;
  3. import com.yizhu.entity.User;
  5. public interface UserRepository extends JpaRepository<User, Long>{
  6. }

下面看看jpa为我们提供了哪些默认操作单表数据的方法

  1. package org.springframework.data.jpa.repository;
  2. @NoRepositoryBean
  3. public interface JpaRepository<T, ID> extends PagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T> {
  4.     List<T> findAll(); // 查询全表数据
  6.     List<T> findAll(Sort var1); // 查询全表数据，支持排序
  8.     List<T> findAllById(Iterable<ID> var1); // 根据id字段查询所有匹配数据
  10.     <S extends T> List<S> saveAll(Iterable<S> var1); // 批量保存或更新数据
  12.     void flush(); // 刷新本地缓存到数据库
  14.     <S extends T> S saveAndFlush(S var1); // 保存或更新单挑数据及刷新本地缓存到数据库
  16.     void deleteInBatch(Iterable<T> var1); // 批量删除数据
  18.     void deleteAllInBatch(); // 批量删除全表数据
  20.     T getOne(ID var1); // 根据id查询一条匹配数据
  22.     <S extends T> List<S> findAll(Example<S> ar1); // Example方式的查询指定实体
  24.     <S extends T> List<S> findAll(Example<S> var1, Sort var2);  // Example方式的查询指定实体并排序
  25. }
  1. package org.springframework.data.repository;
  2. @NoRepositoryBean
  3. public interface PagingAndSortingRepository<T, ID> extends CrudRepository<T, ID> {
  4.     Iterable<T> findAll(Sort var1);  // 根据排序查询全表，返回类型是任意集合
  6.     Page<T> findAll(Pageable var1); // 根据分页参数分页查询
  7. }
  1. package org.springframework.data.repository;
  2. @NoRepositoryBean
  3. public interface CrudRepository<T, ID> extends Repository<T, ID> {
  4.     <S extends T> S save(S var1);   // 保存或更新单条数据
  6.     <S extends T> Iterable<S> saveAll(Iterable<S> var1);  // 批量保存或更新
  8.     Optional<T> findById(ID var1);  // 根据id查询数据，返回类型是Optional
  10.     boolean existsById(ID var1);    // 根据id判断数据是否存在
  12.     Iterable<T> findAll(); // 查询全表数据，返回类型为集合
  14.     Iterable<T> findAllById(Iterable<ID> var1); // 根据id集合查询数据
  16.     long count();   // 统计全表数据量
  18.     void deleteById(ID var1); // 根据id删除数据
  20.     void delete(T var1);    // 删除单条数据
  22.     void deleteAll(Iterable<? extends T> var1);     // 删除指定集合数据
  24.     void deleteAll();   // 删除全表数据
  25. }
  1. package org.springframework.data.repository.query;
  2. public interface QueryByExampleExecutor<T> {
  3.     <S extends T> Optional<S> findOne(Example<S> var1); // 根据Example查询一条
  5.     <S extends T> Iterable<S> findAll(Example<S> var1); // 根据Example查询所有数据
  7.     <S extends T> Iterable<S> findAll(Example<S> var1, Sort var2);  // 根据Example查询所有数据，并排序
  9.     <S extends T> Page<S> findAll(Example<S> var1, Pageable var2);  // 根据Example分页查询
  11.     <S extends T> long count(Example<S> var1);  // 根据Example统计
  13.     <S extends T> boolean exists(Example<S> var1);  // 根据Example判断数据是否存在
  14. }

除此之外，jpa提供了一套新的生成sql的机制，非常方便好用，jpa根据Repository接口的方法中的关键字、实体字段及出入参，自动生成sql，这种方式启动容器的时候就可以检查语法是否正确，简单使用例子如下：

  1. package com.yizhu.repository;
  3. import com.yizhu .entity.User;
  4. import org.springframework.data.jpa.repository.EntityGraph;
  5. import org.springframework.data.jpa.repository.JpaRepository;
  6. import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
  7. import org.springframework.data.jpa.repository.Query;
  8. import org.springframework.data.repository.query.Param;
  10. import java.util.List;
  12. public interface UserRepository extends JpaRepository<User, Long>{
  14.     /**
  15.      * 根据年龄查询用户信息
  16.      * @param age
  17.      * @return
  18.      */
  19.     List<User> findAllByAge(Integer age);
  21.     /**
  22.      * 根据用户性别和所属组织名称查询用户信息
  23.      * @param userSex
  24.      * @param orgName
  25.      * @return
  26.      */
  27.     List<User> findBySexAndOrg(@Param("sex") Integer sex, @Param("name") String name);
  29.     /**
  30.      * 根据用户名模糊查询
  31.      * @return
  32.      */
  33.     List<User> findAllByNameLike(@Param("name") String name);
  34. }

除了find 、By、And之外，还有一些关键词，全部定义在PartTree、Part类，组装起来可以生成各种各样的sql，下面截取部分代码，感兴趣的同学可以打开源码去阅读

  1. package org.springframework.data.repository.query.parser;
  2. public class PartTree implements Streamable<PartTree.OrPart> {
  3.     private static final String KEYWORD_TEMPLATE = "(%s)(?=(\\p{Lu}|\\P{InBASIC_LATIN}))";
  4.     private static final String QUERY_PATTERN = "find|read|get|query|stream";
  5.     private static final String COUNT_PATTERN = "count";
  6.     private static final String EXISTS_PATTERN = "exists";
  7.     private static final String DELETE_PATTERN = "delete|remove";
  8.     private static final Pattern PREFIX_TEMPLATE = Pattern.compile("^(find|read|get|query|stream|count|exists|delete|remove)((\\p{Lu}.*?))??By");
  9.     private final PartTree.Subject subject;
  10.     private final PartTree.Predicate predicate;
  11.     ...
  12.     private static String[] split(String text, String keyword) {
  13.         Pattern pattern = Pattern.compile(String.format("(%s)(?=(\\p{Lu}|\\P{InBASIC_LATIN}))", keyword));
  14.         return pattern.split(text);
  15.     }
  17.     private static class Predicate implements Streamable<PartTree.OrPart> {
  18.         private static final Pattern ALL_IGNORE_CASE = Pattern.compile("AllIgnor(ing|e)Case");
  19.         private static final String ORDER_BY = "OrderBy";
  20.         private final List<PartTree.OrPart> nodes;
  21.         private final OrderBySource orderBySource;
  22.         private boolean alwaysIgnoreCase;
  24.         public Predicate(String predicate, Class<?> domainClass) {
  25.             String[] parts = PartTree.split(this.detectAndSetAllIgnoreCase(predicate), "OrderBy");
  26.             if (parts.length > 2) {
  27.                 throw new IllegalArgumentException("OrderBy must not be used more than once in a method name!");
  28.             } else {
  29.                 this.nodes = (List)Arrays.stream(PartTree.split(parts[0], "Or")).filter(StringUtils::hasText).map((part) -> {
  30.                     return new PartTree.OrPart(part, domainClass, this.alwaysIgnoreCase);
  31.                 }).collect(Collectors.toList());
  32.                 this.orderBySource = parts.length == 2 ? new OrderBySource(parts[1], Optional.of(domainClass)) : OrderBySource.EMPTY;
  33.             }
  34.         }
  35.         ...
  36.     }
  38.     private static class Subject {
  39.         private static final String DISTINCT = "Distinct";
  40.         private static final Pattern COUNT_BY_TEMPLATE = Pattern.compile("^count(\\p{Lu}.*?)??By");
  41.         private static final Pattern EXISTS_BY_TEMPLATE = Pattern.compile("^(exists)(\\p{Lu}.*?)??By");
  42.         private static final Pattern DELETE_BY_TEMPLATE = Pattern.compile("^(delete|remove)(\\p{Lu}.*?)??By");
  43.         private static final String LIMITING_QUERY_PATTERN = "(First|Top)(\\d*)?";
  44.         private static final Pattern LIMITED_QUERY_TEMPLATE = Pattern.compile("^(find|read|get|query|stream)(Distinct)?(First|Top)(\\d*)?(\\p{Lu}.*?)??By");
  45.         private final boolean distinct;
  46.         private final boolean count;
  47.         private final boolean exists;
  48.         private final boolean delete;
  49.         private final Optional<Integer> maxResults;
  51.         public Subject(Optional<String> subject) {
  52.             this.distinct = (Boolean)subject.map((it) -> {
  53.                 return it.contains("Distinct");
  54.             }).orElse(false);
  55.             this.count = this.matches(subject, COUNT_BY_TEMPLATE);
  56.             this.exists = this.matches(subject, EXISTS_BY_TEMPLATE);
  57.             this.delete = this.matches(subject, DELETE_BY_TEMPLATE);
  58.             this.maxResults = this.returnMaxResultsIfFirstKSubjectOrNull(subject);
  59.         }
  61.         private Optional<Integer> returnMaxResultsIfFirstKSubjectOrNull(Optional<String> subject) {
  62.             return subject.map((it) -> {
  63.                 Matcher grp = LIMITED_QUERY_TEMPLATE.matcher(it);
  64.                 return !grp.find() ? null : StringUtils.hasText(grp.group(4)) ? Integer.valueOf(grp.group(4)) : 1;
  65.             });
  66.         }
  67.         ...
  69.         private boolean matches(Optional<String> subject, Pattern pattern) {
  70.             return (Boolean)subject.map((it) -> {
  71.                 return pattern.matcher(it).find();
  72.             }).orElse(false);
  73.         }
  74.     }
  75. }
  1. package org.springframework.data.repository.query.parser;
  2. public class Part {
  3.     private static final Pattern IGNORE_CASE = Pattern.compile("Ignor(ing|e)Case");
  4.     private final PropertyPath propertyPath;
  5.     private final Part.Type type;
  6.     private Part.IgnoreCaseType ignoreCase;
  7.     ...
  8.     public static enum Type {
  9.         BETWEEN(2, new String[]{"IsBetween", "Between"}),
  10.         IS_NOT_NULL(0, new String[]{"IsNotNull", "NotNull"}),
  11.         IS_NULL(0, new String[]{"IsNull", "Null"}),
  12.         LESS_THAN(new String[]{"IsLessThan", "LessThan"}),
  13.         LESS_THAN_EQUAL(new String[]{"IsLessThanEqual", "LessThanEqual"}),
  14.         GREATER_THAN(new String[]{"IsGreaterThan", "GreaterThan"}),
  15.         GREATER_THAN_EQUAL(new String[]{"IsGreaterThanEqual", "GreaterThanEqual"}),
  16.         BEFORE(new String[]{"IsBefore", "Before"}),
  17.         AFTER(new String[]{"IsAfter", "After"}),
  18.         NOT_LIKE(new String[]{"IsNotLike", "NotLike"}),
  19.         LIKE(new String[]{"IsLike", "Like"}),
  20.         STARTING_WITH(new String[]{"IsStartingWith", "StartingWith", "StartsWith"}),
  21.         ENDING_WITH(new String[]{"IsEndingWith", "EndingWith", "EndsWith"}),
  22.         IS_NOT_EMPTY(0, new String[]{"IsNotEmpty", "NotEmpty"}),
  23.         IS_EMPTY(0, new String[]{"IsEmpty", "Empty"}),
  24.         NOT_CONTAINING(new String[]{"IsNotContaining", "NotContaining", "NotContains"}),
  25.         CONTAINING(new String[]{"IsContaining", "Containing", "Contains"}),
  26.         NOT_IN(new String[]{"IsNotIn", "NotIn"}),
  27.         IN(new String[]{"IsIn", "In"}),
  28.         NEAR(new String[]{"IsNear", "Near"}),
  29.         WITHIN(new String[]{"IsWithin", "Within"}),
  30.         REGEX(new String[]{"MatchesRegex", "Matches", "Regex"}),
  31.         EXISTS(0, new String[]{"Exists"}),
  32.         TRUE(0, new String[]{"IsTrue", "True"}),
  33.         FALSE(0, new String[]{"IsFalse", "False"}),
  34.         NEGATING_SIMPLE_PROPERTY(new String[]{"IsNot", "Not"}),
  35.         SIMPLE_PROPERTY(new String[]{"Is", "Equals"});
  37.         private static final List<Part.Type> ALL = Arrays.asList(IS_NOT_NULL, IS_NULL, BETWEEN, LESS_THAN, LESS_THAN_EQUAL, GREATER_THAN, GREATER_THAN_EQUAL, BEFORE, AFTER, NOT_LIKE, LIKE, STARTING_WITH, ENDING_WITH, IS_NOT_EMPTY, IS_EMPTY, NOT_CONTAINING, CONTAINING, NOT_IN, IN, NEAR, WITHIN, REGEX, EXISTS, TRUE, FALSE, NEGATING_SIMPLE_PROPERTY, SIMPLE_PROPERTY);
  38.         public static final Collection<String> ALL_KEYWORDS;
  39.         private final List<String> keywords;
  40.         private final int numberOfArguments;
  41.         ...
  42.         static {
  43.             List<String> allKeywords = new ArrayList();
  44.             Iterator var1 = ALL.iterator();
  46.             while(var1.hasNext()) {
  47.                 Part.Type type = (Part.Type)var1.next();
  48.                 allKeywords.addAll(type.keywords);
  49.             }
  51.             ALL_KEYWORDS = Collections.unmodifiableList(allKeywords);
  52.         }
  53.     }
  54. }

可以看到单表操作的大部分需求jpa都为我们提供了现成的实现，但也支持我们使用@Query注解自定义查询sql，方便有sql基础的同学使用，sql可控性强。

  1. package com.yizhu.repository;
  3. import com.yizhu .entity.User;
  4. import org.springframework.data.jpa.repository.EntityGraph;
  5. import org.springframework.data.jpa.repository.JpaRepository;
  6. import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
  7. import org.springframework.data.jpa.repository.Query;
  8. import org.springframework.data.repository.query.Param;
  10. import java.util.List;
  12. public interface UserRepository extends JpaRepository<User, Long>{
  14.     /**
  15.      * 查询所有用户信息
  16.      * @return
  17.      */
  18.     @Query(value = "from User u")
  19.     List<User> findAll();
  21.     /**
  22.      * 根据年龄查询用户信息
  23.      * @param age
  24.      * @return
  25.      */
  26.     @Query(value = "select * from t_user u where u.user_age = ?1", nativeQuery = true)
  27.     List<User> findAllByAge(Integer age);
  29.     /**
  30.      * 根据用户性别和所属组织名称查询用户信息
  31.      * @param userSex
  32.      * @param orgName
  33.      * @return
  34.      */
  35.     @Query(value = "select u from User u left join u.org o where u.userSex = :userSex and o.orgName = :orgName")
  36.     List<User> findUsersBySexAndOrg(@Param("userSex") Integer userSex, @Param("orgName") String orgName);
  38. }

多表关联

@OneToOne、@OneToMany、@ManyToOne、@ManyToMany

  1. @Entity
  2. @Table(name = "t_user")
  3. @NamedEntityGraph(name = "User.findUsers", attributeNodes = {@NamedAttributeNode("jobs"), @NamedAttributeNode("roles")})
  4. @Data
  5. @Builder
  6. @NoArgsConstructor
  7. @AllArgsConstructor
  8. public class User implements Serializable {
  10.     private static final long serialVersionUID = 1L;
  12.     @ApiModelProperty(hidden = true)
  13.     @Id
  14.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  15.     private Long id;
  17.     @ApiModelProperty(value = "用户名")
  18.     @Column(name = "user_name")
  19.     private String name;
  21.     @ApiModelProperty(value = "用户密码")
  22.     @Column(name = "user_password")
  23.     private String password;
  25.     @ApiModelProperty(value = "用户年龄")
  26.     @Column(name = "user_age")
  27.     private Integer age;
  29.     @ApiModelProperty(value = "用户性别")
  30.     @Column(name = "user_sex")
  31.     private Integer sex;
  33.     @ApiModelProperty(value = "所属组织id")
  34.     @Column(name = "org_id")
  35.     private Long orgId;
  37.     @ApiModelProperty(value = "用户信息")
  38.     @OneToOne
  39.     @JoinColumn(name = "id", updatable = false, insertable = false)
  40.     private UserInfo userInfo;
  42.     @ApiModelProperty(value = "用户所属组织")
  43.     @ManyToOne
  44.     @JoinColumn(name = "org_id", updatable = false, insertable = false)
  45.     private Organization org;
  47.     @ApiModelProperty(value = "用户角色")
  48.     @OneToMany
  49.     @JoinColumn(name = "user_id", referencedColumnName = "id", insertable = false, updatable = false)
  50.     @NotFound(action = NotFoundAction.IGNORE)
  51.     private Set<Role> roles;
  53.     @ApiModelProperty(value = "用户工作")
  54.     @ManyToMany
  55.     @JoinTable(
  56.             name = "t_user_job",
  57.             joinColumns = @JoinColumn(name = "user_id", referencedColumnName = "id"),
  58.             inverseJoinColumns = @JoinColumn(name = "job_id", referencedColumnName = "id")
  59.     )
  60.     @NotFound(action = NotFoundAction.IGNORE)
  61.     private Set<Job> jobs;

private Set<Role> roles;和private Set<Job> jobs;不能用同时使用List集合代替，会报错org.hibernate.loader.MultipleBagFetchException: cannot simultaneously fetch multiple bags: [com.yizhu.entity.User.jobs, com.yizhu.entity.User.roles]

动态查询

  1. package com.yizhu.repository;
  3. import com.yizhu.dto.UserQueryDto;
  4. import com.yizhu.entity.Organization;
  5. import com.yizhu.entity.User;
  6. import org.springframework.data.jpa.domain.Specification;
  8. import javax.persistence.criteria.Join;
  9. import javax.persistence.criteria.JoinType;
  10. import javax.persistence.criteria.Predicate;
  11. import java.util.ArrayList;
  12. import java.util.List;
  13. import java.util.Optional;
  15. public class UserSpecs {
  17.     public static Specification<User> listQuerySpec(UserQueryDto userQueryDto){
  18.         return (root, query, builder) -> {
  19.             List<Predicate> predicates = new ArrayList<>();
  21.             Optional.ofNullable(userQueryDto.getId()).ifPresent(i -> predicates.add(builder.equal(root.get("id"), i)));
  22.             Optional.ofNullable(userQueryDto.getName()).ifPresent(n -> predicates.add(builder.equal(root.get("name"), n)));
  23.             Optional.ofNullable(userQueryDto.getAge()).ifPresent(a -> predicates.add(builder.equal(root.get("age"), a)));
  24.             Optional.ofNullable(userQueryDto.getOrgId()).ifPresent(oi -> predicates.add(builder.equal(root.get("orgId"), oi)));
  25.             Optional.ofNullable(userQueryDto.getOrgName()).ifPresent(on -> {
  26.                 Join<User, Organization> userJoin = root.join(root.getModel().getSingularAttribute("org", Organization.class), JoinType.LEFT);
  27.                 predicates.add(builder.equal(userJoin.get("orgName"), on));
  28.             });
  30.             return builder.and(predicates.toArray(new Predicate[predicates.size()]));
  31.         };
  32.     }
  33. }
  1. package com.yizhu.service;
  3. import com.yizhu.dto.UserQueryDto;
  4. import com.yizhu.entity.User;
  5. import com.yizhu.repository.UserRepository;
  6. import com.yizhu.repository.UserSpecs;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.stereotype.Service;
  10. import java.util.List;
  12. @Service
  13. public class UserService {
  15.     @Autowired
  16.     private UserRepository userRepository;
  18.     public List<User> findUsersDynamic(UserQueryDto userQueryDto){
  19.         return userRepository.findAll(UserSpecs.listQuerySpec(userQueryDto));
  20.     }
  21. }

审计功能使用

在启动类添加@EnableJpaAuditing注解表示开启jpa审计功能

  1. package com.yizhu;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
  7. @EnableJpaAuditing
  8. @SpringBootApplication
  9. public class DemoApplication {
  11.     public static void main(String[] args) {
  12.         SpringApplication.run(DemoApplication.class, args);
  13.     }
  14. }

在需要使用审计功能的实体类添加@EntityListeners(AuditingEntityListener.class)注解

  1. package com.yizhu.entity;
  3. import lombok.Builder;
  4. import lombok.Data;
  5. import org.springframework.data.jpa.domain.support.AuditingEntityListener;
  7. import javax.persistence.*;
  8. import java.io.Serializable;
  9. import java.util.Date;
  11. @Entity
  12. @Table(name = "t_role")
  13. @Data
  14. @Builder
  15. @EntityListeners(AuditingEntityListener.class)
  16. public class Role implements Serializable {
  17.     private static final long serialVersionUID=1L;
  19.     @ApiModelProperty(hidden = true)
  20.     @Id
  21.     @GeneratedValue(strategy = GenerationType.AUTO)
  22.     private Long id;
  24.     private String roleName;
  26.     @CreatedDate
  27.     private Date createTime;
  28.     
  29.     @CreatedBy
  30.     private Long createId;
  31.     
  32.     @LastModifiedDate
  33.     private Date updateTime;
  34.     
  35.     @LastModifiedBy
  36.     private Long updateId;
  37. }

实现AuditorAware接口，告诉容器当前登录人id

  1. package com.yizhu.configuration;
  3. import org.springframework.data.domain.AuditorAware;
  4. import org.springframework.web.context.request.RequestContextHolder;
  5. import org.springframework.web.context.request.ServletRequestAttributes;
  7. import java.util.Optional;
  9. public class UserAuditorAwareImpl implements AuditorAware<Long> {
  10.     @Override
  11.     public Optional<Long> getCurrentAuditor() {
  12.         // 从session中获取登录人id
  13.         ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
  14.         Long userId = (Long)servletRequestAttributes.getRequest().getSession().getAttribute("userId");
  15.         return Optional.of(userId);
  16.     }
  17. }

ok，然后jpa就会根据ID和Version判断当前操作是更新还是新增数据，新增时会注入当前登录人id到标有@CreateBy注解的字段上，当前时间注入到标有@CreateTime注解字段上；更新时则注入到@LastModifiedBy和@LastModifiedDate对应的字段上。想详细了解的可查看org.springframework.data.jpa.domain.support.AuditingEntityListener源码。

常见的坑

  • N+1问题，当使用@ManyToMany、@ManyToOne、@OneToMany、@OneToOne关联
    关系的时候，FetchType怎么配置LAZY或者EAGER。SQL真正执行的时
    候是由一条主表查询和N条子表查询组成的。这种查询效率一般比较
    低下，比如子对象有N个就会执行N+1条SQL。使用JPA 2.1推出来的@EntityGraph、@NamedEntityGraph可以解决该问题。如下。
  1. @ApiModel
  2. @Entity
  3. @Table(name = "t_user")
  4. @NamedEntityGraph(name = "User.findUsers", attributeNodes = {@NamedAttributeNode("jobs"), @NamedAttributeNode("roles")})
  5. @Data
  6. @Builder
  7. @NoArgsConstructor
  8. @AllArgsConstructor
  9. public class User implements Serializable {
  11.     private static final long serialVersionUID = 1L;
  13.     @ApiModelProperty(hidden = true)
  14.     @Id
  15.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  16.     private Long id;
  17.     
  18.     // 省略其他属性
  19. }
  1. package com.yizhu.repository;
  3. import com.yizhu.entity.User;
  4. import org.springframework.data.jpa.repository.EntityGraph;
  5. import org.springframework.data.jpa.repository.JpaRepository;
  6. import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
  7. import org.springframework.data.jpa.repository.Query;
  8. import org.springframework.data.repository.query.Param;
  9. import java.util.List;
  11. public interface UserRepository extends JpaRepository<User, Long>, JpaSpecificationExecutor<User> {
  13.     /**
  14.      * 根据id查询用户信息
  15.      * @param id
  16.      * @return
  17.      */
  18.     @EntityGraph(value = "User.findUsers", type = EntityGraph.EntityGraphType.FETCH)
  19.     User findAllById(Long id);
  21.     /**
  22.      * 根据name查询用户信息
  23.      * @param name
  24.      * @return
  25.      */
  26.     @EntityGraph(value = "User.findUsers", type = EntityGraph.EntityGraphType.FETCH)
  27.     @Query(value = "select * from t_user where user_name = :name", nativeQuery = true)
  28.     List<User> findAllByUserName(@Param("name") String name);
  29. }
  • 所有的注解要么全配置在字段上，要么全配置在get方法上，不能混用，混用就会启动不起来，但是语法配置没有问题。
  • 所有的关联都是支持单向关联和双向关联的，视具体业务场景而定。JSON序列化的时候使用双向注解会产生死循环，需要人为手动转化一次，或者使用@JsonIgnore。
  • 在所有的关联查询中，表一般是不需要建立外键索引的。@mappedBy的使用需要注意。
  • 级联删除比较危险，建议考虑清楚，或者完全掌握。
  • 不同的关联关系的配置，@JoinClumn里面的name、referencedColumnName代表的意思是不一样的，很容易弄混，可以根据打印出来的SQL做调整。
  • 当配置这些关联关系的时候建议大家直接在表上面，把外键建好，然后通过后面我们介绍的开发工具直接生成，这样可以减少自己调试的时间。

JPA常用注解

摘自《Spring Data JPA从入门到精通》

1554619508054

1554619555135

1554619583326

1554619600777

1554619615592

1554619631450

1554620031094

1554620213902

1554620262086

原文链接：http://www.cnblogs.com/coder2017/p/11690051.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Spring Boot热门文章

  • 史上最详 Thymeleaf 使用教程
  • Spring Boot如何通过java -jar启动
  • Spring Boot 2.x（六）：优雅的统一返回值
  • Springboot使用Logback实现日志配置与异常记录
  • 使用SpringBoot+EasyExcel+Vue实现excel表格的导入和导出详解
  • spring boot上传文件超出大小异常无法捕获问题
  • paging组件的用法和意义
  • springboot2.0集成rabbitmq的示例代码
  • Spring MVC学习step1——框架熟悉
  • spring boot ${}占位符不起作用的解决方案

    • Spring Boot推荐文章

  • 3分钟带你搞定Spring Boot中Schedule
  • 不单独部署注册中心，又要具备注册中心的功能，我能上天！
  • 从零开始学Spring Boot系列-集成Spring Security实现用户认证与授权
  • 不单独部署注册中心，又要具备注册中心的功能，咋不让我上天？
  • EasyExcel 无法读取图片？用poi写了一个工具类
  • 【进阶篇】使用 Stream 流对比两个集合的常用操作分享
  • 关于DDD和COLA的一些总结和思考
  • SnakeYaml反序列化分析
  • RestTemplate进行https请求时适配信任证书
  • Kryo反序列化链分析

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号