博客分类：
Shift+第一个+最后一个=全部选中jar包1.数据库和tomcat服务器不在一台电脑上，一级缓存是保存在服务器的内存中，二级缓存保存在服务器的硬盘上（因此我们可以设置溢出时保存到哪个硬盘），二级缓存也是在tomcat服务器上的，因此减少了与数据库的交互次数(因为保存到服务器的话不用跟其他的电脑进行交互)。2.hibernate的一级缓存是session级别的缓存。sessionFactory级别的缓存是二级缓存。3.二级缓存要指定hibernate的二级缓存插件（插件是个现成的程序，需要我们指定用这个插件），需要开启4.hibernate主配置文件中的设置都是给某个类进行赋值，是个sessionFactory类（session工厂）中的属性赋值。sessionFactory是个接口，实现类是sessionFactoryimpl资源文件Properties 继承了hashtable，因此Properties 是个键值对。来自JDK1.6说明文档：Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。
5.在properties文件中#表示注释6，使用二级缓存的步骤：
---1.开启二级缓存 ---2.指定缓存插件（功能是把内容写到磁盘中，当开启二级缓存之后就该想到我们将来要把内容存到哪里）
--3.写配置文件说明二级缓存的大小，在src下配置缓存文件
--4.指定需要缓存的对象和缓存策略7.statics是对二级缓存进行统计，输出来的内容create（可瑞的）是该对象的属性。在主配置文件中配置。他是查看二级缓存或查询缓存区域的内容，但是如果想查看二级缓存，需要在主配置文件中进行配置。查看二级缓存是SessionFactory类中的的方法Statistics ss=HibernateSessionFactory.getSessionFactory().getStatistics();其实不难理解为什么是SessionFactory类中的方法，因为SessionFactory表示的是二级缓存。而session表示一级缓存。
8.适合放入二级缓存中的数据：1.不经常做修改的数据，2.安全性不高的数据。9.先查询已经缓存，一级缓存中如果没有在查询二级缓存，如果二级缓存中也没有，就查询数据库。10.session（一级）和sesionFactroy（二级）的线程安全问题 session是线程不安全的：ThreadLocal是给每个来的线程都给他一个副本，用这种方式来解决多线程问题。sessionFactroy是线程安全的。注意：在hibernate主配置文件中，二级缓存的配置要放到映射文件配置的前面
11.session和sessionFactory都有evict方法，该方法的参数是个对象或者类，表示让该对象与一级缓存或者二级缓存断开联系：sessionFactory.evict(Cat.class, catId); sessionFactory.evict(Cat.class); /**关于二级缓存：二级缓存就是给大家共享的，每个线程都能够使用，因此就出现了多线程并发的现象。
第一步（1）：在hibernate主配置文件中写：
&!--设置二级缓存
&property name="hibernate.cache.provider_class"&
org.hibernate.cache.EhCacheProvider
&/property&
&!--默认是使用二级缓存的，但是可以设置关闭
&property name="hibernate.cache.use_second_level_cache"&
&/property&
&!-- 使用查询缓存 --&
&property name="hibernate.cache.use_query_cache"&true&/property&
第一步（2）：在映射文件中写二级缓存的并发策略。usage表示并发策略。 &cache usage="read-write"/&
第二步：指定二级缓存的插件（有好多种插件都能实现二级缓存，其实就是把某个xml文件放到src目录下（放在src下就会随着项目的启动而启动二级缓存）。现在要指定插件，在老师给的hibernate-3.2下的ect目录下）
第三步：配置上面的插件（可以只配置缓存的大小）----------------------------------注意：现在我们只导入了hibernate的jar包，在配置好二级缓存之后运行的时候报错Exception in thread "main" java.lang.NoClassDefFoundError: org/apache/commons/logging/LogFactory。这是找不到这个jar包（也就是说明二级缓存要使用这个jar包），因此我们可以找一个这样的jar包放到项目中，也可以直接把struts框架的jar包生成，因为struts2框架的jar包就有这个jar包并发策略有好多种，看张老师的，可是我们常用的只有两种只读模式和读写模式，当我们设置读写模式的时候就不能设置事务的隔离级别了，因为这两个是互相矛盾的。**/
11.主键生成策略：increment（k瑞特门）:自动增长因用于mysql，identity自增用于mysql，server，db2，sequence是oracle中的自增native（内t我）：根据数据库自动匹配（相当于综合各种数据库），由数据库底层自己决定。assigned：程序员自己指定uuid：是个算法
12.hql的多表关联(多表关联有三种，一种是hql的多表关联，一个createCriteria（也就是QBC查询），一个是本地sql查询)inner默认是内连接，inner join。左是left join
内左外右外连接查询：查询结果是个object类型的数组，因为这个查询结果中包含两个或者两个以上的表（类），因此不能是具体类型，只能是object类型。因为包含多个表，表中又有属性，因此每个表都是一个数组。
迫切查询：返回值是个对象
13.createCriteria多表关联
两个参数，第一个是类名，第二个是别名，单词是alias
两个参数，第一个参数表示地址，第二个参数是数据类型（在Criteria里面的常量）
14，hibernate的源码在hibernate-3.2这个老师给的文件中的src中，如果找二级缓存的资源文件在这个文件夹中的ect中。
一级缓存session的声明周期是与数据库的一次交互过程，当我们把session放到action层的时候，它的声明周期是一次请求和响应的过程（可能多次与数据库交互）而二级缓存是：不但在一级缓存的map结构中存放（），还在二级缓存中存放（在二级缓存存放的内容是共享的）。一级缓存的作用域相当于是hibernate主配置文件中的map标签里，而二级缓存的作用域相当于是整个hibernate主配置文件。------------------书17章：三种检索（查询）方式1.hql语句检索：session.createQuery(hql);2.QBC检索：session.createCriteria(XXX.class)3.本地SQL检索：session.createSQLQuery(sql)
第二：代码
1、hibernate主配置文件
&?xml version='1.0' encoding='UTF-8'?&&!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
&!-- Generated by MyEclipse Hibernate Tools.
--&&hibernate-configuration& &!-- 注意：hibernatefactory里面配置的所有标签其实就是hibernatefactory接口中的属性，该接口的实现类是hibernatefactoryImpl，下面的所有配置 都是该实现类中的属性。 --&&session-factory& &property name="dialect"&
org.hibernate.dialect.Oracle9Dialect &/property& &property name="connection.url"&
jdbc:oracle:thin:@localhost:1521:ORCL &/property& &property name="connection.username"&chu1&/property& &property name="connection.password"&1234&/property& &property name="connection.driver_class"&
oracle.jdbc.OracleDriver &/property& &property name="myeclipse.connection.profile"&chu&/property& &property name="format_sql"&true&/property& &property name="show_sql"&true&/property& &!--设置二级缓存，指定缓存插件，是个类，是个jar包里面的类
--& &property name="hibernate.cache.provider_class"&
org.hibernate.cache.EhCacheProvider &/property& &!--默认是使用二级缓存的，但是可以设置关闭。打开二级缓存
--& &property name="hibernate.cache.use_second_level_cache"&
true &/property& &!-- 使用查询缓存，查询缓存有利于提高查询速度，也是个jar包里的类 --& &property name="hibernate.cache.use_query_cache"&true&/property& &!--表示允许查看二级缓存里面放的数据--& &property name="generate_statistics"&true&/property&
&mapping resource="com/model/pojo/Student6.hbm.xml" /&
&/session-factory&
&/hibernate-configuration&
2.basedao公共类
package com.
import java.io.S
import org.hibernate.Simport org.hibernate.SessionFimport org.hibernate.Timport org.hibernate.cfg.C
public class BaseDao { public static SessionF static {
Configuration cfg=new Configuration().configure("/hibernate.cfg.xml");
sf = cfg.buildSessionFactory();
System.out.println(sf); }
public Session getSession() {
return sf.openSession(); }
public Serializable save(Object obj) {
Transaction
Session session=
Serializable ser=
session = this.getSession();
tr= session.beginTransaction();
ser=session.save(obj);
tr.commit();
catch(Exception ex)
ex.printStackTrace();
session.close();
public static void main(String[] args) {
new BaseDao(); }}
package com.model.
import org.hibernate.Simport org.hibernate.Timport org.hibernate.stat.S
import com.comm.BaseDimport com.comm.HibernateSessionFimport com.model.pojo.Student6;
public class StudentDao extends BaseDao{ //一级缓存。此时不开启二级缓存。在主配置文件中设置成false public void search(){
Session session=super.getSession();
Student6 stu=(Student6) session.get(Student6.class, 168);
System.out.println(stu.getSname()+"\t"+stu.getSsex());
//session.evict(stu);//将当前对象与session断开
//session.clear();//清空session
session.close();//关闭session
Session session2=super.getSession();
System.out.println("session是打开的？"+session.isOpen());
//System.out.println("当前session"+session.hashCode());
System.out.println(stu.getSname()+"\t"+stu.getSsex());//无论什么操作，这里都会输出值，因为这里跟缓存无关，由于限制存在一个完整的stu对象，所以理所当然的能够输出他的属性值。
} //自己的session关闭之后其他session来访问相同的内容（id相同的学生），由于第一个session把查询结果放在了二级缓存中了，因此第二个session查询相同的学生的时候不会访问数据库而是直接去二级缓存中取，因此控制台输出一条sql语句 public void search2(){
Session session=HibernateSessionFactory.getSession();
Student6 stu=(Student6) session.get(Student6.class, 168);
System.out.println(stu.getSname()+"\t"+stu.getSsex());
//session.clear();//清空一级缓存
session.close();
Session session2=HibernateSessionFactory.getSession();
Student6 stu2=(Student6) session2.get(Student6.class, 168);//会查看二级缓存中有没有，当我们开启二级缓存的时候，使用二级缓存，因此不会再输出select语句了
System.out.println(stu2.getSname()+"\t"+stu2.getSsex());//
Statistics ss=HibernateSessionFactory.getSessionFactory().getStatistics();//getSessionFactory()是获得sesionFactory也就是获得二级缓存，getStatistics是获得二级缓存中的统计信息
System.out.println(ss); }
public static void main(String[] args) {
StudentDao sdao = new StudentDao();
//sdao.search();
sdao.search2();
//sdao.search3(); }
第三：多表连接查询，对象查询的代码
1.员工表的映射文件
&?xml version="1.0" encoding="utf-8"?&&!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"""&&!--
Mapping file autogenerated by MyEclipse Persistence Tools--&&hibernate-mapping package="com.model.pojo"&
&class name="Emp" table="HIB_EMP" schema="CHU1"&
&id name="eid" type="int"&
&column name="EID" precision="10" scale="0" /&
&generator class="assigned" /&
&many-to-one name="dept" class="Dept" fetch="select"&
&column name="DID" precision="10" scale="0" /&
&/many-to-one&
&property name="ename" type="string"&
&column name="ENAME" length="40" /&
&/property&
&property name="job" type="string"&
&column name="JOB" length="40" /&
&/property&
&/class&&/hibernate-mapping&
2.部门表的映射文件
&?xml version="1.0" encoding="utf-8"?&&!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"""&&!--
Mapping file autogenerated by MyEclipse Persistence Tools--&&hibernate-mapping package="com.model.pojo"&
&class name="Dept" table="HIB_DEPT" schema="CHU1"&
&id name="did" type="int"&
&column name="DID" precision="10" scale="0" /&
&generator class="assigned" /&
&property name="dname" type="string"&
&column name="DNAME" length="40" /&
&/property&
&set name="emps" inverse="true"&
&column name="DID" precision="10" scale="0" /&
&one-to-many class="Emp" /&
&/class&&/hibernate-mapping&
3.连接查询和本地查询
package com.model.
import java.util.Iimport java.util.Limport java.util.S
import org.hibernate.Qimport org.hibernate.S
import com.comm.HibernateSessionFimport com.model.pojo.Dimport com.model.pojo.E
public class DeptDao {
public static void main(String[] args) {
DeptDao ddao=new DeptDao();
//ddao.selDept();
//ddao.selDept1();
//ddao.selDept2();
ddao.selDept3(); } //通过这个方法我们发现内连接，左连接、右连接的查询结果是个object类型的数组 public void selDept(){
Session session=HibernateSessionFactory.getSession();
String hql="from Dept as d inner join d.emps";
Query query = session.createQuery(hql);
List list = query.list();
for(int x=0;x&list.size();x++){
System.out.print(list.get(x)+"
");//这个得到的是个数组，也就是说集合里面放的是数组。由此得出结论
System.out.println();
} //通过这个方法我们知道，数组中的每个元素都表示多表关联中的每个表，也就是说有几个表数组中就会有几个元素 public void selDept1(){
Session session=HibernateSessionFactory.getSession();
String hql="from Dept as d inner join d.emps";
Query query = session.createQuery(hql);
List&Object[]& list = query.list();//首先查询结果有很多，是个list集合（query.list的返回值就是个list）。每个查询结果又是个数组，数组中的每个元素表示一个表（由于内连接，左右连接都是两个或者两个以上的表在参与）
for(Object[] d:list){
System.out.println(d[0].getClass().getName()+"\t"+d[1].getClass().getName());
} //迫切左外连接。集合的返回值得到的是对象类型的list集合 public void selDept2(){
Session session=HibernateSessionFactory.getSession();
String hql="from Dept as d left join
fetch d.emps";
Query query = session.createQuery(hql);
List&Dept& list=query.list();
for(Dept d:list){
System.out.println(d.getDname());
Set&Emp& set=d.getEmps();
Iterator&Emp& it = set.iterator();
while(it.hasNext()){
System.out.println(it.next().getEname());
} //本地sql查询 public void selDept3(){
Session session=HibernateSessionFactory.getSession();
String sql="select *　from dept";//创建sql语句
Query query = session.createSQLQuery(sql).addEntity(Dept.class);//addEntity是把sql变成hql，把表名变成类名
System.out.println(query);
int a=query.executeUpdate();
System.out.println(a);
4.对象查询
package com.model.
import java.util.L
import org.hibernate.Cimport org.hibernate.Simport org.hibernate.criterion.R
import com.comm.HibernateSessionFimport com.model.pojo.E
public class EmpDao { public static void main(String[] args) {
EmpDao edao=new EmpDao();
edao.selEmp();
} //QBC查询，也叫对象查询 public void selEmp(){
Session session=HibernateSessionFactory.getSession();
//第一个参数是个路径，第二个参数是别名(String associationPath, String alias)
Criteria c = session.createCriteria(Emp.class, "e");//创建QBC查询语句，并给则个对象起个别名e
//第一个参数是路径，第二个参数是连接类型（例如左外连接，内连接等）(String associationPath, int joinType)
//连接类型中的1是Criteria接口的实现类CriteriaSpecification（查看源代码）中的一个常量的值，
c.createCriteria("e.dept",1);//左连接
c.add(Restrictions.eq("e.ename","喜洋洋"));
List&Emp& elist = c.list();
for(Emp e:elist){
System.out.println(e.getEname());
System.out.println(e.getDept().getDname());
天津店小二
浏览: 13706 次
来自: 天津
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'博客分类：
&& 因为系统中同时采用Hibernate和Jdbc两种技术，为了提高性能我们一般打开Hibernate的二级缓存和查询缓存功能，但是无法兼顾Jdbc的变动，而且Hibernate的缓存我们无法进行微调,是位于Dao层，也影响了缓存的性能。
&& 因为我们有必要做出一种灵活性和性能更好的缓存来适应这种情况。spring cache已经提供了一个良好的框架和cache annotation给我们使用，但是我们需要那他来开刀，改造为我们想要的效果。由于目前对spring cache的应用介绍都是点到为止，因此我们可以直接从spring 的代码和它的文档入手。
目标
提高系统性能，在有限的资源下支持更多的用户并发量
取消并模拟Hibernate的二级缓存机制，整合Hibernate和JDBC的缓存
更高的灵活性和实时性
原则
1. 针对系统中不改动或者少量改动的数据对象，不适宜用在频繁改动的数据上
2. 缓存越靠近系统前端，表现越好
关键点
1. 设计缓存的关键字 "key"
2. 设计缓存的更新机制
3. 缓存以key - value 方式存在
..........
具体介绍已经写在ppt中，实现代码稍后上传，因为这个思路不一定成熟，欢迎讨论。
(112.4 KB)
下载次数: 279
下载次数: 212
论坛回复 /
(23 / 12385)
浏览: 159084 次
来自: 广州
最困难的事情就是认识自己
只要坚持下去，总会有意想不到的收获。
听从了大家的意见，LegendShop已经把Hibernate ...
最新版本已经不是免费的了
最新公司做了套不错的商城系统，需要的话联系。
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'Hibernate的一级和二级缓存
1. 管理session
session对象的生命周期与本地线程绑定
&!-- 配置session对象的生命周期和本地线程绑定 --&
&property name=”hibernate.current_session_context_class”&thread&/property&
使用本地线程绑定,每次都从当前的线程提取session!!!
* 当前线程如果存在session对象,取出直接使用
* 当前线程如果不存在session对象,获取一个新的session对象和当前线程绑定
Session s1 = sf.getCurrentSession();
Session s2 = sf.getCurrentSession();
System.out.println(s1==s2);
2. hibernate缓存机制
Hibernate中提供了两个级别的缓存
第一级别的缓存是 Session的缓存，它是属于线程范围的缓存。这一级别的缓存由 hibernate 管理的，我们无需干预
第二级别的缓存是 SessionFactory的缓存，它是属于进程范围的缓存
缓存的作用主要用来提高性能，可以简单的理解成一个Map
使用缓存涉及到三个操作：把数据放入缓存、从缓存中获取数据、删除缓存中的无效数据
2.1 一级缓存
一级缓存指的是session对象内部的一个HashMap
(session的实现类是:SessionImpl)
用户不需要做任何配置就可以使用,但它的生命周期非常小, 只要session关闭,缓存就消失
每个session拥有自己的缓存区, 执行session.save()操作的时候,会先放入一级缓存
--& 放入一级缓存的对象称为持久化对象
* 执行查询的时候,会先到session的一级缓存中查找
* 如果找到,直接从缓存中获取该对象,这时不再查询数据库
* 如果没有找到,此时查询数据库,产生select语句,并把查询到的对象放入缓存
Customer c1 = (Customer) session.get(Customer.class, 1);
* 执行查询的时候,会将查到的对象放到session的一级缓存中一份,同时在session的快照中有一份复制
当执行session.close()的时候,清理缓存,这时会比对缓存中对象的属性值和快照中对象的属性值,看是否一致
* 如果一致,不再执行update语句
* 如果不一致,执行update语句
* session如何判断持久化对象的状态发生改变呢?
* session加载对戏那个后会为对象属性复制一份快照,当session清理缓存时,会比较当前对象和它的快照就可以知道哪些属性发生了改变
* 在什么时候session会清理缓存呢?
* 当应用程序调用Transaction的commit()方法时,该方法先清理缓存,然后向数据库提交事务
* 当应用程序执行一些查询操作,如果缓存中持久化对象的属性已经发生了变化,会先清理缓存,以保证查询结果能反应持久化对象的最新状态
* 显式的调用Session的flush()方法
注意: 清理缓存,缓存中的数据不会丢失,清理不等于清除
session.clear()为清空缓存
session.refresh(customer) 刷新数据库中的数据和缓存中的同步,方向: 从数据库--&缓存
session.fresh() 刷新session的一级缓存中的数据到数据库,让缓存中的数据跟数据库同步,方向: 从缓存--& 数据库
session在清理缓存时,会根据持久化对象的属性变化,来同步更新数据库
* session缓存的作用?
* 减少数据库的访问频率,提高访问性能
* 保证缓存中的对象与数据库同步,位于缓存中的对象称为持久化对象
2.2 SessionFactory的缓存
1.) 内置缓存: 只读的
* 连接数据库的信息
* 映射文件的信息
* 预定义的sql语句
2.) 外置缓存(二级缓存) 一个可以配置的缓存插件,第三方的,分为四个部分
-& 所谓的缓存就是hashmap
* 类级别的缓存
* 放置的是查询到的对象(散列数据),
同时还要把查询的时间放置到类级别的时间戳区域
* 集合级别的缓存 (存放的永远是查询条件)
* 放置的是查询条件,真正的实体还是在类级别的缓存区域中
* 查询缓存
* 放置的是查询条件,真正的实体还是在类级别的缓存区域中
&property name=”hibernate.cache.use_query_cache”&true&/property&
// 配置启用查询缓存
query.setCacheable(true);
// 启用查询缓存
* 更新时间戳缓存
* 适合放入二级缓存的数据: 可以缓解数据库的压力
* 很少被修改
* 不是很重要的数据,允许出现偶尔的并发问题
* 不适合放入二级缓存的数据:
* 经常被修改
* 财务数据,绝对不允许出现并发问题
* 与其他应用数据共享的数据
* hibernate有了一级缓存,为什么还要有二级缓存?
* 一级缓存只对当前的session有效
* 二级缓存里的数据可以跨多个session,可以被多个session共享
* 缓存的时间更久,不会像一级缓存那样,一旦session销毁就销毁
* 二级缓存散列数据的概念!
* 做查询的时候: Customer c = (Customer) session.get(Customer.class,1); // 已配置了Customer类级别的二级缓存
会将c放入一级缓存和二级缓存!!! 二级缓存中放置的是不是对象,而是对象的属性值!所以称二级缓存存放的是散列数据
每次取出的对象是不同的对象
2.3 缓存策略
read-only - 只可执行读取，不能进行更新。
read-wirte: - 可读,也可以写
对于查询缓存，如果只查询一个类，则只配置cache即可，
但如果查询的结果是一个集合, 则必须要hibernate.cfg.xml中配置开启查询缓存
3. 配置二级缓存
第一步：导jar包echace.jar.
第二部: 先使用ehcache-1.5.0.jar该缓存的默认配置,此时执行的是jar包下的ehcache-failsafe.xml文件
第三步：开启二级缓存,配置缓存提供的供应商,并将需要支持二级缓存的类配置到hibernte.cfg.xml中.
第四步：配置ehcache自己的配置文件：classpath:ehcache.xml (针对某个对象设置缓存)
第五步：配置一些信息，如：最多存多少个数据对象，数据对像太多时，不用的对象是否应该保存到硬盘上去
要使用二级缓存,还需要引入两个jar包(spring包下)
..\lib\concurrent\backport-util-concurrent.jar
..\lib\commons-logging.jar
Hibernate.cfg.xml:&!-- 以下配置二级缓存-以下启动了二级缓存,默认是不开启的--&
&property name="cache.use_second_level_cache"&true&/property&
&property name="hibernate.cache.provider_class"&
org.hibernate.cache.EhCacheProvider
&/property&
&!-- 以下打开查询缓存 --&
&property name="hibernate.cache.use_query_cache"&true&/property&
&!-- 打开二级缓存的统计信息
hit:命中次数：是指从二级缓存中获取到了几次数据。
miss:没有命中的次数。
&property name="hibernate.generate_statistics"&true&/property&
&!--配置二级缓存中存放的数据类型,要放置在mapping元素的下面--&
&!--配置类级别的二级缓存--&
&class-cache class=”cn.itcast.Customer” usage=”read-write”/&
&class-cache class=”cn.itcast.Order” usage=”read-write”/&
&!--配置集合级别的二级缓存--&
&collection-cache class=”cn.itcast.Customer.orders” usage=”read-write”/&也可以在映射文件里面配置(不推荐)&class name=”cn.itcast.Customer” table=”customers”&
&!--配置类级别的二级缓存,此时二级缓存中能存放Customer对象--&
&cache usage=”read-write”/&
&id name=”id” type=”integer”&
&set name=”orders” table=”orders” inverse=”true”&
&!—配置集合级别的二级缓存,此时orderes订单集合放入到二级缓存中--&
&cache usage=”read-write”/&
&/class&eacache.xml&ehcache&
&!-- 设置当内存数据太多时，保存到哪一个目录 --&
&diskStore path="d:/a"/&
&!--以下是默认缓存区，必须存在
eternal：在内存中的数据是否永不过期。建议设置为false
&defaultCache
maxElementsInMemory="100"
eternal="false"
timeToIdleSeconds="120"
timeToLiveSeconds="300"
overflowToDisk="true"
&!-- 以下定义一个有名的cache区 --&
&cache name="itcast"
maxElementsInMemory="100"
eternal="false"
timeToIdleSeconds="300"
timeToLiveSeconds="600"
overflowToDisk="true"
&/ehcache&辅助理解一级缓存:// 核心类,维护了一个map,相当于一个缓存
public class Baidu {
private static Map&String,City& citys = new HashMap&String,City&();
public static City getCity(String name){
City city = citys.get(name);
if(city==null){
city = new City(name);
citys.put(name, city);
}// 一个javabean,封装了城市的信息public class City {
public City(String name) {
this.name =
}// 测试类public class Main {
public static void main(String[] args) {
City city1 = Baidu.getCity("Beijing");
// 第一次获取北京的信息 -& 查缓存 -& 没有 -& 查数据库 -& 维护到缓存
City city2 = Baidu.getCity("Beijing");
// 第二次查缓存 -& 有 -& 直接从缓存获取
System.out.println(city1==city2);
没有更多推荐了，}