持久化对象的状态:
瞬时对象(Transient Objects):使用new操作符初始化的对象不是立刻就持久化的。他们的状态是瞬时的,也就是说他们没有任何跟数据库表相关联的行为,只要应用不再引用这些对象(不再被任何其他对象所引用),他们的状态将会丢失,并由垃圾回收机制回收。
临时对象的特征。临时对象具有以下特征:
(1) 不处于Session的缓存中,也可以说,不被任何一个Session实例关联。
(2) 在数据库中没有对应的记录。
在以下情况下,Java对象进入临时状态:
(1) 当通过new语句刚创建了一个Java对象,它处于临时状态,此时不和数据库中的任何记录对应。
(2) Session的delete()方法能使一个持久化对象或游离对象转变为临时对象。对于游离对象,delete()方法从数据库中删除与它对应的记录;对于持久化对象,delete()方法从数据库中删除与它对应的记录,并且把它从Session的缓存中删除。
持久化对象(Persist Objects):持久实例是任何具有数据库标识的实例。它有持久化管理器Session统一管理,持久实例是在事务中进行操作的———他们的状态在事务结束时同数据库进行同步。当事务提交时,通过执行SQL的INSERT,UPDATE和DELETE语句把内存中的状态同步到数据库中。
持久化对象的特征。持久化对象具有以下特征:
(1) 位于一个Session实例的缓存中,也可以说,持久化对象总是被一个Session实例关联。
(2) 持久化对象和数据库中的相关记录对应。
(3) Session在清理缓存时,会根据持久化对象的属性变化,来同步更新数据库,在此期间如果修改了属性值只是session中对象的值会改变,并没有同步到数据库。
Session的许多方法都能够触发Java对象进入持久化状态:
(1) Session的save()方法把临时对象转变为持久化对象。
(2) Session的load()或get()方法返回的对象总是处于持久化状态。
(3) Session的find()方法返回的List集合中存放的都是持久化对象。
(4) Session的update()、saveOrUpdate()和lock()方法使游离对象转变为持久化对象。
(5)当一个持久化对象关联一个临时对象,在允许级联保存的情况下,Session在清理缓存时会把这个临时对象也转变为持久化对象。
Hibernate保证在同一个Session实例的缓存中,数据库表中的每条记录只对应惟一的持久化对象。例如对于以下代码,共创建了两个Session实例:session1和session2。session1和session2拥有各自的缓存。在session1的缓存中,只会有惟一的OID为1的Customer持久化对象,在session2的缓存中,也只会有惟一的OID为2的Customer持久化对象。因此在内存中共有两个Customer持久化对象,一个属于session1的缓存,一个属于session2的缓存。引用变量a和b都引用session1缓存中的Customer持久化对象,而引用变量c引用session2缓存中的Customer持久化对象:
Session session1=sessionFactory.openSession();
Session session2=sessionFactory.openSession();
Transaction tx1 = session1.beginTransaction();
Transaction tx2 = session2.beginTransaction();
Customer a=(Customer)session1.load(Customer.class,new Long(1));
Customer b=(Customer)session1.load(Customer.class,new Long(1));
Customer c=(Customer)session2.load(Customer.class,new Long(1));
System.out.println(a= =b); //true
System.out.println(a= =c); //false
tx1.commit();
tx2.commit();
session1.close();
session2.close();
Java对象的持久化状态是相对于某个具体的Session实例的,以下代码试图使一个Java对象同时被两个Session实例关联:
Session session1=sessionFactory.openSession();
Session session2=sessionFactory.openSession();
Transaction tx1 = session1.beginTransaction();
Transaction tx2 = session2.beginTransaction();
Customer c=(Customer)session1.load(Customer.class,new Long(1)); //Customer对象被session1关联
session2.update(c); //Customer对象被session2关联
c.setName("Jack"); //修改Customer对象的属性
tx1.commit(); //执行update语句
tx2.commit(); //执行update语句
session1.close();
session2.close();
当执行session1的load()方法时,OID为1的Customer对象被加入到session1的缓存中,因此它是session1的持久化对象,此时它还没有被session2关联,因此相对于session2,它处于游离状态。当执行session2的update()方法时,Customer对象被加入到session2的缓存中,因此也成为session2的持久化对象。接下来修改Customer对象的name属性,会导致两个Session实例在清理各自的缓存时,都执行相同的update语句:
update CUSTOMERS set NAME='Jack' …… where ID=1;
在实际应用程序中,应该避免一个Java对象同时被多个Session实例关联,因为这会导致重复执行SQL语句,并且极容易出现一些并发问题。
离线对象(Detached Objects):Session关闭之后,持久化对象就变为离线对象。离线表示这个对象不能再与数据库保持同步,他们不再受Hibernate管理。
游离对象的特征。游离对象具有以下特征:
(1) 不再位于Session的缓存中,也可以说,游离对象不被Session关联。
(2) 游离对象是由持久化对象转变过来的,因此在数据库中可能还存在与它对应的记录(前提条件是没有其他程序删除了这条记录)。
游离对象与临时对象的相同之处在于,两者都不被Session关联,因此Hibernate不会保证它们的属性变化与数据库保持同步。游离对象与临时对象的区别在于:前者是由持久化对象转变过来的,因此可能在数据库中还存在对应的记录,而后者在数据库中没有对应的记录。
Session的以下方法使持久化对象转变为游离对象:
(1) 当调用Session的close()方法时,Session的缓存被清空,缓存中的所有持久化对象都变为游离对象。如果在应用程序中没有引用变量引用这些游离对象,它们就会结束生命周期。
(2)Session的evict()方法能够从缓存中删除一个持久化对象,使它变为游离状态。当Session的缓存中保存了大量的持久化对象,会消耗许多内存空间,为了提高性能,可以考虑调用evict()方法,从缓存中删除一些持久化对象。但是多数情况下不推荐使用evict()方法,而应该通过查询语言,或者显式的导航来控制对象图的深度。
Java对象在JVM中的生命周期:
创建一个Java对象时,JVM会为这个对象分配一个内存空间,只要这个对象被引用变量引用,就一直存在于内存中,如果一个对象不被任何引用变量引用,就结束生命周期。Java集合(List、Map、Set)存放的是Java对象的引用,当向集合中添加一个对象时,其实是把这个对象的引用添加到集合中。因此集合中含有的对象生命周期一直存在。
操纵持久化对象
1. 理解Session的缓存:
在Java里面,缓存通常是指Java对象的属性占用的内存空间,通常是一些集合类型的属性。在session接口的实现类SessionImpl中定义了一系列的Java集合,这些Java集合就构成了Session的缓存。
当Session的save()方法持久化一个对象时,这个对象被加入到Session的缓存中,以后即使应用程序中的引用变量不再引用这个对象,只要Session的缓存还没有被清空,这个对象仍然处于生命周期中。当Session的load()方法加载一个对象时,Session会先判断缓存中是否已经存在这个对象了,如果存在,就不需要再到数据库中重新加载了。
Session的缓存有两大作用:
1.1. 减少访问数据库的频率。
1.2. 保证缓存中的对象与数据库中的相关记录保持同步。
Session有两个方法:一个commit()事务提交方法,还有flush()刷新缓存方法,都有着清理缓存的作用。flush()进行缓存的清理,执行一系列的SQL语句,但不会提交事务。而commit()方法会先调用flush()方法,然后在提交事务。
2. 定义持久化类的建议:
在应用程序中,用来实现业务问题实体的(如,在电子商务应用程序中的Customer和Order)类就是持久化类。如果这些持久化类遵循一些简单的规则,Hibernate能够工作得更好,这些规则也被称作简单传统Java对象(POJO:Plain Old Java Object)编程模型。但是这些规则并不是必需的。最好要遵循以下几条主要的规则:
1) 实现一个默认的(即无参数的)构造方法(constructor):
我们强烈建议,在Hibernate中,为了运行期代理的生成,构造方法至少是包(package)内可见的。
2) 提供一个标识属性(identifier property):
我们建议你对持久化类声明命名一致的标识属性。我们还建议你使用一个可以为空(也就是说,不是原始类型)的类型。
3) 使用非final的类:
代理(proxies)是Hibernate的一个重要的功能,它依赖的条件是,持久化类或者是非final的,或者是实现了一个所有方法都声明为public的接口。你也应该避免在非final类中声明public final的方法。
4) 为持久化字段声明访问器(accessors):
5) 如果你有如下需求,你必须重载 equals()和 hashCode()方法:
l 想把持久类的实例放入Set中(当表示多值关联时,推荐这么做)
l 想重用脱管实例
Hibernate保证,仅在特定会话范围内,持久化标识(数据库的行)和Java标识是等价的。因此,一旦我们混合了从不同会话中获取的实例,如果希望Set有明确的语义,就必须实现equals()和hashCode()。
3. Session的保存、删除、更新和查询方法:
3.1. Session的save()方法:使用一个临时对象转变为持久对象。
方法签名:public Serializable save(Object object) throws HibernateException;它完成以下操作:
1) 把持久化类的实例加入到缓存中,使它变为持久化对象。
2) 选用映射文件指定的标识符生成器为持久化对象分配唯一的OID。
3) 计划执行一个insert语句,把持久化对象当前的属性值组装到insert语句(SQL DML)中。值得注意的是,save()方法并不是立即执行SQL insert语句。只有当Session清理缓存时,才会执行SQL insert语句。
另外,需要注意的是:Hibernate通过持久化对象的OID来维持它和数据库相关记录的对应关系。所以当持久化的实例处于持久化状态时,不允许程序随意修改它的OID。其实,无论java对象处于瞬时状态、持久化状态还是脱管状态,程序都不应该修改它的OID。3.2. Session的update()方法:使一个脱管对象转变为持久化对象。
方法签名:public void update(Object object) throws HibernateException;它完成以下操作:
1) 把脱管对象重新加入到Session缓存中,使它变为持久化对象。
2) 计划执行一个update语句。值得注意的是,Session只有在清理缓存的时候才会执行update语句,并且在执行时才会把持久化对象当前的属性值组装到update语句中。3.3. Session的saveOrUpdate()方法:
方法签名:public void saveOrUpdate(Object object) throws HibernateException ; saveOrUpdate()方法同时包含了save()与update()方法的功能,如果传入的参数是瞬时对象,就调用save()方法;如果传入的参数是脱管对象,就调用update()方法;如果传入的参数是持久化对象,方法就直接返回。那么,saveOrUpdate()方法如果判断一个对象处于瞬时状态不是脱管状态呢?如果满足以下情况之一,Hibernate就把它作为临时对象:
1) Java对象的OID取值为null。
2) Java对象具有version属性,并且取值了null。
3) 在映射文件中为<id>元素设置了unsaved-value属性,并且OID取值与unsaved-value属性值匹配。
4) 在映射文件中为<version>元素设置了unsaved-value属性,并且version属性取值与unsaved-value属性值匹配。
5) 自定义了Hibernate的Interceptor实现类,并且Interceptor的isUnsaved()方法返回Boolean.TRUE。
3.4. Session的delete()方法:
方法签名:public void delete(Object object) throws HibernateException; delete()方法用于从数据库中删除与Java对象对应的记录。如果传入的参数是持久化对象,Session就计划执行一个delete语句。如果传入的参数是游离对象,先使游离对象被Session关联,使它变为持久化对象,然后计划执行一个delete语句。值得注意的也是,Session只有在清理缓存的时候才会执行delete语句。
4. 通过主键ID取得数据对象:
4.1. Session的get()方法:
方法签名:public Object get(Class clazz, Serializable id) throws HibernateException;根据给定的OID从数据库中加载一个持久化对象,若数据库中不存在与OID对应的记录,此方法返回null。
get()方法的执行顺序如下:
1) 首先通过id在session缓存中查找对象,如果存在此id主键值的对象,直接将其返回。如果不存在,将进行第2步。
2) 在二级缓存中查找,找到后将其返回。
3) 如果在session缓存和二级缓存中都找不到此对象,刚从数据库加载拥有此id的对象。如果数据库也不存在这个拥有此id的对象,则返回null。
4.2. Session的load()方法:
方法签名:public Object load(Class theClass, Serializable id) throws HibernateException;根据给定的OID从数据库中加载一个持久化对象,若数据库中不存在与OID对应的记录,此方法将抛出org.hibernate.ObjectNotFoundException异常。
对于get和load的根本区别,一句话,hibernate对于load方法认为该数据在数据库中一定存在,可以放心的使用代理来延迟加载,如果在使用过程中发现了问题,只能抛异常;而对于get方法,hibernate一定要获取到真实的数据,否则返回null。
5. Query接口:
Hibernate提供Query接口,它用来执行HQL语句。
5.1. 绑定参数
5.1.1. 使用 “?”按参数位置绑定:
通过Query接口执行HQL语句时,可以先设定查询参数,然后通过setXXX()方法来绑定参数。如下
Query query = session.createQuery("from User as u where u.age > ? and u.name like ?"); query.setInteger(0, 25); query.setString(1, "%a%"); List list = query.list(); |
Hibernate提供了绑定各种类型的参数的方法,如参数为字符串类型,可调用setString(),如果参数为整数类型,可调用setInteger()方法,以此类推。这些setXXX()方法的第1个参数HQL查询语句中参数的位置,第2个参数代表HQL查询语句中参数的值。
5.1.2. 使用 “:”后跟变量名来按命名参数绑定:
可以使用命名参数来取代使用“?”设置参数的方法,这可以不用依照特定的顺序来设定参数值,如上例可改成:
Query query = session.createQuery("from User as u where u.age > :minAge and u.name like likeName"); query.setInteger("minAge", 25); query.setString("likeName", "%a%"); List list = query.list(); |
使用命名参数方式的绑定方式有以下优势:
1) 代码可读性更好。
2) 命名参数不依赖它们在查询字符串中出现的位置。
3) 在同一个查询中可以多次使用。
所以,应该优先考虑使用命名参数方式。
5.2. 使用命名查询(nameQuery):
可以将HQL语句编写在程序之外,以避免硬编码在程序之中,这样要修改HQL语句时就很方便。在xxx.hbm.xml中使用<qiuery/>标签,并在<![CDATA[与 ]]> 之间编写HQL,如下Student.hbm.xml:
...... <hibernate-mapping> <classname="org.qiujy.demo.User"table="user"> <idname="id"column="id"type="java.lang.Integer"> <generatorclass="native"/> </id> <propertyname="name"column="name"type="java.lang.String"/> <propertyname="age"column="age"type="java.lang.Integer"/> </class> <query name="queryUserByAgeAndName"> <![CDATA[ from User as u where u.age >:minAge and u.name like :likeName ]]> </query> </hibernate-mapping> |
在代码中这样来调用:
Query query = session.getNamedQuery("queryUserByAgeAndName"); query.setInteger("minAge", 25); query.setString("likeName", "%a%"); List list = query.list(); |
5.3. Query接口的list()方法:
Query接口的list()方法用于取得一个List类的实例,此实例中包括的可能是一个对象集合,也可能是一个对象数组集合。最常见的使用是用list()方法来取得一组符合实例对象。如上示例。
5.4. Query接口的uniqueResult()方法:
当确信使用的HQL语句查询时返回的集合中只有一个对象时,就可以使用这个方法。但如果返回结果中有多个对象,使用这个方法会抛出org.hibernate.NonUniqueResultException异常,说“query did not return a unique result”。