Spring休眠惰性负载行为

我正在spring/hibernate中制作一个基于web的应用程序。在数据库中，我使用一对一和多对一关系。我在位置的用户中有多个One关系，在位置的用户中有多个One关系。在这两个实体中，我都启用了延迟加载选项。根据我的理解，如果启用此选项，则在显式调用之前不应执行获取位置的数据库查询，但每当我从userdao执行get时，都会执行下面的查询，这使我认为即使启用了lazy选项，它也在检索位置信息。有人能告诉我我做错了什么，或者这是预期的行为吗

Below is my user entity code

package com.kwisque.database.model;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

import javax.persistence.*;

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

    @Id
    @Column(name = "USER_ID", unique = true, nullable = false)
    private String userId;

    @Column(name = "NAME", nullable = true, length = 32)
    private String name;

    @Column(name = "PASSWORD", nullable = false, length = 64)
    private String password;

    @Column(name = "EMAIL_ID", nullable = true, length = 128)
    private String emailId;

    @Column(name = "ACTIVE", nullable = false, length = 1)
    private Integer active;

    @Column(name = "PROVIDER", nullable = false, length = 32)
    private String provider;

    @ManyToMany(fetch = FetchType.EAGER,cascade = CascadeType.ALL)
    @JoinTable(
            name = "USER_ROLE",
            joinColumns = @JoinColumn(name = "USER_ID"),
            inverseJoinColumns = @JoinColumn(name = "ROLE_ID")
    )
    private Set<Role> roles = new HashSet<>();

    //@ManyToOne(fetch = FetchType.LAZY)
    //@JoinColumn(name = "LOCATION_ID", nullable = true)
    @ManyToOne(fetch=FetchType.LAZY, cascade={javax.persistence.CascadeType.ALL})
    @JoinTable(name="USER_LOCATION_INFO", 
               joinColumns={@javax.persistence.JoinColumn(name="USER_ID")}, 
              inverseJoinColumns={@javax.persistence.JoinColumn(name="LOCATION_ID")})
    private Location location;

   // @OneToMany(fetch = FetchType.LAZY)
   //   @JoinColumn(name = "SPECIALIZATION_ID", nullable = true)

    @OneToMany(fetch=FetchType.LAZY, cascade={javax.persistence.CascadeType.ALL})
    @JoinTable(name="USER_SPECIALIZATION_INFO", 
               joinColumns={@javax.persistence.JoinColumn(name="USER_ID")}, 
               inverseJoinColumns={@javax.persistence.JoinColumn(name="SPECIALIZATION_ID")})
    private Set<Specialization> specialization = new HashSet<>();

    public User() {
    }

    public User(final String userId, final String name, final String password, final String emailId, final Integer active, final String provider, final Set<Role> roles, final Location location) {
        this.userId = userId;
        this.name = name;
        this.password = password;
        this.emailId = emailId;
        this.active = active;
        this.provider = provider;
        this.roles = roles;
        this.location = location;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(final String userId) {
        this.userId = userId;
    }

    public String getName() {
        return name;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(final String password) {
        this.password = password;
    }

    public Integer getActive() {
        return active;
    }

    public void setActive(final Integer active) {
        this.active = active;
    }

    public Set<Role> getRoles() {
        return roles;
    }

    public void setRoles(final Set<Role> roles) {
        this.roles = roles;
    }

    public String getProvider() {
        return provider;
    }

    public void setProvider(final String provider) {
        this.provider = provider;
    }

    public String getEmailId() {
        return emailId;
    }

    public void setEmailId(final String emailId) {
        this.emailId = emailId;
    }


    public Location getLocation() {
        return location;
    }

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


Location entity code

package com.kwisque.database.model;

import java.io.Serializable;
import java.util.Set;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

import com.fasterxml.jackson.annotation.JsonIgnore;

@Entity
@Table(name = "LOCATION")
public class Location implements Serializable {
    private static final long serialVersionUID = -7153748534015057865L;
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "LOCATION_ID", unique = true, nullable = false)
    private Integer locationId;
    @Column(name = "ZIP_CODE", nullable = true, length = 132)
    private String zipCode;
    @Column(name = "STATE_ABBR", nullable = true, length = 132)
    private String stateAbbr;
    @Column(name = "LATITUDE", nullable = true, length = 132)
    private double latitude;
    @Column(name = "LONGITUDE", nullable = true, length = 132)
    private double longitude;
    @Column(name = "CITY", nullable = true, length = 132)
    private String city;
    @Column(name = "STATE", nullable = true, length = 132)
    private String state;

    @JsonIgnore
    @OneToMany(fetch = FetchType.LAZY, mappedBy = "location")
    private Set<User> users;

    public double getLatitude() {
        return this.latitude;
    }

    public void setLatitude(double latitude) {
        this.latitude = latitude;
    }

    public double getLongitude() {
        return this.longitude;
    }

    public void setLongitude(double longitude) {
        this.longitude = longitude;
    }

    public Location() {
    }

    public Location(Integer locationId, long longitude, String city, long latitude, String zipCode, String state,
            String stateAbbr, Set<User> users) {
        this.locationId = locationId;
        this.longitude = longitude;
        this.latitude = latitude;
        this.city = city;
        this.state = state;
        this.stateAbbr = stateAbbr;
        this.users = users;
    }

    public Integer getLocationId() {
        return this.locationId;
    }

    public void setLocationId(Integer locationId) {
        this.locationId = locationId;
    }

    @JsonIgnore
    public Set<User> getUser() {
        return this.users;
    }

    @JsonIgnore
    public void setUser(Set<User> users) {
        this.users = users;
    }

    public String getCity() {
        return this.city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getState() {
        return this.state;
    }

    public void setState(String state) {
        this.state = state;
    }

    public String getZipCode() {
        return this.zipCode;
    }

    public void setZipCode(String zipCode) {
        this.zipCode = zipCode;
    }

    public String getStateAbbr() {
        return this.stateAbbr;
    }

    public void setStateAbbr(String stateAbbr) {
        this.stateAbbr = stateAbbr;
    }
}


Query being executed at my get from USerDao

Hibernate: select user0_.USER_ID as USER_ID1_3_0_, user0_.ACTIVE as ACTIVE2_3_0_, user0_.EMAIL_ID as EMAIL_ID3_3_0_, user0_.NAME as NAME4_3_0_, user0_.PASSWORD as PASSWORD5_3_0_, user0_.PROVIDER as PROVIDER6_3_0_, user0_1_.LOCATION_ID as LOCATION1_4_0_, roles1_.USER_ID as USER_ID1_3_1_, role2_.ROLE_ID as ROLE_ID2_5_1_, role2_.ROLE_ID as ROLE_ID1_1_2_, role2_.NAME as NAME2_1_2_ from USERS user0_ left outer join USER_LOCATION_INFO user0_1_ on user0_.USER_ID=user0_1_.USER_ID left outer join USER_ROLE roles1_ on user0_.USER_ID=roles1_.USER_ID left outer join ROLE role2_ on roles1_.ROLE_ID=role2_.ROLE_ID where user0_.USER_ID=?

下面是我的用户实体代码
包com.kwisque.database.model；
导入java.io.Serializable；
导入java.util.HashSet；
导入java.util.Set；
导入javax.persistence.*；
@实体
@表（name=“USERS”）
公共类用户实现可序列化{
@身份证
@列（name=“USER\u ID”，unique=true，nullable=false）
私有字符串用户标识；
@列（name=“name”，nullable=true，长度=32）
私有字符串名称；
@列（name=“PASSWORD”，null=false，长度=64）
私有字符串密码；
@列（name=“EMAIL\u ID”，null=true，长度=128）
私有字符串emailId；
@列（name=“ACTIVE”，nullable=false，length=1）
私有整数活动；
@列（name=“PROVIDER”，null=false，长度=32）
私有字符串提供者；
@ManyToMany（fetch=FetchType.EAGER，cascade=CascadeType.ALL）
@可接合(
name=“用户角色”，
joinColumns=@JoinColumn（name=“USER\u ID”），
inverseJoinColumns=@JoinColumn（name=“ROLE\u ID”）
)
私有集角色=新HashSet（）；
//@manytone（fetch=FetchType.LAZY）
//@JoinColumn（name=“LOCATION\u ID”，nullable=true）
@manytone（fetch=FetchType.LAZY，cascade={javax.persistence.CascadeType.ALL}）
@JoinTable（name=“USER\u LOCATION\u INFO”，
joinColumns={@javax.persistence.JoinColumn（name=“USER\u ID”）}，
inverseJoinColumns={@javax.persistence.JoinColumn（name=“LOCATION\u ID”）}
私人位置；
//@OneToMany（fetch=FetchType.LAZY）
//@JoinColumn（name=“SPECIALIZATION\u ID”，nullable=true）
@OneToMany（fetch=FetchType.LAZY，cascade={javax.persistence.CascadeType.ALL}）
@JoinTable（name=“USER\u SPECIALIZATION\u INFO”，
joinColumns={@javax.persistence.JoinColumn（name=“USER\u ID”）}，
inverseJoinColumns={@javax.persistence.JoinColumn（name=“SPECIALIZATION\u ID”）}
私有集专门化=新HashSet（）；
公共用户（）{
}
公共用户（最终字符串用户标识、最终字符串名称、最终字符串密码、最终字符串电子邮件标识、最终整数活动、最终字符串提供程序、最终设置角色、最终位置）{
this.userId=userId；
this.name=名称；
this.password=密码；
this.emailId=emailId；
这个.active=active；
this.provider=提供者；
this.roles=角色；
这个位置=位置；
}
公共字符串getUserId（）{
返回用户标识；
}
public void setUserId（最终字符串userId）{
this.userId=userId；
}
公共字符串getName（）{
返回名称；
}
public void setName（最终字符串名）{
this.name=名称；
}
公共字符串getPassword（）{
返回密码；
}
public void setPassword（最终字符串密码）{
this.password=密码；
}
公共整数getActive（）{
主动返回；
}
public void setActive（最终整数激活）{
这个.active=active；
}
公共集getRoles（）{
返回角色；
}
公共无效集合角色（最终集合角色）{
this.roles=角色；
}
公共字符串getProvider（）{
退货供应商；
}
公共void集提供程序（最终字符串提供程序）{
this.provider=提供者；
}
公共字符串getEmailId（）{
返回emailId；
}
public void setEmailId（最终字符串emailId）{
this.emailId=emailId；
}
公共位置getLocation（）{
返回位置；
}
公共无效设置位置（最终位置）{
这个位置=位置；
}
}
位置实体代码
包com.kwisque.database.model；
导入java.io.Serializable；
导入java.util.Set；
导入javax.persistence.Column；
导入javax.persistence.Entity；
导入javax.persistence.FetchType；
导入javax.persistence.GeneratedValue；
导入javax.persistence.GenerationType；
导入javax.persistence.Id；
导入javax.persistence.OneToMany；
导入javax.persistence.Table；
导入com.fasterxml.jackson.annotation.JsonIgnore；
@实体
@表（name=“LOCATION”）
公共类位置实现可序列化{
私有静态最终长serialVersionUID=-7153748534015057865L；
@身份证
@GeneratedValue（策略=GenerationType.IDENTITY）
@列（name=“LOCATION\u ID”，unique=true，nullable=false）
私有整数locationId；
@列（name=“ZIP_CODE”，null=true，长度=132）
私有字符串zipCode；
@列（name=“STATE_ABBR”，nullable=true，length=132）
私有字符串状态缩写；
@列（name=“LATITUDE”，nullable=true，length=132）
私人双纬度；
@列（name=“LONGITUDE”，nullable=true，length=132）
私人双经度；
@列（name=“CITY”，null=true，长度=132）
私人城市；
@列（name=“STATE”，nullable=true，length=132）
私有字符串状态；
@杰索尼奥雷
@OneToMany（fetch=FetchType.LAZY，mappedBy=“location”）
私人用户；
公共双纬度（）{
返回此值。纬度；
}
公共纬度（双纬度）{
这个。纬度=纬度；
}
公共双getLongitude（）{
返回这个经度；
}
公共经度（双经度）{
这个，罗