10

我有以下几种用于休眠实体层次结构的类。我试图有两个具体的子类Sub1Class和Sub2Class. 它们由field中定义的鉴别器列 ( )分隔MappedSuperClass。有一个抽象实体类EntitySuperClass被其他实体引用。其他实体不应该关心它们是否实际引用Sub1Class或Sub2Class。

这实际上可能吗？目前我收到此错误（因为列定义在 Sub1Class 和 EntitySuperClass 中被继承了两次）：

Repeated column in mapping for entity: my.package.Sub1Class column: field (should be mapped with insert="false" update="false")

如果我添加@MappedSuperClass到EntitySuperClass，那么我会从 hiberante 得到断言错误：它不喜欢一个类既是实体又是映射的超类。@Entity如果我从中删除EntitySuperClass，则该类不再是实体，并且无法从其他实体中引用：

MappedSuperClass是外部包的一部分，所以如果可能的话，它不应该被改变。

我的课程：

@MappedSuperclass
public class MappedSuperClass {
    private static final String ID_SEQ = "dummy_id_seq";
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = ID_SEQ)
    @GenericGenerator(name=ID_SEQ, strategy="sequence")

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

    @Column(name="field", nullable=false, length=8)
    private String field;

    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getField() {
        return field;
    }
    public void setField(String field) {
        this.field = field;
    }
}


@Entity
@Table(name = "ACTOR")
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name="field", discriminatorType=DiscriminatorType.STRING)
abstract public class EntitySuperClass extends MappedSuperClass {


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

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}

@Entity
@DiscriminatorValue("sub1")
public class Sub1Class extends EntitySuperClass {

}


@Entity
@DiscriminatorValue("sub2")
public class Sub2Class extends EntitySuperClass {

}


@Entity
public class ReferencingEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE)
    private Integer id;

    @Column
    private Integer value;

    @ManyToOne
    private EntitySuperClass entitySuperClass;


    public Integer getId() {
        return id;
    }

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

    public Integer getValue() {
        return value;
    }

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

    public EntitySuperClass getEntitySuperClass() {
        return entitySuperClass;
    }

    public void setEntitySuperClass(EntitySuperClass entitySuperClass) {
        this.entitySuperClass = entitySuperClass;
    }

}
4

4 回答 4

16

在我的项目中是这样完成的：

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "field", discriminatorType = DiscriminatorType.STRING)
@DiscriminatorValue("dummy")
public class EntitySuperClass {
    // here definitions go 
    // but don't define discriminator column here
}

@Entity
@DiscriminatorValue(value="sub1")
public class Sub1Class extends EntitySuperClass {
    // here definitions go
}

它有效。我认为您的问题是您在超类定义中不必要地定义了鉴别器字段。删除它，它会工作。

于 2010-07-14T10:26:49.893 回答
13

为了将鉴别器列用作普通属性，您应该使用 将该属性设置为只读insertable = false, updatable = false。既然你不能改变MappedSuperClass，你需要使用@AttributeOverride：

@Entity 
@Table(name = "ACTOR") 
@Inheritance(strategy=InheritanceType.SINGLE_TABLE) 
@DiscriminatorColumn(name="field", discriminatorType=DiscriminatorType.STRING) 

@AttributeOverride(name = "field", 
    column = @Column(name="field", nullable=false, length=8, 
        insertable = false, updatable = false))

abstract public class EntitySuperClass extends MappedSuperClass { 
    ...
}
于 2010-07-14T11:10:59.087 回答
2

您只能将数据库列映射一次作为读写字段（具有insertable=true和/或的字段updatable=true），并将任意次数映射为只读字段（insertable=false 和 updatable=false）。使用列作为@DiscriminatorColumn读写映射，因此您不能有额外的读写映射。

@DiscriminatorColumnHibernate 将根据具体的类实例在后台设置指定的值。如果您可以更改该字段，它将允许修改该@DiscriminatorColumn字段，以便您的子类和该字段中的值可能不匹配。

于 2010-07-15T06:12:42.523 回答
0

一个基本原则：您实际上不需要从数据库中检索您的鉴别器列。您应该已经在代码中拥有该信息，您可以在 @DiscriminatorValue 标记中使用这些信息。如果您需要从 DB 中读取，请仔细重新考虑分配鉴别器的方式。

如果您在最终实体对象中需要它，一个好的做法是从鉴别器值实现一个 Enum 并将其返回存储在 @Transient 字段中：

@Entity
@Table(name="tablename")
@DiscriminatorValue(Discriminators.SubOne.getDisc())
public class SubClassOneEntity extends SuperClassEntity {

    ...

    @Transient
    private Discriminators discriminator;

    // Setter and Getter
    ...
}

public enum Discriminators {
     SubOne ("Sub1"),
     SubOne ("Sub2");

     private String disc;
     private Discriminators(String disc) { this.disc = disc; }
     public String getDisc() { return this.disc; }
}
于 2013-11-22T20:06:04.777 回答