java缓存技术memcached实例

怼烎@ 2022-08-08 16:56 147阅读 0赞

1 下载memcached-1.2.1-win32.zip  并且解压.

2 新建web project项目 名字自己取,然后导入必要的包,alisoft-xplatform-asf-cache-2.5.1.jar,commons-logging-1.0.3.jar,log4j-1.2.13.jar

3 新建类 user.java

package bean;

import java.io.Serializable;

public class User implements Serializable\{  
   
    /\*\*  
     \* 序列号  
     \*/  
    private static final long serialVersionUID = -3896605600471191953L;  
    private int uid;  
    private String uname;  
    private String upass;  
      
    public int getUid() \{  
       return uid;  
    \}  
    public void setUid(int uid) \{  
       this.uid = uid;  
    \}  
    public String getUname() \{  
       return uname;  
    \}  
    public void setUname(String uname) \{  
       this.uname = uname;  
    \}  
    public String getUpass() \{  
       return upass;  
    \}  
    public void setUpass(String upass) \{  
       this.upass = upass;  
    \}

4 新建 JdbcConnector.java

package util;

import java.sql.Connection;  
import java.sql.DriverManager;  
import java.sql.SQLException;

public class JdbcConnector \{  
  // 定义数据库连接常量  
    private final static String DRIVER = "com.mysql.jdbc.Driver";  
    private final static String URL = "jdbc:mysql://192.168.1.13:3306/test";  
    private final static String DBNAME = "root";  
    private final static String DBPASS = "123456";  
      
    /\*\*  
     \* 得到数据库连接  
     \* @return  
     \* @throws ClassNotFoundException  
     \* @throws SQLException  
     \*/  
    public Connection getConn()throws ClassNotFoundException,SQLException \{  
       // 加载驱动  
       Class.forName(DRIVER);  
       // 通过DriverManager对象得到连接  
       Connection conn = DriverManager.getConnection(URL,DBNAME,DBPASS);  
       // 返回数据库连接  
       return conn;  
    \}  
\}

5 新建 UserDao.java

package util;

import java.sql.SQLException;  
import java.util.ArrayList;  
import java.util.List;

import bean.User;

import com.mysql.jdbc.Connection;  
import com.mysql.jdbc.PreparedStatement;  
import com.mysql.jdbc.ResultSet;

public class UserDao extends JdbcConnector \{  
    // 定义全局变量  
    Connection conn = null;  
    PreparedStatement pstmt = null;  
    ResultSet rs = null;  
      
    /\*\*  
     \* 根据Id查询用户  
     \* @param uid  
     \* @return  
     \*/  
    public User getUserById(int uid) \{  
       // 创建User对象  
       User user = null;  
       // 创建SQL语句  
       String sql = "select \* from user where uid=?";  
         
       try \{  
           // 获得数据库连接  
           conn = (Connection) this.getConn();  
           // 通过Connection对象创建PrepareStatement对象  
           pstmt = (PreparedStatement) conn.prepareStatement(sql);  
           // 设置SQL语句的参数  
           pstmt.setInt(2, uid);  
           // 执行查询，将查询结果赋给ResultSet对象  
           rs = (ResultSet) pstmt.executeQuery();  
           // 遍历指针  
           while (rs.next())  
           \{  
              user = new User();  
              user.setUid(rs.getInt("uid"));  
              user.setUname(rs.getString("uname"));  
              user.setUpass(rs.getString("upass"));  
           \}  
       \} catch (ClassNotFoundException e) \{  
           e.printStackTrace();  
       \} catch (SQLException e) \{  
           e.printStackTrace();  
       \}  
       return user;  
    \}  
      
    /\*\*  
     \* 查询所有用户  
     \* @return  
     \*/  
    @SuppressWarnings("unchecked")  
    public List getUserList() \{  
       // 创建ArrayList对象  
       List userList = new ArrayList();  
         
       // 创建SQL对象  
       String sql = "select \* from user";  
         
       try \{  
           conn = (Connection) this.getConn();  
           pstmt = (PreparedStatement) conn.prepareStatement(sql);  
           rs = (ResultSet) pstmt.executeQuery();  
           while (rs.next())  
           \{  
              User user = new User();  
              user.setUid(rs.getInt("uid"));  
              user.setUname(rs.getString("uname"));  
              user.setUpass(rs.getString("upass"));  
                
              userList.add(user);  
           \}  
       \} catch (ClassNotFoundException e) \{  
           e.printStackTrace();  
       \} catch (SQLException e) \{  
           e.printStackTrace();  
       \}  
       return userList;  
    \}

6 新建 MemcachedManager.java

package memcachedTest;

import java.util.Date;  
import java.util.List;

import util.UserDao;  
import bean.User;

import com.alisoft.xplatform.asf.cache.memcached.client.MemCachedClient;  
import com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool;

public class MemcachedManager \{  
   
   // 创建MemCachedClient全局对象  
    private static MemCachedClient mcc = new MemCachedClient();  
      
    static \{  
       // 创建服务器列表及其权重  
       String\[\] servers = \{"127.0.0.1:11211"\};  
       Integer\[\] weights = \{3\};  
         
       // 创建Socket连接池对象  
       SockIOPool pool = SockIOPool.getInstance();  
         
       // 设置服务器信息  
       pool.setServers(servers);  
       pool.setWeights(weights);  
       pool.setFailover(true);  
         
       // 设置初始连接数、最小和最大连接数以及最大处理时间  
       pool.setInitConn(5);  
       pool.setMinConn(5);  
       pool.setMaxConn(250);  
       pool.setMaxIdle(1000\*60\*60\*6);  
         
       // 设置主线程睡眠时间  
       pool.setMaintSleep(30);  
         
       // 设置TCP参数、连接超时等  
       pool.setNagle(false);  
       pool.setSocketTO(3000);  
       pool.setSocketConnectTO(0);  
       pool.setAliveCheck(true);  
         
       // 初始化连接池  
       pool.initialize();  
         
       // 压缩设置，超过指定大小（单位为K）的数据都会被压缩  
       mcc.setCompressEnable(true);  
       mcc.setCompressThreshold(64 \* 1024);  
    \}  
      
    /\*\*  
     \* 无参构造  
     \*/  
    protected MemcachedManager ()\{  
         
    \}  
      
    // 受保护的对象  
    protected static MemcachedManager instance = new MemcachedManager();  
      
    /\*\*  
     \* 为受保护的对象提供一个公共的访问方法  
     \*/  
    public static MemcachedManager getInstance () \{  
       return instance;  
    \}  
      
    /\*\*  
     \* 添加对象到缓存中，构成方法重载  
     \* @param key  
     \* @param value  
     \* @return  
     \*/  
    public boolean add(String key,Object value) \{  
       return mcc.add(key, value);  
    \}  
    public boolean add (String key,Object value,Date expiry) \{  
       return mcc.add(key, value,expiry);  
    \}  
      
    public boolean replace (String key,Object value) \{  
       return mcc.replace(key, value);  
    \}  
      
    public boolean replace (String key,Object value,Date expiry)  
    \{  
       return mcc.replace(key, value, expiry);  
    \}  
      
    /\*\*  
     \* 根据指定的关键字获取对象  
     \*/  
    public Object get(String key) \{  
       return mcc.get(key);  
    \}  
      
      
      
    /\*\*  
     \* 利用MemCached测试将单个对象存入缓存，并从缓存中取出  
     \*/  
//  public static void main(String\[\] args) \{  
//      // 得到MemcachedManager实例  
//     MemcachedManager cache = MemcachedManager.getInstance();  
//       
//     // 创建UserDao对象  
//     UserDao userDao = new UserDao();  
//     // 查询单个User对象  
//     User user = userDao.getUserById(4);  
//       
//     // 将User对象添加到缓存中  
//     cache.add("user", user.getUname());  
//       
//     // 将User对象从缓存中取出来  
//     String uname = (String)cache.get("user");  
//       
//     System.out.println("从缓存中取出的对象为：" + uname);  
//  \}  
      
      
      
    /\*\*  
     \* 利用MemCached对象将集合存入缓存，并从缓存中取出  
     \*/  
    @SuppressWarnings(\{ "unchecked", "rawtypes" \})  
    public static void main(String\[\] args) \{  
       // 得到MemcachedManager实例  
       MemcachedManager cache = MemcachedManager.getInstance();  
         
       // 创建UserDao对象  
       UserDao userDao = new UserDao();  
       // 得到集合对象  
       List userList = userDao.getUserList();  
         
       // 创建User对象  
       User user = null;  
       for (int i=0; i<userList.size(); i++)  
       \{  
           // 循环遍历集合对象  
           user = (User)userList.get(i);  
           user.getUid();  
           user.getUname();  
           user.getUpass();  
             
           // 将集合对象存入缓存中  
           cache.add("userList" + i,user.getUname());  
             
           // 将集合从缓存中取出  
           String uname = (String)cache.get("userList"+i);  
             
           System.out.println("从缓存中取得的集合为：" + uname);  
       \}  
    \}

结果从控制台输出:

从缓存中取得的集合为：uname  
从缓存中取得的集合为：uname1  
从缓存中取得的集合为：uname2  
从缓存中取得的集合为：uname3

1缓存为什么要存在?  
2缓存可以存在于什么地方?  
3缓存有哪些属性?  
4缓存介质?  
  
搞清楚这4个问题,那么我们就可以随意的通过应用的场景来判断使用何种缓存了.  
  
  
1. 缓存为什么要存在?  
一 般情况下,一个网站,或者一个应用,它的一般形式是,浏览器请求应用服务器,应用服务器做一堆计算后再请求数据库,数据库收到请求后再作一堆计算后把数据 返回给应用服务器,应用服务器再作一堆计算后把数据返回给浏览器.这个是一个标准流程.但是随着互连网的普及,上网的人越来越多,网上的信息量也越来越 多,在这两个越来越多的情况下,我们的应用需要支撑的并发量就越来越多.然后我们的应用服务器和数据库服务器所做的计算也越来越多,但是往往我们的应用服 务器资源是有限的,数据库每秒中接受请求的次数也是有限的(谁叫俺们的硬盘转速有限呢).如果利用有限的资源来提供尽可能大的吞吐量呢,一个办法:减少计 算量,缩短请求流程(减少网络io或者硬盘io),这时候缓存就可以大展手脚了.缓存的基本原理就是打破上图中所描绘的标准流程,在这个标准流程中,任何 一个环节都可以被切断.请求可以从缓存里取到数据直接返回.这样不但节省了时间,提高了响应速度,而且也节省了硬件资源.可以让我们有限的硬件资源来服务 更多的用户.  
  
2 缓存可以存在于什么地方?  
Java代码

1.  浏览器---?浏览器和app之间---?分过层的app-?数据库

浏览器---?浏览器和app之间---?分过层的app-?数据库  
  
在上图中,我们可以看到一次请求的一般流程,下面我们重新绘制这张图,让我们的结构稍微复杂一点点.  
(将app分层)  
浏览器---?浏览器和app之间---?分过层的app-?数据库  
  
  
理 论上来将,请求的任何一个环节都是缓存可以作用的地方.第一个环节,浏览器,如果数据存在浏览器上,那么对用户来说速度是最快的,因为这个时候根本无需网 络请求.第二个环节,浏览器和app之间,如果缓存加在这个地方,那么缓存对app来说是透明的.而且这个缓存中存放的是完整的页面.第三个节点,app 中本身就有几个层次,那么缓存也可以放在不同的层次上,这一部分是情况或者场景比较复杂的部分.选择缓存时需要谨慎.第四个环节,数据库中也可以有缓存, 比如说mysql的querycache.  
  
那么也就是说在整个请求流程的任何一点,我们都可以加缓存.但是是所有的数据都可以放进缓存的吗.当然不是,需要放进缓存的数据总是有一些特征的,要清楚的判断数据是否可以被缓存,可以被怎样缓存就必须要从数据的变化特征下手.  
  
数 据有哪些变化特征?最简单的就是两种,变和不变.我们都知道,不会变化的数据不需要每次都进行计算.问题是难道所有的数据理论上来讲都会变化,变化是世界 永恒的主题.也就是说我们把数据分为变和不变两种是不对的,那么就让我们再加一个条件:时间.那么我们就可以把数据特征总结为一段时间内变或者不变.那么 根据这个数据特征,我们就可以在合适的位置和合适的缓存类型中缓存该数据.  
  
3缓存有哪些属性  
从面向对象的角度来看,缓存就是一个对象,那么是对象,必然有属性.那么下面我们来探讨一下缓存有哪些属性.以下列举我们常用到的3个属性.  
(1) 命中率  
命中率是指请求缓存次数和缓存返回正确结果次数的比例.比例越高,就证明缓存的使用率越高.  
  
命中率问题是缓存中的一个非常重要的问题,我们都希望自己缓存的命中率能达到100%,但是往往事与愿违,而且缓存命中率是衡量缓存有效性的重要指标.  
  
(2) 最大元素  
缓存中可以存放得最大元素得数量,一旦缓存中元素数量超过这个值,那么将会起用缓存清空策略,根据不同的场景合理的设置最大元素值往往可以一定程度上提高缓存的命中率.从而更有效的时候缓存.  
  
(3) 清空策略  
  
1 FIFO ，first in first out ，最先进入缓存得数据在缓存空间不够情况下(超出最大元素限制时)会被首先清理出去  
2 LFU ， Less Frequently Used ，一直以来最少被使用的元素会被被清理掉。这就要求缓存的元素有一个hit 属性，在缓存空间不够得情况下,hit 值最小的将会被清出缓存。  
2 LRU ，Least Recently Used ，最近最少使用的，缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。  
  
4缓存介质  
从硬件介质上来将无非就是两种,内存和硬盘(对应应用层的程序来讲不用考虑寄存器等问题).但是往往我们不会从硬件上来划分,一般的划分方法是从技术上划分,可以分成几种,内存,硬盘文件.数据库.  
(1) 内存.将缓存放在内存中是最快的选择,任何程序直接操作内存都比操作硬盘要快的多,但是如果你的数据要考虑到break down的问题,因为放在内存中的数据我们称之为没有持久话的数据,如果硬盘上没有备份,机器down机之后,很难或者无法恢复.  
  
(2) 硬盘.一般来说,很多缓存框架会结合使用内存和硬盘,比如给内存分配的空间有满了之后,会让用户选择把需要退出内存空间的数据持久化到硬盘.当然也选择直 接把数据放一份到硬盘(内存中一份,硬盘中一份,down机也不怕).也有其他的缓存是直接把数据放到硬盘上.  
  
  
(3) 数据库.说到数据库,可能有的人会想,之前不是讲到要减少数据库查询的次数,减少数据库计算的压力吗,现在怎么又用数据库作为缓存的介质了呢.这是因为数 据库又很多种类型,比如berkleydb,这种db不支持sql语句,没有sql引擎,只是key和value的存储结构,所以速度非常的快,在当代一 般的pc上,每秒中十几w次查询都是没有问题的(当然这个是根据业务特征来决定的,如果您访问的数据在分布上是均匀的,那ahuaxuan可不能保证这个 速度了).  
  
除了缓存介质之外,ahuaxuan根据缓存和应用的耦合程度将其划分为local cache和remote cache.  
Local cache是指包含在应用之中的缓存组件.而remote cache指和应用解耦在应用之外的缓存组件.典型的local cache有ehcache,oscache,而remote cache有大名鼎鼎的memcached.  
  
Localcache 最大的优点是应用和cache的时候是在同一个进程内部,请求缓存非常快速,完全不需要网络开销等.所以单应用,不需要集群或者集群情况下cache node不需要相互通知的情况下使用local cache比较合适.这也是java中ehcache和oscache这么流行的原因.  
但是 Local cache是有一定的缺点的,一般这种缓存框架(比如java中的ehcache或者oscache)都是local cache.也就是跟着应用程序走的,多个应用程序无法直接共享缓存,应用集群的情况下这个问题更加明显,当然也有的缓存组件提供了集群节点相互通知缓存 更新的功能,但是由于这个是广播,或者是环路更新,在缓存更新频繁的情况下会导致网络io开销非常大,严重的时候会影响应用的正常运行.而且如果缓存中数 据量较大得情况下使用localcache意味着每个应用都有一份这么大得缓存,着绝对是对内存的浪费.  
  
所以这个情况下,往往我们会 选择remote cache,比如memcached.这样集群或者分布式的情况下各个应用都可以共享memcached中的数据,这些应用都通过socket和基于 tcp/ip协议上层的memcached协议直接连接到memcached,有一个app更新了memcached中的值,所有的应用都能拿到最新的 值.虽然这个时候多了很多了网络上的开销,但是往往这种方案要比localcache广播或环路更新cache节点要普遍的多,而且性能也比后者高.由于 数据只需要保存一份,所以也提高了内存的使用率.  
  
通过以上分析可以看出,不管是local cache,还是remote cache在缓存领域都有自己的一席之地,所以ahuaxuan建议在选择或者使用缓存时一定要根据缓存的特征和我们的业务场景准确判断使用何种缓存.这样才能充分发挥缓存的功能.  
  
Ahuaxuan 认为,缓存的使用是架构师的必备技能,好的架构师能够根据数据的类型,业务的场景来准确的判断出使用何种类型的缓存,并且如何使用这种类型的缓存.在缓存 的世界里也没有银弹,目前还没有一种缓存可以解决任何的业务场景或者数据类型,如果这种技术出现了,那架构师就又更不值钱了.呵呵.

OSCache  
　　  
　　OSCache是个一个广泛采用的高性能的J2EE缓存框架，OSCache能用于任何Java应用程序的普通的缓存解决方案。  
　　  
　　OSCache有以下特点：  
　　  
　　缓存任何对象，你可以不受限制的缓存部分jsp页面或HTTP请求，任何java对象都可以缓存。  
　　  
　　拥有全面的API--OSCache API给你全面的程序来控制所有的OSCache特性。  
　　  
　　永久缓存--缓存能随意的写入硬盘，因此允许昂贵的创建（expensive-to-create）数据来保持缓存，甚至能让应用重启。  
　　  
　　支持集群--集群缓存数据能被单个的进行参数配置，不需要修改代码。  
　　  
　　缓存记录的过期--你可以有最大限度的控制缓存对象的过期，包括可插入式的刷新策略（如果默认性能不需要时）。  
　　  
　　官方网站 [http://www.opensymphony.com/oscache/][http_www.opensymphony.com_oscache]  
　　  
　　Java Caching System  
　　  
　　JSC(Java Caching System)是一个用分布式的缓存系统，是基于服务器的java应用程序。它是通过提供管理各种动态缓存数据来加速动态web应用。  
　　  
　　JCS和其他缓存系统一样，也是一个用于高速读取，低速写入的应用程序。  
　　  
　　动态内容和报表系统能够获得更好的性能。  
　　  
　　如果一个网站，有重复的网站结构，使用间歇性更新方式的数据库（而不是连续不断的更新数据库），被重复搜索出相同结果的，就能够通过执行缓存方式改进其性能和伸缩性。  
　　  
　　官方网站 [http://jakarta.apache.org/turbine/jcs/][http_jakarta.apache.org_turbine_jcs]  
　　  
　　EHCache  
　　  
　　EHCache 是一个纯java的在进程中的缓存，它具有以下特性：快速，简单，为Hibernate2.1充当可插入的缓存，最小的依赖性，全面的文档和测试。  
　　  
　　官方网站 [http://ehcache.sourceforge.net/][http_ehcache.sourceforge.net]  
　　  
　　JCache  
　　  
　　JCache是个开源程序，正在努力成为JSR-107开源规范，JSR-107规范已经很多年没改变了。这个版本仍然是构建在最初的功能定义上。  
　　  
　　官方网站 [http://jcache.sourceforge.net/][http_jcache.sourceforge.net]  
　　  
　　ShiftOne  
　　  
　　ShiftOne Java Object Cache是一个执行一系列严格的对象缓存策略的Java lib，就像一个轻量级的配置缓存工作状态的框架。  
　　  
　　官方网站 [http://jocache.sourceforge.net/][http_jocache.sourceforge.net]  
　　  
　　SwarmCache  
　　  
　　SwarmCache是一个简单且有效的分布式缓存，它使用IP multicast与同一个局域网的其他主机进行通讯，是特别为集群和数据驱动web应用程序而设计的。SwarmCache能够让典型的读操作大大超过写操作的这类应用提供更好的性能支持。  
　　  
　　SwarmCache使用JavaGroups来管理从属关系和分布式缓存的通讯。  
　　  
　　官方网站 [http://swarmcache.sourceforge.net][http_swarmcache.sourceforge.net]  
　　  
　　TreeCache / JBossCache  
　　  
　 　JBossCache是一个复制的事务处理缓存，它允许你缓存企业级应用数据来更好的改善性能。缓存数据被自动复制，让你轻松进行JBoss服务器之间 的集群工作。JBossCache能够通过JBoss应用服务或其他J2EE容器来运行一个MBean服务，当然，它也能独立运行。  
　　  
　　JBossCache包括两个模块：TreeCache和TreeCacheAOP。  
　　  
　　TreeCache --是一个树形结构复制的事务处理缓存。  
　　  
　　TreeCacheAOP --是一个“面向对象”缓存，它使用AOP来动态管理POJO(Plain Old Java Objects)  
　　  
　　注：AOP是OOP的延续，是Aspect Oriented Programming的缩写，意思是面向方面编程。  
　　  
　　官方网站 [http://www.jboss.org/products/jbosscache][http_www.jboss.org_products_jbosscache]  
　　  
　　WhirlyCache  
　　  
　　Whirlycache是一个快速的、可配置的、存在于内存中的对象的缓存。它能够通过缓存对象来加快网站或应用程序的速度，否则就必须通过查询数据库或其他代价较高的处理程序来建立。

[http_www.opensymphony.com_oscache]: http://wenwen.soso.com/z/UrlAlertPage.e?sp=Shttp://www.opensymphony.com/oscache/
[http_jakarta.apache.org_turbine_jcs]: http://wenwen.soso.com/z/UrlAlertPage.e?sp=Shttp://jakarta.apache.org/turbine/jcs/
[http_ehcache.sourceforge.net]: http://wenwen.soso.com/z/UrlAlertPage.e?sp=Shttp://ehcache.sourceforge.net/
[http_jcache.sourceforge.net]: http://wenwen.soso.com/z/UrlAlertPage.e?sp=Shttp://jcache.sourceforge.net/
[http_jocache.sourceforge.net]: http://wenwen.soso.com/z/UrlAlertPage.e?sp=Shttp://jocache.sourceforge.net/
[http_swarmcache.sourceforge.net]: http://wenwen.soso.com/z/UrlAlertPage.e?sp=Shttp://swarmcache.sourceforge.net
[http_www.jboss.org_products_jbosscache]: http://wenwen.soso.com/z/UrlAlertPage.e?sp=Shttp://www.jboss.org/products/jbosscache