基于 自己定义注解 和 aop 实现使用memcache 对数据库的缓存 演示样例

时间：2021-10-08 19:16:44

好久没更新blog了，在新公司打拼了两个月，每天都从早忙到晚，学到了非常多东西，可是没有时间来更新blog了。。。。

以下開始解说这次的主题

公司老大让我研究 ocs 就是阿里云的 开放缓存服务 点击打开链接

事实上就是一个memcache的服务

memchech 就是用内存来存放 key -value  在一些情况下就不必频繁的訪问 数据库了（事实上就是个map）

怎样在经常使用的Dao中方便的使用这个map呢，我首先想到了 aop，然后又想到了自己定义注解，那么就開始干吧。。。。

aop动态代理要使用的jar包例如以下

aspectjrt-1.6.12.jar（jdk7.0 须要这么高的版本号，否则报错）

aspectjweaver-1.6.12.jar

cglib-nodep-2.2.jar

com.springsource.org.aopalliance-1.0.0.jar

和其它的spring包请自行搜索

spring加上这一行 开启自己主动代理：

 <aop:aspectj-autoproxy/>

我的spring配置

<?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:context="http://www.springframework.org/schema/context"

	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"

	xmlns:mvc="http://www.springframework.org/schema/mvc"

	xsi:schemaLocation="

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-3.0.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop-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/mvc

http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd

 ">

 <!-- 默认扫描的包路径 -->

 <context:component-scan base-package="com.test" />

 <!-- 加入注解驱动 -->

 <mvc:annotation-driven />

 <aop:aspectj-autoproxy/>  

</beans>

首先模拟一个 memCache 我写了一个工具类

package com.test.action;

import java.io.IOException;

import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.ExecutionException;

public class OcsUtil {

       private static Map<String, Object> memMap=new HashMap<String, Object>();

       //模拟

       public static void add(String key,Object val) throws IOException, InterruptedException, ExecutionException{

    	   memMap.put(key, val);

       }

       //模拟

       public static Object get(String key) throws IOException{

    	  return memMap.get(key);

       }

}

这个就临时取代memCached吧。

dao层：

package com.test.dao;

import org.springframework.stereotype.Repository;

import com.test.aop.MemCache;

@Repository

public class TestDao {

	@MemCache

	public Object selectKeyValue(String arg1,Integer arg2){

		return "12345";

	}

}

两个參数随便写的，这样用来模拟真实情况下的多个查询參数

方法名上的@MemCache 注解 就是我自定义的注解，当拥有这个注解的方法在调用时首先会在memCache中去找，这样就提高了性能

自己定义注解例如以下：

package com.test.aop;

import java.lang.annotation.*;

import static java.lang.annotation.ElementType.*;

@Target({METHOD})

@Retention(RetentionPolicy.CLASS)

public @interface MemCache {

}

我们要做的就是用aop拦截 拥有@MemCache注解的方法，然后处理它。以下是aop拦截器

package com.test.aop;

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.stereotype.Component;

import com.google.gson.Gson;

import com.test.action.OcsUtil;

@Component

@Aspect

public class MemCacheInterceptor {

	private Gson gson=new Gson();

	@Pointcut("execution(* com.test.dao.TestDao.select*(..))&& @annotation(com.test.aop.MemCache)")

	private void theMethod(){}//定义一个切入点

	@Around("theMethod()")

	public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable{

		String  key=pjp.getSignature().toString();

		key+=gson.toJson(pjp.getArgs());		

		Object memValue=OcsUtil.get(key);

		if(memValue!=null){

			System.out.println("memcache获取到");

			return memValue;

		}

		Object object = pjp.proceed();//运行该方法

		OcsUtil.add(key, object+" cache");

		System.out.println("db获取");

		return object;

	}

}

*1为了測试我在memCache中放的时候追加了一个字符串 “ cache”

这个拦截器 使用 “方法的签名” 和 “參数转换成的json字符串” 作为 memCache的key

就像这个样子 Object com.test.dao.TestDao.selectKeyValue(String,Integer)["1",2]

这样就能够保证memCache的存取与dao的操作相应了

这样就大功告成了。

相关文章