使用Memcached、Spring AOP构建数据库前端缓存框架

总的来说也是用的java的动态代理机制,貌似spring中大部分地方都有用动态代理机制。

以下转自:http://www.zuidaima.com/share/1781569917635584.htm


原创整理不易,转载请注明出处:使用Memcached、Spring AOP构建数据库前端缓存框架
代码下载地址:http://www.zuidaima.com/share/1781569917635584.htm
数 据库访问可能是很多网站的瓶颈。动不动就连接池耗尽、内存溢出等。前面已经讲到如果我们的网站是一个分布式的大型站点,那么使用memcached实现数 据库的前端缓存是个很不错的选择;但如果网站本身足够小只有一个服务器,甚至是vps的那种,不推荐使用memcached,使用Hibernate或者 Mybatis框架自带的缓存系统就行了。
  一、开启memcached服务器端服务
  如果已经安装了memcached服务器端程序,请确认服务器端服务已开启。
   二、引入jar
  1.  alisoft-xplatform-asf-cache-2.5.1.jar
  2.  commons-logging-1.0.4.jar
  3.  hessian-3.0.1.jar
  4.  log4j-1.2.9.jar  
    5.  stax-api-1.0.1.jar
  6.  wstx-asl-2.0.2.jar
   三、创建memcached客户端配置文件
<memcached>  
 <!-- name 属性是程序中使用Cache的唯一标识;socketpool 属性将会关联到后面的socketpool配置; -->  
 <client name="mclient_0" compressEnable="true" defaultEncoding="UTF-8"  
  socketpool="pool_0">  
  <!-- 可选,用来处理出错情况 -->  
  <errorHandler>com.alisoft.xplatform.asf.cache.memcached.MemcachedErrorHandler  
  </errorHandler>  
 </client>  

 <!--  
  name 属性和client 配置中的socketpool 属性相关联。  
  maintSleep属性是后台线程管理SocketIO池的检查间隔时间,如果设置为0,则表明不需要后台线程维护SocketIO线程池,默认需要管理。  
  socketTO 属性是Socket操作超时配置,单位ms。 aliveCheck  
  属性表示在使用Socket以前是否先检查Socket状态。  
 -->  
 <socketpool name="pool_0" maintSleep="5000" socketTO="3000"  
  failover="true" aliveCheck="true" initConn="5" minConn="5" maxConn="250"  
  nagle="false">  
  <!-- 设置memcache服务端实例地址.多个地址用","隔开 -->  
  <servers>127.0.0.1:11211</servers>  
  <!--  
   可选配置。表明了上面设置的服务器实例的Load权重. 例如 <weights>3,7</weights> 表示30% load 在  
   10.2.224.36:33001, 70% load 在 10.2.224.46:33001  
    
  <weights>3,7</weights>  
  -->  
 </socketpool>  
</memcached>  
  

   四、创建memcached客户端程序
  客户端工具类:
package com.zuidaima.usersmanager.memcached.client;  
  
import com.alisoft.xplatform.asf.cache.ICacheManager;  
import com.alisoft.xplatform.asf.cache.IMemcachedCache;  
import com.alisoft.xplatform.asf.cache.memcached.CacheUtil;  
import com.alisoft.xplatform.asf.cache.memcached.MemcachedCacheManager;  
  
public class MemcachedCache {  
 private ICacheManager<IMemcachedCache> manager;  
 private IMemcachedCache cache;  
   
 public MemcachedCache(){  
  manager = CacheUtil.getCacheManager(IMemcachedCache.class,  
    MemcachedCacheManager.class.getName());  
  manager.setConfigFile("memcached.xml");  
  manager.setResponseStatInterval(5*1000);  
  manager.start();  
  cache = manager.getCache("mclient_0");  
 }  
   
 /** 
  * 获取缓存接口 
  * @return 
  */  
 public IMemcachedCache getCache(){  
  return cache;  
 }  
   
 /** 
  * 数据放入缓存 
  * @param key 
  * @param object 
  */  
 public void put(String key,Object object){  
  cache.put(key, object);  
 }  
   
 /** 
  * 从缓存中读取数据 
  * @param key 
  * @return 
  */  
 public Object get(String key){  
  return cache.get(key);  
 }  
}  

   五、使用Spring AOP在数据查询的Service层实现数据缓存及读取
   实现数据缓存的过程很简单,就是在Service层查询数据库操作前判断要查询的数据在缓存中是否存在,如果不存在就到数据库中查询,查询完成后将数据 放入缓存系统;如果要查询的数据在缓存中已经存在,则直接从缓存中读取,不需要操作数据库。这就大大降低了数据库的连接次数。原理就是这么简单。
  但是,如果直接对Service层代码进行修改,就违背了“开放-封闭”原则,也会导致缓存系统的操作代码散落到Service层的各处,不方便代码的管理和维护。所以,Spring AOP华丽登场了。它使用非入侵式的来创建、管理这些缓存操作代码。
  关于Spring AOP本身的一些知识,我们这里不做讲述。参考资料:
  由于首先要判断查询数据是否存在于缓存系统,如果存在直接从缓存中读取,也就是说Service层的查询代码根本不会执行;另一方面,如果数据在缓存系统中不存在,从数据库查询出的结果,我们需要将其放入缓存系统中。
  我们来看Spring AOP的几个装备中哪个适用呢?那就是最强大的环绕通知装备@Around!
  下面以UserService为例,其源代码如下:
package com.zuidaima.usersmanager.service.impl;  
  
import java.util.List;  
  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Service;  
import org.springframework.transaction.annotation.Transactional;  
  
import com.zuidaima.usersmanager.dao.IUserMapper;  
import com.zuidaima.usersmanager.model.Users;  
import com.zuidaima.usersmanager.service.IUserService;  
  
//使用Service注解 不需要再在配置文件中配置bean  
@Service  
public class UserServiceImpl implements IUserService{  
 @Autowired  
 private IUserMapper userMapper;  
   
 @Override  
 @Transactional  
 public Users findUserByName(String name) {  
  return userMapper.findUserByName(name);  
 }  
  
 ……  
}  

  findUserByName主要实现按照用户名查询用户的功能,现在我们使用Spring AOP来实现缓存:
package com.zuidaima.usersmanager.aop.service;  
  
import org.apache.log4j.Logger;  
import org.aspectj.lang.ProceedingJoinPoint;  
import org.aspectj.lang.annotation.Around;  
import org.aspectj.lang.annotation.Aspect;  
import org.aspectj.lang.annotation.Pointcut;  
import org.springframework.beans.factory.annotation.Autowired;  
  
import com.zuidaima.usersmanager.memcached.client.MemcachedCache;  
import com.zuidaima.usersmanager.model.Users;  
  
@Aspect  
public class UserServiceInterceptor {  
 public static final Logger log = Logger  
   .getLogger(UserServiceInterceptor.class);  
  
//将缓存客户端工具类 MemcachedCache 织入进来  
 @Autowired  
 private MemcachedCache memcachedCache;  
  
 /* 
  * 定义pointcunt 
  */  
 @Pointcut("execution(* com.zuidaima.usersmanager.service.impl.UserServiceImpl.*(..))")  
 public void aPointcut() {  
  
 }  
  
 /** 
  * 环绕装备 用于拦截查询 如果缓存中有数据,直接从缓存中读取;否则从数据库读取并将结果放入缓存 
  *  
  * @param call 
  * @param name 
  * @return 
  */  
 @Around("aPointcut()&&args(name)")  
 public Users doFindUserByNameAround(ProceedingJoinPoint call, String name) {  
  Users users = null;  
  if (memcachedCache.getCache().containsKey("findUserByName_" + name)) {  
   users = (Users) memcachedCache.get("findUserByName_" + name);  
   log.debug("从缓存中读取!findUserByName_" + name);  
  } else {  
   try {  
    users = (Users) call.proceed();  
    if (users != null) {  
     memcachedCache.put("findUserByName_" + name, users);  
     log.debug("缓存装备被执行:findUserByName_" + name);  
    }  
   } catch (Throwable e) {  
    e.printStackTrace();  
   }  
  }  
  return users;  
 }  
}  

 环绕通知装备需要一个ProceedingJoinPoint 类型的参数,它的强大之处在于可以代理一个我们的切入点,指定切入点方法是否执行,或者获取执行后的返回结果!!
  memcachedCache.getCache().containsKey("findUserByName_" + name)
  可以判断缓存中是否有指定的数据。如果有则直接从缓存中读取:
  users = (Users) memcachedCache.get("findUserByName_" + name);
  否则调用切入点UserServiceImpl的findUserByName方法:
  users = (Users) call.proceed();
  call.proceed()表示执行切入点的方法。
  使用Spring AOP以后,整个缓存系统代码看起来 就是这么优雅!UserServiceImpl根本不知道外界发了什么,更不知道外界调用它的findUserByName的时候已经被拦截了!
  那天不用缓存系统,只需要将Aop这块的代码去掉即可。
  当然,我们还需要在Spring配置文件中注册一个memcached客户端工具类的bean:
<!-- MemcachedCache缓存 -->  
<bean id="MemcachedCache" class="com.zuidaima.usersmanager.memcached.client.MemcachedCache"></bean>
 

你可能感兴趣的:(spring aop)