l         操作系统Windows XP Professional Pack2

l         数据库 Oracle - OraDb10g_home1

l         内存1.21GB

l         CPU AMD Athlon(tm) 1.15 GHz

l         编译环境 eclipse JDK1.5

l         程序测试运行环境 spring+hibernate+junit+mock ；
mock提供测试用例的基类，提供SPRING的ConfigurableListableBeanFactory，可以从配置文件中得到DAO对象,Dao对象调用getHibernateTemplate()

2         单表测试

l         表名：employee_role  共9个字段，大字符字段为blob，其它均为字符类型，总记录数 109580；

l         大字符字段：共670个字符

l         测试结果：

l         时间是平均值

3         表关联测试

l         父(一) 表名 employee 共8个字段, 没有大字符字段 总记录数10958

l         子(多) 表名 employee_role共8个字段, 没有大字符字段 总记录数109580

l         时间是平均值

如果您采取的是对象模型的方式来设计程序，那么继承关系可能就会在您的程序设计中出现，然而关系型数据库的关联模型与对象模型并不匹配，为了映像对象模型 与关联模型，您可以采取三种策略，这边先介绍最简单的一种：Table per concrete class，也就是每一个类别就对应一个表格。

以实例来说明，如果您的程序中有以下的继承关系：

以Table per concrete class的方式在关系型数据库中设计表格以作映像，就是直接对DefaultUser与PowerUser设计两个表格与之对应，如下：

两个表格没有任何的关系，defaultuser与poweruser表格各自拥有id、name字段，您可以如下建立表格：

CREATE TABLE defaultuser (

    id INT(11) NOT NULL auto_increment PRIMARY KEY,

    name VARCHAR(100) NOT NULL default '',

    someProperty VARCHAR(100)

);

CREATE TABLE poweruser (

    id INT(11) NOT NULL auto_increment PRIMARY KEY,

    name VARCHAR(100) NOT NULL default '',

    otherProperty VARCHAR(100)

);

User.java

package onlyfun.caterpillar;

public class User {

    private Integer id;

    private String name;

    // 必须要有一个预设的建构方法

    // 以使得Hibernate可以使用Constructor.newInstance()建立对象

    public User() {

    }

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

}

DefaultUser.java

package onlyfun.caterpillar;

public class DefaultUser extends User {

    private String someProperty;

    public DefaultUser() {

    }

    public String getSomeProperty() {

        return someProperty;

    }

    public void setSomeProperty(String someProperty) {

        this.someProperty = someProperty;

    }

}

在映射文件方面分别如下：

DefaultUser.hbm.xml

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-mapping

    PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

    <class name="onlyfun.caterpillar.DefaultUser" table="defaultuser">

        <id name="id" column="id" type="java.lang.Integer">

            <generator class="native"/>

        </id>

        <property name="name" column="name" type="java.lang.String"/>

        <property name="someProperty" column="someProperty" type="java.lang.String"/>        

    </class>

</hibernate-mapping>

PowerUser.hbm.xml

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-mapping

    PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

    <class name="onlyfun.caterpillar.PowerUser" table="poweruser">

        <id name="id" column="id" type="java.lang.Integer">

            <generator class="native"/>

        </id>

        <property name="name" column="name" type="java.lang.String"/>

        <property name="otherProperty" column="otherProperty" type="java.lang.String"/>        

    </class>

</hibernate-mapping>

当然，别忘了在hibernate.cfg.xml中定义使用这两个映射文件：

hibernate.cfg.xml

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-configuration PUBLIC

 "-//Hibernate/Hibernate Configuration DTD 3.0//EN"

      "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">    

<hibernate-configuration>

    <session-factory>

        ...

        <!-- 对象与数据库表格映像文件 -->

        <mapping resource="onlyfun/caterpillar/DefaultUser.hbm.xml"/>

        <mapping resource="onlyfun/caterpillar/PowerUser.hbm.xml"/>

    </session-factory>

</hibernate-configuration>

在储存对象时很简单，例如分别储存DefaultUser与PowerUser的实例：

DefaultUser defaultUser = new DefaultUser();

defaultUser.setName("Bush");

defaultUser.setSomeProperty("hu....hu...");

PowerUser powerUser = new PowerUser();

powerUser.setName("caterpillar");

powerUser.setOtherProperty("Bla...Bla...");

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();

session.save(powerUser);

session.save(defaultUser);

tx.commit();

session.close();

至于查询方面，视您想查询哪个数据表，如果想同时查询User类对应的所有资料，则可以如下：

Session session = sessionFactory.openSession();

Query query = session.createQuery("from onlyfun.caterpillar.User");

Iterator iterator = query.list().iterator();

while(iterator.hasNext()) {

        User user = (User) iterator.next();

        System.out.println(user.getName());

}

session.close();

这个查询会找出所有User之子类别所对应之数据，Hibernate实际上会使用以下的SQL进行查询：

Hibernate: select defaultuse0_.id as id, defaultuse0_.name as name0_, defaultuse0_.someProperty as someProp3_0_

           from defaultuser defaultuse0_

Hibernate: select poweruser0_.id as id, poweruser0_.name as name1_, poweruser0_.otherProperty as otherPro3_1_

           from poweruser poweruser0_

也就是Hibernate自动判断User的继承关系，并分别对DefaultUser与PowerUser对应的表格进行查询。

文件虽然很长，但其实不写这份文件也可以，还记得 基本查询 中曾经提过，如果您直接使用"from java.lang.Object"这样的HQL查询，所得到的结果是数据库中所有的数据，因为Object是Java中所有类别的父类别，写这份文件只是在加强您的印象，了解继承关系映像最基本的方式而已。

父类别User对应的表格呢？这边没有建立，如果需要的话，就自己再建立一个吧！并撰写对应的映射文件就可以了。

接续 上一个主题，Table per concrete class的继承映像方式是最简单，但没有效率（例如查询同为User类型时，需要两次SQL）且不易管理的映像方式，来看看继承关系映像至关系型数据库 的第二种方式：Table per class hierarchy。

这种方式使用一个表格储存同一个继承阶层的所有类别，并使用额外的字段来表示所记录的是哪一个子类别的数据。
具体来说，对于继承User类别的DefaultUser及PowerUser，可以设计以下的表格来储存数据：

可以使用以下的SQL来建立表格：

CREATE TABLE user (

    id INT(11) NOT NULL auto_increment PRIMARY KEY,

    userType VARCHAR(50) NOT NULL,

    name VARCHAR(100) NOT NULL default '',

    someProperty VARCHAR(100),

    otherProperty VARCHAR(100)

);

现在所决定的是，如果要储存的数据是来自DefalutUser，则在userType记下"Default"，如果储存的数据来PowerUser，则 在userType记下"Power"，由userType就可以在数据从数据库取回时，决定其该封装为DefaultUser或是PowerUser， 在使用Hibernate的话，这要在映射文件中使用<discriminator>等相关标签来定义，例如：

User.hbm.xml

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-mapping

    PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

    <class name="onlyfun.caterpillar.User" table="user">

        <id name="id" column="id" type="java.lang.Integer">

            <generator class="native"/>

        </id>

        <discriminator column="userType" type="java.lang.String"/>        

        <property name="name" column="name" type="java.lang.String"/>

        <subclass name="onlyfun.caterpillar.DefaultUser"

                  discriminator-value="Default">

            <property name="someProperty"

                      column="someProperty"

                      type="java.lang.String"/>

        </subclass>

        <subclass name="onlyfun.caterpillar.PowerUser"

                  discriminator-value="Power">

            <property name="otherProperty"

                      column="otherProperty"

                      type="java.lang.String"/>

        </subclass>         

    </class>

</hibernate-mapping>

当然，别忘了在hibernate.cfg.xml 中指定映像文件：
hibernate.cfg.xml

hibernate.cfg.xml

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-configuration PUBLIC

 "-//Hibernate/Hibernate Configuration DTD 3.0//EN"

      "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

    <session-factory>

        ....

        <!-- 对象与数据库表格映像文件 -->

        <mapping resource="onlyfun/caterpillar/User.hbm.xml"/>

    </session-factory>

</hibernate-configuration>

使用上一个主题中的储存程序的话，则Hibernate会使用以下的SQL来储存数据：

Hibernate: insert into user (name, otherProperty, userType) values (?, ?, 'Power')

Hibernate: insert into user (name, someProperty, userType) values (?, ?, 'Default')

而实际上数据表会储存以下的内容：

+----+----------+-------------+-------------------+-------------------+

| id | userType | name     | someProperty      | otherProperty     |

+----+----------+-------------+-------------------+-------------------+

| 1 | Power | caterpillar | NULL        | Bla...Bla...    |

| 2 | Default | Bush    | hu....hu...     | NULL        |

+----+----------+-------------+-------------------+-------------------+

缺点就是，因子类别属性的不同，对映储存时会有许多字段没有数据，但查询效率较好，例如查询User类型的数据时，只需一次SQL，如使用 上一个主题 中的查询程序时，Hibernate会使用以下的SQL进行查询：

Hibernate:

 select user0_.id as id, user0_.name as name0_,

 user0_.someProperty as someProp4_0_, user0_.otherProperty as otherPro5_0_,

 user0_.userType as userType from user user0_

接续上一个主题，在使用Table per class hierarchy映像继承关系时，会有大量的字段有NULL的情况，好处是使用一个表格，查询时只需一次SQL。

Table per subclass的继承映像方式，给予父类与子类分别的表格，而父类与子类对应的表格透过外键来产生关联，具体的说，User类别、DefaultUser类别与PowerUser类别所映像的表格如下：

其中user表格的id与defaultuser及poweruser的id 一致，具体的说，在储存DefaultUser实例时，id与name属性记录在user表格中，而someProperty记录在 defaultuser中，假设user表格的id值为1，则defaultuser表格对应的该笔记录其id值也会为一。

可以使用以下的SQL建立资料表：

CREATE TABLE user (

    id INT(11) NOT NULL auto_increment PRIMARY KEY,

    name VARCHAR(100) NOT NULL default ''

);

CREATE TABLE defaultuser (

    id INT(11) NOT NULL PRIMARY KEY,

    someProperty VARCHAR(100)

);

CREATE TABLE poweruser (

    id INT(11) NOT NULL PRIMARY KEY,

    otherProperty VARCHAR(100)

);

在映射文件上，如下定义：

User.hbm.xml

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-mapping

    PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

    <class name="onlyfun.caterpillar.User" table="user">

        <id name="id" column="id" type="java.lang.Integer">

            <generator class="native"/>

        </id>

        <property name="name" column="name" type="java.lang.String"/>

        <joined-subclass name="onlyfun.caterpillar.DefaultUser"

                         table="defaultuser">

            <key column="id"/>             

            <property name="someProperty"

                      column="someProperty"

                      type="java.lang.String"/>

        </joined-subclass>

        <joined-subclass name="onlyfun.caterpillar.PowerUser"

                         table="poweruser">

            <key column="id"/>             

            <property name="otherProperty"

                      column="otherProperty"

                      type="java.lang.String"/>

        </joined-subclass>      

    </class>

</hibernate-mapping>

<joined-subclass>指明了子类别与所对应的表格，<key column>指明子类别的对应表格中，哪一个字段要与父类别的主键一致。

使用 继承 - Table per concrete class 中的储存程序片段，则查询表格时可以发现以下的结果：

mysql> select * from user;

+-----+-------------+

| id | name        |

+-----+-------------+

| 1 | caterpillar |

| 2 | Bush        |

+-----+-------------+

2 rows in set (0.00 sec)

mysql> select * from defaultuser;

+----+-------------------+

| id | someProperty      |

+----+-------------------+

| 2 | hu....hu...       |

+----+-------------------+

1 row in set (0.00 sec)

mysql> select * from poweruser;

+----+-------------------+

| id | otherProperty     |

+----+-------------------+

| 1 | Bla...Bla...      |

+----+-------------------+

1 row in set (0.00 sec)

仔细观察一下，看看defaultuser与poweruser表格中的id各自是对应于user表格中的哪笔数据。 

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1305132

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1594494

lazy=true 一句查询 有getPicture()
Hibernate: select photos0_.id as id0_0_, photos0_.userid as userid0_0_, photos0_.typeid as typeid0_0_, photos0_.name as name0_0_, photos0_.createtime as createtime0_0_, photos0_.description as descript6_0_0_, photos0_.faceid as faceid0_0_, photos0_.uri as uri0_0_ from super.photos photos0_ where photos0_.id=?

lazy=true 一句查询  有getPicture() 并且访问了里面的元数Picture 且有异常抛出
Hibernate: select photos0_.id as id0_0_, photos0_.userid as userid0_0_, photos0_.typeid as typeid0_0_, photos0_.name as name0_0_, photos0_.createtime as createtime0_0_, photos0_.description as descript6_0_0_, photos0_.faceid as faceid0_0_, photos0_.uri as uri0_0_ from super.photos photos0_ where photos0_.id=?

lazy="false" 两句查询  肯定没问题，因为全部数据都个查了出来 所以怎么调用都正常
Hibernate: select photos0_.id as id0_0_, photos0_.userid as userid0_0_, photos0_.typeid as typeid0_0_, photos0_.name as name0_0_, photos0_.createtime as createtime0_0_, photos0_.description as descript6_0_0_, photos0_.faceid as faceid0_0_, photos0_.uri as uri0_0_ from super.photos photos0_ where photos0_.id=?
Hibernate: select pictures0_.photosid as photosid1_, pictures0_.id as id1_, pictures0_.id as id2_0_, pictures0_.photosid as photosid2_0_, pictures0_.name as name2_0_, pictures0_.clicked as clicked2_0_, pictures0_.uploaddate as uploaddate2_0_, pictures0_.size as size2_0_, pictures0_.description as descript7_2_0_, pictures0_.uri as uri2_0_ from super.picture pictures0_ where pictures0_.photosid=?

fetch="join"  一句查询  效果 ＝＝ lazy="false" 呵呵，哪个效率高，我就不知道了。。。。。。。。。。。
Hibernate: select photos0_.id as id0_1_, photos0_.userid as userid0_1_, photos0_.typeid as typeid0_1_, photos0_.name as name0_1_, photos0_.createtime as createtime0_1_, photos0_.description as descript6_0_1_, photos0_.faceid as faceid0_1_, photos0_.uri as uri0_1_, pictures1_.photosid as photosid3_, pictures1_.id as id3_, pictures1_.id as id2_0_, pictures1_.photosid as photosid2_0_, pictures1_.name as name2_0_, pictures1_.clicked as clicked2_0_, pictures1_.uploaddate as uploaddate2_0_, pictures1_.size as size2_0_, pictures1_.description as descript7_2_0_, pictures1_.uri as uri2_0_ from super.photos photos0_ left outer join super.picture pictures1_ on photos0_.id=pictures1_.photosid where photos0_.id=?

不加fetch＝"join" 一句查询  没有getPicture() 正常
Hibernate: select photos0_.id as id0_0_, photos0_.userid as userid0_0_, photos0_.typeid as typeid0_0_, photos0_.name as name0_0_, photos0_.createtime as createtime0_0_, photos0_.description as descript6_0_0_, photos0_.faceid as faceid0_0_, photos0_.uri as uri0_0_ from super.photos photos0_ where photos0_.id=?

不加fetch＝"join" 一句查询  有getPicture() 正常
Hibernate: select photos0_.id as id0_0_, photos0_.userid as userid0_0_, photos0_.typeid as typeid0_0_, photos0_.name as name0_0_, photos0_.createtime as createtime0_0_, photos0_.description as descript6_0_0_, photos0_.faceid as faceid0_0_, photos0_.uri as uri0_0_ from super.photos photos0_ where photos0_.id=?

不加fetch＝"join" 一句查询 有getPicture() 并且访问里面的元素Picture的ID 有异常抛出
Hibernate: select photos0_.id as id0_0_, photos0_.userid as userid0_0_, photos0_.typeid as typeid0_0_, photos0_.name as name0_0_, photos0_.createtime as createtime0_0_, photos0_.description as descript6_0_0_, photos0_.faceid as faceid0_0_, photos0_.uri as uri0_0_ from super.photos photos0_ where photos0_.id=?

来个两兵交战 fetch="join" lazy="true"  呵呵 结果，一句查询， 结构正常 所以就当lazy不存在好了。 看来fetch 是老大。、、、、、、、、、、、、、
Hibernate: select photos0_.id as id0_1_, photos0_.userid as userid0_1_, photos0_.typeid as typeid0_1_, photos0_.name as name0_1_, photos0_.createtime as createtime0_1_, photos0_.description as descript6_0_1_, photos0_.faceid as faceid0_1_, photos0_.uri as uri0_1_, pictures1_.photosid as photosid3_, pictures1_.id as id3_, pictures1_.id as id2_0_, pictures1_.photosid as photosid2_0_, pictures1_.name as name2_0_, pictures1_.clicked as clicked2_0_, pictures1_.uploaddate as uploaddate2_0_, pictures1_.size as size2_0_, pictures1_.description as descript7_2_0_, pictures1_.uri as uri2_0_ from super.photos photos0_ left outer join super.picture pictures1_ on photos0_.id=pictures1_.photosid where photos0_.id=?

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1594975

  <property name="hibernateProperties">
   <props>
    <prop key="hibernate.dialect">org.hibernate.dialect.OracleDialect</prop>
    <prop key="hibernate.show_sql">true</prop>   
    
   </props>
  </property>
  <property name="lobHandler"><ref bean="oracleLobHandler" /> </property>
 </bean>