Java JPA hibernate 4延迟加载问题。如何在多通中加载惰性数据，而无需急于

有两张桌子

一个表与另一个表有许多连接

所有连接都是延迟加载样式。当我想从UppeningUsers中获取一些信息时，延迟加载可以工作，我可以获取数据。这一部分很清楚

Session session = this.sessionFactory.getCurrentSession();
    List<UppeningUsers> countryList =  session.createQuery("from UppeningUsers").list();

这家伙是代理，这意味着我无法获得任何数据。 即使我要求得到，我也没有得到任何信息。 表1

表2

所以如果我从母桌打电话。我们可以在需要的时候拿到名单。这部分没问题。

现在的问题是，如果我从有多个关系的子表调用，我将从那里获取代理。我没有得到完整的信息。 如果我真的渴望，我会得到它，但我不想要它。是否有其他方法可以在需要时获取这些惰性数据，而无需执行“急切”操作。

更新1

    package com.uppening.models;

    import com.sun.istack.internal.Nullable;
    import org.hibernate.annotations.Formula;
    import org.hibernate.annotations.Proxy;

    import javax.persistence.*;
    import java.util.Set;


   @Entity
  @Table(name = "uppening_users")
  @Proxy(lazy = true)

   public class UppeningUsers {

@Id
@Column(name = "id")
@GeneratedValue(strategy = GenerationType.IDENTITY)
int id;

private String name;
private boolean isblocked;

private String mail;
private String birthday;
private String source;
private String gender;
private String link;

private String description;
private String traveller;
private String interests;
private String device;
private String location;
private String showup;

@OneToMany(mappedBy = "user", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private Set<UsersPhotos> listPhotoObj;

@OneToMany(mappedBy = "personBlocked", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private Set<UserBlocks> peopleWhoBlockedMe;

@OneToMany(mappedBy = "blocker", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private Set<UserBlocks> peopleIBlocked;

@OneToMany(mappedBy = "activityUser", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private Set<UserActivities> listActivities;


@Formula(" DATE_FORMAT( FROM_DAYS( TO_DAYS( NOW( ) ) - TO_DAYS( birthday ) ) ,  '%Y' )    ")
@Nullable
private Integer age;














public UppeningUsers() {
    super();
}

@Transient
public Integer getAge() {
    return age;
}

public UppeningUsers(String name, boolean isblocked, String mail, String birthday,
                     String source, String gender, String link, String description,
                     String traveller, String interests, String device, String location,
                     String showup, Set<UsersPhotos> listPhotoObj, Set<UserBlocks> peopleWhoBlockedMe,
                     Set<UserBlocks> peopleIBlocked, Set<UserActivities> listActivities, Integer age) {
    this.name = name;
    this.isblocked = isblocked;
    this.mail = mail;
    this.birthday = birthday;
    this.source = source;
    this.gender = gender;
    this.link = link;
    this.description = description;
    this.traveller = traveller;
    this.interests = interests;
    this.device = device;
    this.location = location;
    this.showup = showup;
    this.listPhotoObj = listPhotoObj;
    this.peopleWhoBlockedMe = peopleWhoBlockedMe;
    this.peopleIBlocked = peopleIBlocked;
    this.listActivities = listActivities;
    this.age = age;
}
public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public boolean isIsblocked() {
    return isblocked;
}

public void setIsblocked(boolean isblocked) {
    this.isblocked = isblocked;
}

public String getMail() {
    return mail;
}

public void setMail(String mail) {
    this.mail = mail;
}

public String getBirthday() {
    return birthday;
}

public void setBirthday(String birthday) {
    this.birthday = birthday;
}

public String getSource() {
    return source;
}

public void setSource(String source) {
    this.source = source;
}

public String getGender() {
    return gender;
}

public void setGender(String gender) {
    this.gender = gender;
}

public String getLink() {
    return link;
}

public void setLink(String link) {
    this.link = link;
}

public String getDescription() {
    return description;
}

public void setDescription(String description) {
    this.description = description;
}

public String getTraveller() {
    return traveller;
}

public void setTraveller(String traveller) {
    this.traveller = traveller;
}

public String getInterests() {
    return interests;
}

public void setInterests(String interests) {
    this.interests = interests;
}

public String getDevice() {
    return device;
}

public void setDevice(String device) {
    this.device = device;
}

public String getLocation() {
    return location;
}

public void setLocation(String location) {
    this.location = location;
}

public String getShowup() {
    return showup;
}

public void setShowup(String showup) {
    this.showup = showup;
}

public Set<UsersPhotos> getListPhotoObj() {
    return listPhotoObj;
}

public void setListPhotoObj(Set<UsersPhotos> listPhotoObj) {
    this.listPhotoObj = listPhotoObj;
}

public Set<UserBlocks> getPeopleWhoBlockedMe() {
    return peopleWhoBlockedMe;
}

public void setPeopleWhoBlockedMe(Set<UserBlocks> peopleWhoBlockedMe) {
    this.peopleWhoBlockedMe = peopleWhoBlockedMe;
}

public Set<UserBlocks> getPeopleIBlocked() {
    return peopleIBlocked;
}

public void setPeopleIBlocked(Set<UserBlocks> peopleIBlocked) {
    this.peopleIBlocked = peopleIBlocked;
}

public Set<UserActivities> getListActivities() {
    return listActivities;
}

public void setListActivities(Set<UserActivities> listActivities) {
    this.listActivities = listActivities;
}

public void setAge(Integer age) {
    this.age = age;
}
   }

}

更新2 我看到，如果我调用这个UserPhoto对象中的任何User setter，它就会得到信息。例如countryList.get（0）.getUser（）.getLink（）实际上进入数据库并检索信息。。但只有这些信息它不会作为完整的对象数据响应，我指的是countryList.get（0）.getUser（）这一个。我不想看所有的数据，所以这是我的问题

更新3 Fetch sql建议是答案，但它产生了另一个问题

   @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private Set<UsersPhotos> listPhotoObj;

@OneToMany(mappedBy = "personBlocked", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private Set<UserBlocks> peopleWhoBlockedMe;

@OneToMany(mappedBy = "blocker", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private Set<UserBlocks> peopleIBlocked;

@OneToMany(mappedBy = "activityUser", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private Set<UserActivities> listActivities;

那么我实际上不需要这些sqls发生

您可以使用来触发任何相关数据的提取，只需确保在同一

会话中使用它

例如：

Session session = this.sessionFactory.getCurrentSession();
List<UsersPhotos> countryList =  session.createQuery("from UsersPhotos").list();

for(UsersPhotos usersPhotos : countryList){ // don't forget the null countryList case
  Hibernate.initialize(usersPhotos.getUser());
}

Session Session=this.sessionFactory.getCurrentSession（）；
List countryList=session.createQuery（“来自UsersPhotos”）.List（）；
对于（UsersPhotos UsersPhotos:countryList）{//不要忘记null countryList的大小写
初始化（usersPhotos.getUser（））；
}

试试这个：

List<UsersPhotos> countryList =  session.createQuery("from UsersPhotos up JOIN FETCH up.user").list();

---

请下次复制源代码，而不是打印屏幕，这样它可以更可读。在上一个打印屏幕中，您对用户对象进行了延迟初始化，当您告诉hibernate使用

FetchType.lazy

时，这是正常的。您可以演示如何访问用户数据吗？List countryList=session.createQuery（“from UsersPhotos”）.List（）；我称之为，用户数据为空。我想填充这个用户数据，但我想保持懒惰。当我想的时候，有没有类似于力的东西。要访问I do countryList.get（0）.getUser（），这根本不返回任何内容。我把完整的源代码放进去。这是关于hibernate的问题还是关于调试器如何工作的问题？Hibernate看起来正是按照你们告诉它的那个样做的。问题是，若我从照片中查询，我并并没有得到升级，这是因为延迟加载。但若我想从服务器返回那个些信息，那个么我就会得到这个延迟错误。因此，我想初始化对象，以便作为服务器响应传递。我不想做渴望的事。如果我使用每个变量的get，那么我就得到了所有的信息。然而，我想要的是《乌宾尼古斯》的who对象，而不仅仅是它的特定部分。对不起，同样的事情发生了。然而，通过我的调查，我发现如果我调用这个UserPhoto对象中的任何用户setter，那么它就会得到信息。例如countryList.get（0）.getUser（）.getLink（）实际上进入数据库并检索信息。。但只有这些信息它不会作为完整的对象数据响应，我指的是countryList.get（0）.getUser（）这一个。我不想看所有的数据，所以这是我的问题。我把全部的数据都放进去了source@legend12345您是正确的，触发获取延迟初始化实体的方法之一是在会话Hibernate.initialize（）中为它们调用getter方法Hibernate提供了一种更简洁的方法，即不调用代码中的getter方法而不将其分配给任何variable@legend12345检查这个答案@legend12345这是所有方法的一个很好的列表，在所有情况下，你都必须实现一些特定的方法来获取这些数据是的，这已经完成了。即使是惰性的，我也可以获取列表中的特定项数据。谢谢，但这里的问题是，现在所有的UppeningUser对象延迟加载程序也在加载：）它有3个延迟加载程序。所以他们也会进来。你对此有什么建议吗？你可以用子句来过滤你的查询。请把你的评论移到问题上，你的代码很难读。

   @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private Set<UsersPhotos> listPhotoObj;

@OneToMany(mappedBy = "personBlocked", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private Set<UserBlocks> peopleWhoBlockedMe;

@OneToMany(mappedBy = "blocker", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private Set<UserBlocks> peopleIBlocked;

@OneToMany(mappedBy = "activityUser", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private Set<UserActivities> listActivities;

private String mail;
private String birthday;
private String source;
private String gender;
private String link;

Session session = this.sessionFactory.getCurrentSession();
List<UsersPhotos> countryList =  session.createQuery("from UsersPhotos").list();

for(UsersPhotos usersPhotos : countryList){ // don't forget the null countryList case
  Hibernate.initialize(usersPhotos.getUser());
}

List<UsersPhotos> countryList =  session.createQuery("from UsersPhotos up JOIN FETCH up.user").list();

List<UsersPhotos> countryList =  session.createQuery("from UsersPhotos up LEFT JOIN FETCH up.user").list();