Hibernate JPA中的多个manytone:更新/创建引用

（我是JPA的新手） 我有3个JPA实体：用户、设置和用户设置。
这些关系是： 用户设置、用户之间的多工单； 用户设置和设置之间有多个选项

目的是： 向UserSetting添加条目时，仅当设置中的条目不存在时才应添加该条目

问题： 我在设置中尝试了cascade=All-in-UserSetting，但如果设置已经存在，则失败

我可以编写多个查询，在设置不存在的情况下添加设置，然后添加UserSetting，而无需级联到设置表。但这听起来不合理。 在JPA中，什么是可以接受的方法

以下是实体代码：

    @Entity
    @Table(name = "USERS", uniqueConstraints = @UniqueConstraint(columnNames = "USER_ID"))
    @SequenceGenerator(name = "UserSeq", sequenceName = "USER_SEQ")
    public class UserEntity {
        private long id;
        private Set<UserSettingEntity> settings;

        public UserEntity() {
        }

        @Id
        @GeneratedValue(strategy = GenerationType.AUTO, generator = "UserSeq")
        @Column(name = "ID")
        public long getId() {
            return id;
        }

        public void setId(long id) {
            this.id = id;
        }

        @Column(name = "SETTING")
        @OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
        public Set<UserSettingEntity> getSettings() {
            if (settings == null) {
                settings = new HashSet<UserSettingEntity>();
            }
            return settings;
        }
    }


    @Entity
    @Table(name = "USER_SETTINGS", uniqueConstraints = @UniqueConstraint(columnNames = {"USER_ID", "SETTING_ID"}))
    @SequenceGenerator(name = "UserSettingSeq", sequenceName = "USER_SETTING_SEQ")
    public class UserSettingEntity {

        private Long id;
        private UserEntity user;
        private SettingEntity setting;
        private String value;

        public UserSettingEntity() {
        }

        public UserSettingEntity(UserEntity user, SettingEntity setting, String value) {
            this.user = user;
            this.setting = setting;
            this.value = value;
        }

        @Id
        @GeneratedValue(strategy = GenerationType.AUTO, generator = "UserSettingSeq")
        @Column(name = "ID")
        public Long getId() {
            return id;
        }

        public void setId(Long id) {
            this.id = id;
        }

        @ManyToOne(cascade = CascadeType.ALL)
        @JoinColumn(name = "USER_ID", nullable = false)
        public UserConfigEntity getUser() {
            return user;
        }

        public void setUser(UserConfigEntity user) {
            this.user = user;
        }
        //if setting exists in database, dont try to add it again
        @ManyToOne(cascade = CascadeType.REFRESH)
        @JoinColumn(name = "SETTING_ID", nullable = false)
        public SettingEntity getSetting() {
            return setting;
        }
    public void setSetting(SettingEntity setting) {
        this.setting = setting;
    }
  @Column(name = "VALUE")
    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }
}

@Entity
@Table(name = "SETTING", uniqueConstraints = @UniqueConstraint(columnNames = {"CATEGORY", "CONTEXT", "NAME"}))
@SequenceGenerator(name = "SettingEntitySeq", sequenceName = "SETTING_SEQ")
public class SettingEntity {

    private Long id;
    private String name;

...

    public SettingEntity(String category, String name) {
        this.name = name;
    }

    public SettingEntity() {
    }

    @Id
    @Column(name = "SETTING_ID", nullable = false)
    @GeneratedValue(strategy = GenerationType.AUTO, generator = "SettingEntitySeq")
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

}

@实体
@表（name=“USERS”，uniqueConstraints=@UniqueConstraint（columnNames=“USER\u ID”））
@SequenceGenerator（name=“UserSeq”，sequenceName=“USER_SEQ”）
公共类用户实体{
私人长id；
私人设置；
公共用户实体（）{
}
@身份证
@GeneratedValue（策略=GenerationType.AUTO，generator=“UserSeq”）
@列（name=“ID”）
公共长getId（）{
返回id；
}
公共无效集合id（长id）{
this.id=id；
}
@列（name=“SETTING”）
@OneToMany（mappedBy=“user”，cascade=CascadeType.ALL）
公共设置getSettings（）{
如果（设置==null）{
设置=新的HashSet（）；
}
返回设置；
}
}
@实体
@表（name=“USER\u SETTINGS”，uniqueConstraints=@UniqueConstraint（columnNames={“USER\u ID”，“SETTING\u ID”}））
@SequenceGenerator（name=“UserSettingSeq”，sequenceName=“USER\u SETTING\u SEQ”）
公共类UserSettingEntity{
私人长id；
私有用户实体用户；
私人设置实体设置；
私有字符串值；
公共用户设置实体（）{
}
公共用户设置实体（用户实体用户，设置实体设置，字符串值）{
this.user=用户；
这个。设置=设置；
这个值=值；
}
@身份证
@GeneratedValue（策略=GenerationType.AUTO，generator=“UserSettingSeq”）
@列（name=“ID”）
公共长getId（）{
返回id；
}
公共无效集合id（长id）{
this.id=id；
}
@多通（级联=级联类型.ALL）
@JoinColumn（name=“USER\u ID”，nullable=false）
公共用户配置实体getUser（）{
返回用户；
}
public void setUser（UserConfigEntity用户）{
this.user=用户；
}
//如果数据库中存在设置，请不要再次尝试添加它
@manytone（cascade=CascadeType.REFRESH）
@JoinColumn（name=“SETTING_ID”，nullable=false）
公共设置实体getSetting（）{
返回设置；
}
公共作废设置（设置实体设置）{
这个。设置=设置；
}
@列（name=“VALUE”）
公共字符串getValue（）{
返回值；
}
公共void设置值（字符串值）{
这个值=值；
}
}
@实体
@表（name=“SETTING”，uniqueConstraints=@UniqueConstraint（columnNames={“CATEGORY”，“CONTEXT”，“name”}））
@SequenceGenerator（name=“SettingEntitySeq”，sequenceName=“SETTING_SEQ”）
公共类设置实体{
私人长id；
私有字符串名称；
...
公共设置实体（字符串类别、字符串名称）{
this.name=名称；
}
公共设置实体（）{
}
@身份证
@列（name=“SETTING_ID”，nullable=false）
@GeneratedValue（策略=GenerationType.AUTO，generator=“SettingEntitySeq”）
公共长getId（）{
返回id；
}
公共无效集合id（长id）{
this.id=id；
}
}

要创建持久的UserSetting实例，您需要一个持久的设置实例。Hibernate无法决定您需要哪个实例。在新的UserSetting实例中进行设置之前，您负责查找设置实例或创建新实例。

我找到的答案是通过UserEntity管理UserSettingEntity：创建/获取SettingEntities，获取UserEntity，将其所有UserSettingEntities添加到User.settings并持久化。这意味着对于n个设置，查询数=（2*n+2）

谢谢您的回答。这意味着当我有几个UserSettings时，我需要4个查询来添加一个UserSetting？（检查设置是否存在，创建设置，检查用户设置是否存在，创建用户设置）