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

当我尝试添加新的clientlicense时，我收到密钥用户名已经存在，即使它不存在。例如，如果我有这个用户表：

username    enabled id_role id_clientVersion
luca        1       1       1
roberto     1       4       1

和这个clientlicense：

id_clientLicense startDate  endDate     counter macAddress cpuId   id_username
1                2016-01-29 2017-01-29  300     12587.3645 658cPI  luca

我尝试使用id_username roberto添加客户端许可证，但它不起作用给我跟随错误

Duplicate entry 'roberto' for key 'PRIMARY'

这是来自java，使用mySQL workbench我可以添加roberto和luca两次。显然，我想添加一次用户，以尊重一对一的关系。错误发生在此隐藏查询中，自动创建：

insert 
    into
        ats.user
        (id_clientVersion, enabled, id_role, username) 
    values
        (?, ?, ?, ?)

但我只打电话给

@Override
    public ClientLicense createClientLicense(ClientLicense clientLicense) {
        return clientLicenseServices.create(clientLicense);
    }

通过此代码：

License license = new License();
license.setCounter(clientLicenseForm.getCounter());
license.setCpuId(clientLicenseForm.getCpuId());
license.setStartDate(clientLicenseForm.getStartDate());
license.setEndDate(clientLicenseForm.getEndDate());
license.setMacAddress("macAddress");

//Store license into database 
ClientLicense clientLicense;
try{
    clientLicense = new ClientLicense();
    clientLicense.setCounter(clientLicenseForm.getCounter());
    clientLicense.setCpuId(clientLicenseForm.getCpuId());
    clientLicense.setEndDate(clientLicenseForm.getEndDate());
    clientLicense.setStartDate(clientLicenseForm.getStartDate());
    clientLicense.setMacAddress(clientLicenseForm.getMacAddress());
    clientLicense.setUser(databaseAdministrationServices.findById(clientLicenseForm.getUser()));
    databaseAdministrationServices.createClientLicense(clientLicense);
}catch(Exception e){
    throw new QueryException(e);
}

为什么要尝试创建新用户？

Answer 1

隐藏查询的原因是CascadeType.ALL：

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

从这些类型中，您可以选择合适的类型。 JPA级联类型

Java Persistence Architecture支持的级联类型如下：

CascadeType.PERSIST ：表示save（）或persist（）操作级联到相关实体。
CascadeType.MERGE ：表示合并拥有实体时相关实体合并为托管状态。
CascadeType.REFRESH ：对refresh（）操作执行相同的操作。 CascadeType.REMOVE ：删除拥有实体后，删除与此设置相关的所有相关实体。
CascadeType.DETACH ：如果发生“手动分离”，则会分离所有相关实体。
CascadeType.ALL ：是所有上述级联操作的简写。

OneToOne使用Hibernate和Spring数据创建查询

1 个答案: