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

灰太狼 2022-08-21 08:43 109阅读 0赞

原文：[使用Memcached、Spring AOP构建数据库前端缓存框架][Memcached_Spring AOP]

源代码下载地址：[http://www.zuidaima.com/share/1781569917635584.htm][Memcached_Spring AOP]

数 据库访问可能是很多网站的瓶颈。动不动就连接池耗尽、内存溢出等。前面已经讲到如果我们的网站是一个分布式的大型站点，那么使用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>
     
     <client name="mclient_0" compressEnable="true" defaultEncoding="UTF-8"
      socketpool="pool_0">
      
      <errorHandler>com.alisoft.xplatform.asf.cache.memcached.MemcachedErrorHandler
      </errorHandler>
     </client>
    
     
     <socketpool name="pool_0" maintSleep="5000" socketTO="3000"
      failover="true" aliveCheck="true" initConn="5" minConn="5" maxConn="250"
      nagle="false">
      
      <servers>127.0.0.1:11211</servers>
      
     </socketpool>
    </memcached>

**四、创建memcached客户端程序**

客户端工具类：

package com.hl.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.hl.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.hl.usersmanager.dao.IUserMapper;
    import com.hl.usersmanager.model.Users;
    import com.hl.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.hl.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.hl.usersmanager.memcached.client.MemcachedCache;
    import com.hl.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.hl.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：

<bean id="MemcachedCache" class="com.hl.usersmanager.memcached.client.MemcachedCache"></bean>

[Memcached_Spring AOP]: http://www.zuidaima.com/share/1781569917635584.htm