Java Hibernate:参数索引超出范围（8个参数，即7个）

不是这个问题的重复

我的SaltTranDef实体类是

@Id
@Column(name="salt_id")
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Integer saltId;

@Column(name="tran_type")
private String transactionType;

@Column(name="user_id")
private String userId;

@Column(name="parent_system")
private String parentSystem;

@Column(name="parent_sys_ref_id")
private String parentSystemReference;

@Column(name="status")
private int status;

@OneToMany(mappedBy = "saltTranDef")
@Cascade({ org.hibernate.annotations.CascadeType.ALL,
         org.hibernate.annotations.CascadeType.DELETE_ORPHAN })
private Set<SaltTranUser> saltTranUsers;

@Id
@Column(name="salt_id")
private Integer saltId;

@Id
@Column(name="salt_property")
private String saltProp;

@Column(name="salt_value")
private String saltValue;

@ManyToOne
@JoinColumn(name="salt_id")
private SaltTranDef saltTranDef;

上述两个实体类都扩展了mappedSuperclass

@Column(name="cre_suid")
private String creatorId;

@Column(name="mod_suid")
private String modifiedId;

@Column(name="cre_date")
private Timestamp creationDate;

@Column(name="mod_date")
private Timestamp modificationDate;

从JUnit插入时：

@Test
public void testInsert(){

    SaltTranDef std = new SaltTranDef();
    SaltTranUser stu1 = new SaltTranUser();
    SaltTranUser stu2 = new SaltTranUser();
    SaltTranUser stu3 = new SaltTranUser();
    Set<SaltTranUser> set1 = new HashSet<SaltTranUser>();

    Transaction tx = session.beginTransaction();

    std.setParentSystem("A");
    std.setParentSystemReference("123");
    std.setStatus(10);
    std.setTransactionType("A");
    std.setUserId("1234");
    std.setCreationDate(new Timestamp(new Date().getTime()));
    std.setCreatorId("1234");

    session.persist(std);
//  session.flush();

    stu1.setCreationDate(new Timestamp(new Date().getTime()));
    stu1.setCreatorId("1234");
    stu1.setSaltProp("Fname");
    stu1.setSaltValue("Swateek");
    stu1.setSaltId(std.getSaltId());

    stu2.setCreationDate(new Timestamp(new Date().getTime()));
    stu2.setCreatorId("1234");
    stu2.setSaltProp("Lname");
    stu2.setSaltValue("Jena");
    stu2.setSaltId(std.getSaltId());

    stu3.setCreationDate(new Timestamp(new Date().getTime()));
    stu3.setCreatorId("1234");
    stu3.setSaltProp("Phone");
    stu3.setSaltValue("9900056668");
    stu3.setSaltId(std.getSaltId());

    set1.add(stu1);
    set1.add(stu2);
    set1.add(stu3);

    std.setSaltTranUsers(set1);

    session.save(std);
    tx.commit();
}

@测试
公共无效测试集（）{
SaltTranDef std=新的SaltTranDef（）；
SaltTranUser stu1=新的SaltTranUser（）；
SaltTranUser stu2=新的SaltTranUser（）；
SaltTranUser stu3=新的SaltTranUser（）；
Set set1=新的HashSet（）；
事务tx=会话.beginTransaction（）；
标准setParentSystem（“A”）；
标准setParentSystemReference（“123”）；
标准设定状态（10）；
标准setTransactionType（“A”）；
std.setUserId（“1234”）；
std.setCreationDate（新时间戳（新日期（）.getTime（））；
标准setCreatorId（“1234”）；
会话（std）；
//session.flush（）；
stu1.setCreationDate（新时间戳（new Date（）.getTime（））；
stu1.setCreatorId（“1234”）；
stu1.设置属性（“Fname”）；
stu1.设定值（“Swateek”）；
stu1.setSaltId（标准getSaltId（））；
stu2.setCreationDate（新时间戳（new Date（）.getTime（））；
stu2.setCreatorId（“1234”）；
stu2.设置属性（“Lname”）；
stu2.设定价值（“耶拿”）；
stu2.setSaltId（标准getSaltId（））；
stu3.setCreationDate（新时间戳（new Date（）.getTime（））；
stu3.setCreatorId（“1234”）；
stu3.设置altprop（“电话”）；
stu3.设定值（“9900056668”）；
stu3.setSaltId（标准getSaltId（））；
set1.添加（stu1）；
set1.add（stu2）；
set1.添加（stu3）；
标准SETALTTRANUSERS（set1）；
会话保存（std）；
tx.commit（）；
}

我得到一个错误，说：

严重：参数索引超出范围（8>参数数量，即7）。 2015年3月25日上午8:06:35 org.hibernate.event.def.AbstractFlushingEventListener性能执行 严重：无法将数据库状态与会话同步 org.hibernate.exception.genericjdbception:无法插入：[com.salt.entity.SaltTranUser] 位于org.hibernate.exception.sqlstatecoverter.handlednonspecificeexception（sqlstatecoverter.java:103） 原因：java.sql.SQLException:参数索引超出范围（8>参数数，即7）。 位于com.mysql.jdbc.SQLError.createSQLException（SQLError.java:1055）

---

这类问题几乎总是与双列映射有关。的确如此。我们可以看到，此映射使用一列两次“salt\u id”：

saltranuser

实体类：

@Id
@Column(name="salt_id")
private Integer saltId;
...

@ManyToOne
@JoinColumn(name="salt_id")
private SaltTranDef saltTranDef;

这是错误的。Hibernate在最后两次插入一列，即插入、更新中的参数多于列

---

这里的解决方案可能非常简单，因为

@manytone

似乎是错误的。我希望有一些特别的专栏可以参考，比如：

saltrandef\u id

在我的例子中，问题是关于

用户类型的字段。它被定义为歧视者和公共财产。它没有标记为
@Column
，但无论如何Hibernate在这个问题上失败了

@Entity
@Table(
    name = "abstract_users",
    indexes = {@Index(name = "idx__abstract_users__is_enabled", columnList = "is_enabled")}
)
@Access(AccessType.FIELD)
@Inheritance(strategy = InheritanceType.JOINED)
// @TODO: rename user_type to discriminator
@DiscriminatorColumn(name = "user_type", discriminatorType = DiscriminatorType.STRING, length = 10)
abstract public class AbstractUser extends CreateUpdateTimestampableBase
{

    // @TODO: rename user_type to discriminator
    public String user_type;

    @Min(0)
    @NotNull
    @Column(precision = 19, scale = 2)
    protected BigDecimal balance;

    //...
}

当我使用单向映射（父类包含子类，但子类不保留父类的引用）时，我遇到了同样的问题。
地图看起来像

@OneToMany(cascade = CascadeType.ALL, fetch=FetchType.EAGER, orphanRemoval = true)
@JoinColumn(name="jobcard_id", nullable=false)
private List<JobServiceMapping> services;

@OneToMany（cascade=CascadeType.ALL，fetch=FetchType.EAGER，orphandremovation=true）
@JoinColumn（name=“jobcard\u id”，可空=false）
私人名单服务；

我得到的错误参数索引超出范围。
然后我稍微修改了注释，现在它对我有用了

@OneToMany(mappedBy="jobcardId", cascade = CascadeType.ALL, fetch=FetchType.EAGER, orphanRemoval = true)
private List<JobServiceMapping> services;

@OneToMany（mappedBy=“jobcardId”，cascade=CascadeType.ALL，fetch=FetchType.EAGER，orphan=true）
私人名单服务；
在您的实体中，替换

@ManyToOne
@JoinColumn(name="salt_id")
private SaltTranDef saltTranDef;

借

它对我有效
由于一些商业原因，我无法采用这种方法。因此，在第二个表中，第一个表和另一个表的标识列将是复合主键。第二个表中的标识列将是依赖于第一个表的外键。请将其标记为只读。但总的来说，我的答案是正确的。一列的两个映射不能用作可写。。。希望它能帮助Snow..对entity类进行一些更改。。（我也是只读的）这个错误不会发生。但还有一些事情要发生，我不知道我应该编辑这个问题还是开始一个不同的线程？请帮忙。要引起更多的注意，请提出新问题。这是我发布的一个新问题，在实体类中也有一些变化。如果你能帮忙的话。Hibernate拾取任何未标记为transient或未注释为@transient的属性。这就是用户类型被检测为数据库列的原因。我们可以说Hibernate不允许您将鉴别器列用作类的属性吗？将
@Transient
放在
@ManyToOne
之前对我来说很好。这是正确的答案！
@ManyToOne
@JoinColumn(name="salt_id", updatable = false, insertable = false)
private SaltTranDef saltTranDef;