Hibernate和 OsCache的使用

下载地址:[url]http://java.net/downloads/oscache/[/url]

oscache这个jar里面的jms架包已经无法下载了。
那么我就在网上自己下载了一个jms.jar安装到本地的仓库中去，就ok了。
进入安装maven的目录bin中，执行如下命令：
[i][color=blue]mvn install:install-file -Dfile=jms-1.1.jar -DgroupId=javax.jms -DartifactId=jms -Dversion=1.1 -Dpackaging=jar[/color][/i]
其中最重要的参数是：-Dfile=jar包放的目录
-DgroupId ，-DartifactId ，-Dversion ，-Dpackaging这几个参数.

然后就可以使用:

		<dependency>
			<groupId>javax.jms</groupId>
			<artifactId>jms</artifactId>
			<version>1.1</version>
		</dependency>
		<dependency>
			<groupId>opensymphony</groupId>
			<artifactId>oscache</artifactId>
			<version>${oscache.version}</version>
		</dependency>

[color=red][b]hibernate使用OSCache[/b][/color][url]http://www.verydemo.com/demo_c146_i3116.html[/url]
拷oscache-2.4.1.jar到WEB-INF/lib下面，添加oscache.properties文件到classes，oscache.properties文件配置可以参考oscache-2.4.1-full.zip包里面的oscache.properties文件.

1、hibernate使用OSCache。

在spring配置文件，session bean的hibernateProperties属性添加：

<prop key="hibernate.current_session_context_class">thread</prop> 
    <prop key="hibernate.cache.use_query_cache">true</prop> 
                <prop key="hibernate.cache.use_second_level_cache">true</prop> 
                <prop key="hibernate.cache.provider_class">com.opensymphony.oscache.hibernate.OSCacheProvider</prop> 
                <prop key="hibernate.jdbc.batch_size">25</prop> 

在*.hbm.xml文件中添加<cache usage="read-only"/>

2、ibatis中使用OSCache

在sql-map-config.xml文件<sqlMapConfig>树下配置

<settings cacheModelsEnabled="true" lazyLoadingEnabled="true" enhancementEnabled="true" errorTracingEnabled="true"/> 

在xml映射文件中添加：

<cacheModel id="userCache" type="OSCACHE"> 
  <!-- 24小时强制清空缓冲区的所有内容 --> 
  <flushInterval hours="24"/> 
  <!-- 指定执行特定的statement时，将缓存清空 --> 
  <flushOnExecute statement="update_user" /> 
   <!-- cache的最大容积 -->  
  <property name="size" value="1000" /> 
</cacheModel>

statement语句中指定要使用的缓存：

<select id="findUserByDept" parameterClass="java.util.HashMap" resultClass="java.util.HashMap" cacheModel="userCache">

[b][color=red]OSCache - 在Hibernate中应用[/color][/b]
OSCache - 在Hibernate中使用
创建一个Java工程OSCacheTest，在其中引入Hibernate 3.2的类库文件。因为需要使用OSCache，还需要引入oscache-2.1.jar包。
一般使用OSCache缓存需要进行三个步骤的配置，具体如下：
[color=red][b]步骤一：在Hibernate中配置OSCache[/b][/color]
1. 在Hibernate配置文件中打开二级缓存的配置，如下：
<property name="cache.use_second_level_cache">true</property>
2. 这个值在配置文件中，缺省是打开的。这只是打开二级缓存，并没有指定使用哪个二级缓存。所以需要指定使用的何种二级缓存。配置如下：
<property name="cache.provider_class">org.hibernate.cache.OSCacheProvider</property>
特别注意：关于二级缓存的配置，必须在<mapping resource="…………" />配置之前，否则报错

[color=red][b]步骤二：配置OSCache配置文件[/b][/color]
关于缓存中存放多少数据，Hibernate是不关心的，全部由OSCache来完成。需要将OSCache的配置文件oscache.properties放入classpath中（注意不能修改这个文件名），对二级缓存进行具体配置。
在oscache.properties中，有如下的参数配置：cache.capacity=1000
这个数值代表放入缓存的对象数量，这个数量根据用户机器的内存来配置，一般只需要配置这个参数即可。

[color=red][b]步骤三：通知Hibernate那些类需要OSCache进行缓存[/b][/color]
这个步骤有两种方式可以使用，其作用相同：
第1种：在hibernate.cfg.xml的session-factory中加入：

<class-cache usage="read-only" class="com.mixele.oscache.entity.UserOS"/>

第2种：在映射文件的class元素加入子元素：

<class-cache usage="read-only" />

关于usage属性，有4个值可以配置：
[color=blue]read-only：[/color]只读，缓存效率最高，用于不更新的数据
[color=blue]read-write：[/color]可读写
[color=blue]nonstrict-read-write：[/color]用于不重视并发修改的操作（会出现一定的错误数据，即不同步数据）
[color=blue]transactional：[/color]事务缓存，可支持事务回滚（OSCache中没有此项功能）

经过以上配置，OSCache缓存就已经生效。
编写测试程序：
Hibernate配置：

<hibernate-configuration>
    <session-factory>
    	<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="connection.url">jdbc:mysql://localhost:3306/cachetest</property>
		<property name="connection.username">root</property>
		<property name="connection.password">root</property>
		<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
		<property name="show_sql">true</property>
		<property name="hbm2ddl.auto">create</property>

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

		<property name="generate_statistics">true</property>
		<mapping resource="com/mixele/oscache/entity/UserOS.hbm.xml" />
    </session-factory>
</hibernate-configuration>

POJO类及hbm：

public class UserOS {
	private int id;
	private String name;
	private Date birthday;
	………………
}

<hibernate-mapping package="com.mixele.oscache.entity">
	<class name="UserOS">
        <cache usage="read-only"/>
		<id name="id"> <generator class="native"/> </id>
		<property name="name" length="100"/>
		<property name="birthday"/>
	</class>
</hibernate-mapping>

缓存测试类：

public class CacheTest{
	public static void main(String [] args) {
		int num = 1;
		DataPutInDB.saveData(num);
		for(int i=0;i<num;i++) {
			getOSCacheCache(i+1);
		}
		Statistics st = HibernateUtil.getSessionfactory().getStatistics();
		System.out.println("输出统计信息............");
		System.out.println(st);
		System.out.println("放入: "+st.getSecondLevelCachePutCount()+"次");
		System.out.println("命中: "+st.getSecondLevelCacheHitCount()+"次");
		System.out.println("失去: "+st.getSecondLevelCacheMissCount()+"次");
	}

	static UserOS getOSCacheCache(int id) {
		Session s = null;
		UserOS useros = null;
		try{
			s = HibernateUtil.getSession();
			useros = (UserOS)s.get(UserOS.class, id);//第一次查询，二级缓存中没有信息，miss一次
			useros = (UserOS)s.load(UserOS.class, id);//第二次查询，在一级缓存中找到，不进入二级缓存
			s.clear();//清空一级缓存
		}finally{
			if(s != null){ 
				s.close();
			}
		}
		for(int i=1;i<101;i++){
			try{
				s = HibernateUtil.getSession();
				useros = (UserOS)s.get(UserOS.class, id);//在二级缓存中找到，hit两次
				System.out.println("第"+i+"次从二级缓存查找   "+useros.getClass());
			}finally{
				if(s != null){ s.close(); }
			}
		}
		return useros;
	}
}

[color=red][b]OSCache----Hibernate和 OsCache的使用[/b][/color][url]http://blog.csdn.net/joliny/article/details/2090692[/url]
OSCache标记库由OpenSymphony设计，它是一种开创性的JSP定制标记应用，提供了在现有
JSP页面之内实现快速内存缓冲的功能。OSCache是个一个广泛采用的高性能的J2EE缓存框架,
OSCache能用于任何Java应用程序的普通的 缓存解决方案。OSCache有以下特点：缓存任何对象,
你可以不受限制的缓存部分jsp页面或HTTP请求，任何java对象都可以缓存。 拥有全面的
API--OSCache API给你全面的程序来控制所有的OSCache特性。 永久缓存--缓存能随意的写入硬盘,
因此允许昂贵的创建（expensive-to-create）数据来保持缓存，甚至能让应用重启。 支持集群--
集群缓存数据能被单个的进行参数配置，不需要修改代码。 缓存记录的过期--你可以有最大限度的
控制缓存对象的过期，包括可插入式的刷新策略（如果默认性能不需要时）。
OSCache是当前运用最广的缓存方案，JBoss,Hibernate,Spring等都对其有支持，
下面简单介绍一下OSCache的配置和使用过程。

1.安装过程
从http://www.opensymphony.com/oscache/download.html下载合适的OSCache版本，
我下载的是oscache-2.0.2-full版本。
解压缩下载的文件到指定目录
从解压缩目录取得oscache.jar 文件放到 /WEB-INF/lib 或相应类库目录 目录中，
jar文件名可能含有版本号和该版本的发布日期信息等，如oscache-2.0.2-22Jan04.jar如果你的jdk版本为1.3.x,
建议在lib中加入Apache Common Lib 的commons-collections.jar包。
如jdk是1.4以上则不必
从src或etc目录取得oscache.properties 文件，放入src根目录或发布环境的/WEB-INF/classes 目录
如你需要建立磁盘缓存，须修改oscache.properties 中的cache.path信息 (去掉前面的#注释)。
win类路径类似为c://app//cache
unix类路径类似为/opt/myapp/cache
拷贝OSCache标签库文件oscache.tld到/WEB-INF/classes目录。

现在你的应用目录类似如下：
[i]$WEB_APPLICATION/WEB-INF/lib/oscache.jar
$WEB_APPLICATION/WEB-INF/classes/oscache.properties
$WEB_APPLICATION/WEB-INF/classes/oscache.tld[/i]

将下列代码加入web.xml文件中

<taglib>
<taglib-uri>oscache</taglib-uri>
<taglib-location>/WEB-INF/classes/oscache.tld</taglib-location>
</taglib>

2.为了便于调试日志输出，须加入commons-logging.jar和log4j-1.2.8.jar到当前类库路径中

在src目录加入下面两个日志输出配置文件：
log4j.properties 文件内容为：
[i]log4j.rootLogger=DEBUG,stdout,file
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=[start]%d{yyyy/MM/dd/ HH:mm:ss}[DATE]%n%p
[PRIORITY]%n%x[NDC]%n%t[THREAD] n%c[CATEGORY]%n%m[MESSAGE]%n%n
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.File=oscache.log
log4j.appender.file.MaxFileSize=100KB
log4j.appender.file.MaxBackupIndex=5
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[start]%d{yyyy/MM/dd/ HH:mm:ss}[DATE]%n%p[PRIORITY]
%n%x[NDC]%n%t[THREAD] n%c[CATEGORY]%n%m[MESSAGE]%n%n
log4j.logger.org.apache.commons=ERROR
log4j.logger.com.opensymphony.oscache.base=INFO
commons-logging.properties 文件内容为
org.apache.commons.logging.Log=org.apache.commons.logging.impl.Log4JCategoryLog[/i]


3.hibernate-session配置

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="mappingResources">
            <list>
                <value>com/ouou/album/model/Albums.hbm.xml</value>
            </list>
        </property>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                <prop key="hibernate.current_session_context_class">thread</prop>
                <prop key="hibernate.cglib.use_reflection_optimizer">false</prop>
                <!--<prop key="hibernate.query.substitutions">true 'Y', false 'N'</prop>-->
                <prop key="hibernate.query.substitutions">true 1, false 0</prop>
                <prop key="hibernate.cache.use_query_cache">true</prop>
                <prop key="hibernate.cache.use_second_level_cache">true</prop>                                              <prop key="hibernate.cache.provider_class">com.opensymphony.oscache.hibernate.OSCacheProvider
                 </prop>
                <prop key="hibernate.show_sql">true</prop>
                <!--<prop key="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</prop> -->
                <prop key="hibernate.jdbc.batch_size">25</prop>
            </props>
        </property>
    </bean>

4.oscache.properties 文件配置向导
[b]cache.memory[/b]
值为true 或 false ，默认为在内存中作缓存，
如设置为false，那cache只能缓存到数据库或硬盘中，那cache还有什么意义：）
[b]cache.persistence.class[/b]
持久化缓存类，如此类打开，则必须设置cache.path信息
[b]cache.capacity[/b]
缓存元素个数
[b]cache.cluster 相关[/b]
为集群设置信息。
如
[b]cache.cluster.multicast.ip[/b]为广播IP地址
[b]cache.cluster.properties[/b]为集群属性

配置例子:
[b]cache.memory=true
cache.key=__oscache_cache
cache.path=/data/oscache
cache.capacity=100000
cache.unlimited.disk=true[/b]

5.OSCache的基本用法

cache1.jsp 内容如下

<%@ page import="java.util.*" %>
<%@ taglib uri="oscache" prefix="cache" %>
<html>
<body>
没有缓存的日期: <%= new Date() %><p>
<!--自动刷新-->
<cache:cache time="30">
每30秒刷新缓存一次的日期: <%= new Date() %>
</cache:cache>
<!--手动刷新-->
<cache:cache key="testcache">
手动刷新缓存的日期: <%= new Date() %> <p>
</cache:cache>
<a href="cache2.jsp">手动刷新</a>
</body>
</html>

cache2.jsp 执行手动刷新页面如下

<%@ taglib uri="oscache" prefix="cache" %>
<html>
<body>
缓存已刷新...<p>
<cache:flush key="testcache" scope="application"/>
<a href="cache1.jsp">返回</a>
</body>
</html>

你也可以通过下面语句定义Cache的有效范围,如不定义scope,scope默认为Applcation

<cache:cache time="30" scope="session">
...
</cache:cache>

6. 缓存过滤器 CacheFilter
你可以在web.xml中定义缓存过滤器，定义特定资源的缓存。

<filter>
<filter-name>CacheFilter</filter-name>
<filter-class>com.opensymphony.oscache.web.filter.CacheFilter</filter-class>
<init-param>
<param-name>time</param-name>
<param-value>60</param-value>
</init-param>
<init-param>
<param-name>scope</param-name>
<param-value>session</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>CacheFilter</filter-name>
<url-pattern>*.jsp</url-pattern>
</filter-mapping> 

上面定义将缓存所有.jsp页面，缓存刷新时间为60秒，缓存作用域为Session
注意，CacheFilter只捕获Http头为200的页面请求，即只对无错误请求作缓存，
而不对其他请求（如500,404,400）作缓存处理

7.关于oscache的几个基础方法:

public abstract class BaseManager<T extends BaseObject> implements Manager<T> {

    private static Log logger = LogFactory.getLog(BaseManager.class);

    private Cache oscache;
    public Cache getOscache() {
        return oscache;
    }
    public void setOscache(Cache oscache) {
        this.oscache = oscache;
    }
    protected final String createCachekey(Object keyParams[]) {
        if (keyParams == null) {
            return "";
        }

        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < (keyParams.length - 1); i++) {
            sb.append(keyParams[i].toString()).append("':'");
        }

        return sb.append(keyParams[keyParams.length - 1]).toString();
    }

    public Object getCacheValue(String key) {
        return getCacheValue(key, null);
    }

    public Object getCacheValue(String key, Object obj) {
        Object new_obj = null;

        try {
            new_obj = oscache.getFromCache(key);
        } catch (NeedsRefreshException nre) {
            oscache.cancelUpdate(key);

            if (logger.isWarnEnabled()) {
                logger.warn("Failed to get from Cache");
            }
        }

        return (new_obj != null) ? new_obj : obj;
    }

    public void setCache(String key, Object serial) {
        setCache(key, serial, default_cache_time_second);
    }

    public void setCache(String key, Object serial, int cache_time) {
        if (oscache != null) {
            oscache.putInCache(key, serial, new ExpiresRefreshPolicy(cache_time));
        }
    }

    public void delCache(String key) {
        if (oscache != null) {
            oscache.removeEntry(key);
        }
    }

    public void flushCache(String key) {
        if (oscache != null) {
            oscache.flushEntry(key);
        }
    }
 }