当前位置: 首页>数据库>正文

Java 内存缓存redis缓存一致性 java 内存缓存持久化

         创建一个Java对象时,JVM会为这个对象分配一个内存空间,只要这个对象被引用变量引用,就一直存在于内存中,如果一个对象不被任何引用变量引用,就结束生命周期。Java集合(List、Map、Set)存放的是Java对象的引用,当向集合中添加一个对象时,其实是把这个对象的引用添加到集合中。因此集合中含有的对象生命周期一直存在。

理解Session的缓存

在Session接口的实现中定义一系列的Java集合,这些集合构成了Session的缓存。

Session缓存的作用:1、减少访问数据库的频率,可以提高数据库访问的性能。2、保证缓存中的对象与数据库中的相关记录保持同步。3、当缓存中的持久化对象(位于缓存中的对象)之间存在循环关联关系时,Sessioin会保证不出现访问对象的死循环。

在Hibernate应用中Java对象的状态:

临时状态(transient):刚用new语句创建,还没有被持久化,不处于Session的缓存中。处于临时状态的Java对象称为临时对象。

持久化状态(persistent):已经被持久化,加入到Session的缓存中。处于持久化状态的Java对象称为持久化对象。

游离状态(detached):已经被持久化,但不再处于Session的缓存中。处于游离状态的Java对象称为游离对象。

Java对象:开始生命周期——》临时状态——》持久化状态——》游离状态——》结束生命周期

 


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

1、Session的save()方法

session.save(customer);完成的操作:

(1)把Customer对象加载到缓存中,使它变为持久化对象。

(2)选用映射文件指定的标识符生成器为持久化对象分配唯一的OID。Customer.hbm.xml文件中<id>元素的<generator>子元素指定标识符生成器。

(3)计划执行一个insert语句,把Customer对象当前的属性值组装到insert语句中。

insert into CUSTOMERS(ID, NAME, ......) values(1, "Tom", ......)

save()方法并不立即执行SQL insert语句。只有当Session清理缓存时,才会执行SQL语句。

2、Session的update()方法

session.update(customer);完成的操作:

(1)把Customer对象重新加入到Session缓存中,使它变为持久化对象。

(2)计划执行一个update语句。Session只有在清理缓存时才会执行update语句,并且在执行时才会把Customer对象当前的属性值组装到update语句中。

(3)只要通过update()方法使游离对象被一个Session关联,即使没有修改Customer对象的任何属性,Session在清理缓存时也会执行由update()方法计划的update语句。

update CUSTOMERS set NAME="Tom", ...... where ID=1

如果希望Session仅当修改了Customer对象的属性时,才执行update语句,可把映射文件Customer.hbm.xml中<class>元素的"select-before-update"设为true(该属性默认为false)

<class name="mypack.Customer" table="CUSTOMERS" select-before-update="true">

当Session清理缓存时,先执行一条select语句,然后比较Customer对象的属性是否和从数据库中检索出来的记录一致,只有在不一致时才执行update语句。

3、Session的saveOrUpdate()方法

如果传入的参数是临时对象,就调用save()方法;如果传入的参数是游离对象,就调用update()方法;如果传入的参数是持久化对象,那就直接返回。

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

4、Session的load()方法和get()方法

根据给定的OID从数据库中加载一个持久化对象。

当数据库中不存在与OID对应的记录时

load()方法,返回ObjectNotFoundException异常

get()方法,返回null。

5、Session的delete()方法

如果传入的参数是持久化对象,Session就计划执行一个delete语句;如果传入的参数是游离对象,先使游离对象被Session关联,使它变为持久化对象,然后计划执行一个delete语句。

Session只有在清理缓存的时候才会执行delete语句。只有当调用Session的close()方法时,才会从Session的缓存中删除该对象。

session.delete(customer);

session.delete("from Customer as c where c.id>8");

级联操纵对象图

在对象-关系关联映射文件中,用于映射持久化类之间关联关系的元素<set>、<many-to-one>、<one-to-one>有cascade属性,用于指定如何操纵与当前对象关联的其他对象。

cascade属性可选值:none、save-update、delete、all、delete-orphan、all-delete-orphan

Hibernate与触发器协同工作

能激发触发器运行的事件:

插入(insert)记录事件、更新(update)记录事件、删除(delete)记录事件

 利用拦截器(Interceptor)生成审计日志

用户定义的拦截器必须实现org.hibernate.Interceptor接口。

Interceptor对象有两种存放方式:

SessionFactory.openSession(Interceptor):为每个Session实例分配一个Interceptor实例,这个实例存放在Session范围内。

Configuration.setInterceptor(Interceptor):为SessionFactory实例分配一个Interceptor实例,这个实例存放在SessionFactory范围内,被所有Session实例共享。



 

 

 

操纵持久化对象

 


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.   持久化对象的三种状态:


一个持久化类的实例可能处于三种不同状态中的某一种。


3.1.   瞬时(transient)状态:


该实例是刚用new语句创建的,还没有被持久化,不处于任何Session的缓存中。它没有持久化标识(相当于主键值)。处于瞬时状态的实例被称为瞬时对象。它的特点是:


不和任何一个Session实例关联。在数据库中没有对应的记录。


3.2.   持久化(persistent)状态:


已经被持久化,加入到Session缓存中。处于持久化状态的实例被称为持久化对象。


实例目前与某个Session有关联。 它拥有持久化标识(相当于主键值),并且可能在数据库中有一个对应的行。 Hibernate保证在同一个Sesion实例的缓存中,数据库中的每条记录只对应唯一的持久化对象。 它的特点是:


       持久化对象总是被一个Session实例关联。持久化对象和数据库中的相关记录对应。Session在清理缓存时,会根据持久化对象的属性变化,来同步更新数据库。


3.3.   脱管(detached)状态:


已经被持久化过,但不再处于Session的缓存中。处于脱管状态的实例被称为脱管对象。实例曾经与某个持久化上下文发生过关联,不过那个上下文被关闭了, 或者这个实例是被序列化(serialize)到另外的进程。 它拥有持久化标识,并且在数据库中可能存在一个对应的行。 对于脱管状态的实例,Hibernate不保证任何持久化标识和Java标识的关系。它的特点是:


不再位于session的缓存中,即它不再和session关联。它拥有持久化标识。


 





 


4.   Session的保存、删除、更新和查询方法:


4.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。


4.2.   Session的update()方法:使一个脱管对象转变为持久化对象。


方法签名:public void update(Object object) throws HibernateException; 它完成以下操作:


1)     把脱管对象重新加入到Session缓存中,使它变为持久化对象。


2)     计划执行一个update语句。值得注意的是,Session只有在清理缓存的时候才会执行update语句,并且在执行时才会把持久化对象当前的属性值组装到update语句中。


4.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。


4.4.   Session的delete()方法:


方法签名:public void delete(Object object) throws HibernateException; delete()方法用于从数据库中删除与Java对象对应的记录。如果传入的参数是持久化对象,Session就计划执行一个delete语句。如果传入的参数是游离对象,先使游离对象被Session关联,使它变为持久化对象,然后计划执行一个delete语句。值得注意的也是,Session只有在清理缓存的时候才会执行delete语句。


5.   通过主键ID取得数据对象:


5.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。


5.2.   Session的load()方法:


方法签名:public Object load(Class theClass, Serializable id) throws HibernateException; 根据给定的OID从数据库中加载一个持久化对象,若数据库中不存在与OID对应的记录,此方法将抛出org.hibernate.ObjectNotFoundException异常。


对于get和load的根本区别,一句话,hibernate对于load方法认为该数据在数据库中一定存在,可以放心的使用代理来延迟加载,如果在使用过程中发现了问题,只能抛异常;而对于get方法,hibernate一定要获取到真实的数据,否则返回null。


6.   Query接口:


Hibernate提供Query接口,它用来执行HQL语句。


6.1.   绑定参数


6.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查询语句中参数的值。


6.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)     在同一个查询中可以多次使用。


所以,应该优先考虑使用命名参数方式。


6.2.   使用命名查询(nameQuery):


可以将HQL语句编写在程序之外,以避免硬编码在程序之中,这样要修改HQL语句时就很方便。在xxx.hbm.xml中使用<qiuery/>标签,并在<![CDATA[ 与 ]]> 之间编写HQL,如下Student.hbm.xml:


......

< hibernate-mapping >

    < class name = "org.qiujy.demo.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" />

        < property name = "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 >


在代码中这样来调用:


"queryUserByAgeAndName");

query.setInteger("minAge", 25);

query.setString("likeName", "%a%");

List list = query.list();


6.3.   Query接口的list()方法:


Query接口的list()方法用于取得一个List类的实例,此实例中包括的可能是一个对象集合,也可能是一个对象数组集合。最常见的使用是用list()方法来取得一组符合实例对象。如上示例。


6.4.   Query接口的uniqueResult()方法:


当确信使用的HQL语句查询时返回的集合中 只有一个对象时,就可以使用这个方法。但如果返回结果中有多个对象,使用这个方法会抛出org.hibernate.NonUniqueResultException 异常,说“query did not return a unique result”。


https://www.xamrdz.com/database/6z41932726.html

相关文章: