cglib缓存_hibernate清理缓存后缓存中还有数据吗

Ⅰ 应该怎么确定ssh，ssm等框架整合需要的jar包

Hibernate Jar： hibernate3.jar,这个是hibernate3.0的核心jar包，必选，常用的Session,Query,Transaction都位于这个jar文件中。

cglib-2.1.3.jar，CGLIB库，Hibernate用它来实现PO字节码的动态生成，非常核心的库。

asm.jar ASM字节码库如果使用“cglib”

asm-attrs.jar ASM字节码库如果使用“cglib”

ehcache.jar EHCache缓存如果没有其它缓存

antlr.jar

ANother Tool for Language Recognition是一个工具。

jta.jar JTA规范，当Hibernate使用JTA的时候需要，不过App Server都会带上，所以也是多余的。但是为了测试方便建议还是带上。

commons-logging.jar Apache Commons包中的一个，包含了日志功能，必须使用的jar包。

commons-collections.jar Apache Commons包中的一个，包含了一些Apache开发的集合类，功能比java.util.*强大。

dom4j是一个Java的XML API，类似于jdom，用来读写XML文件的。Hibernate用它来读写配置文件。

Ⅱ hibernate框架的优缺点有哪些什么时候才用二级缓存

Hibernate有什么优势？ Hibernate 易于学习和使用。正如我在上面提到的，在您可以使用它之前，您只需要了解几个简单、自我描述的配置文件。它非常灵活。您可以在任何需要持久化服务的应用程序架构中使用 Hibernate。您可以通过 Servlet 和/或 Enterprise Java Bean 在 Standard Java 应用程序、Enterprise Java 应用程序中使用它。它也可以和 Spring 框架很好地集成。它可以很好地向上扩展，因为它被设计为从底层一直到集群环境中工作。通过类似 Lazy Initialization 的技术以及通过 CGLIB 运行时间字节代码生成库优化 Java 反射，最新版的 Hibernate 的性能也得到了加强。 Hibernate有什么缺点？ Hibernate 是另一个拥有自己的应用和维护周期的框架。尽管有积极的社区支持，但是有时候缺乏专注于此产品的提供商也使得宣传应用此框架显得没有说服力。什么时候才用二级缓存：如果应用中，检索的频率相当高，每次都要去检索数据库，代价可想而知。此时就可以设置Hibernate的二级缓存，减少系统开销，提高应用的效率，减少客户端检索的响应时间。

Ⅲ spring3.1中的asm包跟哪个冲突

asm.jar ANother Tool for Language Recognition 必要 ASM字节码库如果使用“cglib” 则必要 asm-attrs.jar ehcache.jar cglib.jar ASM字节码库如果使用“cglib” 则必要 EHCache缓存如果没有其他的缓存，则是必要的如果使用“cglib” 则必要对be...

Ⅳ ssh的jar包怎么搭配

Ⅳ hibernate清理缓存后缓存中还有数据吗

脏检查

Session到底是如何进行脏检查的呢？当一个Customer对象被加入到Session缓存中时，Session会为Customer对象的值类型的属性复制一份快照。当Session清理缓存时，会先进行脏检查，即比较Customer对象的当前属性与它的快照，来判断Customer对象的属性是否发生了变化，如果发生了变化，就称这个对象是“脏对象”，Session会根据脏对象的最新属性来执行相关的SQL语句，从而同步更新数据库。

脏数据检查：

什么是脏数据？脏数据并不是废弃和无用的数据，而是状态前后发生变化的数据。我们看下面的代码：

Transaction tx=session.beginTransaction();

User user=(User)session.load(User.class,”1”);//从数据库中加载符合条件的数据

user.setName(“zz”);//改变了user对象的姓名属性，此时user对象成为了所谓的“脏数据”

tx.commit();

当事务提交时，Hibernate会对session中的PO(持久化对象)进行检测，判断持久化对象的状态是否发生了改变，如果发生了改变就会将改变更新到数据库中。这里就存在一个问题，Hibernate如何来判断一个实体对象的状态前后是否发生了变化。也就是说Hibernate是如何检查出一个数据已经变脏了。

通常脏数据的检查有如下两种办法：

A、数据对象监控：

数据对象监控是通过拦截器对数据对象的setter方法进行监控来实现的，这类似于数据库中的触发器的概念，当某一个对象的属性调用了setter方法而发生了改变，这时拦截器会捕获这个动作，并且将改属性标志为已经改变，在之后的数据库操作时将其更新到数据库中。这个方法的优点是提高了数据更新的同步性，但是这也是它的缺点，如果一个实体对象有很多属性发生了改变，势必造成大量拦截器回调方法的调用，这些拦截器都是通过Dynamic Proxy或者CGLIB实现的，在执行时都会付出一定的执行代价，所以有可能造成更新操作的较大延时。

B、数据版本比对:

这种方法是在持久化框架中保存数据对象的最近读取版本，当提交数据时将提交的数据与这个保存的版本进行比对，如果发现发生了变化则将其同步跟新到数据库中。这种方法降低了同步更新的实时性，但是当一个数据对象的很多属性发生改变时，由于持久层框架缓存的存在，比对版本时可以充分利用缓存，这反而减少了更新数据的延迟。

在Hibernate中是采用数据版本比对的方法来进行脏数据检查的，我们结合下面的代码来讲解Hibernate的具体实现策略。

Transaction tx=session.beginTransaction();

User user=(User)session.load(User.class,”1”);

user.setName(“zz”);

tx.commit();

当调用tx.commit();时好戏就此开场，commit()方法会调用session.flush()方法，在调用flush()方法时，会首先调用flushEverything()来进行一些预处理（如调用intercepter,完成级联操作等），然后调用flushEntities()方法，这个方法是进行脏数据检查的关键。

在继续讲解之前，我要先来介绍一个内部数据结构EntityEntry,EntityEntry是从属于SessionImpl(Session接口的实现类)的内部类，每一个EntityEntry保存了最近一次与数据库同步的实体原始状态信息（如：实体的版本信息，实体的加锁模式，实体的属性信息等）。除了EntityEntry结构之外，还存在一个结构，这个结构称为EntityEntries，它也是SessionImpl的内部类，而且是一个Map类型，它以”key-value”的形式保存了所有与当前session实例相关联的实体对象和原始状态信息，其中key是实体对象，value是EntityEntry。而flushEntities()的工作就是遍历entityEntities,并将其中的实体对象与原始版本进行对比，判断实体对象是否发生来了改变。flushEntities()首先会判断实体的ID是否发生了改变，如果发生了改变则认为发生了异常，因为当前实体与EntityEntry的对应关系非法。如果没有发生异常，而且经过版本比对判断确实实体属性发生了改变，则向当前的更新任务队列中加入一个新的更新任务，此任务将在将在session.flush()方法中的execute()方法的调用中，转化为相应的SQL语句交由数据库去执行。最后Transaction将会调用当前session对应的JDBC Connection的commit()方法将当前事务提交。

脏数据检查是发生在显示保存实体对象时，所谓显示保存是指在代码中明确使用session调用save,update,saveOrupdate方法对实体对象进行保存，如：session.save(user);但是有时候由于级联操作的存在，会产生一个问题，比如当保存一个user对象时，会根据user对象的状态来对他所关联的address对象进行保存，但是此时并没有根据级联对象的显示保存语句。此时需要Hibernate能根据当前对象的状态来判断是否要将级联对象保存到数据库中。此时，Hibernate会根据unsaved-value进行判断。Hibernate将首先取出目标对象的ID，然后将ID与unsaved-value值进行比较，如果相等，则认为实体对象尚未保存，进而马上将进行保存，否则，则认为实体对象已经保存，而无须再次进行保存。比如，当向一个user对象新加入一个它所关联的address对象后，当进行session.save(user)时，Hibernate会根据unsaved-value的值判断出哪个address对象需要保存，对于新加入的address对象它的id尚未赋值，以此为null，与unsaved-value值相等，因此Hibernate会将其视为未保存对象，生成insert语句加以保存。如果想使用unsaved-value必须如下配置address对象的id属性：

……

</id>

……

缓存清理机制

当Session缓存中对象的属性每次发生了变化，Session并不会立即清理缓存和执行相关的SQL update语句，而是在特定的时间点才清理缓存，这使得Session能够把几条相关的SQL语句合并为一条SQL语句，一遍减少访问数据库的次数，从而提高应用程序的数据访问性能。

在默认情况下，Session会在以下时间点清理缓存。

当应用程序调用org.hibernate.Transaction的commit()方法的时候.commit方法先清理缓存，然后再向数据库提交事务。Hibernate之所以把清理缓存的时间点安排在事务快结束时，一方面是因为可以减少访问数据库的频率，还有一方面是因为可以尽可能缩短当前事务对数据库中相关资源的锁定时间。
当应用程序执行一些查询操作时，如果缓存中持久化对象的属性已经发生了变化，就会清理缓存，使得Session缓存与数据库已经进行了同步，从而保证查询结果返回的是正确的数据。
当应用程序显示调用Session的flush()方法的时候。

Session进行清理缓存的例外情况是，如果对象使用native生成器来生成OID，那么当调用Session的save()方法保存该对象时，会立即执行向数据库插入该实体的insert语句。

Ⅵ hibernate核心包有哪些

hibernate核心包：hibernate-distribution-3.5.1-Final（8个）

cglib-2.2.jar
hibernate\lib\bytecode\cglib\cglib-2.2.jar
cglib库，hibernate用它来实现PO字节码的动态生成，非常核心的库，必须使用的jar包

antlr-2.7.6.jar
Antlr（ANother Tool for Language Recognition）是一个工具，它为我们构造自己的识别器（recognizers）、编译器（compiler）和转换器（translators）提供了一个基础。通过定义自己的语言规则，Antlr可以为我们生成相应的语言解析器，这样便可以省却了自己全手工打造的劳苦。

commons-collections-3.1.jar
dom4j-1.6.1.jar
javassist-3.9.0.GA.jar
jta-1.1.jar
slf4j-api-1.5.8.jar
hibernate\lib\required\*

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

hibernate注解包：hibernate-annotations-3.4.0.GA（3个）

hibernate-annotations.jar
ejb3-persistence.jar
hibernate-commons-annotations.jar

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

hibernate针对JPA的实现包：hibernate-entitymanager-3.4.0.GA（3个）

hibernate-entitymanager.jar
log4j.jar
slf4j-log4j12.jar
hibernate 所需jar包及简介
Hibernate3.jar 这个是hibernate最主要的jar包

ant-1.63.jar Ant 的核心包,在构建Hibernate 时会用到

antlr-2.7.5H3.jar 语言转换工,Hibernate利用它实现 HQL 到 SQL的转换

asm.jar/asm-attrs.jar ASM 字节转换库

c3p0-0.8.5.2.jar C3PO JDBC 连接池工具

cglib-2.1.jar 高效的代码生成工具, Hibernate用它在运行时扩展 Java类和实现 Java 接口

commons-collections-2.1.1.jar Apache 的工具集,用来增强Java对集合的处理能力

commons-logging-1.0.4.jar Apache 软件基我组所提供的日志工具

concurrent-1.3.2.jar 线程同步工具,在使用JBoss 的树状缓存时需要用到

connector.jar 用连接多个应用服务器的标准连接器

dom4j-1.6.jar dom4j XML 解析器

ehcache-1.1.jar 缓存工具.在没有提供其他缓存工具时,这个缓存工具是必不可少的

jaas.jar 标准的 Java 权限和认证服务包

jaxen-1.1-beta-4.jar 通用的 XPath 处理引擎

jboss-cache.jar JBoss 的一种树状缓存实现工具

jboss-common.jar Jboss 的基础包,在使用 JBoss 的树状缓存时必须有此包

jboss-jmx.jar JBoss 的 JMX 实现包

jboss-system.jar JBoss 的核心,包括服务器和部署引擎

jdbc2_0-stdext.jar 标准的 JDBC 2.0 扩展API

jgroups2.2.7.jar 网络通信工具包

jta.jar 标准的 JAVA 事务处理接口

junit-3.8.1.jar JUnit 测试框架

log4.j-1.2.9.jar log4j 库,Apache 的日志工具

oscache-2.1.jar Java 对象的缓存工具

proxool-0.8.3.jar Proxool JDBC 连接池工具

swarmcache-1.0rc2.jar Hibernate 可以使用的一种缓存工具

versioncheck.jar 版本检查工具包,用于在构建 Hibernate 的时候检查辅助 jar 包文件的版本

xerces-2.6.2.jar SAX XML 解析器

xml-apis.jar Java语言中标准的XML 解析器

Ⅶ 异常:ERROR [org.hibernate.proxy.BasicLazyInitializer] - CGLIB Enhancement failed...

之前遇到过类似问题.需要升级cglib-2.1.jar到2.2

用这个版本的你在试试
http://sourceforge.net/project/showfiles.php?group_id=56933&package_id=98218&release_id=419752

再有就是把HIBERNATE需要的相关jar包10个
COPY到工程的LIB目录下
（如果你在JAVA构建路径，通过添加外部JAR包，添加了那几个必须的包，在此还要把他们COPY到工程的LIB目录下！）

Ⅷ hibernate导jar包

最小必要包为antlr.jar,cglib.jar,asm.jar, asm-attrs.jar, commons-collections.jar, commons-loggins.jar ,encache.jar, dom4j.jar,log4j.jar,jta.jar

Hibernate3.2 核心包作用
包作用说明
jta.jar 标准的JTA API 必要
commons-logging.jar 日志功能必要
commons-collections.jar 集合类必要
antlr.jar ANother Tool for Language Recognition(antlr) 必要
dom4j.jar XML配置和映射解释器必要
Hibernate3.jar 核心库必要
asm.jar ASM字节码库如果使用“cglib”则必要
asm-attrs.jar ASM字节码库如果使用“cglib”则必要
ehcache.jar EHCache缓存如果没有其它的缓存，则它是必要的
cglib.jar CGLIB 字节码解释器如果使用“cglib”则必要
以下包可选
versioncheck.jar 版本检查
swarmcache.jar
jboss-cache.jar TreeCache
jgroups.jar
xml-apis.jar JAXP API
c3p0-0.9.1.jar C3PO JDBC链接池
connector.jar JCA API
jboss-system.jar 使用TreeCache时必要
jacc-1_0-fr.jar JACC 库
checkstyle-all.jar
junit.jar
javassist.jar Javassist 字节码解释器
ant-lanuncher.jar
jaas.jar JAAS API
jdbc2_0-stdext.jar JDBC扩展API
ant-antlr.jar Ant antlr支持
jboss-jmx.jar
cleanimports.jar cleanimports
xerces.jar SAX parser JDK版本低于1.4时必要
jaxen-1.1-beta-7.jar Jaxen 如果想提高启动性能则去使用
ant-junit.jar Ant junit support
ant-swing.jar ant swing support
ant.jar
proxool.jar Proxool JDBC连接池
concurrent.jar 使用TreeCache需要
syndiag2.jar

Ⅸ hibernate工作原理及为什么要用

hibernate 简介：
hibernate是一个开源框架，它是对象关联关系映射的框架，它对JDBC做了轻量级的封装，而我们java程序员可以使用面向对象的思想来操纵数据库。
hibernate核心接口
session：负责被持久化对象CRUD操作
sessionFactory:负责初始化hibernate，创建session对象
configuration:负责配置并启动hibernate，创建SessionFactory
Transaction:负责事物相关的操作
Query和Criteria接口：负责执行各种数据库查询

hibernate工作原理：
1.通过Configuration config = new Configuration().configure();//读取并解析hibernate.cfg.xml配置文件
2.由hibernate.cfg.xml中的<mapping resource="com/xx/User.hbm.xml"/>读取并解析映射信息
3.通过SessionFactory sf = config.buildSessionFactory();//创建SessionFactory
4.Session session = sf.openSession();//打开Sesssion
5.Transaction tx = session.beginTransaction();//创建并启动事务Transation
6.persistent operate操作数据，持久化操作
7.tx.commit();//提交事务
8.关闭Session
9.关闭SesstionFactory

为什么要用hibernate：
1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。
2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作
3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。
4. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。

Hibernate是如何延迟加载?get与load的区别
1. 对于Hibernate get方法，Hibernate会确认一下该id对应的数据是否存在，首先在session缓存中查找，然后在二级缓存中查找，还没有就查询数据库，数据库中没有就返回null。这个相对比较简单，也没有太大的争议。主要要说明的一点就是在这个版本(bibernate3.2以上)中get方法也会查找二级缓存！
2. Hibernate load方法加载实体对象的时候，根据映射文件上类级别的lazy属性的配置(默认为true)，分情况讨论：
(1)若为true,则首先在Session缓存中查找，看看该id对应的对象是否存在，不存在则使用延迟加载，返回实体的代理类对象(该代理类为实体类的子类，由CGLIB动态生成)。等到具体使用该对象(除获取OID以外)的时候，再查询二级缓存和数据库，若仍没发现符合条件的记录，则会抛出一个ObjectNotFoundException。
(2)若为false,就跟Hibernateget方法查找顺序一样，只是最终若没发现符合条件的记录，则会抛出一个ObjectNotFoundException。
这里get和load有两个重要区别:
如果未能发现符合条件的记录，Hibernate get方法返回null，而load方法会抛出一个ObjectNotFoundException。
load方法可返回没有加载实体数据的代理类实例，而get方法永远返回有实体数据的对象。
(对于load和get方法返回类型：好多书中都说：“get方法永远只返回实体类”，实际上并不正确，get方法如果在session缓存中找到了该id对应的对象，如果刚好该对象前面是被代理过的，如被load方法使用过，或者被其他关联对象延迟加载过，那么返回的还是原先的代理对象，而不是实体类对象，如果该代理对象还没有加载实体数据（就是id以外的其他属性数据），那么它会查询二级缓存或者数据库来加载数据，但是返回的还是代理对象，只不过已经加载了实体数据。)
总之对于get和load的根本区别，一句话，hibernate对于 load方法认为该数据在数据库中一定存在，可以放心的使用代理来延迟加载，如果在使用过程中发现了问题，只能抛异常；而对于get方法，hibernate一定要获取到真实的数据，否则返回null。

Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系)
类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many、

说下Hibernate的缓存机制：
Hibernate缓存的作用：
Hibernate是一个持久层框架，经常访问物理数据库，为了降低应用程序对物理数据源访问的频次，从而提高应用程序的运行性能。缓存内的数据是对物理数据源中的数据的复制，应用程序在运行时从缓存读写数据，在特定的时刻或事件会同步缓存和物理数据源的数据
Hibernate缓存分类：
Hibernate缓存包括两大类：Hibernate一级缓存和Hibernate二级缓存
Hibernate一级缓存又称为“Session的缓存”，它是内置的，意思就是说，只要你使用hibernate就必须使用session缓存。由于Session对象的生命周期通常对应一个数据库事务或者一个应用事务，因此它的缓存是事务范围的缓存。在第一级缓存中，持久化类的每个实例都具有唯一的OID。
Hibernate二级缓存又称为“SessionFactory的缓存”，由于SessionFactory对象的生命周期和应用程序的整个过程对应，因此Hibernate二级缓存是进程范围或者集群范围的缓存，有可能出现并发问题，因此需要采用适当的并发访问策略，该策略为被缓存的数据提供了事务隔离级别。第二级缓存是可选的，是一个可配置的插件，在默认情况下，SessionFactory不会启用这个插件。

什么样的数据适合存放到第二级缓存中？
1 很少被修改的数据
2 不是很重要的数据，允许出现偶尔并发的数据
3 不会被并发访问的数据
4 常量数据
不适合存放到第二级缓存的数据？
1经常被修改的数据
2 .绝对不允许出现并发访问的数据，如财务数据，绝对不允许出现并发
3 与其他应用共享的数据。

Hibernate查找对象如何应用缓存？
当Hibernate根据ID访问数据对象的时候，首先从Session一级缓存中查；查不到，如果配置了二级缓存，那么从二级缓存中查；如果都查不到，再查询数据库，把结果按照ID放入到缓存
删除、更新、增加数据的时候，同时更新缓存

Hibernate管理缓存实例
无论何时，我们在管理Hibernate缓存（Managing the caches）时，当你给save()、update()或saveOrUpdate()方法传递一个对象时，或使用load()、 get()、list()、iterate() 或scroll()方法获得一个对象时, 该对象都将被加入到Session的内部缓存中。
当随后flush()方法被调用时，对象的状态会和数据库取得同步。如果你不希望此同步操作发生，或者你正处理大量对象、需要对有效管理内存时，你可以调用evict() 方法，从一级缓存中去掉这些对象及其集合。

Hibernate的查询方式
Sql、Criteria,object comptosition
Hql：
1、属性查询
2、参数查询、命名参数查询
3、关联查询
4、分页查询
5、统计函数

如何优化Hibernate？
1.使用双向一对多关联，不使用单向一对多
2.灵活使用单向一对多关联
3.不用一对一，用多对一取代
4.配置对象缓存，不使用集合缓存
5.一对多集合使用Bag,多对多集合使用Set
6. 继承类使用显式多态
7. 表字段要少，表关联不要怕多，有二级缓存撑腰

hibernate的开发步骤：
开发步骤
1)搭建好环境
引入hibernate最小的jar包
准备Hibernate.cfg.xml启动配置文件
2)写实体类(pojo)
3)为实体类写映射文件"User.hbm.xml"
在hibernate.cfg.xml添加映射的实体
4)创建库表
5)写测试类
获得Configuration
创建SessionFactory
打开Session
开启事务
使用session操作数据
提交事务
关闭资源

Ⅹ 初学hibernate配JAR包很痛苦!

到官方网站：http://www.hibernate.org/6.html 下载(当前版本：Hibernate Core 3.2.3GA )hibernate包。解开压缩包。在lib目录下找到以下hibernate应用所必须的包(可以查看该目录下的_README.txt文件来确定哪些包是必需的)：
1. hibernate.jar ：hibernate核心包。必需的。
2. antlr.jar ：Hibernate使用ANTLR来产生查询分析器，这个类库在运行环境下时也是必需的。
3. cglib.jar ：CGLIB库，Hibernate用它来实现PO字节码的动态生成，非常核心的库，必需的jar包。
4. asm.jar ：ASM字节码库，cglib.jar包依赖的包。必需的jar包。
5. asm-attrs.jar ：ASM字节码库，cglib.jar包依赖的包。必需的jar包。
6. commons-collections.jar ：Apache Commons包中的一个，包含了一些Apache开发的集合类，功能比java.util.*强大。必须使用的jar包。
7. commons-logging.jar ：Apache Commons包中的一个，包含了日志功能，必须使用的jar包。这个包本身包含了一个Simple Logger，但是功能很弱。在运行的时候它会先在CLASSPATH找log4j，如果有，就使用log4j，如果没有，就找JDK1.4带的java.util.logging，如果也找不到就用Simple Logger。必需的。
8. ehcache.jar ：Hibernate可以使用不同cache缓存工具作为二级缓存。EHCache是缺省的cache缓存工具。如果没有其它的可选缓存工具，则为必需的。
9. jta.jar ：JTA规范，当Hibernate使用JTA的时候需要。必需的。
10. dom4j.jar ：dom4j是一个Java的XML API，类似于jdom，用来读写XML文件的。Hibernate使用dom4j解析XML配置文件和XML映射元文件。必需的。
11. log4j.jar ：日志包，可选的。
把以上必需的jar放置到应用程序的类路径中(web应用的WEB-INF/lib目录下)。
话说你问了2次！

cglib缓存

与cglib缓存相关的内容