FetchType。LAZY和FetchType。EAGER用于定义默认的读取计划。

不幸的是，您只能覆盖LAZY抓取的默认抓取计划。EAGER抓取不太灵活，可能导致许多性能问题。

我的建议是克制将关联设置为EAGER的冲动，因为取回是查询时的责任。因此，您的所有查询都应该使用fetch指令来只检索当前业务用例所需的内容。

我想在上面说的基础上补充这一点。

假设您正在使用Spring (MVC和数据)与这个简单的架构:

Controller <-> Service <-> Repository

如果你使用FetchType，你想返回一些数据到前端。LAZY，在你将数据返回给控制器方法后，你会得到一个LazyInitializationException，因为会话在服务中关闭了，所以JSON Mapper对象无法获得数据。

根据设计、性能和开发人员的不同，有两种常见的方法来解决这个问题:

最简单的方法是使用FetchType。EAGER或任何其他反模式解决方案，使会话仍然活跃在控制器方法，但这些方法将影响性能。 最佳实践是使用FetchType。LAZY使用映射器(如MapStruct)将数据从Entity传输到另一个数据对象DTO，然后将其发送回控制器，因此会话关闭时没有异常。

有一个简单的例子:

@RestController
@RequestMapping("/api")
public class UserResource {

    @GetMapping("/users")
    public Page<UserDTO> getAllUsers(Pageable pageable) {
        return userService.getAllUsers(pageable);
    }
}

@Service
@Transactional
public class UserService {

    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @Transactional(readOnly = true)
    public Page<UserDTO> getAllUsers(Pageable pageable) {
        return userRepository.findAll(pageable).map(UserDTO::new);
    }
}

@Repository
public interface UserRepository extends JpaRepository<User, String> {

    Page<User> findAll(Pageable pageable);
}

public class UserDTO {

    private Long id;

    private String firstName;

    private String lastName;

    private String email;
    
    private Set<String> addresses;

    public UserDTO() {
        // Empty constructor needed for Jackson.
    }

    public UserDTO(User user) {
        this.id = user.getId();
        this.firstName = user.getFirstName();
        this.lastName = user.getLastName();
        this.email = user.getEmail();
        this.addresses = user.getAddresses().stream()
            .map(Address::getAddress)
            .collect(Collectors.toSet());
    }

    // Getters, setters, equals, and hashCode
}

@Entity
@Table(name = "user")
public class User implements Serializable {

    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column
    private String firstName;

    @Column
    private String lastName;

    @Column(unique = true)
    private String email;
    
    @OneToMany(mappedBy = "address", fetch = FetchType.LAZY)
    private Set<Address> addresses = new HashSet<>();

    // Getters, setters, equals, and hashCode
}

@Entity
@Table(name = "address")
public class Address implements Serializable {

    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column
    private String address;

    @ManyToOne
    @JsonIgnoreProperties(value = "addresses", allowSetters = true)
    private User user;

    // Getters, setters, equals, and hashCode
}

如果你在使用Hibernate，你可以在调用getStudents()方法时调用Hibernate.initialize():

Public class UniversityDaoImpl extends GenericDaoHibernate<University, Integer> implements UniversityDao {
    //...
    @Override
    public University get(final Integer id) {
        Query query = getQuery("from University u where idUniversity=:id").setParameter("id", id).setMaxResults(1).setFetchSize(1);
        University university = (University) query.uniqueResult();
        ***Hibernate.initialize(university.getStudents());***
        return university;
    }
    //...
}

对集合的EAGER加载意味着在获取它们的父类时，它们被完全获取。如果你有课程并且它有List<Student>，所有的学生在课程被获取的同时从数据库中获取。

另一方面，LAZY意味着只有当您试图访问List的内容时才会获取它们。例如，调用course.getStudents().iterator()。调用List上的任何访问方法都将启动对数据库的调用以检索元素。这是通过围绕列表(或集合)创建代理来实现的。所以对于惰性集合，具体的类型不是ArrayList和HashSet，而是PersistentSet和PersistentList(或PersistentBag)。

LAZY:它惰性地获取子实体，即在获取父实体时，它只是获取子实体的代理(由cglib或任何其他实用程序创建)，当你访问子实体的任何属性时，它实际上是由hibernate获取的。

EAGER:它与父实体一起获取子实体。

为了更好地理解，请参阅Jboss文档，或者使用hibernate。Show_sql =true，检查hibernate发出的查询。

默认情况下，对于所有的集合和映射对象，获取规则是FetchType。LAZY，对于其他实例，它遵循FetchType。急切的政策。 简而言之，@OneToMany和@ManyToMany关系并不隐式地获取相关对象(集合和映射)，但检索操作通过@OneToOne和@ManyToOne中的字段级联。

(提供:- objectdbcom)