Memcache/Redis/Oscache/Ehcache缓存技术比较

最新推荐文章于 2021-09-11 10:01:07 发布

chunsuo2480

最新推荐文章于 2021-09-11 10:01:07 发布

阅读量609

点赞数

文章标签：数据库 memcached 运维

原文链接：https://my.oschina.net/u/3581789/blog/1502979

版权

Memcache/Redis/Oscache/Ehcache

标签（空格分隔）： Redis

[TOC] ###一、四大缓存的基本介绍 ####1、memcached

1).什么是memcached 自由开源，高性能，分布式内存对象缓存系统，Memcache是一个内存中键值对的储存，为了解决大型数据的高速缓存而诞生 2).占用其他电脑的内存，在实现负载均衡时，可以让多台计算机共享一个memcache上的缓存消息传递信息已键值对的形式储存，传递数据时要实现序列化 3).多线程的支持，默认是单线程的操作 4).通过内存中缓存数据和对象来减少对数据库的fa访问次数 5).memcached 和 redis：memcache都不支持持久化，redis支持持久化

####2、Ehcache

1).快 2).简单：被运用在了hibernate上 3).袖珍：2M不到 4).轻量：核心程序只需依赖一个slf4g一个jar包 5).好扩展 6).监听器：缓存管理监听器/缓存监听器

####3、Oscache

1).页面级缓存，占用本机的内存资源，存储方式分为内存和磁盘，如果存储到磁盘即便你重启也可以拿到上次持久化到本地的数据，如果存储到内存的话就不行 2).Oscache作用域：application/Session 3).支持集群 4).可以缓存任何对象，不受限制的换成一部分或者全部jsp页面或http请求 5).永久缓存，能够随意写入硬盘

####4、Redis

1).拥有丰富的数据类型(set/String/Hash/List/SortedSet) 2).支持持久化，持久化的类型分为2种RDB/AOF 3).高性能，内存操作毫秒级 4).replication(主从)

###二、Oscache代码实现 java bean

package com.shsxt.model;

import java.io.Serializable;

public class User implements Serializable {
	
	private String id;
	private String name;
	private Integer age;
	private String sex;
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", age=" + age + ", sex=" + sex + "]";
	}
	
	

}

BeanCache

package com.shsxt.cache;

import java.util.Date;

import com.opensymphony.oscache.base.NeedsRefreshException;
import com.opensymphony.oscache.general.GeneralCacheAdministrator;

public class BaseCache extends GeneralCacheAdministrator {     

	private static final long serialVersionUID = -4397192926052141162L;
	private String keyPrefix; //关键字前缀字符，区别属于哪个模块
	private int refreshPeriod; //过期时间(单位为秒);         

    public BaseCache(String keyPrefix,int refreshPeriod){    
        super();    
        this.keyPrefix = keyPrefix;    
        this.refreshPeriod = refreshPeriod;    

    }    

    /**
     *     
     * put(添加被缓存的对象)
     * @param key
     * @param value 
     * @return void
     * @createDate 2013-1-31 下午04:16:46
     * @since  1.0.0
     */
    public void put(String key,Object value){    
        this.putInCache(this.keyPrefix+"_"+key,value);    
    }    

    /**
     * remove(删除被缓存的对象)
     * @param key 
     * @return void
     * @createDate 2013-1-31 下午04:17:06
     * @since  1.0.0
     */
    public void remove(String key){    
        this.flushEntry(this.keyPrefix+"_"+key);    
    }    

    /**
     * removeAll(删除指定日期所有被缓存的对象)
     * @param date 
     * @return void
     * @createDate 2013-1-31 下午04:17:29
     * @since  1.0.0
     */
    public void removeAll(Date date){    
        this.flushAll(date);    
    }           

    /**
     * removeAll(删除所有被缓存的对象) 
     * @return void
     * @createDate 2013-1-31 下午04:18:01
     * @since  1.0.0
     */
    public void removeAll(){    
        this.flushAll();    
    }    

    /**
     * get(获取被缓存的对象)
     * @param key
     * @return
     * @throws Exception 
     * @return Object
     * @createDate 2013-1-31 下午04:18:45
     * @since  1.0.0
     */
    public Object get(String key) throws Exception{    
        try{    
            return this.getFromCache(this.keyPrefix+"_"+key,this.refreshPeriod);    
        } catch (NeedsRefreshException e) {    
            this.cancelUpdate(this.keyPrefix+"_"+key);    
            e.printStackTrace();
            throw e;
        }      
    }  
    
 
}

Test

package com.shsxt.service;

import java.util.Date;

import com.shsxt.cache.BaseCache;
import com.shsxt.model.User;

public class CacheManager {
	private BaseCache baseCache;
    private static CacheManager instance;      
    private static Object lock = new Object();
    
    private CacheManager() {   
        //这个根据配置文件来，初始BaseCache      
     baseCache = new BaseCache("CacheManager",120);           
    }
    
    public static CacheManager getInstance(){
    	if(instance==null){
    		synchronized (lock) {
    			if(instance==null){
    				instance=new CacheManager();
    			}
			}
    	}
    	return instance;
    }
    
    /**
     * <pre>putUser(将对象存入缓存中)   
     * @param 对象 </pre>
     */
    public void putObj(String id,Object obj) {
     baseCache.put(id,obj);     
    }         
    /**
     * <pre>removeUser(根据id 缓存中的对象移除)   
     * @param id</pre>
     */
    public void removeObj(String id) {
     baseCache.remove(id);       
    }    
    /**
     * <pre>removeAllUser(删除缓存中所有的对象)   
     */
    public void removeAllObj(){
     baseCache.removeAll();
    }
    /**
     * <pre>removeAllUser(根据时间清除 缓存中所有的对象)   
     */
 
    public void removeAllObj(Date date){
     baseCache.removeAll(date);
    }
    /**
     * <pre>getUser(根据id 从缓存中提取对应的对象)   
     * @param  id
     * @return 对象 </pre>
     */
    public Object getObj(String id,Object obj) {      
        try {      
            return baseCache.get(id);
        } catch (Exception e) {      
         System.out.println("get>>id["+id+"]>>"+e.getMessage());      
            User user = new User();      
            this.putObj(id, obj);      
            return user;    
        }      
    }  
    public static void main(String[] args) {
    	//将对象存入缓存中
    	CacheManager instance = CacheManager.getInstance();
    	//实例化一个用户对象
    	User user =new User();
    	user.setId("0202");
    	user.setName("莉莉");
    	user.setSex("男");
    	user.setAge(15);
    	// 添加 缓存的对象
    	instance.putObj(user.getId(), user);
    	//从缓存中删除所有的用户对象
    	//instance.removeAllObj();
    	//从缓存中删除用户id 为001 的用户
    	//instance.removeObj(user.getId());
    	//在**时间从缓存中清除对象
    	//instance.removeAllObj(new Date());
    	//根据id 从缓存中取得用户数据
    	User userInfo = (User) instance.getObj(user.getId(), user);
    	System.out.println("User id is  "+userInfo.getId());
    	System.out.println("User name is  "+userInfo.getName());
    	System.out.println("User sex is  "+userInfo.getSex());
    	System.out.println("User age is  "+userInfo.getAge()); 
    	}
}

oscache.properties

1.cache.capacity=1000 缓存容量的大小 2.cache.memory=true 是否用内存缓存，默认是true 3.cache.persistence.class=com.opensymphony.oscache.plugins.diskpersistence.DiskPersistenceListener 如果要写入磁盘，这个必须配置否则采用内存存储 4.cache.path=D:\oscache 硬盘存储的位置 5.cache.unlimited.disk=false 是否限定硬盘缓存大小

###三、Oscache页面缓存 web.xml配置

<listener>
        <listener-class>com.opensymphony.oscache.web.CacheContextListener</listener-class>
    </listener>
    <session-config>
        <session-timeout>3600</session-timeout>
    </session-config>
 <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>10</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>

项目引入标签库的三种方式

1.直接在JSP页面引入如下语句
<%@ taglib uri="http://www.opensymphony.com/oscache" prefix="cache" %>

2.在jsp引入如下语句也可以
<%@ taglib uri="/WEB-INF/classes/oscache.tld" prefix="cache"%>

3.配置web.xml
    <jsp-config>
     <taglib>
       <taglib-uri>
        oscache
       </taglib-uri>
       <taglib-location>
         /WEB-INF/classes/oscache.tld
       </taglib-location>
     </taglib>
  </jsp-config>
  
  jsp页面
  <%@ taglib uri="oscache" prefix="cache"%>

####页面的小demo ####jsp页面标签介绍

cache：用来缓存某一个具体的内容，请保证这个key的唯一，同时可以指定超时的时间 usecached：一种保险策略，当前缓存出错时可以采用系统老版本的旧缓存，这个标签必须存在cache内 flush:强制情况缓存，缓存的应用范围有3个 application、session、null 当设置为null时会清空所有缓存，否则只清楚指定的缓存
####cache属性介绍 1）key ：这个缓存的键，需要唯一标识 2）scope：应用范围，application、session、null 3）time：缓存有效时间，默认3600秒 4）duration：缓存有效期时间，这个时间可以采用简单的格式 5）cron：通过cron表达式设置缓存时间，这个可以参考文档 6）refresh：如果为true，则缓存内容得到刷新，也就是从新缓存内容 7）groups：为缓存指定一个分组，便于统一管理

以上配置就可以实现页面

###三、注意的问题要缓存的对象必须实现Serializable接口，否则会发生无法写入硬盘的错误

###四、Memcached代码实现 ####1).安装windows64位版Memcached

网址：http://download.csdn.net/download/hitoha/8199575 解压：解压在指定的目录(你随意你能找得到就行) 安装：在当前解压的目录打开命令窗口(shift+右键) ：执行memcached.exe -d install(没有意外你已经成功了！) 测试：memcached -d 如果有命令东西出来证明成功(不是错误提示就成) 启动：memcached.exe -d start(打开任务管理器查看进程如果有memcached.exe证明启动成功) 连接：telnet 127.0.0.1 11211(默认端口)

注意：win7中可能会出现“telnet’不是内部或外部命令”的错误，这是因为系统中默认没有安装telnet的缘故，可在“控制面板”->“程序”->“程序和功能”->“打开或关闭Windows功能”中打开“Telnet客户端”。

####2).关于Memcached端口的修改

1).因为Memcached是注册成服务从window启动所有命令都是服务中带的必须修改imagePath的值 2).你可能看到的是这样一串东西："C:\Users\TangZhiMing\Downloads\memcached\memcached.exe" -d runservice 3).不要修改的太多将-d前面加上 -p port(端口号) -m number(表示占用内存的最大数) 4).保存重启，命令中输入netstat -n -a 查看端口(如果看不懂我表示无能为力，因为也看不懂 -_-!)

####3).代码部分

1).下载jar包，引入jar包

package com.shsxt.cache;
import java.net.InetSocketAddress;
import java.util.concurrent.Future;

import net.spy.memcached.MemcachedClient;
public class MemcacheDemo {
	
	public static void main(String[] args) {
		
		try {
			//连接memcached客户端
			MemcachedClient mmc = new MemcachedClient(new InetSocketAddress("127.0.0.1",11211));
			System.out.println("连接成功！");
			
			//存储数据(900是过期时间)
			Future of = mmc.set("shsxt", 900, "900是什么？");
			//获取结果
			System.out.println(of.get());
			
			System.out.println(mmc.get("shsxt"));
			//关闭连接
			mmc.shutdown();
			
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	

}

####4).常用命令一、查找命令 get key:获取存储在key中的value，如果key不存在返回空 delete key [noreply]:删除一个已经存在的key noreply可选值，告诉系统需不需要返回数据 incr/decr:自增/自减二、存储命令 set:将指定的value放入指定key中(可以更新value) add：同上(不能更新一个已经存在的key)同时会发挥一个状态NOT_STORED replace：替换一个已经存在key的value值，如果key不存在替换失败 append：对于已经存在key的value值后面追加数据 prepend:对于一个已经存在key的value值前面追加数据

转载于:https://my.oschina.net/u/3581789/blog/1502979

chunsuo2480

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Memcache/Redis/Oscache/Ehcache缓存技术比较

Memcache/Redis/Oscache/Ehcache标签（空格分隔）： Redis[TOC]###一、四大缓存的基本介绍####1、memcached1).什么是memcached自由开源，高性能，分布式内存对象缓存系统，Memcache是一个内存中键值对的储存，为了解...
复制链接

扫一扫