JPA persistent eine neue Entität mit eingebetteter ID mit vom Benutzer bereitgestellten Werten

Question

Wie richte ich Entitäten so ein, dass sie beibehalten werden, wenn die eingebetteten ID-Werte nicht sequenziert oder generiert, sondern von Benutzereingaben bereitgestellt werden? Der Fall ist, dass ich einen CustomDeviceType mit einer Liste von CustomDeviceModels habe. Wenn ein Benutzer einen neuen CustomDeviceType erstellt, werden die Attribute einschließlich der für die ID verwendeten Nummer angegeben. Das gleiche gilt für jedes CustomDeviceModel, das an CustomDeviceType angehängt ist.

Da die Tabelle devmodels einen zusammengesetzten Primärschlüssel von (dev_type, model_nbr) hat, habe ich einen EmbeddedEd für CustomDeviceModel erstellt. Wenn ich versuche, die CustomDeviceType ich folgende Fehlermeldung erhalten, bestehen bleiben:

javax.persistence.EntityNotFoundException: Unable to find com.etisoftware.manager.beans.cborg.devices.CustomDeviceModel with id com.etisoftware.manager.beans.cborg.devices.DeviceModelId@de70 

Welche Sinn von überwintert Sicht macht da DeviceModeId Werte hat, sollte es in der Datenbank vorhanden sind. Aber das tut es nicht.

Also diese Tabelle Setup, die ich nicht ändern kann. Wie richte ich meine Entitäten so ein, dass ich neue CustomDeviceModels speichern kann?

Ich habe zwei Tabellen devtypes und devmodels:

CREATE TABLE devtypes (
    dev_type integer NOT NULL, 
    dev_desc nchar(16) NOT NULL, 
    off_premise integer NOT NULL, 
    unrouteable integer DEFAULT 0                                                                , 
    custom_models integer DEFAULT 0                                                                , 
    force_case nchar(1) DEFAULT 'U                                                                ', 
    has_siblings integer DEFAULT 0                                                                , 
    PRIMARY KEY (dev_type) 
); 


CREATE TABLE devmodels (
    dev_type integer NOT NULL, 
    model_nbr integer NOT NULL, 
    model_desc nchar(20), 
    cablecard integer DEFAULT 0                                                                , 
    ont_type integer DEFAULT 0                                                                NOT NULL, 
    ont_port_type nchar(1) NOT NULL, 
    PRIMARY KEY (dev_type,model_nbr) 
); 

ALTER TABLE devmodels 
    ADD CONSTRAINT FOREIGN KEY (dev_type) 
    REFERENCES devtypes (dev_type); 

Ich habe folgende Einheiten:

@Entity 
@Table(name = "devtypes") 
public class CustomDeviceType 
{ 
    @Id 
    @Column(name = "dev_type") 
    private Integer   number; 

    @Column(name = "dev_desc") 
    private String   name; 

    @Column(name = "unrouteable") 
    private Boolean   unrouteable; 

    @Column(name = "off_premise") 
    private Boolean   offPremise; 

    @Column(name = "has_siblings") 
    private Boolean   hasSiblings; 

    @OneToMany(mappedBy = "deviceType", fetch = FetchType.LAZY) 
    private Set<CustomDeviceModel> deviceModels; 

    // Setters 

} 



@Entity 
@Table(name = "devmodels") 
public class CustomDeviceModel 
{ 
    @EmbeddedId 
    private DeviceModelId id; 

    public CustomDeviceModel() 
    { 
    id = new DeviceModelId(); 
    } 

    @Column(name = "model_desc") 
    private String   name; 

    @ManyToOne(fetch = FetchType.LAZY) 
    @JoinColumn(name = "dev_type") 
    @MapsId("deviceTypeNumber") 
    private CustomDeviceType deviceType; 

    @OneToOne(mappedBy = "deviceModel", fetch = FetchType.LAZY) 
    @JoinColumns({ @JoinColumn(name = "dev_type"), @JoinColumn(name = "model_nbr") }) 
    private CustomDeviceTypeConfig deviceConfig; 

    public Integer getNumber() 
    { 
    return id.getNumber(); 
    } 

    public void setNumber(Integer number) 
    { 
    id.setNumber(number); 
    } 

    public void setDeviceType(CustomDeviceType deviceType) 
    { 
    this.deviceType = deviceType; 
    id.setDeviceTypeNumber(deviceType.getNumber()); 
    } 

    public CustomDeviceTypeConfig getDeviceConfig() 
    { 
    return deviceConfig; 
    } 

    public void setDeviceConfig(CustomDeviceTypeConfig deviceConfig) 
    { 
    this.deviceConfig = deviceConfig; 
    id.setDeviceTypeNumber(deviceConfig.getDeviceModel().getDeviceType().getNumber()); 
    id.setNumber(deviceConfig.getDeviceModel().getNumber()); 
    } 

    // other setters 

} 




@Embeddable 
public class DeviceModelId implements Serializable 
{ 
    private static final long serialVersionUID = 5215223205194404431L; 

    private Integer   deviceTypeNumber; 

    @Column(name = "model_nbr") 
    private Integer   number; 

    public Integer getNumber() 
    { 
    return number; 
    } 

    public void setNumber(Integer number) 
    { 
    this.number = number; 
    } 

    public Integer getDeviceTypeNumber() 
    { 
    return deviceTypeNumber; 
    } 

    public void setDeviceTypeNumber(Integer deviceTypeNumber) 
    { 
    this.deviceTypeNumber = deviceTypeNumber; 
    } 

    @Override 
    public int hashCode() 
    { 
    return new HashCodeBuilder().append(deviceTypeNumber).append(number).toHashCode(); 
    } 

    @Override 
    public boolean equals(final Object object) 
    { 
    if (object instanceof DeviceModelId) 
    { 
     final DeviceModelId other = (DeviceModelId) object; 
     return new EqualsBuilder().append(deviceTypeNumber, other.getDeviceTypeNumber()).append(number, other 
      .getNumber()).isEquals(); 
    } 
    return false; 
    } 
} 

Answer 1

Also das war ein Fehler meinerseits. Ich habe vergessen, den Kaskadentyp hinzuzufügen.

@OneToMany (mappedBy = "Gerätetyp", fetch = FetchType.LAZY, cascade = CascadeType.ALL) private Set deviceModels;