映射文件的结构和属性
一个映射文件（mapping file)由一个根节点<hibernate-mapping>和多个<class>节点组成，
首先看看根节点<hibernate-mapping>支持什么属性：
<hibernate-mapping
schema="schemaName" (1)
catalog="catalogName" (2)
default-cascade="cascade_style" (3)
default-access="field|property|ClassName" (4)
default-lazy="true|false" (5)
auto-import="true|false" (6)
package="package.name" (7)
/>
这8个属性都是可选的，下面解释几个重要的属性，
default-lazy:延迟加载，默认为true，Hibernate通过默认加载提升性能，通常建议设置为true。在后面的配置属性和集合映射时也可以指定lazy值
auto-import：是否允许查询语句中使用非全限定类名，默认为true，当一个映射文件中有两个持久化类，包名不同，类名相同时，需要设置auto-import为false才能区分。
package:设置该值之后，映射文件就不再需要指定全限定类名
再看看<class>标签支持什么样的属性，
<class
name="ClassName" (1)
table="tableName" (2)
discriminator-value="discriminator_value" (3)
mutable="true|false" (4)
schema="owner" (5)
catalog="catalog" (6)
proxy="ProxyInterface" (7)
dynamic-update="true|false" (8)
dynamic-insert="true|false" (9)
select-before-update="true|false" (10)
polymorphism="implicit|explicit" (11)
where="arbitrary sql where condition" (12)
persister="PersisterClass" (13)
batch-size="N" (14)
optimistic-lock="none|version|dirty|all" (15)
lazy="true|false" (16)
entity-name="EntityName" (17)
check="arbitrary sql check condition" (18)
rowxml:id="rowid" (19)
subselect="SQL expression" (20)
abstract="true|false" (21)
node="element-name"
/>
一对<class>就代表一个持久化实体类，即数据库中的表，在<class>元素下，通常还会有<id>和<property>子元素，用来构成表的各个字段，<id>通常用来映射主键，<property>则用来映射普通字段，另外还可以通过<set> <map>等映射集合字段，下面一一讲解。
映射主键(<id...>
Hibernate建议为持久化类定义一个标识属性（identifier property），如private int id, 标识属性映射数据库底层的主键字段（primary key column ）。在映射文件中，标识属性用<id>表示，<id>标签支持以下属性：
<id
name="propertyName" (1)
type="typename" (2)
column="column_name" (3)
unsaved-value="null|any|none|undefined|id_value" (4)
access="field|property|ClassName"> (5)
node="element-name|@attribute-name|element/@attribute|." <generator class="generatorClass"/>
</id>
unsaved-value:指定刚创建尚未保存时的标识属性值，用来区分已经加载到session但未再次持久化的实例，Hibernate 3中已经不需要指定这个属性。
上面几个属性通常只需要指定 name, type, column这三个属性，在泛型中，type属性也不需要指定，Hibernate会通过反射获取字段类型
在Hibernate中，提供了一个逻辑主键生成器，在映射文件中通过<id>元素的子元素<generator>表示，可以为每个持久化类生成唯一逻辑主键，
主键生成器<generator>的class属性支持以下值，代表不同种类的主键生成器策略，
<generator class="increment|identity|sequence|hilo|seqhilo|uuid|guid|native|assigned|select|foreign" />
其中最常用的identiry，适合DB2,MySQL, MSSQL等支持自增长字段的数据库，可以返回long, short, int等。
sequence，适合DB2,Oracle等。
映射普通属性(<property...>
<property>标签支持以下属性，
<property
name="propertyName" (1)
column="column_name" (2)
type="typename" (3)
update="true|false" (4)
insert="true|false" (4)
formula="arbitrary SQL expression" (5)
access="field|property|ClassName" (6)
lazy="true|false" (7)
unique="true|false" (8)
not-null="true|false" (9)
optimistic-lock="true|false" (10)
generated="never|insert|always" (11)
node="element-name|@attribute-name|element/@attribute|."
index="index_name"
unique_key="unique_key_id"
length="L"
precision="P"
scale="S"
/>
通常情况下只需指定name, column, type的值， 另外部分属性解释如下
update和insert:输入属性值不需要Hibernate生成，则指定为false
formula=(sql)：直接写SQL获取数据，括号不能少
lazy：是否延迟加载，默认为false
下面演示一下formula的用法，
如果我们在实体类Person.java中有一个普通属性 private String fullContent;
private String fullContent;
在映射文件中，这个属性的值是通过formula的方式获取的，则映射文件应该这么写，
...
<property name="fullContent" formula="(select concat(p.name,p.age) from person_inf p where p.person_id = person_id)" />
...
这样，我们在测试类中如果要获取这个属性值的话，就会取formula的值
Person p = (Person)sess.get(Person.class, 3);
System.out.println(p.getFullContent());
上面的例子只是得到一个实体类的属性字段值，但是在数据库层面并没有生成这个字段，
要想数据库也生成这个字段，则要通过<property>标签的generated属性来指定， 例如
...
<property name="fullContent" column="full_content" type="string" generated="insert" />
...
同时，需要有一个数据库的触发器配合使用才能实现上面的功能，
drop database test;
create database test;
use test;
create table person_inf
(
id auto_increment primary key,
title varchar(255) not null,
content varchar(255)
full_content varchar(255)
);
DELEMITER |
create trigger t_full_content_gen BEFORE INSERT ON person_inf
FOR EACH ROW BEGIN
set person_inf.full_content=concat(person_inf.title, person_inf.content);
END;
|
DELIMITER ;
先执行上面的SQL脚本，然后才执行java程序，另外需要将hibernate.cfg.xml的hbm2ddl.auto改为update，避免重建数据库时丢失触发器。
之后，便可以像上面那样访问这个属性了，
1 Person p = (Person)sess.get(Person.class, 3);
2 System.out.println(p.getFullContent());
映射集合属性
在一个实体类中，有标志属性，普通属性，经常还会有集合属性，集合属性中会包含多个值，多个值与实体类形成一对多的关联关系。
例如Set集合，List集合，Map集合等等，比如下面这样的实体类定义，
public class SetPerson {
private int id;
private String name;
private int age;
private Set<String> schools = new HashSet<String>();
...
这里的schools就是一个集合属性。
Hibernate要求集合属性必须声明为接口而不是实现类，可以是java.util.Set, java.util.List, java.util.Map等。
集合属性将会保存在单独的表中，当实体类对象保存时，集合属性也会自动持久化（即保存到单独表中去），当实体类对象删除时，集合属性也会自动删除；当集合从一个实体类对象传递到另一个持久化对象时，集合记录也会从一个表转移到另一个表。
-集合标签
常用的集合属性在映射文件中的元素有 <list>, <set>, <map>, <array>, <bag>,<idbag>, <rimitive-array>等，这些集合属性元素标签也有自己的属性，部分属性解释如下：
table:表名（集合属性元素需要单独存在一张表里）
lazy：默认为true，延迟加载
inverse：反转集合属性与实体类关联的控制权，这个对于Set之类的无序集合在性能提升上有用
sort:有序集合排序属性
order-by:也是指定排序，不过是通过SQL语句实现
-外键
由于集合元素和实体类是一个从属关系，所以在集合元素中需要有一个外键，与实体类的标志属性相关联。这个外键在映射文件中通常用<key>标签标识，<key>标签也有自己的属性，如column, on-delete, property-ref,update,unique等等。
-索引
对于有序集合，都需要指定一个索引列，无序集合（Set，bag）则不需要。例如在
<list-index>，List或者数组集合中用来表示索引，
<map-key>，映射Map集合，基本数据列的索引
<map-key-many-to-many>, 映射Map集合，实体引用类索引
<composite-map-key>, 映射Map集合，复合数据类型的索引
-数据列
在映射文件中的集合元素，通常还会有一个数据列，根据不同的数据类型，在映射文件中的标签可能不同，通常会有以下几种
<element> 基本数据类型，或者其包装类型
<composite-element>复合类型
<one-to-many>或<many-to-many>引用类型
下面，将针对List, Set, Map, SortedMap等不同的集合属性具体说明每种集合属性的特性
List集合属性
List是有序集合， 因此需要一个索引列来表示集合的次序。 下面演示List集合属性的用法，
首先定义一个持久化实体类ListPerson, 类中定义了一个List集合属性 schools.
package hib; import java.util.ArrayList;
import java.util.List; public class ListPerson {
private int id;
private String name;
private int age;
private List<String> schools = new ArrayList<String>(); public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
} public List<String> getSchools() {
return this.schools;
}
public void setSchools(List<String> schools) {
this.schools = schools;
} }
对于这个持久化类， 其映射文件如下， 在映射文件中，我们定义了外键标签<key>用来关联集合属性和持久化类，
定义了索引列<list-index>来记录集合属性元素的次序，定义了数据列<element>来保存集合元素的值
<?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 package="hib">
<class name="ListPerson" table="Person_inf">
<id name="id" column="person_id" type="int">
<generator class="identity" />
</id>
<property name="name" type="string" />
<property name="age" type="int" />
<list name="schools" table="school">
<!-- 外键列-->
<key column="personid" not-null="true"/>
<!-- 索引列 -->
<list-index column="list_order"/>
<!-- 数据列，这里的type属性其实可以省略，因为在实体类中使用了泛型，Hibernate会通过反射取得元素数据类型-->
<element type="string" column="school_name" />
</list>
</class>
</hibernate-mapping>
下面写一个测试类用来测试上面的持久化类，
package hib; import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet; import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.tool.hbm2ddl.SchemaExport; public class PersonManager {
private static void exec(String resource, Object obj) {
// 打开线程安全的session
Configuration conf = new Configuration().configure();
conf.addResource("hib/"+resource);
// 用Configuration创建SessionFactory
SessionFactory sf = conf.buildSessionFactory();
// 用SessionFactory打开Session
Session sess = sf.openSession();
Transaction tx = sess.beginTransaction();
sess.save(obj);
tx.commit();
sess.close();
sf.close();
}
private static void listTest() {
ListPerson lp = new ListPerson();
lp.setAge(20);
lp.setName("xiao ming");
List<String> schools = new ArrayList<String>();
schools.add("小学");
schools.add("中学");
lp.setSchools(schools);
exec("ListPerson.hbm.xml", lp);
} public static void main(String[] args) {
listTest();
}
}
PersonManager类中定义了一个通用方法private static void exec(String resource, Object obj)用来保存持久化类实例，
在方法listTest()中，实例化了一个持久化类ListPerson, 并且实例化了一个集合属性schools并赋值。
运行PersonManager.java之后，发现数据库中多了两张表，person_inf和school，且两张表通过personid关联（即在school表中增加了外键约束如下：FK_48amgp8tko414xxqs1q1vaat4）。
eclipse中执行结果，
Hibernate: drop table if exists Person_inf
Hibernate: drop table if exists school
Hibernate: create table Person_inf (person_id integer not null auto_increment, name varchar(255), age integer, primary key (person_id))
Hibernate: create table school (personid integer not null, school_name varchar(255), list_order integer not null, primary key (personid, list_order))
Hibernate: alter table school add constraint FK_48amgp8tko414xxqs1q1vaat4 foreign key (personid) references Person_inf (person_id)
十二月 29, 2016 11:11:30 下午 org.hibernate.tool.hbm2ddl.SchemaExport execute
INFO: HHH000230: Schema export complete
Hibernate: insert into Person_inf (name, age) values (?, ?)
Hibernate: insert into school (personid, list_order, school_name) values (?, ?, ?)
Hibernate: insert into school (personid, list_order, school_name) values (?, ?, ?)
mysql中的数据，
总共有两张表
MariaDB [information_schema]>
MariaDB [information_schema]> select table_name from tables where table_schema =
'test';
+------------+
| table_name |
+------------+
| person_inf |
| school |
+------------+
2 rows in set (0.00 sec)
实体类表
MariaDB [(none)]> use test;
Database changed
MariaDB [test]>
MariaDB [test]> select * from person_inf;
+-----------+-----------+------+
| person_id | name | age |
+-----------+-----------+------+
| 1 | xiao ming | 20 |
+-----------+-----------+------+
1 row in set (0.00 sec)
MariaDB [test]>
集合属性表
MariaDB [test]> select * from school;
+----------+-------------+------------+
| personid | school_name | list_order |
+----------+-------------+------------+
| 1 | 小学 | 0 |
| 1 | 中学 | 1 |
+----------+-------------+------------+
2 rows in set (0.00 sec)
数组集合属性
Hibernate对数组和List的处理非常相似，只是前者长度不可变，后者可变而已，也因此数组集合一般是无法实现延迟加载的（长度不可变）。
将上面的list集合修改成数组集合，代码如下，
持久化类，
package hib; import java.util.ArrayList;
import java.util.List; public class ArrayPerson {
private int id;
private String name;
private int age; public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
} public String[] getSchools() {
return schools;
}
public void setSchools(String[] schools) {
this.schools = schools;
} private String[] schools;
}
映射文件，
<?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 package="hib">
<class name="ArrayPerson" table="Person_inf">
<id name="id" column="person_id" type="int">
<generator class="identity" />
</id>
<property name="name" type="string" />
<property name="age" type="int" />
<array name="schools" table="school">
<!-- 外键列-->
<key column="personid" not-null="true"/>
<!-- 索引列 -->
<list-index column="list_order"/>
<!-- 数据列，这里的type属性其实可以省略，因为在实体类中使用了泛型，Hibernate会通过反射取得元素数据类型-->
<element type="string" column="school_name" />
</array>
</class>
</hibernate-mapping>
在测试类PersonManager.java中，新家一个测试方法arrayTest(),
private static void arrayTest() {
ArrayPerson ap = new ArrayPerson();
ap.setAge(20);
ap.setName("xiao ming");
String[] schools = new String[] {"小学","中学","大学"};
ap.setSchools(schools);
exec("ArrayPerson.hbm.xml", ap);
}
执行PersonManager.java, 看到hibernate生成的sql如下，
...
Hibernate: insert into person_inf (name, age) values (?, ?)
Hibernate: insert into school (personid, list_order, school_name) values (?, ?, ?)
Hibernate: insert into school (personid, list_order, school_name) values (?, ?, ?)
Hibernate: insert into school (personid, list_order, school_name) values (?, ?, ?)
mysql中的数据，
person_inf表，
school表，
Set集合属性
Set集合与List集合不同，Set是无序集合，因此映射文件中就没有像list那样的索引列<list-index>。作为一个与持久化实例管理的集合属性，Set集合也是需要一个<key>外键来关联的，Set集合演示如下，
持久化类，
package hib; import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set; public class SetPerson {
private int id;
private String name;
private int age; public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
} public Set<String> getSchools() {
return this.schools;
}
public void setSchools(Set<String> schools) {
this.schools = schools;
}
private Set<String> schools = new HashSet<String>();
}
映射文件，
<?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 package="hib">
<class name="SetPerson" table="Person_inf">
<id name="id" column="person_id" type="int">
<generator class="identity" />
</id>
<property name="name" type="string" />
<property name="age" type="int" />
<set name="schools" table="school">
<!-- 外键列-->
<key column="personid" not-null="true"/>
<!-- 数据列，这里的type属性其实可以省略，因为在实体类中使用了泛型，Hibernate会通过反射取得元素数据类型-->
<element type="string" column="school_name" not-null="true" />
</set>
</class>
</hibernate-mapping>
在PersonManager.java中新增一个测试方法setTest()，
private static void setTest() {
SetPerson sp = new SetPerson();
sp.setAge(20);
sp.setName("xiao ming");
Set<String> schools = new HashSet<String>();
schools.add("小学");
schools.add("中学");
sp.setSchools(schools);
exec("SetPerson.hbm.xml", sp);
}
运行PersonManager.java，查看mysql，能得到前面类似的结果
bag集合元素映射
<bag>可以映射list，映射Set，甚至映射Collection，但是不论映射成哪种集合，<bag>都会将它们映射为无序集合。
<bag>集合对应的表没有主键，在映射文件中通过<key>与持久化类关联，用<element>保存元素值，下面演示<bag>集合映射成Collection集合属性，
持久化类，
package hib; import java.util.ArrayList;
import java.util.Collection;
import java.util.List; public class BagPerson {
private int id;
private String name;
private int age; public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
} public Collection<String> getSchools() {
return schools;
}
public void setSchools(Collection<String> schools) {
this.schools = schools;
} private Collection<String> schools = new ArrayList<String>();
}
映射文件， 注意在无序集合中<bag>标签中，可以添加一个order-by属性，直接以SQL实现，这个排序将会添加进hibernate生成的SQL中，通过数据库来实现排序，而不是在程序运行内存中排序。
<?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 package="hib">
<class name="BagPerson" table="Person_inf">
<id name="id" column="person_id" type="int">
<generator class="identity" />
</id>
<property name="name" type="string" />
<property name="age" type="int" />
<bag name="schools" table="school" order-by="school_name asc">
<!-- 外键列-->
<key column="personid" not-null="true"/>
<!-- 数据列，这里的type属性其实可以省略，因为在实体类中使用了泛型，Hibernate会通过反射取得元素数据类型-->
<element type="string" column="school_name" not-null="true"/>
</bag>
</class>
</hibernate-mapping>
在PersonManager.java中，添加一个新的测试方法bagTest()，
private static void bagTest() {
BagPerson sp = new BagPerson();
sp.setAge(20);
sp.setName("xiao ming");
Set<String> schools = new HashSet<String>();
schools.add("小学");
schools.add("中学");
sp.setSchools(schools);
exec("BagPerson.hbm.xml", sp);
}
执行PersonManager.java后会发现school表中只有两列，外键列和数据列，没有索引列，因为<bag>是无序集合，
Map集合属性
Map集合属性使用<map>标签，需要使用<key>列作为外键列和持久化类关联。Map是有序集合，因此还需要<may-key>类作为Map集合的索引。Map集合对应的表将以外键列和索引列作为联合主键。下面演示Map集合用法，
package hib; import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map; public class MapPerson {
private int id;
private String name;
private int age; public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
} public Map<String, Float> getScores() {
return scores;
}
public void setScores(Map<String, Float> scores) {
this.scores = scores;
} private Map<String, Float> scores = new HashMap<String, Float>();
}
映射文件，
<?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 package="hib">
<class name="MapPerson" table="Person_inf">
<id name="id" column="person_id" type="int">
<generator class="identity" />
</id>
<property name="name" type="string" />
<property name="age" type="int" />
<map name="scores" table="score">
<!-- 外键列-->
<key column="person_id" not-null="true"/>
<!-- 索引列 -->
<map-key column="subject" type="string"/>
<!-- 数据列，这里的type属性其实可以省略，因为在实体类中使用了泛型，Hibernate会通过反射取得元素数据类型-->
<element column="grade" type="float" />
</map>
</class>
</hibernate-mapping>
在PersonManager.java中新增一个测试方法mapTest()，
private static void mapTest() {
MapPerson mp = new MapPerson();
mp.setAge(20);
mp.setName("xiao ming");
Map<String, Float> scores = new HashMap<String, Float>();
scores.put("语文", new Float(100.01));
scores.put("数学", new Float(130.05));
mp.setScores(scores);
exec("MapPerson.hbm.xml", mp);
}
执行PersonManager.java, mysql中score表的数据如下，subject将作为map集合索引， person_id + subject 将作为表的联合主键。
SortedSet和SortedMap集合映射
使用这两个集合作为集合实现类时，需要为<set>或者<map>标签指定sort属性，sort支持unsorted, natural, 以及通过java.utilComparator自定义排序。
下面演示一个SortedSet的用法，
持久化类，
package hib; import java.util.HashMap;
import java.util.Map;
import java.util.SortedSet;
import java.util.TreeSet; public class SortedPerson {
private int id;
private String name;
private int age; public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
} public SortedSet<String> getTrainings() {
return trainings;
}
public void setTrainings(SortedSet<String> trainings) {
this.trainings = trainings;
} private SortedSet<String> trainings = new TreeSet<String>();
}
映射文件， 需要在<set>上添加sort属性，
<?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 package="hib">
<class name="SortedPerson" table="person_inf">
<id name="id" column="person_id" type="int">
<generator class="identity" />
</id>
<property name="name" type="string" />
<property name="age" type="int" />
<set name="trainings" table="training" sort="natural">
<!-- 外键列-->
<key column="person_id" not-null="true"/>
<!-- 数据列 -->
<element column="training_name" type="string" not-null="true"/>
</set>
</class>
</hibernate-mapping>
在PersonManager.java中添加测试方法sortedSetTest()，
private static void sortedSetTest() {
SortedPerson ssp = new SortedPerson();
ssp.setAge(20);
ssp.setName("xiao ming");
SortedSet<String> trainings = new TreeSet<String>();
trainings.add("Wild Java Camp");
trainings.add("Sun SCJP");
ssp.setTrainings(trainings);
exec("SortedPerson.hbm.xml", ssp);
}
执行PersonManager.java，发现mysql中training表记录已经按照element列按字母排序，
数据库SQL排序
上面这种排序是在程序运行内存中实现的，之后再将已排序记录持久化到数据库中。
如果我们不希望用程序内心来排序，而是希望通过数据来排序，则可以在<set> <map> <bag>中添加order-by属性。
这种方式是通过继承LinkedHashSet或者LinkedHashMap来实现的，因此确保你的JDK版本至少大于1.4
例如我们可以在上面的SetPerson.hbm.xml中，在<set>标签中添加order-by属性，
<set name="schools" table="school" order-by="school_name asc">
集合属性的性能分析
延迟加载
Hibernate对集合属性默认采用延迟加载策略，即lazy="true". 因为集合属性很可能有成千上万条数据，而持久化类在实例化的时候并不一定会马上用关联的集合属性。
修改属性（增删改）的性能
集合可分两类
有序集合：集合元素可根据key或者index访问
无序集合：集合元素只能遍历
对于有序集合，因为有联合主键存在（主键已被索引），因此可以直接定位到相应元素进行修改，效率高。
对于无序集合，只有外键，没有索引，也就没有联合主键，也就没法按主键索引定位元素（可能可以建立索引，但性能可能非常差），修改这种集合性能将会很低。
因此对于<bag>这种集合，即没有索引字段，同时还不允许元素重复，hibernate无法直接判断元素是否重复，当需要修改集合属性值时，只能先删除全部集合，再重新创建集合，因此性能是最差的。
所以，对于有序集合属性的增，删，改将会有比较好的性能。（数组也是有序集合，但数组属性不支持延迟加载（因为长度固定），所以数组属性性能其实很低的）
延迟更新
对于多对多关联，值数据而言，如果改变Set集合的某个元素，hibernate并不能立即更新该元素对应的数据行。对于Set而言，只有在插入和删除操作时改变才有效。
反向集合（inverse="true")
修改Set集合属性性能并不高，但Hibernate还是处处采用了Set集合，这一方面是因为Set更贴近集合语意，
另一方面，在1-N关联中，1的一端通常都带有inverse="true"属性，即这种关联关系不再由一的一端维护，更新操作将在N的一端处理，这种情况下，无序考虑集合性能。
映射数据库对象
最后，还要来看看映射文件映射数据库对象，数据库对象指的是触发器，存储过程等等。Hibernate中使用<database-object>标签来映射数据库对象，用<create><drop>等标签标识具体的数据库操作，
下面演示映射创建数据表（DDL语句），
首先要定义一个映射文件，映射文件中可以用<create><drop>等指定具体的操作，然后直接将sql语句写在标签中。还可以添加一些<dialect>之类的标签指定更多属性，例如只在MySQL中有效，
<?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>
<database-object>
<create>create table test(t_name varchar(255));</create>
<drop></drop>
</database-object>
</hibernate-mapping>
此映射文件不需要持久化类，我们直接在测试类中初始化一个Configuration对象并加载配置文件，打开一个SessionFactory，此映射文件就会生效，
在PersonManager.java中，新增测试方法dbObject()
private static void dbObject() {
//加载数据触发器来创建表
Configuration conf = new Configuration().configure();
conf.addResource("hib/DbObject.hbm.xml");
SessionFactory sf = conf.buildSessionFactory();
}
注意，通过这种方式创建表，好一定要将hibernate.cfg.xml中的hbm2ddl.auto设置为create才能生效
<property name="hbm2ddl.auto">create</property>
执行PersonManager.java将会创建一张test表，
除了上面根据配置文件生成表的方法之外，还可以使用hibernate自带工具SchemaExport(可直接命令行执行）， 使用工具的代码如下，
映射文件保持不变，在PersonManager.java中，将dbObject()方法修改为，
private static void dbObject() {
//加载数据触发器来创建表
Configuration conf = new Configuration().configure();
conf.addResource("hib/DbObject.hbm.xml");
//SessionFactory sf = conf.buildSessionFactory();
SchemaExport se = new SchemaExport(conf);
se.setFormat(true).setOutputFile("new.sql").create(true, true);
}
注意如果通过SchemaExport的方式创建表，hibernate.cfg.xml中的hbm2ddl.auto就不需要强制设置为create了，update也行。
执行PersonManger.java，也能创建test表。