使用Memcached作为全网站分布式缓存

使用Memcached作为全网站分布式缓存，大体思路就是：

首先搭建一些Memcached服务器，作为全网站的分布式缓存服务器。当Controller层调用以get*开头的service查询方法时，首先进入配置的切面对象，执行环绕通知方法，查看Memcached中是否已经有了此查询方法执行后的结果，如果有数据，则直接返回Controller，如果没有数据，就返回service层执行查询方法，并且把执行结果放入到Memcached中缓存起来。

当Controller层调用以add*，delete*，update*开头的service方法时，因为这些这些方法的执行会导致数据库数据变更，因此要清理受到影响的那部分缓存的数据，以免造成数据延迟，即也要进入在spring中配置的切面对象，执行后置通知方法，清空受影响的部分缓存数据。

其中有个关键点，是把service查询的数据结果放入Memcached时的K怎么设置，为了保证唯一性，可以设定K生成规则如下：

K=包名+类名+方法名+参数(可以多个)，其中，如果参数是javabean的话，要先转为json串，再与前面的包名+类名+方法名进行拼接。

其中包名+类名比如:com.core.serice.product.ProductServiceImpl.productList

①首先要在Linux服务器上搭建Memcache服务器，这个可以查看Memcached官方文档

②在java项目中加入memcache-xx.jar，又分为两个包：

com.danga.MemCached与

net.spy.memcached

因为danga包有连接池，更稳定，因此此次使用的是danga包的Memcached

③Spring引入Memcached.xml，在其中进行连接池，切面对象和aop配置，这样就能保证所有对系统所有以get*,add*,delete*,update*开头的service方法生效：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx" xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation=" http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

<!-- 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>
<!-- 此处可以配置多台安装了Memcached的服务器，Memcached自带路由功能，我们不需要知道数据具体存到了哪个数据库 -->
<value>192.168.200.149:11211</value>
</list>
</property>
<property name="weights">
<list>
<value>1</value>
</list>
</property>
</bean>

<!-- 配置切面对象，expiry是切面类里加的时间参数 -->
<bean id="cacheInterceptor" class="com.common.web.aop.CacheInterceptor">
<property name="expiry" value="4200000"/>
</bean>

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

④先写个测试类测试下Memcached

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:application-context.xml")
public class MemcachedTest{

@Autowired
private MemCachedClient memCachedClient;
@Test
public void testAdd() throws Exception {
Student student = new Student();
student.setName("哈哈");
//存数据
//memCachedClient.set("aa",student);
//取数据
Object object = memCachedClient.get("aa");
System.out.println(object);
}
}

⑤写切面类com.common.web.aop.CacheInterceptor:

/**
* 缓存Memcached中数据的切面对象
*/
public class CacheInterceptor {

@Autowired
private MemCachedClient memCachedClient;

//缓存时间,单位是秒
private int expiry = 60*60*24*3;

//配置环绕通知方法，get*会执行，环绕通知使用ProceedingJoinPoint，其中包含了请求的一些参数，能够获取要执行的包名，类型，方法名，参数之类的数据
public Object doAround(ProceedingJoinPoint pjp) throws Throwable{
//去Memcached中查看有没有此get方法查找的数据  包名+ 类名 + 方法名 + 参数(多个)
String cacheKey = getCacheKey(pjp);
System.out.println(cacheKey);
//如果Memcached连接不上
if(memCachedClient.stats().isEmpty()){
System.out.println("Memcached服务器可能不存在或是连接不上");
//pjp.proceed()此处就是放开拦截，执行service方法查询
return pjp.proceed();
}

//如果以前没有缓存过此get方法查询的数据
if(null == memCachedClient.get(cacheKey)){
//回Service
Object proceed = pjp.proceed();
//吧数据缓存到Memcached中一份
memCachedClient.set(cacheKey, proceed,expiry);
}
return memCachedClient.get(cacheKey);
}

//add*，update*，delete*后置通知，由于数据库数据变更，因此要清理受到影响的那部分缓存的数据。后置通知使用的是JoinPoint，没有了.proceed()方法
public void doAfter(JoinPoint jp){
//获取包名+类名
String packageName = jp.getTarget().getClass().getName();
//以包名+类名开始的缓存数据都清理掉
//Memcached中获取所有key的方法比较复杂，getKeySet(memCachedClient)也是从网上找的
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());
}
}
}

//使用包名+类名+方法名+参数(多个)的生成策略生成Memcached保存需要的Key
public String getCacheKey(ProceedingJoinPoint pjp){
StringBuilder key = new StringBuilder();
//获取包名+类名，比如com.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();
//因为参数可能是javabean，所以此处要转为json串才能进行拼接生成key
ObjectMapper  om = new ObjectMapper();
om.setSerializationInclusion(Inclusion.NON_NULL);
//遍历参数，转json串
for(Object arg : args){
//流
StringWriter str = new StringWriter();
//对象转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;
}
}

⑥接下来实现Memcached 集群的高可用（HA）架构可参考下面的博客：
http://blog.csdn.net/liu251890347/article/details/38414247