Question

我有这部分数据库架构：和这个User实体：

@Entity
@Table(name = "user", catalog = "ats")
public class User implements java.io.Serializable{

    private static final long serialVersionUID = 1L;
    private String username;
    private boolean enabled;
    private Role role;
    private ClientVersion clientVersion;
    private ClientLicense clientLicense;
    @JsonIgnore
    private Set<NotificationHasUser> notificationHasUsers = new HashSet<NotificationHasUser>(0);

    public User() {
    }

    public User(String username, boolean enabled) {
        this.username = username;
        this.enabled = enabled;
    }

    public User(String username, boolean enabled, Role role, Set<NotificationHasUser> notificationHasUsers) {
        this.username = username;
        this.enabled = enabled;
        this.role = role;
        this.notificationHasUsers = notificationHasUsers;
    }

    @Id
    @Column(name = "username", unique = true, nullable = false, length = 45)
    public String getUsername() {
        return this.username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    @Column(name = "enabled", nullable = false)
    public boolean isEnabled() {
        return this.enabled;
    }

    public void setEnabled(boolean enabled) {
        this.enabled = enabled;
    }

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "id_role", nullable = false)
    public Role getRole() {
        return this.role;
    }

    public void setRole(Role role) {
        this.role = role;
    }

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "id_clientVersion", nullable = false)
    public ClientVersion getClientVersion() {
        return this.clientVersion;
    }

    public void setClientVersion(ClientVersion clientVersion) {
        this.clientVersion = clientVersion;
    }

    @OneToMany(fetch = FetchType.LAZY, mappedBy = "pk.user")
    public Set<NotificationHasUser> getNotificationHasUser() {
        return this.notificationHasUsers;
    }

    public void setNotificationHasUser(Set<NotificationHasUser> notificationHasUsers) {
        this.notificationHasUsers = notificationHasUsers;
    }

    @OneToOne(fetch = FetchType.LAZY, mappedBy = "user")
    public ClientLicense getClientLicense(){
        return this.clientLicense;
    }

    public void setClientLicense(ClientLicense clientLicense){
        this.clientLicense = clientLicense;
    }
}

一切正常，直到我添加一个新的clientlicense。如果我添加这个，我会收到一个无限循环：

Could not write content: Infinite recursion (StackOverflowError) (through reference chain: com.domain.User["clientLicense"]->com.domain.ClientLicense["user"]->com.domain.User["clientLicense"]->com.domain.ClientLicense["user"]->com.domain.User["clientLicense"]->com.domain.ClientLicense["user"]->com.domain.User["clientLicense"]->com.domain.ClientLicense["user"]->com.domain.User["clientLicense"]-....

这是我的ClientLicense实体

@Entity
@Table(name = "clientlicense", catalog = "ats")
public class ClientLicense implements java.io.Serializable{

    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private Integer idClientLicense;
    private Date startDate;
    private Date endDate;
    private int counter;
    private String macAddress;
    private String cpuId;
    private User user;

        public ClientLicense() {
        }

        /**
         * @param startDate
         * @param endDate
         * @param counter
         * @param macAddress
         * @param cpuId
         * @param users
         */
        public ClientLicense(Date startDate, Date endDate, int counter, String macAddress, String cpuId, User user) {
            super();
            this.startDate = startDate;
            this.endDate = endDate;
            this.counter = counter;
            this.setMacAddress(macAddress);
            this.setCpuId(cpuId);
            this.user = user;
        }

        @Id
        @GeneratedValue(strategy = IDENTITY)
        @Column(name = "id_clientLicense", unique = true, nullable = false)
        public Integer getIdClientLicense() {
            return this.idClientLicense;
        }

        public void setIdClientLicense(Integer idClientLicense) {
            this.idClientLicense = idClientLicense;
        }


        @Column(name = "startDate", nullable = false)
        public Date getStartDate() {
            return this.startDate;
        }

        public void setStartDate(Date startDate) {
            this.startDate = startDate;
        }

        @Column(name = "endDate", nullable = false)
        public Date getEndDate() {
            return this.endDate;
        }

        public void setEndDate(Date endDate) {
            this.endDate = endDate;
        }


        @Column(name = "counter", nullable = false)
        public int getCounter() {
            return this.counter;
        }

        public void setCounter(int counter) {
            this.counter = counter;
        }   

        /**
         * @return the macAddress
         */
        @Column(name = "macAddress", nullable = false)
        public String getMacAddress() {
            return macAddress;
        }

        /**
         * @param macAddress the macAddress to set
         */
        public void setMacAddress(String macAddress) {
            this.macAddress = macAddress;
        }

        /**
         * @return the cpuId
         */
        @Column(name = "cpuId", nullable = false)
        public String getCpuId() {
            return cpuId;
        }

        /**
         * @param cpuId the cpuId to set
         */
        public void setCpuId(String cpuId) {
            this.cpuId = cpuId;
        }

        @OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
        @JoinColumn(name = "id_username")
        public User getUser() {
            return this.user;
        }

        public void setUser(User user) {
            this.user = user;
        }
    }

这是我的第一个OneToOne关系，我必须使用哪个正确的注释？我读了一些例子，但我不理解，他们彼此不同。

Answer 1

尝试这样的事情。

public class User {
    private ClientLicense clientLicense;

    @OneToOne(fetch = FetchType.LAZY, mappedBy = "user")
    public ClientLicense getClientLicense() {
        return this.clientLicense;
    }
}

public class ClientLicense {
    private User user;

    @OneToOne
    @JoinColumn(name = "id_username")
    public User getUser() {
        return this.user;
    }
}

Answer 2

问题在于两个实体无法发现这两个字段实际上是在指定单个关系。因此，hibernate假设它们不是相同的关系，因此会尝试获取它们（因为默认情况下会急切地获取一对一的关系）。

在@OneToOne(mappedBy = "user")类的clientLicense字段之前添加User，告诉hibernate该字段是＆＃34;映射为＆＃34;与user类

中的ClientLicense字段相同的列

与hibernate注释的一对一关系

2 个答案: