qileilove

<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>

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);
 }
}

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);
 }

 ……
}

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;
 }
}