Mysql 使用联接表的Jpa一对多

我有一个房间实体、一个规则实体和一个便利设施实体。我想做的是事先手动填写规则和便利设施实体，当我插入房间时，我想根据用户选择的规则和便利设施来映射两个连接表中的两个，房间规则和房间便利设施

我该如何做到这一点？当我保留一个新的房间实体时，它是否应该已经包含规则和设施？如果这些元素的集合没有映射为cascade.persist，它会起作用吗

或者我应该先保留没有它们的房间，然后将它们映射到房间

我该怎么办

更新

我的房间实体：

    public class RoomEntity {

        @Id
        @GeneratedValue(strategy= GenerationType.SEQUENCE)
        @Column(name = "id", nullable =false, unique = true)
        private Integer id;

        @Basic
        @Column(name = "title", nullable = false, length = 45)
        private String title;

        @Basic
        @Column(name = "description", nullable = false, length = 300)
        private String description;

        @Basic
        @Column(name = "square_meters", nullable = false)
        private Integer square_meters;

        @Basic
        @Column(name = "overnight_price", nullable = false)
        private double overnight_price;

        @Basic
        @Column(name = "exta_person_price", nullable = false)
        private double exta_person_price;

        @Basic
        @Column(name = "max_people", nullable = false)
        private Integer max_people;

        @Basic
        @Column(name = "min_overnights", nullable = false)
        private Integer min_overnights;

        @Basic
        @Column(name = "beds", nullable = false)
        private Integer beds;

        @Basic
        @Column(name = "bathrooms", nullable = false)
        private Integer bathrooms;

        @Basic
        @Column(name = "bedrooms", nullable = false)
        private Integer bedrooms;

        @Basic
        @Column(name = "transport", length = 300)
        private String transport;

        @Basic
        @Column(name = "neightborhood", length = 300)
        private String neightborhood;

        @Basic
        @Column(name = "house_rules", length = 200)
        private String house_rules;




        @ManyToOne(cascade = CascadeType.MERGE)
        @JoinColumn(name = "room_host", referencedColumnName = "username", /*nullable = false,*/ insertable = false, updatable = false)
        private HostEntity hostEntity;

        public HostEntity getHostEntity() {
            return hostEntity;
        }

        public void setHostEntity(HostEntity hostEntity) {
            this.hostEntity = hostEntity;
        }

        @OneToOne
        @JoinColumn(name = "room_type_id", referencedColumnName = "id", /*nullable = false,*/ insertable = false, updatable = false)
        private TypeEntity typeEntity;

        public TypeEntity getTypeEntity() {
            return typeEntity;
        }

        public void setTypeEntity(TypeEntity typeEntity) {
            this.typeEntity = typeEntity;
        }

        @OneToOne(cascade={CascadeType.ALL})
        @JoinColumn(name = "room_location", referencedColumnName = "id"/*, nullable = false, insertable = false, updatable = false*/)
        private LocationEntity locationEntity;

        public LocationEntity getLocationEntity() {
            return locationEntity;
        }

        public void setLocationEntity(LocationEntity locationEntity) {
            this.locationEntity = locationEntity;
        }


        @OneToMany(cascade = {CascadeType.ALL})
        @JoinTable(
                /*name = "room_pictures",*/
                joinColumns = {@JoinColumn(name = "room_id", referencedColumnName = "id")},
                inverseJoinColumns = {@JoinColumn (name ="picture_id", referencedColumnName = "id", unique = true)}
        )
        private Collection<PictureEntity> pictureEntities = new ArrayList<>();

        public Collection<PictureEntity> getPictureEntities() {
            return pictureEntities;
        }

        public void setPictureEntities(Collection<PictureEntity> pictureEntities) {
            this.pictureEntities = pictureEntities;
        }

        @OneToMany
        @JoinTable(
                /*name = "room_amenities",*/
                joinColumns = {@JoinColumn(name = "room_id", referencedColumnName = "id")},
                inverseJoinColumns = {@JoinColumn (name ="amenity_id", referencedColumnName = "id")}
        )
        private Collection<AmenitiesEntity> amenitiesEntities = new ArrayList<>();

        public Collection<AmenitiesEntity> getAmenitiesEntities() {
            return amenitiesEntities;
        }

        public void setAmenitiesEntities(Collection<AmenitiesEntity> amenitiesEntities) {
            this.amenitiesEntities = amenitiesEntities;
        }

         @OneToMany
         @JoinTable(
                /*name = "room_amenities",*/
                 joinColumns = {@JoinColumn(name = "room_id", referencedColumnName = "id")},
                 inverseJoinColumns = {@JoinColumn (name ="rule_id", referencedColumnName = "id")}
         )
         private Collection<RuleEntity> ruleEntities = new ArrayList<>();

        public Collection<RuleEntity> getRuleEntities() {
            return ruleEntities;
        }

        public void setRuleEntities(Collection<RuleEntity> ruleEntities) {
            this.ruleEntities = ruleEntities;
        }

 public Collection<Picture> toPicturesModel(){
        Collection<Picture> pictures = new ArrayList<>();
        for(PictureEntity o : this.pictureEntities){
            pictures.add(o.toModel());
        }
        return pictures;
    }

    public Collection<Amenities> toAmenitiesModel(){
        Collection<Amenities> amenities = new ArrayList<>();
        for(AmenitiesEntity o : this.amenitiesEntities){
            amenities.add(o.toModel());
        }
        return amenities;
    }

    public Collection<Rule> toRulesModel(){
        Collection<Rule> rules = new ArrayList<>();
        for(RuleEntity o : this.ruleEntities){
            rules.add(o.toModel());
        }
        return rules;
    }


    public Room toModel(Integer depth){
        System.out.println("RoomEntity:::toModel()");
            return new Room(
                this.hostEntity == null? null : this.hostEntity.toModel(depth),
                this.getTypeEntity() == null? null : this.typeEntity.toModel(),
                this.getLocationEntity()== null? null : this.locationEntity.toModel(),
                this.getPictureEntities() == null ? null : this.toPicturesModel(),
                this.getAmenitiesEntities() == null? null : this.toAmenitiesModel(),
                this.getRuleEntities() == null? null : this.toRulesModel(),
                this.title,  this.description,  this.square_meters,
                this.overnight_price,  this.exta_person_price,
                this.max_people,  this.min_overnights,  this.beds,  this.bathrooms,
                this.bedrooms, this.transport,  this.neightborhood, this.house_rules);
    }
}

我的类型实体：

public class TypeEntity {

@Id
@Column(name = "id", nullable = false, unique = true)
private Integer id;

@Basic
@Column(name = "type_name", nullable = false, length = 45)
private String type;

@OneToOne(mappedBy = "typeEntity")
private RoomEntity roomEntity;

}

我的规则实体：

public class RuleEntity {

    @Id
    @Column(name = "id", nullable =false, unique = true)
    //@GeneratedValue(strategy= GenerationType.SEQUENCE)
    private Integer id;

    @Basic
    @Column(name = "rule", nullable =false , unique = true, length = 50)
    private String rule;
}

我的形象：

public class PictureEntity {

@Id
@Column(name = "id", nullable =false, unique = true)
@GeneratedValue(strategy= GenerationType.SEQUENCE)
private Integer picture_id;

@Basic
@Column(name = "thumbnail_url", nullable =false, length = 100)
private String thumbnail_url;

@Basic
@Column(name = "medium_url", nullable =false, length = 100)
private String medium_url;

@Basic
@Column(name = "picture_url", nullable =false, length = 100)
private String picture_url;

@Basic
@Column(name = "xl_picture_url", nullable =false, length = 100)
private String xl_picture_url;
}

我的礼仪：

public class AmenitiesEntity {

@Id
@Column(name = "id", nullable =false, unique = true)
//@GeneratedValue(strategy= GenerationType.SEQUENCE)
private Integer id;

@Basic
@Column(name = "name", nullable = false, unique = true, length = 50)
private String amenity;
}

我创建房间的代码如下：

public Room addRoom(RoomInput room) {
        dao.setParam("username", room.getOwner());
        List<HostEntity> owner = dao.getTuples("users.findByUsername");
        RoomEntity newRoom = new RoomEntity(room.getTitle(), room.getDescription(), room.getSquare_meters(), room.getOvernight_price(),
                room.getExta_person_price(), room.getMax_people(), room.getMin_overnights(), room.getBeds(), room.getBathrooms(),
                room.getBedrooms(), room.getTransport(), room.getNeightborhood(), room.getHouse_rules());
newRoom.setLocationEntity(room.getLocation().toEntity());
    for(Picture o :room.getPictures()){
        newRoom.getPictureEntities().add(o.toEntity());
    }
    RoomEntity entity = dao.insertTuple(newRoom);
    entity.setHostEntity(owner.get(0));
    for(Amenities o : room.getAmenities()){
        entity.getAmenitiesEntities().add(o.toEntity());
    }
    for(Rule o : room.getRules()){
        entity.getRuleEntities().add(o.toEntity());
    }
    entity.setTypeEntity(room.getType().toEntity());
    entity = dao.updateTuple(entity);
    System.out.println(entity.toString());
    return (entity == null) ? null : entity.toModel(0);
}

公共房间添加室（房间输入室）{
setParam（“username”，room.getOwner（））；
List owner=dao.getTuples（“users.findByUsername”）；
RoomEntity newRoom=新RoomEntity（room.getTitle（）、room.getDescription（）、room.getSquare\u meters（）、room.getNighter\u price（），
room.getExta\u person\u price（），room.getMax\u people（），room.getMin\u overnights（），room.getBeds（），room.getBathrooms（），room，
room.getBedrooms（），room.getTransport（），room.getNeightborhood（），room.getHouse_rules（）；
newRoom.setLocationEntity（room.getLocation（）.toEntity（））；
for（图片o:room.getPictures（））{
newRoom.getPictureEntities（）.add（o.toEntity（））；
}
RoomEntity=dao.insertTuple（newRoom）；
entity.setHostEntity（owner.get（0））；
对于（便利设施o:room.getprofessionals（））{
entity.getAmenitiesEntities（）.add（o.toEntity（））；
}
for（规则o:room.getRules（））{
entity.getRuleEntities（）.add（o.toEntity（））；
}
entity.setTypeEntity（room.getType（）.toEntity（））；
entity=dao.updateTuple（entity）；
System.out.println（entity.toString（））；
返回（entity==null）？null:entity.toModel（0）；
}

现在发生的是，即使我的3个联接表， 房间图片、房间规则、房间设施得到正确更新， 我放在数据库中的房间有主机的外键（用户名） 并且类型（id）为null

有没有更好的方法来做这一切？现在我要去新房间， 保存图片和位置，然后我将房间与更新的主机、设施和规则的新值合并。

更新 我解决了这个问题。现在，我为我希望与文件室（也称为位置和图片）保持一致的实体执行一次插入操作，并合并一次，以连接联接表中已删除的实体/规则，以及文件室表中的主机/键入外键。主机和类型的问题是@JoinColumn中的updateable和insertable为false，这是错误的。在我删除了那些声明之后，它起了作用！最后，我保存/合并已删除的实体和新实体的代码如下：

 public Room addRoom(RoomInput room) {
        dao.setParam("username", room.getOwner());
        HostEntity host = null;
        List<HostEntity> owner = dao.getTuples("users.findByUsername");
        RoomEntity newRoom = new RoomEntity(room.getTitle(), room.getDescription(), room.getSquare_meters(), room.getOvernight_price(),
                room.getExta_person_price(), room.getMax_people(), room.getMin_overnights(), room.getBeds(), room.getBathrooms(),
                room.getBedrooms(), room.getTransport(), room.getNeightborhood(), room.getHouse_rules());
        System.out.println(owner.get(0).toString());
        newRoom.setLocationEntity(room.getLocation().toEntity());
        for(Picture o :room.getPictures()){
            newRoom.getPictureEntities().add(o.toEntity());
        }
        RoomEntity entity = dao.insertTuple(newRoom);

        for(Amenities o : room.getAmenities()){
            entity.getAmenitiesEntities().add(o.toEntity());
        }
        for(Rule o : room.getRules()){
            entity.getRuleEntities().add(o.toEntity());
        }
        entity.setHostEntity(owner.get(0));
        entity.setTypeEntity(room.getType().toEntity());
        dao.updateTuple(entity);
        System.out.println(entity.toString());
        return (entity == null) ? null : entity.toModel(0);
    }

公共房间添加室（房间输入室）{
setParam（“username”，room.getOwner（））；
HostEntityHost=null；
List owner=dao.getTuples（“users.findByUsername”）；
RoomEntity newRoom=新RoomEntity（room.getTitle（）、room.getDescription（）、room.getSquare\u meters（）、room.getNighter\u price（），
room.getExta\u person\u price（），room.getMax\u people（），room.getMin\u overnights（），room.getBeds（），room.getBathrooms（），room，
room.getBedrooms（），room.getTransport（），room.getNeightborhood（），room.getHouse_rules（）；
System.out.println（owner.get（0.toString（））；
newRoom.setLocationEntity（room.getLocation（）.toEntity（））；
for（图片o:room.getPictures（））{
newRoom.getPictureEntities（）.add（o.toEntity（））；
}
RoomEntity=dao.insertTuple（newRoom）；
对于（便利设施o:room.getprofessionals（））{
entity.getAmenitiesEntities（）.add（o.toEntity（））；
}
for（规则o:room.getRules（））{
entity.getRuleEntities（）.add（o.toEntity（））；
}
entity.setHostEntity（owner.get（0））；
entity.setTypeEntity（room.getType（）.toEntity（））；
updateTuple（实体）；
System.out.println（entity.toString（））；
返回（entity==null）？null:entity.toModel（0）；
}

请发布您的实体类。@AbdullahKhan完成！

public Room addRoom(RoomInput room) {
        dao.setParam("username", room.getOwner());
        List<HostEntity> owner = dao.getTuples("users.findByUsername");
        RoomEntity newRoom = new RoomEntity(room.getTitle(), room.getDescription(), room.getSquare_meters(), room.getOvernight_price(),
                room.getExta_person_price(), room.getMax_people(), room.getMin_overnights(), room.getBeds(), room.getBathrooms(),
                room.getBedrooms(), room.getTransport(), room.getNeightborhood(), room.getHouse_rules());
newRoom.setLocationEntity(room.getLocation().toEntity());
    for(Picture o :room.getPictures()){
        newRoom.getPictureEntities().add(o.toEntity());
    }
    RoomEntity entity = dao.insertTuple(newRoom);
    entity.setHostEntity(owner.get(0));
    for(Amenities o : room.getAmenities()){
        entity.getAmenitiesEntities().add(o.toEntity());
    }
    for(Rule o : room.getRules()){
        entity.getRuleEntities().add(o.toEntity());
    }
    entity.setTypeEntity(room.getType().toEntity());
    entity = dao.updateTuple(entity);
    System.out.println(entity.toString());
    return (entity == null) ? null : entity.toModel(0);
}

 public Room addRoom(RoomInput room) {
        dao.setParam("username", room.getOwner());
        HostEntity host = null;
        List<HostEntity> owner = dao.getTuples("users.findByUsername");
        RoomEntity newRoom = new RoomEntity(room.getTitle(), room.getDescription(), room.getSquare_meters(), room.getOvernight_price(),
                room.getExta_person_price(), room.getMax_people(), room.getMin_overnights(), room.getBeds(), room.getBathrooms(),
                room.getBedrooms(), room.getTransport(), room.getNeightborhood(), room.getHouse_rules());
        System.out.println(owner.get(0).toString());
        newRoom.setLocationEntity(room.getLocation().toEntity());
        for(Picture o :room.getPictures()){
            newRoom.getPictureEntities().add(o.toEntity());
        }
        RoomEntity entity = dao.insertTuple(newRoom);

        for(Amenities o : room.getAmenities()){
            entity.getAmenitiesEntities().add(o.toEntity());
        }
        for(Rule o : room.getRules()){
            entity.getRuleEntities().add(o.toEntity());
        }
        entity.setHostEntity(owner.get(0));
        entity.setTypeEntity(room.getType().toEntity());
        dao.updateTuple(entity);
        System.out.println(entity.toString());
        return (entity == null) ? null : entity.toModel(0);
    }