BlogJava-天道酬勤 tiān dào chóu qín-文章分类-hibernate

hibernate 分布式事务的例子

chong — Thu, 09 Jul 2009 10:25:00 GMT

摘要: 对于横跨多个Hibernate SessionFacotry的分布式事务，只需简单地将 JtaTransactionManager 同多个 LocalSessionFactoryBean 的定义结合起来作为事务策略。你的每一个DAO通过bean属性得到各自的 SessionFactory 引用。如果所有的底层JDBC数据源都是支持事务的容器，那么只要业务对象使用了 JtaTransactionMa... 阅读全文

chong 2009-07-09 18:25 发表评论

EJB/JPA继承详解(转)

chong — Tue, 07 Jul 2009 02:50:00 GMT

因为关系数据库的表之间不存在继承关系，Entity 提供三种基本的继承映射策略：
每个类分层结构一张表(table per class hierarchy)
每个子类一张表(table per subclass)
每个具体类一张表(table per concrete class)

一、每个类分层结构一张表(table per class hierarchy)
       这种映射方式只需为基类创建一个表即可。在表中不仅提供基类所有属性对应的字段，还要提供所有子类属性对应的字段，此外还需要一个字段用于区分子类的具体类型
       要使用每个类分层结构一张表(table per class hierarchy) 策略，需要把@javax.persistence.Inheritance 注释的strategy属性设置为InheritanceType.SINGLE_TABLE。除非你要改变子类的映射策略，否则@Inheritance 注释只能放在继承层次的基类。通过鉴别字段的值，持久化引掣可以区分出各个类，并且知道每个类对应那些字段。鉴别字段通过@javax.persistence.DiscriminatorColumn 注释进行定义，name 属性定义鉴别字段的列名，discriminatorType 属性定义鉴别字段的类型（可选值有：String, Char, Integer），如果鉴别字段的类型为String 或Char，可以用length 属性定义其长度。@DiscriminatorValue 注释为继承关系中的每个类定义鉴别值，如果不指定鉴别值，默认采用类名
例:
    @SuppressWarnings("serial")
    @Entity
    @Table(name="Vehicle_Hierarchy")
    @Inheritance(strategy=InheritanceType.SINGLE_TABLE)
    @DiscriminatorColumn(name="Discriminator",
                                         discriminatorType = DiscriminatorType.STRING,
                                         length=30)
    @DiscriminatorValue("Vehicle")
    public class Vehicle implements Serializable{       //基类
    private Long id;
    private Short speed;//速度
    @Id
    @GeneratedValue
    @Column(columnDefinition="integer")//指定使用适配Integer长度的数据类型
    public Long getId() {
    return id;
    }
    public void setId(Long id) {
    this.id = id;
    }

    @SuppressWarnings("serial")
    @Entity
    @DiscriminatorValue("Car")
    public class Car extends Vehicle{        //Vehicle的子类
    private String engine;//发动机
    @Column(nullable=true,length=30)
    public String getEngine() {
    return engine;
    }
    public void setEngine(String engine) {
    this.engine = engine;
        }
    }

     @SuppressWarnings("serial")
     @Entity
     @DiscriminatorValue("Camion")
     public class Camion extends Car{         //Car的子类
     private String container;//集装箱
     @Column(nullable=true,length=30)
     public String getContainer() {
     return container;
     }
     public void setContainer(String container) {
     this.container = container;
          }
     }
分析:
       可以看出，每个子类没有单独的映射，在数据库中没有对应的表存在。而只有一个记录所有自身属性和子类所有属性的表，在基类为Vehicle 的时候，Discriminator 字段的值将为Vehicle,在子类为Car 的时候，Discriminator 字段的值将为Car，子类为Camion 的时候，Discriminator 字段的值将为Camion。那么，如果业务逻辑要求Car 对象的engine 属性不允许为null，显然无法在Vehicle_Hierarchy 表中为engine 字段定义not null 约束，可见这种映射方式无法保证关系数据模型的数据完整性。

二、每个类分层结构一张表(table per class hierarchy)
       这种映射方式为每个类创建一个表。在每个类对应的表中只需包含和这个类本身的属性对应的字段，子类对应的表参照父类对应的表,使用每个子类一张表 (table per subclass)策略，需要把@javax.persistence.Inheritance 注释的strategy 属性设置为InheritanceType.JOINED

     @SuppressWarnings("serial")
     @Entity
     @Inheritance(strategy=InheritanceType.JOINED)
     @Table(name="Vehicle")
     public class Vehicle implements Serializable{      //基类
     private Long id;
     private Short speed;//速度
     @Id
     @GeneratedValue
     @Column(columnDefinition="integer")
     public Long getId() {
     return id;
     }
     public void setId(Long id) {
     this.id = id;
     }
     public Short getSpeed() {
     return speed;
     }
     public void setSpeed(Short speed) {
     this.speed = speed;
     }
     }

     @SuppressWarnings("serial")
     @Entity
     @Table(name="Car")
     @PrimaryKeyJoinColumn(name="CarID")     //把主键对应的列名更改为CarID
     public class Car extends Vehicle{                 //Vehicle的子类
     private String engine;//发动机
     @Column(nullable=true,length=30)
     public String getEngine() {
     return engine;
     }
     public void setEngine(String engine) {
     this.engine = engine;
     }
     }

     @SuppressWarnings("serial")
     @Entity
     @Table(name="Camion")
     @PrimaryKeyJoinColumn(name="CamionID")     //把主键对应的列名更改为CamionID
     public class Camion extends Car{                    //Car的子类
     private String container;
     @Column(nullable=true,length=30)
     public String getContainer() {
     return container;
     }
     public void setContainer(String container) {
     this.container = container;
     }
     }
        这种映射方式支持多态关联和多态查询，而且符合关系数据模型的常规设计规则。在这种策略中你可以对子类的属性对应的字段定义not null 约束。该策略的缺点：
        它的查询性能不如上面介绍的映射策略。在这种映射策略下，必须通过表的内连接或左外连接来实现多态查询和多态关联。
选择原则：子类属性非常多，需要对子类某些属性对应的字段进行not null 约束，且对性能要求不是很严格时，优先选择该策略

三、每个具体类一张表(table per concrete class)
       这种映射方式为每个类创建一个表。在每个类对应的表中包含和这个类所有属性（包括从超类继承的属性）对应的字段,使用每个具体类一张表(table per concrete class)策略，需要把@javax.persistence.Inheritance 注释的strategy 属性设置为InheritanceType.TABLE_PER_CLASS

        注意:一旦使用这种策略就意味着你不能使用AUTO generator 和IDENTITY generator，即主键值不能采用数据库自动生成.

     @SuppressWarnings("serial")
     @Entity
     @Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)
     @Table(name="Vehicle")
     public class Vehicle implements Serializable{            //基类
     private Long id;
     private Short speed;//速度
     @Id
     @Column(columnDefinition="integer")
     public Long getId() {
     return id;
     }
     public void setId(Long id) {
     this.id = id;
     }
     public Short getSpeed() {
     return speed;
     }
     public void setSpeed(Short speed) {
     this.speed = speed;
     }
     }

     @SuppressWarnings("serial")
     @Entity
     @Table(name="Car")
    public class Car extends Vehicle{               //Vehicle的子类
     private String engine;//发动机
     @Column(nullable=true,length=30)
     public String getEngine() {
     return engine;
     }
     public void setEngine(String engine) {
     this.engine = engine;
     }
     }

     @SuppressWarnings("serial")
     @Entity
     @Table(name="Camion")
     public class Camion extends Car{              //Car的子类
     private String container;//集装箱
     @Column(nullable=true,length=30)
     public String getContainer() {
     return container;
     }
     public void setContainer(String container) {
     this.container = container;
     }
     }

注意:在查询时,例如: from Vehicle v
         查询所有Vehicle时，因为他是最继承树中的根，查询结果会得到所有继承于Vehicle类的记录
(构造的SQL Where部分：where Discriminator in ('Car', 'Camion'))
         delete from Vehicle v
         执行该操作会删除自身对应记录，还会删除所有继承Vehicle的记录,因为他是最继承树中的根，就相当于清除整个表的数据

该策略的优点：
                     在这种策略中你可以对子类的属性对应的字段定义not null 约束。
该策略的缺点：
                     不符合关系数据模型的常规设计规则，每个表中都存在属于基类的多余的字段。同时，为了支持策略的映射，持久化管理者需要决定使用什么方法，一种方法是在 entity 载入或多态关联时，容器使用多次查询去实现，这种方法需要对数据库做几次来往查询，非常影响执行效率。另一种方法是容器通过使用SQLUNIOU 查询来实现这种策略。
选择原则：
                     除非你的现实情况必须使用这种策略，一般情况下不要选择。

chong 2009-07-07 10:50 发表评论

标注枚举类型@Enumerated（转）

chong — Tue, 07 Jul 2009 02:46:00 GMT

实体Entity中通过@Enumerated标注枚举类型，例如将CustomerEO实体中增加一个CustomerType类型的枚举型属性，标注实体后的代码如下所示。

@Entity

@Table(name = "customer")

public class CustomerEO implements java.io.Serializable {

……

private CustomerType type;

@Enumerated(EnumType.STRING)

public CustomerType getType() {

return type;

}

public void setType(CustomerType type) {

this.type = type;

}

public enum CustomerType {

COMPETITOR, INVESTOR, PARTNER, VENDER

}

在实体中虽然标注成枚举类型，但当实体持久化后，表中所对应的值仍旧是基本的数据类型，以上代码创建表的SQL语句是：

CREATE TABLE customer (

id int(20) NOT NULL auto_increment,

name varchar(255),

type varchar(255),

PRIMARY KEY (id)

)

使用枚举类型后，在创建实体时便可以直接引用枚举类型，例如以下代码所示。

CustomerEO customer = new CustomerEO();

customer.setName("Janet2");

customer.setType(CustomerType.PARTNER);

entityManager.persist(customer);

在使用@Enumerated注释时，需要注意以下几个问题：

l 因为枚举类型的有名称和值两个属性，所以在持久化时可以选择持久化名称或是持久化值。通过EnumType来定义，它有两个值如下所示。

public enum EnumType {

ORDINAL,

STRING

}

ORDINAL表示持久化的为枚举类型的值，STRING表示持久化的为枚举类型的名称。默认为ORDINAL，持久化值。例如以上示例中标注的为STRING，这样持久化实体后，数据库中保存的是枚举类型的名称，如图所示。

若此时改成ORDINAL，代码如下：

@Enumerated(EnumType.ORDINAL)

public CustomerType getType() {

return type;

}

则同样持久化的实体后，数据库保存的结果如图所示。

l 如何选择STRING和ORDINAL：

如果使用STRING保存，虽然从数据库中查询数据时非常直观，能够清楚的看出该类型代表意义，但这样也会带来其他的问题。若此时枚举类型的定义改变，例如上例中的枚举类型名称改为：

public enum CustomerType {

CUST_COMPETITOR, INVESTOR, PARTNER, VENDER

}

则此时数据库中保存的“COMPETITOR”的值将不能转化为枚举类型CustomerType中的“CUST_COMPETITOR”的值。但若使用ORDINAL则不会带来这种问题。所以建议使用ORDINAL类型来持久化枚举类型。

l 枚举类型的定义位置，实体外部VS实体内部。

上例中CustomerType枚举类型定义在CustomerEO实体内部，这是因为只有CustomerEO这个实体会使用CustomerType类型，其他的实体不会使用该类型。该类型与这个实体关系紧密联系。

但若此时多个实体公用一个枚举类型时，则可以将枚举类型单独定义，定义在实体的外部。有这样一个枚举类型BusinessLine，它定义在实体外部，代码如下：

public enum BusinessLine {

REAL_ESTATE,FINANCE, NON_PROFIT

}

例如CustomerEO实体增加一个BusinessLine的枚举类型，代码如下所示。

@Entity

@Table(name = "customer")

public class CustomerEO implements java.io.Serializable {

……

private BusinessLine businessLine;

@Enumerated(EnumType.STRING)

public BusinessLine getBusinessLine() {

return businessLine;

}

public void setBusinessLine(BusinessLine businessLine) {

this.businessLine = businessLine;

}

chong 2009-07-07 10:46 发表评论