java aop 方式调用memcached

1.在连接memcache服务器之前要事先搭建好memcache服务器，记住创建服务器的ip和端口号，使用java代码连接要使用ip和端口号。

2.开始使用java 链接

2.1在项目里面引入jar文件memcached-2.0.1.jar，memcached-1.1.jar

2.2在spring配置文件里面配置将memcache加载进

<!-- Memcached 配置 -->
<bean id="memCachedClient" class="com.danga.MemCached.MemCachedClient">
    <constructor-arg>
        <value>sockIOPool</value>
    </constructor-arg>
</bean>
<!-- Memcached连接池 -->
<bean id="sockIOPool" class="com.danga.MemCached.SockIOPool" factory-method="getInstance" init-method="initialize" destroy-method="shutDown">
    <constructor-arg>
        <value>sockIOPool</value>
    </constructor-arg>
    <property name="servers">
        <list>
            <value>192.168.200.149:11211</value>
        </list>
    </property>
    <property name="weights">
        <list>
            <value>1</value>
        </list>
    </property>
</bean>

使用memcache是当用户查询数据的时候，先去memcache缓存服务器里面获取数据，如果没有查到就会到service层调用dao层方法去查询数据库，让后同步到memcache缓存服务器里面。这就需要配置一个aop来拦截带有get*的查询方法，配置如下：

[html] view plain copy

<!-- Spring  Aop 配置   get* 配置环绕 -->  
<aop:config>  
    <!-- 面 -->  
    <aop:aspect ref="cacheInterceptor">  
        <!-- 点 -->  
        <aop:around method="doAround" pointcut="execution(* cn.itcast.core.service.*.*.get*(..))"/>  
        <!-- 变更  -->  
        <aop:after method="doAfter" pointcut="execution(* cn.itcast.core.service.*.*.update*(..))"/>  
        <aop:after method="doAfter" pointcut="execution(* cn.itcast.core.service.*.*.add*(..))"/>  
        <aop:after method="doAfter" pointcut="execution(* cn.itcast.core.service.*.*.delete*(..))"/>  
    </aop:aspect>  
</aop:config>  

aop的方法
[html] view plain copy
CacheInterceptor
[java] view plain copy
/**
* 缓存Memcached中数据的切面对象
* aroud
* after
* @author lx
*
*/
public class CacheInterceptor {

@Autowired  
private MemCachedClient memCachedClient;  

//时间 缓存时间  
public static final int TIMEOUT = 360000;//秒  

private int expiry = TIMEOUT;  

//配置环绕方法  
public Object doAround(ProceedingJoinPoint pjp) throws Throwable{  
    //去Memcached中看看有没有我们的数据  包名+ 类名 + 方法名 + 参数(多个)  
    String cacheKey = getCacheKey(pjp);  
    System.out.println(cacheKey);  
    //如果Memcached 连接不上呢  
    if(memCachedClient.stats().isEmpty()){  
        System.out.println("Memcached服务器可能不存在或是连接不上");  
        return pjp.proceed();  
    }  

    //返回值  
    if(null == memCachedClient.get(cacheKey)){  
        //回Service  
        Object proceed = pjp.proceed();  
        //先放到Memcached中一份  
        memCachedClient.set(cacheKey, proceed,expiry);  
    }  
    return memCachedClient.get(cacheKey);  
}  
//后置由于数据库数据变更  清理get*  
public void doAfter(JoinPoint jp){  
    //包名+ 类名 + 方法名 + 参数(多个)  生成Key  
    //包名+ 类名   
    String packageName = jp.getTarget().getClass().getName();  

    //包名+ 类名  开始的 都清理  
    Map<String, Object> keySet = MemCachedUtil.getKeySet(memCachedClient);  
    //  
    Set<Entry<String, Object>> entrySet = keySet.entrySet();  
    //遍历  
    for(Entry<String, Object> entry : entrySet){  
        if(entry.getKey().startsWith(packageName)){  
            memCachedClient.delete(entry.getKey());  
        }  
    }  
}  





//包名+ 类名 + 方法名 + 参数(多个)  生成Key  
public String getCacheKey(ProceedingJoinPoint pjp){  
    //StringBuiter  
    StringBuilder key = new StringBuilder();  
    //包名+ 类名   cn.itcast.core.serice.product.ProductServiceImpl.productList  
    String packageName = pjp.getTarget().getClass().getName();  
    key.append(packageName);  
    // 方法名  
    String methodName = pjp.getSignature().getName();  
    key.append(".").append(methodName);  

    //参数(多个)  
    Object[] args = pjp.getArgs();  

    ObjectMapper  om = new ObjectMapper();  
    om.setSerializationInclusion(Inclusion.NON_NULL);  

    for(Object arg : args){  

        //流  
        StringWriter str = new StringWriter();   

        //对象转Json  写的过程     Json是字符串流  
        try {  
            om.writeValue(str, arg);  
        } catch (IOException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
        //参数  
        key.append(".").append(str);  
    }  

    return key.toString();  
}  
public void setExpiry(int expiry) {  
    this.expiry = expiry;  
}  

}