Hibernate4

内容简介:1、使用log4j的日志存储,2、一对一关系,3、二级缓存

1       整合log4j(了解)

l  slf4j 核心jar  : slf4j-api-1.6.1.jar 。slf4j是日志框架,将其他优秀的日志第三方进行整合。

l  整合导入jar包

log4j 核心包:log4j-1.2.17.jar

过渡jar(整合jar):slf4j-log4j12-1.7.5.jar

l  导入配置文件

log4j.properties  ,此配置文件通知log4j 如何输出日志

l  配置文件内容:

1.记录器

2.输出源

3.布局

l  记录器

例如: log4j.rootLogger=info, stdout,file

格式:log4j.rootLogger=日志级别, 输出源1,输出源2,。。。。

log4j 日志级别 : fatal 致命错误 error 错误 warn 警告 info 信息 debug 调试信息 trace 堆栈信息 (由高到底顺序)

l  输出源:

例如:log4j.appender.file=org.apache.log4j.FileAppender

格式:log4j.appender.输出源的名称=输出源的实现类

名称:自定义

实现类:log4j提供

输出源属性例如:log4j.appender.file.File=d\:mylog.log

输出源属性格式:log4j.appender.名称.属性=值

每一个输出源对应一个实现类,实现类都属性(setter),底层执行setter方法进行赋值

l  常见的输出源实现类

org.apache.log4j.FileAppender  输出文件中

file ,表示文件输出位置

org.apache.log4j.ConsoleAppender 输出到控制台

Target ,表示使用哪种输出方式,在控制台打印内容,取值:System.out / System.err

l  布局  -- 确定输出格式

例如:log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

格式:log4j.appender.数据源.layout=org.apache.log4j.PatternLayout

布局属性:log4j.appender. 数据源.layout.ConversionPattern=值

12:56:30,123  info

l  扩展:对指定的目录设置日志级别

例如:log4j.logger.org.hibernate.transaction=debug

格式:log4j.logger.包结构=级别

2       一对一

l  情况1:主表的主键,与从表的外键(唯一),形成主外键关系

l  情况2:主表的主键,与从表的主键,形成主外键关系 (从表的主键又是外键)

2.1.1   情况1

2.1.2   情况2

3       二级缓存【掌握】

3.1   介绍

3.1.1   缓存

    缓存(Cache): 计算机领域非常通用的概念。它介于应用程序永久性数据存储源(如硬盘上的文件或者数据

  库)之间,其作用是降低应用程序直接读写硬盘(永久性数据存储源)的频率,从而提高应用的运行性能。缓存中

  的数据是数据存储源中数据的拷贝。缓存的物理介质通常是内存

缓存:程序<--(内存)-->硬盘

3.1.2   什么是二级缓存

l  hibernate 提供缓存机制:一级缓存、二级缓存

一级缓存:session级别缓存,在一次请求中共享数据。

二级缓存:sessionFactory级别缓存,整个应用程序共享一个会话工厂,共享一个二级缓存。

l  SessionFactory的缓存两部分:   内置缓存:使用一个Map,用于存放配置信息,预定义HQL语句等,提供

  给Hibernate框架自己使用,对外只读的。不能操作。  外置缓存:使用另一个Map,用于存放用户自定义

  数据。默认不开启。外置缓存hibernate只提供规范(接口),需要第三方实现类。外置缓存有成为二级缓存。

3.1.3   二级缓存内部结构

   二级就是由4部分构成

    类级别缓存

    集合级别缓存

     时间戳缓存

    查询缓存(二级缓存的第2大部分,三级缓存)

3.1.4   并发访问策略

l  访问策略:读写型(read-write)、只读型(read-only)

3.1.5   应用场景

l  适合放入二级缓存中的数据:

很少被修改

不是很重要的数据, 允许出现偶尔的并发问题

l  不适合放入二级缓存中的数据:

经常被修改

财务数据, 绝对不允许出现并发问题

与其他应用数据共享的数据

3.1.6   二级缓存提供商

EHCache: 可作为进程(单机)范围内的缓存, 存放数据的物理介质可以是内存或硬盘,

          对 Hibernate 的查询缓存提供了支持。--支持集群。

l  OpenSymphony `:可作为进程范围内的缓存, 存放数据的物理介质可以是内存或硬盘,

       提供了丰富的缓存数据过期策略, 对 Hibernate 的查询缓存提供了支持

l  SwarmCache: 可作为集群范围内的缓存, 但不支持 Hibernate 的查询缓存

l  JBossCache:可作为集群范围内的缓存, 支持 Hibernate 的查询缓存

X表示支持

3.2   配置(操作)

1.导入jar包:ehcache-1.5.0.jar/ commons-logging.jar/ backport-util-concurrent.jar

2.开启二级缓存(我要使用二级缓存)

3.确定二级缓存提供商(我要使用哪个二级缓存)

4.确定需要缓存内容

1>配置需要缓存的类

2>配置需要缓存的集合

5.配置ehcache自定义配置文件

3.2.1   导入jar包

3.2.2   开启二级缓存

l  在hibernate.cfg.xml 配置二级缓存


<!-- 9.1 开启二级缓存 -->

<property name="hibernate.cache.use_second_level_cache">true</property>

3.2.3   确定提供商

l  hibernate.cfg.xml 配置


<!-- 9.2 提供商 -->

<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>

3.2.4   确定缓存内容

l  在hibernate.cfg.xml 确定 类缓存 和集合缓存配置项

l  配置


<!-- 9.3 确定缓存内容 -->

<!-- 类缓存 -->

<class-cache usage="read-write" class="com.itheima.a_init.Customer"/>

<class-cache usage="read-write" class="com.itheima.a_init.Order"/>

<!-- 集合缓存 -->

<collection-cache usage="read-write" collection="com.itheima.a_init.Customer.orderSet"/>

3.2.5   ehcache配置文件

步骤1:从jar包复制xml文件

步骤2:将xml重命名“ehcache.xml”

步骤3:将修改后的xml,拷贝到src下

3.3   演示

3.3.1   证明


@Test

public void demo01(){

//1 证明二级缓存存在

// * 修改toString()

// * 如果二级缓存开启,查询3 没有select语句,表示从二级缓存获得的。

// * 将二级缓存关闭,查询3将触发select语句。

Session s1 = factory.openSession();

s1.beginTransaction();

//1 查询id=1 -- 执行select (查询后,将数据存放在一级缓存,之后由一级缓存同步到二级缓存)

Customer c1 = (Customer) s1.get(Customer.class, 1);

System.out.println(c1);

//2 查询id=1 --从一级缓存获取

Customer c2 = (Customer) s1.get(Customer.class, 1);

System.out.println(c2);

s1.getTransaction().commit();

s1.close();

System.out.println("----------");

Session s2 = factory.openSession();

s2.beginTransaction();

//3 查询id=1 -- 从二级缓存获取

Customer c3 = (Customer) s2.get(Customer.class, 1);

System.out.println(c3);

s2.getTransaction().commit();

s2.close();

}

3.3.2   类缓存

l  类缓存:只存放数据

l  一级缓存:存放对象本身


@Test

public void demo02(){

//2 类缓存:只存放数据,散装数据。

// * 使用默认的toString();

Session s1 = factory.openSession();

s1.beginTransaction();

//1 查询id=1 -- 执行select

Customer c1 = (Customer) s1.get(Customer.class, 1);

System.out.println(c1);

//2 查询id=1 -- 从一级缓存获取,一级缓存存放对象本身

Customer c2 = (Customer) s1.get(Customer.class, 1);

System.out.println(c2);

s1.getTransaction().commit();

s1.close();

System.out.println("----------");

Session s2 = factory.openSession();

s2.beginTransaction();

//3 查询id=1 -- 对象不一样,数据一样

Customer c3 = (Customer) s2.get(Customer.class, 1);

System.out.println(c3);

s2.getTransaction().commit();

s2.close();

}

3.3.3   集合缓存


@Test

public void demo03(){

//3 集合缓存:只存放关联对象OID的值,如果需要数据,从类缓存中获取。

// * 3.1 默认:第一条select 查询客户,第二天 select 查询客户所有订单

// * 3.2 操作:在hibernate.cfg.xml 将 Order 类缓存删除

// *** <!--  <class-cache usage="read-write" class="com.itheima.a_init.Order"/>-->

// *** 多了10条select,通过订单的id查询订单

Session s1 = factory.openSession();

s1.beginTransaction();

//1 查询id=1

Customer c1 = (Customer) s1.get(Customer.class, 1);

System.out.println(c1);

//2 获得订单

for (Order o1 : c1.getOrderSet()) {

System.out.println(o1);

}

s1.getTransaction().commit();

s1.close();

System.out.println("----------");

Session s2 = factory.openSession();

s2.beginTransaction();

//3 查询id=1

Customer c3 = (Customer) s2.get(Customer.class, 1);

System.out.println(c3);

//4 获得订单

for (Order o2 : c3.getOrderSet()) {

System.out.println(o2);

}

s2.getTransaction().commit();

s2.close();

}

3.3.4   时间戳

l  时间戳:任何操作都在时间戳中记录操作时间。


@Test

public void demo04(){

//4 时间戳: 所有的操作都会在时间戳中进行记录,如果数据不一致,将触发select语句进行查询

// * 修改toString()

Session s1 = factory.openSession();

s1.beginTransaction();

//1 查询id=1

Integer cid = 1;

Customer c1 = (Customer) s1.get(Customer.class, cid);

System.out.println(c1);

//2 绕过一级和二级缓存,修改数据库,修改客户cname=大东哥

s1.createQuery("update Customer set cname = ? where cid = ?")

.setString(0, "大东哥")

.setInteger(1, cid)

.executeUpdate();

//3打印

System.out.println(c1);

s1.getTransaction().commit();

s1.close();

System.out.println("----------");

Session s2 = factory.openSession();

s2.beginTransaction();

//4 查询id=1  -- ?

Customer c3 = (Customer) s2.get(Customer.class, 1);

System.out.println(c3);

s2.getTransaction().commit();

s2.close();

}

3.3.5   查询缓存

l  查询缓存又称为三级缓存(民间)

l  查询缓存默认不使用。需要手动开启

l  查询缓存:将HQL语句与 查询结果进行绑定。通过HQL相同语句可以缓存内容。

默认情况Query对象只将查询结果存放在一级和二级缓存,不从一级或二级缓存获取。

查询缓存就是让Query可以从二级缓存获得内容。

步骤一:开启查询缓存


<!-- 9.4 开启查询缓存 -->

<property name="hibernate.cache.use_query_cache">true</property>

步骤二:在查询query对象,设置缓存内容(注意:存放和查询 都需要设置)


@Test

public void demo05(){

//5 查询缓存

Session s1 = factory.openSession();

s1.beginTransaction();

//1 query查询

Query q1 = s1.createQuery("from Customer");

q1.setCacheable(true);

List<Customer> a1 = q1.list();

for (Customer c1 : a1) {

System.out.println(c1);

}

//2 cid =1  -- 一级缓存获得

Customer customer = (Customer) s1.get(Customer.class, 1);

System.out.println(customer);

s1.getTransaction().commit();

s1.close();

System.out.println("----------");

Session s2 = factory.openSession();

s2.beginTransaction();

//2 cid =1  -- 二级缓存获得

Customer customer2 = (Customer) s2.get(Customer.class, 1);

System.out.println(customer2);

//3 query查询

Query q2 = s2.createQuery("from Customer");

q2.setCacheable(true);

List<Customer> a2 = q2.list();

for (Customer c2 : a2) {

System.out.println(c2);

}

s2.getTransaction().commit();

s2.close();

}

3.4   ehcache配置文件

l  <diskStore path="java.io.tmpdir"/>  设置临时文件存放位置。(缓存一般内存,一定程度时,写入硬盘。)

l  缓存详细设置

<defaultCache> 所有的缓存对象默认的配置

<cache name="类"> 指定对象单独配置

l  参数设置

maxElementsInMemory="10000"  内存最大数

eternal="false"  是否永久(内存常驻留)

timeToIdleSeconds="120"

timeToLiveSeconds="120"

overflowToDisk="true"  内存满了,是否写入到硬盘

maxElementsOnDisk="10000000"  硬盘最大数

diskPersistent="false"  关闭JVM,是否将内存保存硬盘中

diskExpiryThreadIntervalSeconds="120"  轮询

memoryStoreEvictionPolicy="LRU"

Least Recently Used (specified as LRU).

First In First Out (specified as FIFO)

Less Frequently Used (specified as LFU)

  • maxElementsInMemory :设置基于内存的缓存中可存放的对象最大数目
  • eternal:设置对象是否为永久的,true表示永不过期,此时将忽略timeToIdleSeconds timeToLiveSeconds属性; 默认值是false
  • timeToIdleSeconds:设置对象空闲最长时间,以秒为单位, 超过这个时间,对象过期。当对象过期时,EHCache会把它从缓存中清除。如果此值为0,表示对象可以无限期地处于空闲状态。
  • timeToLiveSeconds:设置对象生存最长时间,超过这个时间,对象过期。

    如果此值为0,表示对象可以无限期地存在于缓存中. 该属性值必须大于或等于 timeToIdleSeconds 属性值

  • overflowToDisk:设置基于内在的缓存中的对象数目达到上限后,是否把溢出的对象写到基于硬盘的缓存中
  • diskPersistent 当jvm结束时是否持久化对象 true false 默认是false
  • diskExpiryThreadIntervalSeconds 指定专门用于清除过期对象的监听线程的轮询时间
  •  memoryStoreEvictionPolicy
    -
    当内存缓存达到最大,有新的element加入的时候, 移除缓存中element的策略。默认是LRU(最近最少使用),可选的有LFU(最不常使用)和FIFO(先进先出)
时间: 2024-10-19 10:35:00

Hibernate4的相关文章

SpringMVC + spring3.1.1 + hibernate4.1.0 集成及常见问题总结

一 开发环境 1.动态web工程 2.部分依赖 java代码: hibernate-release-4.1.0.Final.zip hibernate-validator-4.2.0.Final.jar spring-framework-3.1.1.RELEASE-with-docs.zip proxool-0.9.1.jar log4j 1.2.16 slf4j -1.6.1 mysql-connector-java-5.1.10.jar hamcrest 1.3.0RC2 ehcache 2

Spring整合hibernate4:事务管理

Spring和Hibernate整合后,通过Hibernate API进行数据库操作时发现每次都要opensession,close,beginTransaction,commit,这些都是重复的工作,我们可以把事务管理部分交给spring框架完成. 配置事务(xml方式) 使用spring管理事务后在dao中不再需要调用beginTransaction和commit,也不需要调用session.close(),使用API  sessionFactory.getCurrentSession()来

hibernate4之一对多关系映射(三)

示例:一个部门(Department )下面有多个用户(User),多个用户对应一个部门 public class Department {     private Integer id;     private String name;     private Set<User> users;         //getter and setter   } public class User{     private Integer id;     private String userNa

hibernate4之一对多自身映射(四)

示例:部门下有部门(Department ) public class Department {         private Integer id;         private String name;         private Set<Department> departments;         private Department department;         //set get } 用XML映射 <hibernate-mapping package=&q

关于spring4和hibernate4整合,配置事务报“Cannot unwrap to requested type [javax.sql.DataSource]”错误的解决方法及心得

Cannot unwrap to requested type [javax.sql.DataSource] 配置hibernate4和spring4时,出现错误,解决方法: 1.我去了spring4中的事务配置,数据库可以正常执行并访问.如下: <!-- 配置Hibernate  数据事务 --> <bean id="transactionManager" class="org.springframework.orm.hibernate4.Hibernat

Hibernate4 No Session found for current thread

Hibernate4 与 spring3 集成之后, 如果在取得session 的地方使用了getCurrentSession, 可能会报一个错:“No Session found for current thread”, 这个错误的原因,网上有很多解决办法, 但具体原因的分析,却没有多少, 这里转载一个原理分析: SessionFactory的getCurrentSession并不能保证在没有当前Session的情况下会自动创建一个新的,这取决于CurrentSessionContext的实现

J2EE开发框架搭建(2) - springmvc4 + spring4 + hibernate4 整合

1. 打开hqhop-framework-parent项目下的pom.xml文件,添加springmvc4 , spring4 , hibernate4 ,以及数据源druid的依赖包,插件,依赖包版本号 <!-- data source 相关jar? --> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version&g

注意Hibernate4在开发当中的一些改变

Hibernate4的改动较大只有spring3.1以上版本能够支持,Spring3.1取消了HibernateTemplate,因为Hibernate4的事务管理已经很好了,不用Spring再扩展了.这里简单介绍了hibernate4相对于hibernate3配置时出现的错误,只列举了问题和解决方法,详细原理如果大家感兴趣还是去自己搜吧,网上很多. Spring3.1去掉了HibernateDaoSupport类.hibernate4需要通过getCurrentSession()获取sessi

hibernate4.3.5.Final入门1

使用maven管理项目 1.依赖包 <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.10</version> <scope>test</scope> </dependency> <dependency> <groupI

Spring4+Hibernate4 事务管理 配置 注解 AOP

在单独使用hibernate的时候 使用如下配置: <property name="hibernate.current_session_context_class">thread</property> 根据文档,这个是hibernate3.1以后的一个新扩展,目的在于可以让我们在某一个上下文环境(比如说当前线程)中可以通过SessionFactory.getCurrentSession()得到同一个session会话. 该方式hibernate会自动关闭sess