㈠ 如何全局缓存access token java
如何全局缓存access token java
3.5 字符型数据
字符型数据包括字符常量和字符变量。
3.5.1 字符常量
字符常量是用单引号括起来的一个字符。
例如：
'a'、'b'、'='、'+'、'?'
都是合法字符常量。
在C语言中，字符常量有以下特点：
1) 字符常量只能用单引号括起来，不能用双引号或其它括号。
2) 字符常量只能是单个字符，不能是字符串。
3) 字符可以是字符集中任意字符。但数字被定义为字符型之后就不能参与数值运算。如'5'和5 是不同的。'5'是字符常量，不能参与运算。
㈡ 怎样全局缓存access
全局缓存access代码：<?php
class access
{
/**
* 声明存储查询结果ID的数组，数据库连接ID，存储分页信息的数组，缓存数据读取偏移量
*/
public $resultId, $linkId, $pageMsg, $offset;
/**
* 声明显示错误消息的页面地址
*/
public $errPage = '';
/**
* 声明数据库路径，此路径需为绝对路径
*/
public $dbPath = '';
/**
* 缓存存储路径
*/
public $cachePath = '';
/**
* 缓存声明周期，设为0则不适用缓存
*/
public $cacheLifeTime = 3600;
/**
* 当使用分页查询时，最多缓存多少页
*/
public $cacheLimitMax = 100;
/**
* 建立数据库连接
*
* 说明：
* 此数据库类无构造函数，在声明新类之后，需手动运行此函数
*/
public function connect()
{
$dsn = 'DRIVER={Microsoft Access Driver (*.mdb)}; DBQ='.$this->dbPath;
$this->linkId = odbc_connect($dsn,'','',sql_CUR_USE_ODBC);
$this->linkId || $this->setError('Connect database defeat!');
}
/**
* 执行一条SQL语句
*
* 参数：
* $sql 要执行的SQL语句
* $resultId 查询结果的ID，当执行一条不需返回的SQL语句，如删除，更新等时，该参数可省略
*/
public function query($sql ,$resultId = '__id__')
{
$this->resultId[$resultId] = odbc_exec($this->linkId,$sql);
$this->resultId[$resultId] || $this->setError('Carries out the SQL defeat!');
}
/**
* 从查询结果集中读取一条记录，并返回为数组
*
* 参数：
* $resultId 查询结果的ID
*/
public function record($resultId)
{
if (is_array($this->resultId[$resultId]))
{
$offset = $this->offset[$resultId]; $this->offset[$resultId]++;
return $this->resultId[$resultId][$offset];
}
return odbc_fetch_array($this->resultId[$resultId]);
}
/**
* 从查询结果集中读取一条记录，并注册为类的属性，属性名为字段名
*
* 参数：
* $resultId 查询结果ID
*/
public function recordObj($resultId)
{
if (is_array($this->resultId[$resultId]))
{
$rowArray = $this->resultId[$resultId][$this->offset[$resultId]];
$this->offset[$resultId]++;
} else {
$rowArray = $this->record($resultId);
}
for (reset($rowArray);$key = key($rowArray);next($rowArray)) $this->$key = $rowArray[$key];
}
/**
* 获取一个查询结果集的记录数
*
* 参数：
* $resultId 查询结果ID
*/
public function rowsNum($resultId)
{
return odbc_num_rows($this->resultId[$resultId]);
}
㈢ ThinkPHP中关于静态缓存的定义格式为全局的操作静态规则
ThinkPHP内置了静态缓存的功能，并且支持静态缓存的规则定义。
要使用静态缓存功能，需要开启HTML_CACHE_ON 参数，并且使用HTML_CACHE_RULES配置参数设置静态缓存规则文件 。
静态规则的定义方式如下：
'HTML_CACHE_ON'=>true,
'HTML_CACHE_RULES'=> array(
'ActionName' => array('静态规则', '静态缓存有效期', '附加规则'),
'MoleName(小写)' => array('静态规则', '静态缓存有效期', '附加规则'),
'MoleName(小写):ActionName' => array('静态规则', '静态缓存有效期', '附加规则'),
'*' => array('静态规则', '静态缓存有效期', '附加规则'),
//…更多操作的静态规则
)
静态缓存文件的根目录在HTML_PATH 定义的路径下面，并且只有定义了静态规则的操作才会进行静态缓存，注意，静态规则的定义有三种方式：
第一种是定义全局的操作静态规则，例如定义所有的read操作的静态规则为
'read'=>array('{id}','60')
其中，{id} 表示取$_GET['id'] 为静态缓存文件名，第二个参数表示缓存60秒
第二种是定义全局的模块静态规则，例如定义所有的User模块的静态规则为
'user:'=>array('User/{:action}_{id}','600')
其中，{:action} 表示当前的操作名称 静态
第三种是定义某个模块的操作的静态规则，例如，我们需要定义Blog模块的read操作进行静态缓存
'blog:read'=>array('{id}',0)
有个别特殊的规则，例如空模块和空操作的静态规则的定义，可以使用下面的方式：
'empty:index'=>array('{:mole}_{:action}',0) // 定义空模块的静态规则
'User:_empty'=>array('User/{:action}',0) // 定义空操作的静态规则
第四种方式是定义全局的静态缓存规则，这个属于特殊情况下的使用，任何模块的操作都适用，例如
'*'=>array('{$_SERVER.REQUEST_URI|md5}'),
根据当前的URL进行缓存
静态规则是用于定义要生成的静态文件的名称，写法可以包括以下情况
1、使用系统变量 包括 _GET _REQUEST _SERVER _SESSION _COOKIE
格式：
{$_×××|function}
例如：
{$_GET.name} {$_SERVER. REQUEST_URI|md5}
2、使用框架特定的变量
例如：{:app}、{:group} 、{:mole} 和{:action} 分别表示当前项目名、分组名、模块名和操作名
3、使用_GET变量
{var|function}
也就是说 {id} 其实等效于 {$_GET.id}
4、直接使用函数
{|function}
例如：{|time}
5、支持混合定义，例如我们可以定义一个静态规则为：
'{id},{name|md5}'
在{}之外的字符作为字符串对待，如果包含有”/”，会自动创建目录。
例如，定义下面的静态规则：
{:mole}/{:action}_{id}
则会在静态目录下面创建模块名称的子目录，然后写入操作名_id.shtml 文件。
静态有效时间 单位为秒如果不定义，则会获取配置参数HTML_CACHE_TIME 的设置值，如果定义为0则表示永久缓存。
附加规则通常用于对静态规则进行函数运算，例如
'read'=>array('Think{id},{name}','60', 'md5')
翻译后的静态规则是 md5('Think'.$_GET['id']. ', '.$_GET['name']);
和静态缓存相关的配置参数包括：
HTML_CACHE_ON 是否开启静态缓存功能
HTML_FILE_SUFFIX 静态文件后缀 惯例配置的值是 .html
HTML_CACHE_TIME 默认的静态缓存有效期 默认60秒 可以在静态规则定义覆盖
㈣ 定义一个全局数据作为缓存,在运算部分随时往数据里写数据,循环保存,这个怎么修改程序啊只是加入这个东西
许多人认为，“缓存”是内存的一部分
许多技术文章都是这样教授的
但是还是有很多人不知道缓存在什么地方，缓存是做什么用的
其实，缓存是CPU的一部分，它存在于CPU中
CPU存取数据的速度非常的快，一秒钟能够存取、处理十亿条指令和数据（术语：CPU主频1G），而内存就慢很多，快的内存能够达到几十兆就不错了，可见两者的速度差异是多么的大
缓存是为了解决CPU速度和内存速度的速度差异问题
内存中被CPU访问最频繁的数据和指令被复制入CPU中的缓存，这样CPU就可以不经常到象“蜗牛”一样慢的内存中去取数据了，CPU只要到缓存中去取就行了，而缓存的速度要比内存快很多
这里要特别指出的是：
1.因为缓存只是内存中少部分数据的复制品，所以CPU到缓存中寻找数据时，也会出现找不到的情况（因为这些数据没有从内存复制到缓存中去），这时CPU还是会到内存中去找数据，这样系统的速度就慢下来了，不过CPU会把这些数据复制到缓存中去，以便下一次不要再到内存中去取。
2.因为随着时间的变化，被访问得最频繁的数据不是一成不变的，也就是说，刚才还不频繁的数据，此时已经需要被频繁的访问，刚才还是最频繁的数据，现在又不频繁了，所以说缓存中的数据要经常按照一定的算法来更换，这样才能保证缓存中的数据是被访问最频繁的
3.关于一级缓存和二级缓存
为了分清这两个概念，我们先了解一下RAM
ram和ROM相对的，RAM是掉电以后，其中才信息就消失那一种，ROM在掉电以后信息也不会消失那一种
RAM又分两种，
一种是静态RAM，SRAM；一种是动态RAM，DRAM。前者的存储速度要比后者快得多，我们现在使用的内存一般都是动态RAM。
有的菜鸟就说了，为了增加系统的速度，把缓存扩大不就行了吗，扩大的越大，缓存的数据越多，系统不就越快了吗
缓存通常都是静态RAM，速度是非常的快，
但是静态RAM集成度低（存储相同的数据，静态RAM的体积是动态RAM的6倍），
价格高（同容量的静态RAM是动态RAM的四倍），
由此可见，扩大静态RAM作为缓存是一个非常愚蠢的行为，
但是为了提高系统的性能和速度，我们必须要扩大缓存，
这样就有了一个折中的方法，不扩大原来的静态RAM缓存，而是增加一些高速动态RAM做为缓存，
这些高速动态RAM速度要比常规动态RAM快，但比原来的静态RAM缓存慢，
我们把原来的静态ram缓存叫一级缓存，而把后来增加的动态RAM叫二级缓存。
一级缓存和二级缓存中的内容都是内存中访问频率高的数据的复制品（映射），它们的存在都是为了减少高速CPU对慢速内存的访问。
通常CPU找数据或指令的顺序是：先到一级缓存中找，找不到再到二级缓存中找，如果还找不到就只有到内存中找了
㈤ Hibernate的一级缓存和二级缓存分别是什么
Hibernate的缓存包括Session的缓存和SessionFactory的缓存，其中
SessionFactory的缓存又可以分为两类：内置缓存和外置缓存。Session的缓
存是内置的，不能被卸载，也被称为Hibernate的第一级缓存。
SessionFactory的内置缓存和Session的缓存在实现方式上比较相似，前者是
SessionFactory对象的一些集合属性包含的数据，后者是指Session的一些集
合属性包含的数据。SessionFactory的内置缓存中存放了映射元数据和预定义
SQL语句，映射元数据是映射文件中数据的拷贝，而预定义SQL语句是在
Hibernate初始化阶段根据映射元数据推导出来，SessionFactory的内置缓存
是只读的，应用程序不能修改缓存中的映射元数据和预定义SQL语句，因此
SessionFactory不需要进行内置缓存与映射文件的同步。SessionFactory的
外置缓存是一个可配置的插件。在默认情况下，SessionFactory不会启用这个
插件。外置缓存的数据是数据库数据的拷贝，外置缓存的介质可以是内存或者硬
盘。SessionFactory的外置缓存也被称为Hibernate的第二级缓存。
㈥ fancycache
FancyCache是一个可以将系统内存或闪存虚拟成硬盘缓存的软件。它把从硬盘中读取的数据存入系统内存或闪存，使系统在下次访问该数据时可以很快从内存读取，避免再次读取速度较慢的硬盘，从而突破硬盘瓶颈，提升系统性能。 FancyCache还具有检测和利用系统未识别内存的功能，解决32位Windows操作系统无法完全使用4G或更多内存的问题。通过将检测到的系统未识别内存用作硬盘缓存的方式，FancyCache使计算机可以利用全部安装的内存。
FancyCache为硬盘分配内存作缓存，并拦截系统发送至硬盘的IO请求。如果IO请求读取的数据已经在缓存中，则直接读取缓存中的数据并完成IO请求。否则数据则从硬盘中读取出来，并存入缓存，同时完成IO请求。由此可见，从缓存读取的数据量越多，则系统性能提升的越多。
编辑本段主要特性
支持 LRU (最近最少使用调度算法) 和LFU (最近最不常用调度算法) 缓存算法， 支持 读写缓存、仅读缓存和仅写缓存 三种缓存策略， 支持 直接写入 和 延迟写入 两种写入模式， 支持 系统内存、系统未识别内存、闪存盘、固态硬盘SSD作为缓存， 支持对分区或整个硬盘缓存， 支持 TRIM 指令， 支持可视化性能监视统计， 支持动态硬盘， 支持NTFS junction point (符号连接)， 支持自定义文件系统， 支持即插即用。
编辑本段为什么使用FancyCache?
Windows操作系统本身已经实现了基于文件的缓存系统，我们还需要再使用一个缓存系统FancyCache吗？ 某些应用程序会绕过Windows操作系统自身的缓存系统； Windows操作系统的缓存系统是基于全局进行缓存，即对所有数据进行缓存，而FancyCache可以根据用户需要，设置仅对某一特定分区进行缓存。在同等缓存容量下，后者将更具目标性，从而提高缓存命中率。 FancyCache可以识别系统未识别内存，将其利用作缓存； FancyCache可以将闪存盘或SSD固态硬盘用作缓存，提升普通硬盘的访问能力。
编辑本段软件截图
编辑本段支持的操作系统
Windows XP, Windows 2003, Windows Vista, Windows 2008, Windows 7, Windows 2008 R2
编辑本段FancyCache正进行Beta测试!
FancyCache Beta测试版本 0.7.2 已经发布。如果您有时间并愿参与我们的测试，我们表示非常感谢！ 测试版本有效期为3个月，可以从以下地址获取， 分区版（可对每个分区缓存）：最新版本为 (beta 版本 0.7.2) 包含 简体中文语言包 硬盘版（可对整个硬盘缓存）：最新版本为 (beta 版本 0.7.2) 包含 简体中文语言包 强烈建议您在非实际生产和工作环境中测试beta版本软件，以免造成不必要的损失，尽管当前版本已是比较稳定版本。同时Beta测试者请注意在测试之前对重要文件和数据先进行备份，以防万一。如遇系统无法启动等致命问题，用户可以尝试进入安全模式卸载软件。
㈦ 缓存的定义是什么
其实和电脑上缓存的概念是一样的 缓存它充当一个缓冲的作用,因为内存与CPU的速度是不一致的,内存比CPU慢上好多倍,在处理数据时,没有缓存,将会大大浪费CPU的资源,而缓存的速度接近于CPU,在处理数据的时候,系统将内存里的信息先存在缓存上,然后CPU从缓存内读取数据的速度就会很快,大大的提升了系统的性能 但时间长, 缓存是就会储存许多过去的信息而占用大量空间,所以需要你清理
㈧ Okhttp解析（五）缓存的处理
大家好，之前我们讲解了Okhttp网络数据请求相关的内容，这一节我们讲讲数据缓存的处理。本节按以下内容讲解Okhttp缓存相关的内容。
缓存的使用场景很多，通过它可以将数据通过一定的规则存储起来，再次请求数据的时候就可以快速从缓存中读取了，缓存有以下优势。
HTTP本身提供了一套缓存相关的机制。这套机制定义了相关的字段和规则，用来客户端和服务端进行缓存相关的协商，如响应的数据是否需要缓存，缓存有效期，缓存是否有效，服务器端给出指示，而客户端则根据服务端的指示做具体的缓存更新和读取缓存工作。http缓存可以分为两类：
强制缓存，在缓存数据未失效的情况下，可以直接使用缓存数据，有两个字段Expires和Cache-Control用于标明失效规则。
表示过期时间，由服务端返回。那么下次请求数据时，判断这个Expires过期时间是否已经过了，如果还没有到过期时间，则使用缓存，如果过了过期时间，则重新请求服务器的数据。Expires格式如下：
不过因为服务器和客户端的时间并不是同步的，用一个绝对时间作为过期的标记并不是很明智，所以HTTP1.1之后更多的是Cache-Control，它的控制更加灵活。
表示缓存的控制，有服务端返回。它有以下几个取值：
默认情况下是private，也就是不能共享的。Cache-Control格式如下：
对比缓存，表示需要和服务端进行相关信息的对比，由服务器决定是使用缓存还是最新内容，如果服务器判定使用缓存，返回响应吗304，判定使用最新内容，则返回响应码200和最新数据。对比缓存的判定字段有两组：
ETag表示资源的一种标识信息，用于标识某个资源，由服务端返回，优先级更高。格式如下：
然后客户端再次请求时，加入字段If-None-Match，格式如下：
服务端收到请求的该字段时（之前的Etag值），和资源的唯一标识进行对比，如果相同，说明没有改动，则返回状态码304，如果不同，说明资源被改过了，则返回状态码200和整个内容数据。
Last-Modified表示资源的最近修改时间，由服务端返回，优先级更低。格式如下：
Last-Modified
由服务器返回，表示响应的数据最近修改的时间。
If-Modified-Since
由客户端请求，表示询问服务器这个时间是不是上次修改的时间。如果服务端该资源的修改时间小于等于If-Modified-Since指定的时间，说明资源没有改动，返回响应状态码304，可以使用缓存。如果服务端该资源的修改时间大于If-Modified-Since指定的时间，说明资源又有改动了，则返回响应状态码200和最新数据给客户端，客户端使用响应返回的最新数据。
Last-Modified字段的值（服务端返回的资源上次修改时间），常常被用于客户端下次请求时的If-Modified-Since字段中。
HTTP的缓存规则是优先考虑强制缓存，然后考虑对比缓存。
Okhttp缓存相关的类有如下：
要开启使用Okhttp的缓存其实很简单，只需要给OkHttpClient对象设置一个Cache对象即可，创建一个Cache时指定缓存保存的目录和缓存最大的大小即可。
那么下面我们来看看Okhttp缓存执行的大概流程
Okhttp的缓存流程分为读取缓存和存储缓存两个过程，我们分别分析。
读取使用缓存的流程从HttpEngine的sendRequest发送请求开始。
接下来我们分析
从Cache的get方法开始。它按以下步骤进行。
如果存在缓存的话，在指定的缓存目录中，会有两个文件“****.0”和“****.1”，分别存储某个请求缓存的响应头和响应体信息。（“****”是url的md5加密值）对应的ENTRY_METADATA响应头和ENTRY_BODY响应体。缓存的读取其实是由DiskLruCache来读取的，DiskLruCache是支持Lru（最近最少访问）规则的用于磁盘存储的类，对应LruCache内存存储。它在存储的内容超过指定值之后，就会根据最近最少访问的规则，把最近最少访问的数据移除，以达到总大小不超过限制的目的。
接下来我们分析CacheStrategy缓存策略是怎么判定的。
直接看CacheStrategy的get方法。缓存策略是由请求和缓存响应共同决定的。
接来下我们看看CacheControl类里有些什么。
可以发现，它就是用于描述响应的缓存控制信息。
然后我们再看看Okhttp存储缓存是怎么进行的。
存储缓存的流程从HttpEngine的readResponse发送请求开始的。
可以看到这里先通过maybeCache写入了响应头信息，再通过cacheWritingResponse写入了响应体信息。我们再进去看Cache的put方法实现。
我们继续看Cache的writeTo方法，可以看到是写入一些响应头信息。
到这里Okhttp缓存的读取和存储流程我们就清楚了。可以说，缓存的使用策略基本都是按照HTTP的缓存定义来实现的，所以对HTTP缓存相关字段的理解是很重要的。然后关于DiskLruCache是如何管理缓存文件的，这个其实也很好理解，首先的原则就是按照LRU这种最近最少使用删除的原则，当总的大小超过限定大小后，删除最近最少使用的缓存文件，它的LRU算法是使用LinkedHashMap进行维护的，这样来保证，保留的缓存文件都是更常使用的。具体实现大家可以分析DiskLruCache和LinkedHashMap的实现原理。
㈨ hibernate缓存的详细配置
很多人对二级缓存都不太了解，或者是有错误的认识，我一直想写一篇文章介绍一下hibernate的二级缓存的，今天终于忍不住了。
我的经验主要来自hibernate2.1版本，基本原理和3.0、3.1是一样的，请原谅我的顽固不化。
hibernate的session提供了一级缓存，每个session，对同一个id进行两次load，不会发送两条sql给数据库，但是session关闭的时候，一级缓存就失效了。
二级缓存是SessionFactory级别的全局缓存，它底下可以使用不同的缓存类库，比如ehcache、oscache等，需要设置hibernate.cache.provider_class，我们这里用ehcache，在2.1中就是
hibernate.cache.provider_class=net.sf.hibernate.cache.EhCacheProvider
如果使用查询缓存，加上
hibernate.cache.use_query_cache=true
缓存可以简单的看成一个Map，通过key在缓存里面找value。
Class的缓存
对于一条记录，也就是一个PO来说，是根据ID来找的，缓存的key就是ID，value是POJO。无论list，load还是iterate，只要读出一个对象，都会填充缓存。但是list不会使用缓存，而iterate会先取数据库select id出来，然后一个id一个id的load，如果在缓存里面有，就从缓存取，没有的话就去数据库load。假设是读写缓存，需要设置：
<cache usage="read-write"/>
如果你使用的二级缓存实现是ehcache的话，需要配置ehcache.xml
<cache name="com.xxx.pojo.Foo" maxElementsInMemory="500" eternal="false" timeToLiveSeconds="7200" timeToIdleSeconds="3600" overflowToDisk="true" />
其中eternal表示缓存是不是永远不超时，timeToLiveSeconds是缓存中每个元素（这里也就是一个POJO）的超时时间，如果eternal="false"，超过指定的时间，这个元素就被移走了。timeToIdleSeconds是发呆时间，是可选的。当往缓存里面put的元素超过500个时，如果overflowToDisk="true"，就会把缓存中的部分数据保存在硬盘上的临时文件里面。
每个需要缓存的class都要这样配置。如果你没有配置，hibernate会在启动的时候警告你，然后使用defaultCache的配置，这样多个class会共享一个配置。
当某个ID通过hibernate修改时，hibernate会知道，于是移除缓存。
这样大家可能会想，同样的查询条件，第一次先list，第二次再iterate，就可以使用到缓存了。实际上这是很难的，因为你无法判断什么时候是第一次，而且每次查询的条件通常是不一样的，假如数据库里面有100条记录，id从1到100，第一次list的时候出了前50个id，第二次iterate的时候却查询到30至70号id，那么30-50是从缓存里面取的，51到70是从数据库取的，共发送1+20条sql。所以我一直认为iterate没有什么用，总是会有1+N的问题。
（题外话：有说法说大型查询用list会把整个结果集装入内存，很慢，而iterate只select id比较好，但是大型查询总是要分页查的，谁也不会真的把整个结果集装进来，假如一页20条的话，iterate共需要执行21条语句，list虽然选择若干字段，比iterate第一条select id语句慢一些，但只有一条语句，不装入整个结果集hibernate还会根据数据库方言做优化，比如使用mysql的limit，整体看来应该还是list快。）
如果想要对list或者iterate查询的结果缓存，就要用到查询缓存了
查询缓存
首先需要配置hibernate.cache.use_query_cache=true
如果用ehcache，配置ehcache.xml，注意hibernate3.0以后不是net.sf的包名了
<cache name="net.sf.hibernate.cache.StandardQueryCache"
maxElementsInMemory="50" eternal="false" timeToIdleSeconds="3600"
timeToLiveSeconds="7200" overflowToDisk="true"/>
<cache name="net.sf.hibernate.cache.UpdateTimestampsCache"
maxElementsInMemory="5000" eternal="true" overflowToDisk="true"/>
然后
query.setCacheable(true);//激活查询缓存
query.setCacheRegion("myCacheRegion");//指定要使用的cacheRegion，可选
第二行指定要使用的cacheRegion是myCacheRegion，即你可以给每个查询缓存做一个单独的配置，使用setCacheRegion来做这个指定，需要在ehcache.xml里面配置它：
<cache name="myCacheRegion" maxElementsInMemory="10" eternal="false" timeToIdleSeconds="3600" timeToLiveSeconds="7200" overflowToDisk="true" />
如果省略第二行，不设置cacheRegion的话，那么会使用上面提到的标准查询缓存的配置，也就是net.sf.hibernate.cache.StandardQueryCache
对于查询缓存来说，缓存的key是根据hql生成的sql，再加上参数，分页等信息（可以通过日志输出看到，不过它的输出不是很可读，最好改一下它的代码）。
比如hql：
from Cat c where c.name like ?
生成大致如下的sql：
select * from cat c where c.name like ?
参数是"tiger%"，那么查询缓存的key*大约*是这样的字符串（我是凭记忆写的，并不精确，不过看了也该明白了）：
select * from cat c where c.name like ? , parameter:tiger%
这样，保证了同样的查询、同样的参数等条件下具有一样的key。
现在说说缓存的value，如果是list方式的话，value在这里并不是整个结果集，而是查询出来的这一串ID。也就是说，不管是list方法还是iterate方法，第一次查询的时候，它们的查询方式很它们平时的方式是一样的，list执行一条sql，iterate执行1+N条，多出来的行为是它们填充了缓存。但是到同样条件第二次查询的时候，就都和iterate的行为一样了，根据缓存的key去缓存里面查到了value，value是一串id，然后在到class的缓存里面去一个一个的load出来。这样做是为了节约内存。
可以看出来，查询缓存需要打开相关类的class缓存。list和iterate方法第一次执行的时候，都是既填充查询缓存又填充class缓存的。
这里还有一个很容易被忽视的重要问题，即打开查询缓存以后，即使是list方法也可能遇到1+N的问题！相同条件第一次list的时候，因为查询缓存中找不到，不管class缓存是否存在数据，总是发送一条sql语句到数据库获取全部数据，然后填充查询缓存和class缓存。但是第二次执行的时候，问题就来了，如果你的class缓存的超时时间比较短，现在class缓存都超时了，但是查询缓存还在，那么list方法在获取id串以后，将会一个一个去数据库load！因此，class缓存的超时时间一定不能短于查询缓存设置的超时时间！如果还设置了发呆时间的话，保证class缓存的发呆时间也大于查询的缓存的生存时间。这里还有其他情况，比如class缓存被程序强制evict了，这种情况就请自己注意了。
另外，如果hql查询包含select字句，那么查询缓存里面的value就是整个结果集了。
当hibernate更新数据库的时候，它怎么知道更新哪些查询缓存呢？
hibernate在一个地方维护每个表的最后更新时间，其实也就是放在上面net.sf.hibernate.cache.UpdateTimestampsCache所指定的缓存配置里面。
当通过hibernate更新的时候，hibernate会知道这次更新影响了哪些表。然后它更新这些表的最后更新时间。每个缓存都有一个生成时间和这个缓存所查询的表，当hibernate查询一个缓存是否存在的时候，如果缓存存在，它还要取出缓存的生成时间和这个缓存所查询的表，然后去查找这些表的最后更新时间，如果有一个表在生成时间后更新过了，那么这个缓存是无效的。
可以看出，只要更新过一个表，那么凡是涉及到这个表的查询缓存就失效了，因此查询缓存的命中率可能会比较低。
Collection缓存
需要在hbm的collection里面设置
<cache usage="read-write"/>
假如class是Cat，collection叫children，那么ehcache里面配置
<cache name="com.xxx.pojo.Cat.children"
maxElementsInMemory="20" eternal="false" timeToIdleSeconds="3600" timeToLiveSeconds="7200"
overflowToDisk="true" />
Collection的缓存和前面查询缓存的list一样，也是只保持一串id，但它不会因为这个表更新过就失效，一个collection缓存仅在这个collection里面的元素有增删时才失效。
这样有一个问题，如果你的collection是根据某个字段排序的，当其中一个元素更新了该字段时，导致顺序改变时，collection缓存里面的顺序没有做更新。
缓存策略
只读缓存（read-only）：没有什么好说的
读/写缓存（read-write）:程序可能要的更新数据
不严格的读/写缓存（nonstrict-read-write）：需要更新数据，但是两个事务更新同一条记录的可能性很小，性能比读写缓存好
事务缓存（transactional）：缓存支持事务，发生异常的时候，缓存也能够回滚，只支持jta环境，这个我没有怎么研究过
读写缓存和不严格读写缓存在实现上的区别在于，读写缓存更新缓存的时候会把缓存里面的数据换成一个锁，其他事务如果去取相应的缓存数据，发现被锁住了，然后就直接取数据库查询。
在hibernate2.1的ehcache实现中，如果锁住部分缓存的事务发生了异常，那么缓存会一直被锁住，直到60秒后超时。
不严格读写缓存不锁定缓存中的数据。
使用二级缓存的前置条件
你的hibernate程序对数据库有独占的写访问权，其他的进程更新了数据库，hibernate是不可能知道的。你操作数据库必需直接通过hibernate，如果你调用存储过程，或者自己使用jdbc更新数据库，hibernate也是不知道的。hibernate3.0的大批量更新和删除是不更新二级缓存的，但是据说3.1已经解决了这个问题。
这个限制相当的棘手，有时候hibernate做批量更新、删除很慢，但是你却不能自己写jdbc来优化，很郁闷吧。
SessionFactory也提供了移除缓存的方法，你一定要自己写一些JDBC的话，可以调用这些方法移除缓存，这些方法是：
void evict(Class persistentClass)
Evict all entries from the second-level cache.
void evict(Class persistentClass, Serializable id)
Evict an entry from the second-level cache.
void evictCollection(String roleName)
Evict all entries from the second-level cache.
void evictCollection(String roleName, Serializable id)
Evict an entry from the second-level cache.
void evictQueries()
Evict any query result sets cached in the default query cache region.
void evictQueries(String cacheRegion)
Evict any query result sets cached in the named query cache region.
不过我不建议这样做，因为这样很难维护。比如你现在用JDBC批量更新了某个表，有3个查询缓存会用到这个表，用evictQueries(String cacheRegion)移除了3个查询缓存，然后用evict(Class persistentClass)移除了class缓存，看上去好像完整了。不过哪天你添加了一个相关查询缓存，可能会忘记更新这里的移除代码。如果你的jdbc代码到处都是，在你添加一个查询缓存的时候，还知道其他什么地方也要做相应的改动吗？
----------------------------------------------------
总结：
不要想当然的以为缓存一定能提高性能，仅仅在你能够驾驭它并且条件合适的情况下才是这样的。hibernate的二级缓存限制还是比较多的，不方便用jdbc可能会大大的降低更新性能。在不了解原理的情况下乱用，可能会有1+N的问题。不当的使用还可能导致读出脏数据。
如果受不了hibernate的诸多限制，那么还是自己在应用程序的层面上做缓存吧。
在越高的层面上做缓存，效果就会越好。就好像尽管磁盘有缓存，数据库还是要实现自己的缓存，尽管数据库有缓存，咱们的应用程序还是要做缓存。因为底层的缓存它并不知道高层要用这些数据干什么，只能做的比较通用，而高层可以有针对性的实现缓存，所以在更高的级别上做缓存，效果也要好些吧。
㈩ thinkphp 静态缓存的设置方法，怎么设置thinkphp静态页
thinkphp默认是自动开启模版缓存的。你可以在入口文件里面把：
define
(
'runtime_path',
'./runtime/'
);这行代码注释掉