Java 与hibernate注释的一对一关系

我有数据库模式的这一部分： 而这个

用户

实体：

@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

实体

@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

关系，我必须使用的正确注释是什么？我读了一些例子，但我不太明白，它们彼此不同

试试这样的东西

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;
    }
}

---

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

---

在

user

类中的

clientLicense

字段之前添加

@OneToOne（mappedBy=“user”）

，告诉hibernate该字段与

clientLicense

类中的

user

字段“映射”在同一列中

clientLicense
是否需要
user
对象？或者它只能使用用户id吗？试着将
@JsonIgnore
放在
ClientLicense\user
上。我将此注释放在用户类中，它可以工作，但我无法添加新的ClientLicense，我用一个示例更新了我的问题它不工作，无限循环的问题是json注释。@没有
@JoinColumn
注释的luca？@JoinColumn在ClientLicense中entity@luca尝试从
ClientLicense
中删除
@JoinColumn
。没有这个必要
mappedBy
应该足够了。这是必要的，否则我会收到com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException:field list@luca中的未知列“clientlice0.user\u username”，这是因为hibernate表已经存在这样一个列。无论如何，这与您的问题无关，代码看起来很好。您是否尝试过删除表并重新创建它们？也许这两列存在于您的表中，而这正是hibernate所困惑的。或者将hibernate设置为
update
表定义，而不是使用现有的表定义。
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;
    }
}