Warning: file_get_contents(/data/phpspider/zhask/data//catemap/1/hibernate/5.json): failed to open stream: No such file or directory in /data/phpspider/zhask/libs/function.php on line 167

Warning: Invalid argument supplied for foreach() in /data/phpspider/zhask/libs/tag.function.php on line 1116

Notice: Undefined index: in /data/phpspider/zhask/libs/function.php on line 180

Warning: array_chunk() expects parameter 1 to be array, null given in /data/phpspider/zhask/libs/function.php on line 181
Hibernate 涉及连接子类继承的一对一关联_Hibernate_Inheritance_Abstract Class - Fatal编程技术网

Hibernate 涉及连接子类继承的一对一关联

Hibernate 涉及连接子类继承的一对一关联,hibernate,inheritance,abstract-class,Hibernate,Inheritance,Abstract Class,在使用基于JSF的系统时,我遇到了一个Hibernate继承问题。起初,我的目标是使用由两个具体类实现的接口,但由于不可能映射接口,所以我使用了由两个具体类扩展的抽象类。在代码方面: @Entity @Inheritance(strategy=InheritanceType.JOINED) public abstract class AbstractEntity implements Serializable { protected Long id; @Id @Gen

在使用基于JSF的系统时,我遇到了一个Hibernate继承问题。起初,我的目标是使用由两个具体类实现的接口,但由于不可能映射接口,所以我使用了由两个具体类扩展的抽象类。在代码方面:

@Entity
@Inheritance(strategy=InheritanceType.JOINED)
public abstract class AbstractEntity implements Serializable {

    protected Long id;

    @Id
    @GeneratedValue(strategy=GenerationType.TABLE)
    public Long getId() {
        return id;
    }

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

@Entity
@PrimaryKeyJoinColumn(name="id_company")
public class Company extends AbstractEntity {

 private Individal signer;
    private Individuo billHolder;
    private String partIva;

    @OneToOne
    public Individual getSigner() {
        return signer;
    }

    public void setSigner(Individual signer) {
        this.signer = signer;
    }

    @OneToOne
    public Individual getBillHolder() {
        return billHolder;
    }

    public void setBillHolder(Individual billHolder) {
        this.billHolder = billHolder;
    }

    public String getPartIva() {
        return partIva;
    }

    public void setPartIva(String partIva) {
        this.partIva = partIva;
    }
}

@Entity
@PrimaryKeyJoinColumn(name="id_private")
public class Private extends AbstractEntity {

 private Individual billHolder;

    @OneToOne
    public Individual getBillHolder() {
        return billHolder;
    }

    public void setBillHolder(Individual billHolder) {
        this.billHolder = billHolder;
    }

    @OneToOne
    public Individual getSigner() {
        return billHolder;
    }

    public void setSigner(Individual signer) {
    }
}
现在我有了第四个类(名为“Client”),它与AbstractEntity有一对一的单向关系:

@Entity
public class Client implements Serializable {

    private Long id;
    private AbstractEntity holder;

    ...

    @OneToOne
    public SoggettoAstratto getHolder() {
        return holder;
    }

    public void setHolder(SoggettoAstratto cliente) {
        this.intestatario = cliente;
    }

   ...
个体是一个描述性的类,没有关系,也没有一个属性,除此之外,被称为CODFI。 现在,如果我使用以下条件创建查询:

Criteria crit = super.getSession().createCriteria(getPersistentClass());
crit.createCriteria("holder.billHolder")
   .add(Restrictions.eq("codFis", codFis));
List risultati = crit.list();

*NOTE: the code is part of a DAO. The getPersistentClass returns a Client.class, and it works perfectly with other methods in this DAO.*
我得到一个例外:

org.postgresql.util.PSQLException: ERROR: table name "individual1_" specified more than once
 at org.postgresql.core.v3.QueryExecutorImpl.receiveErrorResponse(QueryExecutorImpl.java:2062)
 at org.postgresql.core.v3.QueryExecutorImpl.processResults(QueryExecutorImpl.java:1795)
 at org.postgresql.core.v3.QueryExecutorImpl.execute(QueryExecutorImpl.java:257)
 at org.postgresql.jdbc2.AbstractJdbc2Statement.execute(AbstractJdbc2Statement.java:479)
 at org.postgresql.jdbc2.AbstractJdbc2Statement.executeWithFlags(AbstractJdbc2Statement.java:367)
 at org.postgresql.jdbc2.AbstractJdbc2Statement.executeQuery(AbstractJdbc2Statement.java:271)
 at org.hibernate.jdbc.AbstractBatcher.getResultSet(AbstractBatcher.java:186)
 at org.hibernate.loader.Loader.getResultSet(Loader.java:1787)
我不知道出了什么问题。有人知道吗

提前谢谢。 JLPicard

附言。 物业名称是从我的语言翻译过来的,所以它们的意思在英语中并不完全匹配