我的博客

Hibernate学习笔记7——检索方式

jjr2001425@126.com (jjr) — Wed, 13 May 2009 22:55:39 +0800

1.Hibernate提供的检索方式：导航对象图检索方式、OID检索方式、HQL检索方式、QBC检索方式和本地SQL检索方式。
导航对象图检索方式：根据已经加载的对象，导航到其他对象。如：getOrders().iterator()。
OID检索方式：按照对象的OID来检索对象。Session的get()和load()提供了此功能。
HQL检索方式：Query接口是Hibernate提供的专门的HQL查询接口(跨平台,关键字不区分大小写)。
QBC检索方式：Query By Criteria(跨平台)。
本地SQL检索方式：使用本地数据库的SQL查询语句。

2.HQL和QBC支持多态查询，多态查询是指查询出当前类和所有子类的实例。
from java.lang.Object
多态查询对接口也是用，以下查询对所有实现Serializable接口的实例
from java.io.Serializable

3.Hibernate采用参数绑定机制，它的优点：
a.非常安全，防止怀有恶意的用户非法调用数据库系统的存储过程。
b.能够利用底层数据库预编译SQL语句的功能，提高查询数据的性能。预编译是指底层数据库系统只编译SQL语句一次，把编译出来的可执行代码保存在缓存中，如果多次执行相同形式的SQL语句，不需要重新编译，只要从缓存中获得可执行代码即可。
绑定的形式：1)、按参数名字绑定 2)、按参数位置绑定
绑定参数类型：
1).setEntity()方法
session.createQuery("from Order o where o.customer=:customer").setEntity("customer",customer).list();
2).setParameter()方法
3).setProperties()方法
Customer customer = new Customer();
customer.setName("foolpid");
customer.setAge(18);
query = session.createQuery("from Customer c where c.name=:name and c.age=:age");
query.setProperties(customer);
日期类型有多种，如果命名参数为日期类型，不能使用setProperties()方法来绑定。

4.查询条件
HQL和QBC支持的各种运算

运算类型	HQL运算符	QBC运算符	含义
比较运算	=	Expression.eq()	等于
	<>	Expression.not(Expression.eq())	不等于
	>	Expression.gt()	大于
	>=	Expression.ge()	大于等于
	<	Expression.lt()	小于
	<=	Expression.le()	小于等于
	is null	Expression.isNull()	等于空值
	is not null	Expression.isNotNull()	非空值
范围运算	in(列表)	Expression.in()	等于列表中的某一个值
	not in(列表)	Expression.not(Expression.in())	不等于列表中的任意一个值
	between 值1 and 值2	Expression.between()	大于等于值1并且小于等于值2
	not between 值1 and 值2	Expression.not(Expression.between())	大于等于值1或小于等于值2
字符串模式匹配	like	Expression.like()	字符串模式匹配
逻辑运算	and	Expression.and()或者Expression.conjunction()	逻辑与
	or	Expression.or()或者Expression.disjunction()	逻辑或
	not	Expression.not()	逻辑非

字符串模式中的通配符

通配符名称	通配符	作用
百分号	%	匹配任意类型并且任意长度(可为0)的字符串，如果是中文，则需要两个百分号，即"%%"
下划线	_	匹配单个任意字符，常用来限制字符串表达式的长度

MatchMode类包含的各个静态常量实例

匹配模式	举例
MatchMode.START	Expression.like("name","T",MatchMode.START);姓名以"T"开头
MatchMode.END	Expression.like("name","T",MatchMode.END);姓名以"T"结尾
MatchMode.ANYWHERE	Expression.like("name","T",MatchMode.ANYWHERE);姓名中包含"T"
MatchMode.EXACT	Expression.like("name","Tom",MatchMode.EXACT);姓名必须是"Tom"

HQL查询支持数学运算表达式，而QBC不支持。
from o where o.price/4-100>50;

5.连接查询
HQL与QBC支持的各种连接类型

程序指定查询类型	HQL语法	QBC运算符	使用范围
内连接	inner join或join	Criteria.createAlias()	适用于有关联关系的持久化类，并且在映射文件中对这种关联关系作了映射
迫切内连接	inner join fetch或者join fetch	不支持
隐式内链接		不支持
左外连接	left out join 或者left join	不支持
迫切左外连接	left out join fetch或者left join fetch	FetchMode.EAGER
右外连接	right out join 或者right join	不支持
交叉连接	Class A,Class B	不支持	适用于不存在关联关系的持久化类

a.迫切左外连接和迫切内连接不仅指定了连接查询方式，而且显示指定了关联级别的检索策略，而左外连接和内连接仅仅指定了连接查询方式，并没有指定关联级别的检索策略。
b.迫切左外连接检索策略时，查询结果中可能会包含重复元素，可以通过一个HashSet来过滤重复元素：
HashSet set = new HashSet(result);
c.左外连接获得的是代理，迫切左外连接直接获得了代理类的实例。内链接要求左右数据都存在的。
d.隐式内链接就如o.customer.name=:name,只使用与多对一和一对一关联，不适合与一对多和多对多关联。
e.交叉连接也即是全连接，表A5条记录，表B7条记录，最后会生成35条记录。
f.HQL语句总是忽略映射文件中设置的迫切左外连接检索策略，即使映射文件中设置了迫切左外连接检索策略，如果HQL语句中没有显示指定这种策略，那么HQL仍然采用立即检索策略。

HQL在各种连接方式下的运行时行为

连接方式	对应的SQL查询语句	Orders集合的检索策略	查询结果集中的内容
默认情况	查询单个Customer表	延迟检索策略	集合中包含Customer类型的元素；集合中无重复元素；Customer对象的orders集合没有被初始化
迫切左外连接	左外连接查询Customer和Orders表	迫切左外连接检索策略	集合中包含Customer类型的元素；集合中可能有重复元素；Customer对象的orders集合被初始化
左外连接	左外连接查询Customer和Orders表	延迟检索策略	集合中包含对象数组类型的元素，每个对象数组包含一对Customer对象和Order对象，不同的对象数组可能重复引用同一个Customer对象；Customer对象的Orders没有被初始化
内连接	内连接查询Customer和Orders表	延迟检索策略	集合中包含对象数组类型的元素，每个对象数组包含一对Customer对象和Order对象，不同的对象数组可能重复引用同一个Customer对象；Customer对象的Orders没有被初始化
迫切内连接	内连接查询Customer和Orders表	迫切内连接检索策略	集合中包含Customer类型的元素；集合中可能有重复元素；Customer对象的orders集合被初始化
右外连接	右外连接查询Customer和Orders表	延迟检索策略	集合中包含对象数组类型的元素，每个对象数组包含一对Customer对象和Order对象，不同的对象数组可能重复引用同一个Customer对象；Customer对象的Orders没有被初始化

6.聚集函数
count()、min()、max()、sum()、avg()

7.集合过滤
对于已经加载的Customer持久化对象，假定它的orders集合由于延迟检索策略而没有被初始化，那么调用customer.getOrders().iterator()方法就可以初始化，但存在两个不足：
a).假定customer对象有1000个关联，但只需要其中几个，不需要加载其他数据
b).不能对Order对象排序
解决办法：
1).通过HQL或QBC查询orders集合
session.createQuery("from Order o where o.customer=:customer and o.price>100 order by o.price").setEntity("customer",customer).list();
2).使用集合过滤
List result = session.createFilter(customer.getOrders(),"where this.price>100 order by this.price").list();
Iterator it = result.iterator();
while(it.hasNext()) {
Order o = (Order)it.next();
......
}

集合过滤特点：
a.它返回Query类型的实例
b.它的第一个参数指定持久化对象的集合，这个集合是否已经被初始化并没有关系，但它所属的对象必须处于持久化状态。
c.它的第二个参数指定过滤条件
d.不管持久化对象的集合是否已经被持久化，Query的list()方法都会执行SQL语句查询，到数据库中检索Order对象。
e.如果Customer对象的orders集合已经被初始化，Query的list()方法不会创建order对象，仅仅返回已经存在的Order对象的引用。
f.如果Customer对象的orders集合没有被初始化，Query的list()方法会创建Order对象，但不会初始化Customer对象的orders集合。

集合过滤其他用途：
1).为Customer对象的orders 集合分页
session.createFilter(customer.getOrders(),"order by this.price asc").setFirstResult(10).setMaxResults(50).list();
2).检索Customer对象的orders集合中Order对象的订单编号
session.createFilter(customer.getOrders(),"select this.orderNumber").list();
3).检索数据库中与Customer对象的orders集合中Order对象的价格相同的所有Order对象
session.createFilter(customer.getOrders()."select other from Order other where other.price = this.price").list();
4).检索Order对象的lineItems集合中LineItem对象的Item：
session.createFilter(order.getLineItems(),"select this.item").list();

8.如果自查询语句返回多条记录，可以用一下关键字来量化
all：表示子查询语句返回的所有记录
any：表示子查询语句返回的任意一条记录
some：与any等价
in：与any等价
exists：表示子查询语句至少返回一条记录
//返回所有订单的价格都小于100的客户
from Customer c where 100>all(select o.price from c.orders o)
//返回有一条定的那的价格小于100的客户
from Customer c where 100>any(select o.price from c.orders o)
//至少返回有一条订单的客户
from Customer c where exists(from c.orders)

HQL提供了一组操作集合的函数或者属性：
size()函数或size属性：获得集合中元素的数目
minIndex()函数或minIndex属性：对于建立索引的集合，获得最小的索引
maxIndex()函数或maxIndex属性：对于建立索引的集合，获得最大的索引
minElement()函数或minElement属性：对于包含基本类型元素的集合，获得集合中取值最小的元素
maxElement()函数或maxElement属性：对于包含基本类型元素的集合，获得集合中取值最大的元素
elements()函数：获得集合中所有元素
eg：
from Customer c where c.orders.size>0
from Customer c where size(c.orders)>0
from Customer c where :order in elements(c.orders)

9.本地SQL查询
String sql = "select {c.*},{o.*} from CUSTOMERS c inner join ORDERS o where c.ID=o.CUSTOMER_ID";
Query query = session.createSQLQuery(sql,new String[]{"c","o"},new Class[]{Customer.class,Order.class});

10.查询性能优化
1).降低访问数据库的频率，减少select语句的数目
a.使用迫切左外连接或迫切内连接检索策略
b.对延迟检索或立即检索策略设置批量检索数目
c.使用查询缓存(如果查询结果中包含实体，二级缓存中会存放实体的OID，对于投影查询，二级缓存中存放所有的数据值)
2).避免多余加载程序不需要访问的数据
a.使用延迟检索策略
b.使用集合过滤
3).避免包庇啊哦查询数据占用缓存，实现手段为投影查询功能，查询出实体的部分属性
4).减少select语句的字段，从而降低访问数据库的数据量，实现手段为利用Query的iterate()方法。

11.试比较HQL与QBC的优缺点

通配符名称	HQL检索方式	QBC检索方式
可读性	优点：和SQL查询语言比较接近，比如容易读懂	缺点：QBC把查询语句肢解为一组Criterion实例，可读性差
功能	优点：功能最强大，支持各种各样的查询	缺点：没有HQL的功能强大，例如不支持报表查询和子查询，而且对连接查询也做了很多限制
查询语句形式	缺点：应用程序必须提供基于字符串形式的HQL查询语句	优点：QBC检索方式封装了基于字符串形式的查询语句，提供了更加面向对象的接口
何时被解析	缺点：HQL查询语句具有在运行时才会被解析	优点：QBC在编译时就能被编译，因此更加容易排错
可扩展性	缺点：不具有扩展性	优点：允许用户扩展Criterion接口
对动态查询语句的支持	缺点：尽管支持生成动态查询语句，但是编程很麻烦	优点：适合于生成动态查询语句

Hibernate学习笔记6——检索策略

jjr2001425@126.com (jjr) — Tue, 12 May 2009 22:31:09 +0800

1.Hibernate的检索策略简介

类级别和关联级别可选的检索策略及默认的检索策略

检索策略的作用域	可选的检索策略	默认的检索策略	运行时行为受影响的Session的检索方法
类级别	立即检索延迟检索	立即检索	仅影响load()方法
关联级别	立即检索延迟检索迫切左外连接检索	多对一和一对一为外连接检索	影响load()、get()和find()方法
关联级别	立即检索延迟检索迫切左外连接检索	一对多和多对多为立即检索	影响load()、get()和find()方法

3种检索策略的运行机制

检索策略的类型	类级别	关联级别
立即检索	立即加载检索方法指定的对象	立即加载与检索方法指定的对象关联的对象。可以设定批量检索数量
延迟检索	延迟加载检索方法指定的对象	延迟加载与检索方法指定的对象关联的对象。可以设定批量检索数量
迫切左外连接检索	不使用	通过左外连接加载与检索方法指定的对象关联的对象

映射文件中用于设定检索策略的几个属性

属性	可选值	默认值	描述
lazy	true或false	false	如果为true，表示使用延迟检索策略。在<class>和<set>元素中包含此属性
outer-join	auto、true或false	在<many-to-one>和<one-to-one>元素中为auto，在<set>元素中为false	如果为true，表示使用迫切左外连接的检索策略。在<many-to-one>、<one-to-one>和<set>元素中包含此属性
batch-size	正数值	1	设定批量检索的数量。如果设定此项，合理的取值在3~10之间。仅适用于关联级别的立即检索和延迟检索。在<class>和<set>元素中包含此属性

延迟检索策略能避免多余加载应用程序不需要访问的关联对象，迫切左外连接检索策略则充分利用了SQL的外连接查询功能，能够减少select语句的数目。

在多数情况下，如果程序代码没有显式设定检索策略，则采用映射文件中配置的检索策略。但也有例外，HQL检索方式会忽略映射文件配置的迫切左外连接检索策略。

1).在<class>元素中设置lazy的属性为true，如果加载Customer对象在数据库中不存在时，Session的load()方法不会抛出异常，只有当运行customer.getName()方法时才会抛出LazyInitializer的异常。
2).Customer代理类的实例在Session范围内才能被初始化。以下程序也会抛出LazyIntializer的异常。
tx = session.beginTransaction();
customer = (Customer)session.load(Customer.class,new Long(1));
tx.commit();
session.close();
customer.getName();//这句话会抛出异常

3). Hibernate.initialize(customer.getOrders());只有在Session范围内才能被初始化。
4).不管Customer.hbm.xml文件的<class>元素的lazy属性是true还是false，Session的get()和find()方法在Customer类级别总是使用立即检索策略。get()方法永远不会返回Customer代理类实例，这是与load()方法的不同之处。

2.一对多和多对多关联的检索策略

lazy属性	outer-join属性	检索策略
false	false	采用立即检索策略，这是默认的检索策略，当使用Hibernate的二级缓存时，可以考虑使用立即检索。
false	true	采用迫切左外连接检索。在Hibernate2.x版本，在映射文件中如果有对个<set>元素，只允许一个<set>元素的outer-join属性为true
true	false	采用延迟策略，这是有线考虑使用的检索策略
true	true	没有任何意义

3.多对一和一对一关联的检索策略

设置多对一关联的检索策略

Order的<many-to-one>元素的out-join属性	Customer的<class>元素的lazy属性	检索Order对象时关联的Customer对象使用的检索策略
auto	true	延迟检索
auto	false	迫切左外连接检索
true	true	迫切左外连接检索
true	false	迫切左外连接检索
false	true	延迟检索
false	false	立即检索

如果select语句中的外连接表的数目太多，会影响检索性能，此时可通过Hibernate配置文件中的hibernate.max_fetch_depth属性来控制外连接的深度。

对于一对一关联，如果使用延迟加载策略，必须把<one-to-one>元素的constrained属性设置为true。
<one-to-one name="customer" class="mypack.Customer" constrained="true" />

4.三种检索策略优缺点

检索策略	优点	缺点	优先考虑的场合
立即检索	对应用程序完全透明，不管对象处于持久化状态，还是游离状态，应用程序都可以方便地从一个对象导航到它关联的对象	(1).select语句数目多 (2).可能会加载应用程序不需要访问的对象，白白浪费许多内存空间	(1).类级别 (2).应用程序需要立即访问的对象 (3).使用了二级缓存
延迟检索	由应用程序决定需要加载哪些对象，可以避免多余的select语句，以及避免加载应用程序不需要访问的对象。因此能提高检索性能，并且能节省内存空间	应用程序如果希望访问游离状态的代理类实例，必须保证它在持久化状态时已经被初始化	(1).一对多或在多对多关联 (2).应用程序不需要立即访问或者根本不会访问的对象
迫切左外连接检索	(1).对应用程序完全透明，不管对象处理持久化状态还是游离状态，应用程序都可以方便地从一个对象导航到它关联的对象 (2).使用了外连接，select语句数目少	(1).可能会加载应用程序不需要访问的对象，白白浪费了许多内存空间 (2).复杂的数据库表连接会影响检索性能	(1).多对一或者一对一关联 (2).应用程序需要立即访问的对象 (3).数据库系统具有良好的表连接性能

Eclipse常用插件列表

jjr2001425@126.com (jjr) — Wed, 06 May 2009 22:49:32 +0800

1.源代码管理svn插件

Update site：http://subclipse.tigris.org/update_1.4.x

默认使用JavaHL接口，如果使用中没有问题的话，最好别切换：

2.反编译Jodeclipse与JadClipse插件

Jodeclipse是Jode的Eclipse插件，JadClipse是Jad的Eclipse插件，它们都是非常好的反编译插件。

Jodeclipse安装方法
（1）从如下地址下载：
http://sourceforge.net/projects/jodeeclipse
把下载下来的文件jodeplugin_1.0.5.zip直接解压到eclipse的plugins目录下。

（2）启动eclipse，help -> Software Updates-> Find and Install... -> Search for new features to install,单击"New Remote Site..." 在URL栏输入 http://www.technoetic.com/eclipse/update然后下一步，就可以看到“jode decompiler plugin *.*”，选上安装就可以了。安装好后可以看到Window -> Preferences...-> Java -> Jode Decompiler选项卡，okay，安装成功了。

JadClipse安装方法(直接下载)
(1).下载Jad反编译工具，然后建议将jad.exe文件复制到%JAVA_HOME%\BIN目录下面（不过可以将jad.exe随便放到哪，只要记住路径就好，下面要用到）。
(2).下载jadclipse_3.3.0.jar（http://prdownloads.sourceforge.net/jadclipse/net.sf.jadclipse_3.3.0.jar?download）并解压到eclipse的plugins目录下。
(3).启动eclipse，打开：Window->Preferences->Java->JadClipse.设置反编译工具jad的全路径名Path to decompiler，比如：%JAVA_HOME%\bin\jad.exe

共同配置：如果没有默认,可以在Window-> Preferences... -> General -> Editors -> File Associations找到"*.class"在"Associated editors"里面可以看到"Jode class file viewer"选中它再单击Default按钮.

3.代码段折叠Cold Folding插件（比eclipse自带的更多）

Update site：http://eclipse.realjenius.com/update-site

安装完成后，打开Window-> Preferences... -> Java -> Editor -> Folding下设置。

step1.

step2.

step3.

4.域模型中使用的toString、equals和compareTo插件

插件的官方网址 http://www.jiayun.org/mediawiki/entry/Commons4E
Update site：http://www.jiayun.org/commons4e/updatesite31

插件安装完成后，创建一个类文件，在编辑器按右键，在弹出的菜单上会看到Commons4E lang这一项,如下图:

5.findbugs

Update site：http://findbugs.cs.umd.edu/eclipse-daily

安装完成后点击右键即可使用：

查处来的错误提示，双击一下就能找到bug对应的地方了。

Hibernate学习笔记5——对象关系映射

jjr2001425@126.com (jjr) — Fri, 01 May 2009 17:02:34 +0800

一、映射组成关系

1.聚集关系：在域模型中，部分类的对象的生命周期依赖于整体类的对象的生命周期，当整体消失时，部分也就随之消失。这种整体与部分的关系为聚集关系。例如：计算机系统就是一个聚集体，它由主机、键盘、鼠标等组成。
表现形式->空心菱形箭头表示。

2.组成关系：在有些情况下，部分类的对象可以被多个整体类的对象共享，比如电视机和录像机共用一个遥控器。或者一个部分类的对象只能属于一个整体类的特定对象，例如人和手是整体和部分的关系。如果部分只能属于特定的整体，这种聚集关系也称为组成关系。表现形式->实心菱形箭头表示。

3.组成关系在hbm文件中的写法

public class Customer implements Serializable{
private Address homeAddress;
//get、set方法省略
}
public class Address implements Serializable{
private Customer customer;
private String province;
private String city;
private String street;
private String zipcode;
//get、set方法省略
}

//hbm文件配置信息：
<component name="homeAddress" class="mypack.Address">
<parent name="customer" /> //指定Address所属的整体类
<property name="street" type="string" column="HOME_STREET" />
<property name="city" type="string" column="HOME_CITY" />
<property name="province" type="string" column="HOME_PROVINCE" />
<property name="zipcode" type="string" column="HOME_ZIPCODE" />
</component>

4.值(Value)类型与实体(Entity)类型
值类型与实体类型的最重要的区别是值类型没有OID，不能被单独持久化，它的生命周期依赖于所属的持久化类的对象的生命周期，组件类型就是一种值类型；而实体类型有OID，可以被单独持久化。
在通过Configuration类的addClass()方法加载映射文件时，只需要加载Customer.class类，而不需要单独加载Address.class组件类。

Configuration config = new Configuration();
config.addClass(Customer.class);
sessionFactory = config.buildSessionFactory();

二、Hibernate的内置映射类型

1.Hibernate映射类型分为两种：内置映射类型和客户化映射类型。内置映射类型负责把一些常见的Java类型映射到相应的SQL类型。

2.Java基本类型的Hibernate映射类型

Hibernate映射类型	Java类型	标准SQL类型	大小和取值范围
integer或int	int或java.lang.Integer	INTEGER	4字节，-2^31-2^31-1
long	long或java.lang.Long	BIGINT	8字节，-2^63-2^63-1
short	short或者java.lang.Short	SMALLINT	2字节，-2^15-2^15-1
byte	byte或者java.lang.Byte	TINYINT	1字节，-2^7-2^7-1
float	float或者java.lang.Float	FLOAT	4字节，单精度浮点数
double	double或者java.lang.Double	DOUBLE	8字节，双精度浮点数
big_decimal	java.math.BigDecimal	NUMERIC	NUMERIC(8,2),表示共8位，其中小数部分占2位
character	char或者java.lang.Character,java.lang.String	CHAR(1)	定长字符
string	java.lang.String	VARCHAR	变长字符串
boolean	boolean或者java.lang.Boolean	BIT	布尔类型
yes_no	boolean或者java.lang.Boolean	CHAR(1)('Y'或者'N')	布尔类型
true_false	boolean或者java.lang.Boolean	CHAR(1)('T'或者'F')	布尔类型

3.Java时间和日期类型的Hibernate映射类型

映射类型	Java类型	标准SQ L类型	描述
date	java.util.Date或java.sql.Date	DATE	代表日期，形式：YYYY-MM-DD
time	java.util.Date或java.sql.Time	TIME	代表时间，形式为：HH:MM:SS
timestamp	java.util.Date或java.sql.Timestamp	TIMESTAMP	代表日期和时间，形式：YYYYMMDDHHMMSS
calendar	java.util.Calendar	TIMESTAMP	同上
calendar_date	java.util.Calendar	DATE	代表日期，形式：YYYY-MM-DD

4.Java大对象类型Hibernate映射类型

映射类型	Java类型	标准SQL类型	MySQL类型	Oracle类型
binary	byte[]	VARBINARY(或BLOB)	BLOB	BLOB
text	java.lang.String	CLOB	TEXT	CLOB
serializable	实现java.io.Serializable接口的任意一个java类	VARBINARY(或BLOB)	BLOB	BLOB
clob	java.sql.Clob	CLOB	TEXT	CLOB
blob	java.sql.Blob	BLOB	BLOB	BLOB

尽管java.sql.Blob和java.sql.Clob是处理Java大对象的有效方式，但它们受到以下两点限制：
1).如果在持久化类中定义一个java.sql.Blob或java.sql.Clob类型的属性，只有一个数据库事务中，Blob或Clob的实例才有效。
2).有些数据库系统的JDBC驱动程序不支持java.sql.Blob或java.sql.Clob。

5.使用Hibernate内置映射类型图

三、客户化映射类型

Hibernate还允许用户实现UserType或CompositeUserType接口，来灵活地定制客户化映射类型。

1.实现UserType实例

public class AddressUserType implements UserType{

/**设置和Address类的四个属性province、city、street和zipcode对应的字段的SQL类型，它们均为VARCHAR类型*/
private static final int[] SQL_TYPES={Types.VARCAHR,Types.VARCAHR,Types.VARCAHR,Types.VARCAHR};

public int[] sqlTypes(){return SQL_TYPES};

/**设置AddressUserType所映射的Java类：Address类*/
public Class returnedClass(){ return Address.class;}

/**指明Address类是不可变类*/
public boolean isMutable(){return false;}

/**返回Address对象的快照，由于Address类是不可变类，因此直接将参数代表的Address对象返回*/
public Object deepCopy(Object value){return value;}

/**比较一个Address对象是否和它的快照相同*/
public boolean equals(Object x,Object y){
if(x==y) return true;
if(x==null||y==null) return false;
return x.equals(y);
}

/**从JDBC ResultSet中读取province、city、street和zipcode，然后构造一个Address对象*/
public Object nullSafeGet(ResultSet resultSet,String[] names, Object owner)throws HibernateException,SQLException{

if(resultSet.wasNull()) return null;
String province = resultSet.getString(names[0]);
String city = resultSet.getString(names[1]);
String street = resultSet.getString(names[2]);
String zipcode = resultSet.getString(names[3]);
return new Address(province,city,street,zipcode);

}

/**把Address对象的属性添加到JDBC PreparedStatement中*/
public void nullSafeSet(PreparedStatement statement,Object value,int index)throws HibernateException,SQLException{

if(value==null){
statement.setNull(index,Types.VARCHAR);
statement.setNull(index+1,Types.VARCHAR);
statement.setNull(index+2,Types.VARCHAR);
statement.setNull(index+3,Types.VARCHAR);
}else{
Address address = (Address)vlaue;
satement.setString(index,address.getProvince());
satement.setString(index+1,address.getCity());
satement.setString(index+2,address.getStreet());
satement.setString(index+3,address.getZipcode());
}

}

}

//hbm文件配置信息修改为如下：
<property name="homeAddress" class="mypack.AddressUserType">
<column length="15" name="HOME_STREET" />
<column length="15" name="HOME_CITY" />
<column length="15" name="HOME_PROVINCE" />
<column length="15" name="HOME_ZIPCODE" />
</property>

3.CompositeUserType实例

public class Customer{
private Name name;
//get、set方法省略
}

public class Name implements Serializable{
private String firstname;
private String lastname;
//get、set、equals、hashCode和toString方法均省略

}

public class AddressUserType implements UserType{

/**返回Name类的所有属性的名字*/
public String[] getPropertyNames(){
return new String[]{"firstname","lastname"};
}

/**返回Name类的所有属性的Hiberante映射类型*/
public Type[] getPropertyTypes(){
return new Type{Hibernate.STRING,Hibernate.STRING};
}

/**获得Name对象的某个属性的值，参数component代表Name对象，参数property代表属性在Name对象中的位置*/
public Object getPropertyValue(Object component,int property){
Name name = (Name)component;
String result;
switch(property){
case 0: result = name.getFirstname();break;
case 1: result = name.getLastname();break;
default:throw new IllegalArgumentException("unknown property:"+property);
}
return result;
}

/**设置Name对象的某个属性的值，参数component代表Name对象，参数property代表属性在Name对象中的位置，参数value代表属性值*/
public void setPropertyValue(Object component,int property,Object value){
Name name = (Name)component;
String nameValue = (String)value;
switch(property){
case 0: name.setFirstname(nameValue); break;
case 1: name.setLastname(nameValue);break;
default: throw new IllegalArgumentException("unknown property:"+property);
}
}

/**设置NameCompositeUserType所映射的Java类：Name类*/
public Class returnedClas(){
return Name.class;
}

/**指明Name类是可变类*/
public boolean isMutable(){return true;}

/**比较一个Name对象是否和它的快照相同*/
public boolean equals(Object x,Object y){
if(x==y) return true;
if(x==null||y==null) return false;
return x.equals(y);
}

/**创建Name对象的快照，由于Name类是可变类，因此必须把Name对象的属性复制到一个新的Name实例中*/
public Object deepCopy(Object value){
if(value==null) return null;
Name name = (Name)value;
return new Name(name.getFirstname(),name.getLastname());
}

/**从JDBC ResultSet中读取firstname和lastname，然后构造一个Name对象*/
public Object nullSafeGet(ResultSet resultSet,String[] names, Object owner)throws HibernateException,SQLException{

if(resultSet.wasNull()) return null;
String firstname = resultSet.getString(names[0]);
String lastname = resultSet.getString(names[1]);
return new Name(firstname,lastname);

}

/**把Name对象的属性添加到JDBC PreparedStatement中*/
public void nullSafeSet(PreparedStatement statement,Object value,int index)throws HibernateException,SQLException{
if(value==null){
statement.setNull(index,Types.VARCHAR);
}else{
Name name = (Name)vlaue;
satement.setString(index,name.getFirstname());
satement.setString(index+1,name.getLastname());
}
}

/**根据缓存中的序列化的Name对象，重新构建一个Name对象，参数cached代表缓存中的序列化的Name对象*/
public Object assemble(Serializable cached,SessionImplementor session,Object owner){
return deepCopy(cached);
}

/**创建一个序列化的Name对象，Hibernate将把它保存到缓存中*/
public Serializable disassemble(Object value,SessionImplementor session){
return (Serializable)deepCopy(value);
}

}

//hbm文件配置信息修改为如下：
<property name="name" class="mypack.NameCompositeUserType">
<column length="15" name="FIRSTNAME" />
<column length="15" name="LASTNAME" />
</property>

4.CompositeUserType不仅能完成和UserType相同的功能，而且还提供了Hibernate查询语言的支持，在以上程序中，使用customer.homeAddress.province时会报错，但使用customer.name.firstname就不会。
在创建客户化映射类型时，deepCopy()方法用于生成持久化对象的属性的快照。当Hibernate清理缓存中的持久化对象时，会比较对象的属性以相应的属性是否相同，如果不同，就按照更新后的属性值来同步更新数据库。对于可变类型，deepCopy()方法返回属性值的拷贝，对于不可变类型，deepCopy()方法直接返回属性值。

Hibernate学习笔记4——对象映射与持久化

jjr2001425@126.com (jjr) — Tue, 28 Apr 2009 22:35:04 +0800

一、Hibernate使用对象标识符(OID)来建立内存中的对象和数据库表中记录的对应关系，对象的OID和数据库表中主键对应。

Hibernate提供的内置标识符生成器：

标识符生成器	描述
increment	适用于代理主键。由Hibernate自动以递增的方式生成标识符，每次增量为1
identity	适用于代理主键。由底层数据库生成标识符。前提条件是底层数据库支持自动增长字段类型
sequence	适用于代理主键。Hibernate根据底层数据库的序列来生成标识符。前提条件是底层数据库支持序列
hilo	适用于代理主键。Hibernate根据high/low算法来生成标识符。Hibernate把特定表的字段作为"high"值。在默认情况下hibernate_unique_key表的next_hi字段。
native	适用于代理主键。根据底层数据库对自动生成标识符支持能力，来选择identity、sequence或hilo
uuid.hex	适用于代理主键。Hibernate采用128位的UUID算法来生成标识符。UUID算法能够在网络环境中生成惟一的字符串标识符。这种标识符生成策略并不流行，因为字符串类型的主键比整型的主键占用更多的数据库空间。
assigned	适用于自然主键。由Java应用程序负责生成标识符，为了能让Java应用程序设置OID，不能把setId()方法声明为private类型。应该尽量避免使用自然主键。

常用数据库系统可使用的标识符生成器：
·MySQL:identity、increment、hilo、native
·MS SQL Server：identity、increment、hilo、native
·Oracle：sequence、seqhilo、increment、hilo、native
·跨平台开发：native

注：
1.increment标识符生成器仅仅在只有单个Hibernate应用进程访问数据库的情况下才能有效工作，因此在集群环境下不推荐使用；它不依赖于底层数据库系统，因此适合于所有的数据库系统。
2.hilo标识符生成器不依赖于底层数据库系统，因此适用于所有的数据库系统；hilo算法生成的标识符只能在一个数据库中保证惟一。
3.native根据底层数据库系统的类型自动选择合适的标识符生成器，因此适用于跨数据库平台开发。

二、映射关联关系

多对一<many-to-one>包括以下属性
·name：设定待映射的持久化类的属性名
·column：设定和持久化类的属性对应的表的外键
·class：设定持久化类的属性的类型
·not-null：设定是否允许为null，默认是false
·cascade级联关系，默认为“none”

<many-to-one name="customer" column="customer_id" class="myPackage.Customer" not-null=true />

一对多关联关系
·<set>元素表明Customer类的orders属性为java.util.Set集合类型
·<one-to-many>子元素表明orders集合中存放的是一组Order对象
·<key>子元素表明ORDERS表通过外键CUSTOMER_ID参照CUSTOMERS表
·cascade表明当保存或更新Customer对象时，会级联的操作。
·not-null：设定是否允许为null，默认是false
·inverse：默认为false。在映射一对多的双向关联时，把"one"的inverse属性设置为"true"可以提高应用性能。

<set name="orders" cascade="save-update">
<key column="CUSTOMER_ID" />
<one-to-many class="myPackage.Order" />
</set>

cascade属性	描述
none	在保存、更新或删除对象时，忽略其他关联的对象。它是cascade的默认值
save-update	当通过Session的save()、update()以及saveOrUpdate()方法来保存或更新当前对象时，级联保存所有关联的新建的临时对象，并且级联更新所有关联的游离对象。
delete	当通过Session的delete()方法删除当前对象时，级联删除所有关联的对象
all	包含save-update以及delete的行为。此外，对当前对象执行evict()或lock()操作时，也会对所有关联的持久化对象执行evict()或lock()操作。
delete-orphan	删除所有和当前对象解除关联关系的对象
all-delete-orphan	包含all和delete-orphan的行为

三、操纵持久化对象

Session接口是Hibernate向应用程序提供的操纵数据库的最主要接口，它提供了基本的保存、更新、删除和查询方法。Session具有一个缓存，位于缓存中的对象出于持久化状态，它和数据库中相应记录对应，Session能够在某些时间点，按照缓存中持久化对象的属性变化来同步更新数据库，这一过程被称为清理缓存。

Session缓存的三大作用：
1).减少访问数据库的频率。
2).保证缓存中的对象和数据库中的相关记录保持同步。
3).当缓存中的持久化对象之间存在循环关联关系时，Session保证不出现访问对象图的死循环，以及由死循环引起的JVM堆栈溢出异常。

Session清理缓存时，按照一下顺序执行SQL语句:
·按照应用程序调用session.save()方法的先后顺序，执行所有对实体进行插入的insert语句
·执行所有对实体进行更新的update语句
·执行所有对集合进行删除的delete语句
·执行所有对集合元素进行删除、更新或者插入的SQL语句
·执行所有对集合进行插入的insert语句
·按照应用程序调用session.delete()方法的先后顺序，执行所有对实体进行删除的delete语句

Session清理缓存的时间点：
·当应用程序调用Transaction的commit()方法的时候，commit()方法会先清理缓存，然后再向数据库提交事务
·当应用程序调用Session的find()或者iterate()时，如果缓存中持久化对象的属性发生了变化，就会先清理缓存，以保证查询结果能反应持久化对象的最新状态
·当应用程序显示调用Session的flush()方法的时候

Session的setFlushMode()方法用于设定清理缓存的时间点。FlushMode类定义了三种不同的清理模式：FlushMode.AUTO、FlushMode.COMMIT和FlushMode.NEVER。

清理缓存的模式	Session的查询方法	Session的commit()方法	Session的flush()方法
FlushMode.AUTO	清理	清理	清理
FlushMode.COMMIT	不清理	清理	清理
FlushMode.NEVER	不清理	不清理	清理

四、对象的状态

·临时状态(transient):刚刚用new语句创建，还没有被持久化，不处于Session的缓存中。处于临时状态的Java对象被称为临时对象。
·持久化状态(psersistent):已经被持久化，加入到Session的缓存中。处于持久化状态的Java对象被称为持久化对象。
·游离状态(detached):已经被持久化，但不再处于Session的缓存中。处于游离状态的Java对象被称为游离对象。和临时对象的区别是它由持久化对象转变过来，因此可能在数据库中还存在对应的记录，而临时对象在数据库中没有对应的记录。

五、Session的保存、更新、删除和查询方法

1.保存
session的save()方法并不立即执行SQL insert语句，只有当Session的清理缓存时才会执行SQL insert语句。如果在save()方法之后，又修改了持久化对象的属性，这会使Session在其管理缓存时，额为执行SQL update语句。

Customer c = new Customer();
session.save(c);//预执行insert语句
c.setName("Tom");
session.save(c);//预执行update语句(多余)
tx.commit(); //真正执行上面两条语句

2.更新
Session只有在清理缓存时才执行update语句，并且在执行时才会把Customer对象当前的属性值组装到update语句中，因此及时程序多次修改了Customer属性，在清理缓存时只会执行一次update语句。

c.setName("Tom");
session.update(c);
c.setName("Jim");
session.update(c);
tx.commit(); //最后只有一条语句执行，update语句放在一起或者最后一个效果

注：
a). 当update()方法关联一个游离对象时如果在Session的缓存中已经存在相同OID的持久化对象，会抛出异常。
b). 当update()方法关联一个游离对象时，如果在数据库中不存在相应的记录，也会抛出异常。

3.保存或更新

saveOrUpdate()方法包含了save()和update()方法，如果满足一下情况之一，Hibernate就把它当作临时对象：
·Java对象的OID取值为null
·Java对象具有version属性并且取值为null
·在映射文件中为<id>元素设置了unsaved-value属性，并且OID取值与unsaved-value属性值匹配
·在映射文件中为version属性设置了unsaved-value属性，并且version属性值与unsaved-value属性值匹配
·自定义Hibernate的Interceptor实现类，并且Interceptor的isUnsaved()方法返回Boolean.TRUE.

4.查询
Session的load()和get()方法都能根据给定的OID从数据库中加载一个持久化对象，这两个方法的区别在于：当数据库中不存在与OID对应的记录时，load()方法抛出ObjectNotFoundException异常，而get()方法返回null。

5.删除
delete()方法用于从数据库中删除与Java对象对应的记录。
如果传入的参数是持久化对象，Session就计划执行一个delete语句。
如果传入的参数是游离对象，先使游离对象被Session关联，使它变为持久化对象，然后执行一个delete语句。
Session只有在清理缓存的时候才会执行delete语句。
只有当调用Session的close方法时，才会从Session的缓存中删除持久化对象。

六、与触发器协同工作

触发器在接收到特定的事件时被激发，执行实现定义好的一组数据库操作。能激发触发器运行的时间可以分为以下几种：
·插入记录事件，即执行insert语句
·更新记录事件，即执行update语句
·删除记录事件，即执行delete语句

当Hibernate与数据库中的触发器协同工作时，会造成两类问题：
·触发器使Session的缓存中的数据与数据库不一致
·Session的update()方法盲目地激发触发器。

tx = session.beginTransaction();
session.save(customer);
System.out.println(customer.getRegisteredTime());
tx.commit();

以上代码在获得用户注册时间为null，当运行save()方法时，Session仅仅计划执行一个insert语句，但不会立即执行它。

tx = session.beginTransaction();
session.save(customer);
session.flush();
session.refresh(customer);
System.out.println(customer.getRegisteredTime());
tx.commit();

1.flush()方法会清理缓存，立即执行由save()方法计划的insert语句，refresh()方法重新从数据库中加载刚刚被保存的Customer对象。这两个方法迫使Session的缓存和数据库同步。

2.Session无法判断游离对象的属性是否和数据库保持一致，为了保险起见，不管游离对象的属性是否发生过变化，都会执行update语句，而update语句会激发数据库中相应的触发器。这条update语句显然是多余的，为了避免这一情况，可以在映射文件的<class>元素中设置select-before-update属性，例如：
<class name="mypack.Customer" table="CUSTOMERS" select-before-update="true">
...
</class>

七、拦截器

数据库触发器常常用力啊生成审计日志，并且具有很好的性能，缺点是不支持跨数据库平台。
Hibernate的拦截器也能生成审计日志，它不依赖与数据库平台。
为了能够激发烂机器，必须使拦截器与Session关联。Interceptor对象有两种存放方式：
SessionFactory.openSession(Inteceptor):为每个Session实例分配一个Interceptor实例，这个实例放着Session范围内。
Configuration.setInterceptor(Inteceptor):为SessionFactory实例分配一个Interceptor实例，这个实例存放在SessionFactory范围内，被所有的Session实例共享。

Oracle时间操作函数

jjr2001425@126.com (jjr) — Sat, 25 Apr 2009 21:05:06 +0800

一、oracle的to_char函数和例子：

Parameter	Explanation
YEAR	Year, spelled out
YYYY	4-digit year
YYY YY Y	Last 3, 2, or 1 digit(s) of year.
IYY IY I	Last 3, 2, or 1 digit(s) of ISO year.
IYYY	4-digit year based on the ISO standard
Q	Quarter of year (1, 2, 3, 4; JAN-MAR = 1).
MM	Month (01-12; JAN = 01).
MON	Abbreviated name of month.
MONTH	Name of month, padded with blanks to length of 9 characters.
RM	Roman numeral month (I-XII; JAN = I).
WW	Week of year (1-53) where week 1 starts on the first day of the year and continues to the seventh day of the year.
W	Week of month (1-5) where week 1 starts on the first day of the month and ends on the seventh.
IW	Week of year (1-52 or 1-53) based on the ISO standard.
D	Day of week (1-7).
DAY	Name of day.
DD	Day of month (1-31).
DDD	Day of year (1-366).
DY	Abbreviated name of day.
J	Julian day; the number of days since January 1, 4712 BC.
HH	Hour of day (1-12).
HH12	Hour of day (1-12).
HH24	Hour of day (0-23).
MI	Minute (0-59).
SS	Second (0-59).
SSSSS	Seconds past midnight (0-86399).
FF	Fractional seconds.

以下是 to_char函数的实例

函数	转换后的值
to_char(sysdate, 'yyyy/mm/dd');	would return '2003/07/09'
to_char(sysdate, 'Month DD, YYYY');	would return 'July 09, 2003'
to_char(sysdate, 'FMMonth DD, YYYY');	would return 'July 9, 2003'
to_char(sysdate, 'MON DDth, YYYY');	would return 'JUL 09TH, 2003'
to_char(sysdate, 'FMMON DDth, YYYY');	would return 'JUL 9TH, 2003'
to_char(sysdate, 'FMMon ddth, YYYY');	would return 'Jul 9th, 2003'

如果不要出现在月签名不要出现0，则在前面加FM（09就变成了9）：

函数	转换后的值
to_char(sysdate, 'FMMonth DD, YYYY');	would return 'July 9, 2003'
to_char(sysdate, 'FMMON DDth, YYYY');	would return 'JUL 9TH, 2003'
to_char(sysdate, 'FMMon ddth, YYYY');	would return 'Jul 9th, 2003'

二、常用时间函数

1.trunc(sysdate,'Q') 本季度第一天

SQL> select trunc(sysdate,'Q') from dual;

TRUNC(SYSDATE,'Q')
------------------
2007-4-1

2.trunc(sysdate,'D') 本周的第一天(周日)

SQL> select trunc(sysdate,'D')from dual;

TRUNC(SYSDATE,'D')
------------------
2007-5-27

3.last_day(sysdate) 本月最后一天

SQL> select last_day(sysdate) from dual;

LAST_DAY(SYSDATE)
-----------------
2007-5-31 15:20:3

4.add_months(sysdate,2) 日期sysdate后推2个月

SQL> select add_months(sysdate,2) from dual;

ADD_MONTHS(SYSDATE,2)
---------------------
2007-7-29 15:21:14

5.next_day(sysdate,2) 日期sysdate之后的第一周中,第2(指定星期的第几天)是什么日期

SQL> select next_day(sysdate,2) from dual;

NEXT_DAY(SYSDATE,2)
-------------------
2007-6-4 15:22:10

6.Months_between(f,s) 日期f和s间相差月数

SQL> select months_between(sysdate,to_date('2007-04-12','yyyy-mm-dd'))from dual;

MONTHS_BETWEEN(SYSDATE,TO_DATE('2007-04-12','yyyy-mm-dd'))
-----------------------------------------------------------
1.56909908900836

7.得到SYSDATE+5所在的月份

SQL> SELECT to_char(SYSDATE+5,'mon','nls_date_language=american') FROM dual;

TO_CHAR(SYSDATE+5,'MON','NLS_DATE_LANGUAGE=american')
----------------------------------------------------------
jun

8.current_date()返回当前会话时区中的当前日期。

9.select dbtimezone from dual;

10.extract()找出日期或间隔值的字段值

SQL> select extract(month from sysdate) "This Month" from dual;

This Month
----------
5
SQL> select extract(year from sysdate) "This year" from dual;

This year
----------
2007
SQL> select extract(month from add_months(sysdate,2)) " Month" from dual;

Month
----------
7

==================================================================

三、一些实践后的用法：

1.上月末天：
select to_char(add_months(last_day(sysdate),-1),'yyyy-MM-dd') LastDay from dual；

2.上月今天
SQL> select to_char(add_months(sysdate,-1),'yyyy-MM-dd') PreToday from dual;

3.上月首天
SQL> select to_char(add_months(last_day(sysdate)+1,-2),'yyyy-MM-dd') firstDay from dual;

4.要找到某月中所有周五的具体日期

SELECT to_char(b.a,'YY-MM-DD')
FROM ( SELECT trunc(SYSDATE,'mm')+ROWNUM-1 a
FROM dba_objects where rownum < 32 ) b
WHERE to_char(b.a,'day')='星期五';
如果把where to_char(t.d, 'MM') = to_char(sysdate, 'MM')改成sysdate-90，即为查找当前月份的前三个月中的每周五的日期。

5.得到系统当前月及以后的日期
select trunc(sysdate, 'MM')+ROWNUM-1 FROM dba_objects ;

加法
select sysdate,add_months(sysdate,12) from dual;        --加1年
select sysdate,add_months(sysdate,1) from dual;        --加1月
select sysdate,to_char(sysdate+7,'yyyy-mm-dd HH24:MI:SS') from dual;   --加1星期
select sysdate,to_char(sysdate+1,'yyyy-mm-dd HH24:MI:SS') from dual;   --加1天
select sysdate,to_char(sysdate+1/24,'yyyy-mm-dd HH24:MI:SS') from dual;  --加1小时
select sysdate,to_char(sysdate+1/24/60,'yyyy-mm-dd HH24:MI:SS') from dual;  --加1分钟
select sysdate,to_char(sysdate+1/24/60/60,'yyyy-mm-dd HH24:MI:SS') from dual; --加1秒

减法
select sysdate,add_months(sysdate,-12) from dual;        --减1年
select sysdate,add_months(sysdate,-1) from dual;        --减1月
select sysdate,to_char(sysdate-7,'yyyy-mm-dd HH24:MI:SS') from dual;   --减1星期
select sysdate,to_char(sysdate-1,'yyyy-mm-dd HH24:MI:SS') from dual;   --减1天
select sysdate,to_char(sysdate-1/24,'yyyy-mm-dd HH24:MI:SS') from dual;  --减1小时
select sysdate,to_char(sysdate-1/24/60,'yyyy-mm-dd HH24:MI:SS') from dual;  --减1分钟
select sysdate,to_char(sysdate-1/24/60/60,'yyyy-mm-dd HH24:MI:SS') from dual; --减1秒

-----------------------------------

to_date 字符串类型转为换日期类型
字符串中的相应位置上的字符,必须符合时间范围的限制

JAXB 2.0 API is being loaded……

jjr2001425@126.com (jjr) — Wed, 22 Apr 2009 21:03:13 +0800

错误提示：
Caused by: java.lang.LinkageError: JAXB 2.0 API is being loaded from the bootstrap classloader, but this RI (from jar:file:/E:/workSpace/T82A/WebRoot/WEB-INF/lib/cxf/jaxb-impl-2.1.7.jar!/com/sun/xml/bind/v2/model/impl/ModelBuilder.class) needs 2.1 API. Use the endorsed directory mechanism to place jaxb-api.jar in the bootstrap classloader. (See http://java.sun.com/j2se/1.5.0/docs/guide/standards/)

修正：
在%JAVA_HOME%\jre\lib\下新建endorsed文件夹，放入jaxb-api.jar即可

Hibernate学习笔记3——对象-关系映射

jjr2001425@126.com (jjr) — Mon, 13 Apr 2009 22:10:15 +0800

1.JAVA文件、映射文件和数据库关系转换图

·hbm2java：根据映射文件自动生成Java源文件
·hbm2ddl：根据映射文件自动生成数据库Schema
·XDoclet：根据带有XDoclet标记的Java源文件生成映射文件
·Middlegen：根据数据库Schema自动生成映射文件

2.Hibernate的hbm2java工具自动使持久化类实现java.io.Serializable接口。

<meta>元素的属性

属性	描述
class-description	指定描述类的JavaDoc
field-description	指定描述类的属性的JavaDoc
interface	如果为true，表示生成接口，默认为false
implements	指定类所实现的接口
extends	指定类继承的父类名
generated-class	重新指定生成的类名
scope-class	指定类的修饰符，默认为public
scope-set	指定set方法的修饰符，默认为public
scope-get	指定get方法的修饰符，默认为public
scope-field	指定类的属性的修饰符，默认为private
use-in-toString	如果为true，表示在toString()方法中包含此属性
gen-property	如果是false，不会在Java类中生成此属性，默认为true
finder-method	指定find方法名

<column>元素的属性

属性	描述
name	设定字段的名字
length	设定字段的长度
not-null	如果为true，指明该字段不允许为null，默认为false
unique	如果为true，指明该字段具有唯一约束，默认为false
index	给一个或多个字段建立索引
unique-key	为多个字段设定唯一约束
foreign-key	为外键约束命名
sql-type	设定字段的SQL类型
check	设定SQL检查约束

注：check约束不会影响Hibernate的运行时行为。如：Customers表的age字段建立了大于10的约束，但保存Customer对象时，不会检查age属性是否大于10。

3.Java有8种基本类型:byte、short、char、int、long、float、double和boolean.
8种包装类型：Byte、Short、Character、Integer、Long、Float、Double和Boolean。

4.access默认为property,设置Hibernate访问持久化类属性的策略为field时就不需要调用get和set方法。
<property name="sex" access="field">
<column name="SEX" not-null="true" />
</property>

5.insert和update语句的映射属性

属性	描述
<property>元素的insert属性	如果为false，在insert语句种不包含该字段，表示该字段永远不能被插入，默认为true
<property>元素的update属性	如果为false，update语句种不包含该字段，表示该字段永远不能被更新，默认为true
<class>元素的mutable属性	如果为false，等价于所有的<property>元素的update属性为false，整个实例不能被更新，默认为true
<property>元素的dynamic-insert属性	如果为true，表示当保存一个对象时，会动态生成insert语句，只有这个字段取值不为null，才会把它包含到insert语句中。默认为false
<property>元素的dynamic-update属性	如果为true，表示当更新一个对象时，会动态生成update语句，只有这个字段取值有变化，才会把它包含到update语句中。默认为false
<class>元素的dynamic-insert属性	如果为true，等价于所有的<property>元素的dynamic-insert属性为true，表示当保存一个对象时，会动态生成insert语句，insert语句中仅包含所有取值不为null的字段。默认为false
<class>元素的dynamic-update属性	如果为true，等价于所有的<property>元素的dynamic-update属性为true，表示当保存一个对象时，会动态生成update语句，update语句中仅包含所需要更新的字段。默认为false

6.标识符是指用于为数据库表、视图、字段或索引等命名的字符串，常规标识符不包含空格，也不包含特殊字符，因此无需使用引用符号。
如果数据表名或字段中包含空格，或者包含特殊字符，那么可以使用引用标识符。形式为：'IDENTIFIER NAME'。

ant常用命令

jjr2001425@126.com (jjr) — Mon, 13 Apr 2009 20:21:44 +0800

1.基本的build.xml文件

<?xml version="1.0"?>
<project name="ant文件" default="prepare" basedir=".">


<property name="src.root" location="${basedir}/src" />
<property name="class.root" location="${basedir}/WEB-INF/classes" />
<property name="lib.dir" location="${basedir}/WEB-INF/lib" />


<path id="classpath.je5">
<fileset dir="F:\javaCC\warkspace\EE_5">
<include name="*.jar" />
</fileset>
</path>
<path id="classpath.lib">

<pathelement location="${class.root}">

<fileset dir="${lib.dir}">
<include name="*.jar" />
</fileset>

<path refid = "classpath.je5" />
</path>

<target name="prepare" description="删除class.root路径后新建，并将src.root下的资源文件和xml文件拷入">
<echo>prepare:</echo>

<delete dir="${class.root}">
<mkdir dir="${class.root}">


<copy todir="${class.root}">
<fileset dir="${src.root}">
<include name="**/*.properties" />
<include name="**/*.xml" />
</fileset>
</copy>
</target>

<target name="compile" depends="prepare" description="编译src目录下的java文件，依赖于prepare">
<echo>compile:</echo>
<javac srcdir="${src.root}" destdir="${class.root}" debug="on" optimize="off" deprecation="on">
<classpath refid="${classpath.lib}"/>
</javac>
</target>

<target name="run" depends="compile" description="直接运行mypack包下的MyService程序">
<echo>compile:</echo>
<java classname="mypack.MyService" fork="true">
<classpath refid="${classpath.lib}"/>
</java>
</target>

</project>

2.在hibernate2下使用hbm2java，通过hbm.xml文件生成java代码。

<target name="codeGen" description="通过src.root的*.hbm.xml和配置文件codegen.cfg.xml生成java代码，依赖与前面提到的prepare">
<echo>codeGen:</echo>

<taskdef name="hbm2java" classname="net.sf.hibernate.tool.hbm2java.Hbm2JavaTask" classpathref="${classpath.lib}"/>


<hbm2java output="${src.root}" config="${class.root}/codegen.cfg.xml">
<fileset dir="${src.root}">
<include name="**/*.hbm.xml" />
</fileset>
</hbm2java>
</target>

codegen.cfg.xml的定义：

<generate>子元素设定具体的代码生成器，BasicRender生成器用于生成持久化类的源文件，FinderRender生成器用于生成相关的查询类的源文件。可以设定前缀或后缀。

利用hbm2ddl工具生成数据块Schema，数据库的脚本文件存放在schema子目录下。文件名为schema.sql.

<target name="schema" description="通过src.root的*.hbm.xml和配置文件hibernate.properties生成数据库sql语句">
<echo>schema:</echo>

<taskdef name="schemaexport" classname="net.sf.hibernate.tool.hbm2ddl.SchemaExportTask" classpathref="${classpath.lib}"/>


<schemaexport output="schema/schema.sql" properties="${class.root}/hibernate.properties" quiet="no" text="no" drop="no">
<fileset dir="${src.root}">
<include name="**/*.hbm.xml" />
</fileset>
</schemaexport>
</target>

hbm2ddl工具的命令选项：

属性	描述
quiet	如果为yes，表示不把DDL脚本输出到控制台
drop	如果为yes，只执行删除数据库中表的操作，但不创建新的表
text	如果为yes，只会生成ddl脚本文件，但不会在数据库中执行DDL脚本
output	指定存放ddl脚本的文件
config	设定基于XML格式的配置文件，hbm2ddl工具从这个配置文件中读取数据库配置信息
properties	设定基于java属性文件格式的配置文件，hbm2ddl工具从这个配置文件中读取数据库配置信息
format	设定DDL脚本中sql语句的格式
delimiter	为DDL脚本设置行结束符

Hibernate学习笔记2——Hibernate入门

jjr2001425@126.com (jjr) — Wed, 08 Apr 2009 22:07:47 +0800

Hibernate是Java应用和关系数据块之间的桥梁，它负责Java对象和关系数据块之间的映射。Hibernate内封装了通过JDBC访问数据块的操作，向上层应用提供面向对象的数据访问API。在JAVA应用中使用Hibernate的步骤如下：
1).创建Hibernate配置文件
2).创建持久化类
3).创建对象-关系映射文件
4).通过Hibernate API编写访问数据块的代码。

一、创建Hibernate的配置文件

Hibernate的配置文件格式有两种：一种是XML格式的文件，还有一种是JAVA属性文件，默认命名为hibernate.properties.

属性	描述
hibernate.dialect	指定数据库使用的SQL方言
hibernate.connection.driver_class	指定数据库的驱动程序
hibernate.connection.url	指定连接数据库的URL
hibernate.connection.username	指定连接数据块的用户名
hibernate.connection.password	指定连接数据块的密码
hibernate.show_sql	如果为true，表示在程序运行时，会在控制台输出SQL语句，默认为false

二、创建持久化类

持久化类符合JavaBean的规范，包含一些属性，以及与之对应getXXX()和setXXX()方法。"get"和"set"后面紧跟属性的名字，并且属性名的首字母大写，如果持久化类的属性为boolean类型，那么它的get方法既可以用"get"作为前缀，也可以用"is"作为前缀。
Hibernate并不要求持久化类必须实现java.io.Serializable接口，但对于分布式结构的Java应用，当Java对象在不同的进程节点传输时，所属的类必须实现Serializable接口。此外，如果希望对HttpSession中存放的Java对象进行持久化，那个这个Java对象所属的类也必须实现Serializable接口。
Hibernate要求持久化类必须实现一个不带参数的默认构造函数，在程序运行时，Hibernate运用Java反射机制，调用java.lang.reflect.Constructor.newInstance()方法来构造持久化类的实例。Hibernate在运行时为持久化类创建动态代理，要求持久化的默认构造函数方法访问级别必须是public或protected类型，不能是default或private类型。

三、创建数据库Schema

数据块的创建可以直接用数据模型生成sql来执行，或者通过hbm文件生成sql语句（hbm2ddl工具）。

四、通过Hibernate API操作数据块

1).创建一个Configuration类的实例，Configuration类的构造方法把默认文件路径下的hibernate.properties或hibernate.cfg.xml配置文件中的配置信息读入到内存。
Configuration config = new Configuration();

2).调用Configuration类的addClass(Customer.class)方法。
config.addClass(Customer.class);
该方法把默认文件路径下的Customer.hbm.xml文件中的映射信息读入到内存中。
对于第1、2步，使用Annotations的话可以这样写：
Configuration config = new AnnotationConfiguration().configure();

3).调用Configuration类的buildSessionFactory()方法获得SessionFactory。
sessionFactory = config.buildSessionFactory();
该方法创建一个SessionFactory实例，并把Configuration对象包含的所有配置信息拷贝到SessionFactory对象的缓存中。
当SessionFactory实例创建后，该对象步和Configuration对象关联。因此再修改Configuration对象包含的配置信息不会对SessionFactory对象有任何影响。

SessionFactory的缓存可分为两类：内置缓存和外置缓存。SessionFactory的内置缓存中存放了Hibernate配置信息和映射元数据信息等；外置缓存是一个可配置的缓存插件，在默认情况下，SessionFactory不会启用这个缓存插件。外置缓存能存放大量数据库的拷贝，外置缓存的物理介质可以是内存或者硬盘。

4).初始化过程结束后，就可以调用SessionFactory实例的openSession方法来获得Session实例，然后操纵数据库的各种操作：
·save()方法：把Java对象保持数据库中
·update()方法：更新数据库中的Java对象
·delete()方法：把Java对象从数据库中删除
·load()方法：从数据库中加载Java对象
·find()方法：从数据库中查找Java对象