利用cglib实现aop，简化缓存的使用

本文只适合java菜鸟看，大大请多指教。

关于AOP：

百度百科：面向切面编程(也叫面向方面编程)：Aspect Oriented Programming(AOP)，是软件开发中的一个热点，也是Spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

 

关于AOP的几个概念

百度百科：

Aspect： Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。

Joint point：表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 joint point。

Pointcut：表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。

Advice：Advice 定义了在 pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。

 

 

常用的AOP：

1）利用java动态代理，实现AOP

　　优点：比较底层，灵活方便

　　缺点：被代理的方法要实现接口，比较麻烦。

2）Spring自带AOP功能

　　优点：

　　缺点：

3）使用cglib

　　优点：封装好，无需使用接口即可代理所有方法，易上手。

　　缺点：

 

 

为何使用cglib实现AOP：

由于项目中使用到Redis缓存，经常引起一些纠结：在一个接口要获取数据时，先调用缓存，当缓存中不存在数据时，再查询数据库；而在接口要插入数据时，则先插入数据库，插入成功后，再讲数据存入缓存……

因此思考后，决定使用AOP解决该问题，使得代码稍优美些。

 

1）自定义注解：

package com.tim.cacherAop.annotiation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)  
@Retention(RetentionPolicy.RUNTIME)  
public @interface DaoInsert {

}


//同时还有其他三种注解:DaoQuery,DaoUpdate,DaoDelete只需要改变类名即可，不再全部粘贴

　　

 

2）先创建dao类：

package com.tim.cacherAop.dao;

import com.tim.cacherAop.annotiation.DaoDelete;
import com.tim.cacherAop.annotiation.DaoInsert;
import com.tim.cacherAop.annotiation.DaoQuery;
import com.tim.cacherAop.annotiation.DaoUpdate;


/**
 * 创建Dao类 模拟数据库的操作
 * @author Tim
 *
 */
public class TestDao {//implements DataInterface {
	
	public static final int NORMAL_INSERT = 1;
	

	public TestDao() {
	}

	//模拟插入操作
	@DaoInsert
	public int doInsert(String name){
		System.out.println("dao do insert :" + name);
		return 1;
	}

	//模拟更新操作
	@DaoUpdate
	public int doUpdate(String name,String id){
		System.out.println("dao do doUpdate name :" + name + " and id :" + id);
		return 1;
	}

	//模拟查询操作
	@DaoQuery
	public String doQuery(String id){
		System.out.println("dao do doQuery id :" + id);
		return id;
	}
	
	//模拟删除操作
	@DaoDelete
	public Object doDelete(String id){
		System.out.println("dao do doDelete id :" + id);
		return 1;
	}

	
	
}

其中几个public方法模拟最基本的SQL操作，同时用到第一步定义的@DaoInsert,@DaoQuery,@DaoUpdate,@DaoDelete四个注解，稍后解释。

3）然后创建Cacher类

package com.tim.cacherAop.cacher;


/**
 * cacher类 模拟针对缓存进行操作 适用于Redis等缓存
 * @author Tim
 *
 */
public class TestCacher {//implements DataInterface {

	
	public static final int NORMAL_INSERT = 1;

	
	
	public TestCacher() {
		// TODO Auto-generated constructor stub
	}


	
	public int doInsert(String name){
		System.out.println("cacher do insert :" + name);
		return 1;
	}

	public int doUpdate(String name,String id){
		System.out.println("cacher do doUpdate name :" + name + " and id :" + id);
		return 1;
	}

	public String doQuery(String id){
		System.out.println("cacher do doQuery id :" + id);
		return id;
	}
	
	
	public Object doDelete(String id){
		System.out.println("cacher do doDelete id :" + id);
		return 1;
	}
	
	

}

稍仔细观察下即可发现，cacher类和dao类中方法名和方法参数均相同，这样做是为了解耦（更准确的说是方便调用），在第四步即可发现。

4）创建Hanlder类

package com.tim.cacherAop.Hanlder;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import com.tim.cacherAop.annotiation.DaoDelete;
import com.tim.cacherAop.annotiation.DaoInsert;
import com.tim.cacherAop.annotiation.DaoQuery;
import com.tim.cacherAop.annotiation.DaoUpdate;
import com.tim.cacherAop.cacher.TestCacher;
import com.tim.cacherAop.dao.TestDao;


/**
 * 代理类 继承 net.sf.cglib.proxy.MethodInterceptor
 * @author Tim
 *
 */
public class DaoCglibHanlder implements MethodInterceptor {

	public DaoCglibHanlder() {
		// TODO Auto-generated constructor stub
	}

	
	private TestCacher cacher;
	private TestDao dao;

	
	
	 public static Object getInstance(TestCacher cacher, TestDao dao) {  
		 
	        DaoCglibHanlder hanlder = new DaoCglibHanlder();
	        hanlder.cacher = cacher;
	        hanlder.dao = dao;
	        
	        
	        Enhancer enhancer = new Enhancer();  
	        enhancer.setSuperclass(dao.getClass());  
	        // 回调方法  
	        enhancer.setCallback(hanlder);  
	        // 创建代理对象  
	        return enhancer.create();  
	    } 
	 
	 
	@Override
	public Object intercept(Object obj, Method method, Object[] args,
			MethodProxy proxy) throws Throwable {
		Object result = null;

		try {
			
			//遍历注解 
			Annotation []annArray =  method.getDeclaredAnnotations();
			//遍历注解 
			//doCacherFirst = -1 表示 无注解； 
			//doCacherFirst = 0  表示 查询；
			//doCacherFirst = 1  表示 增 |改| 删；
			int doCacherFirst = -1;
			for (Annotation an : annArray) {
				Class<?> annClass = an.annotationType();
				if(annClass == DaoQuery.class){
					doCacherFirst = 0;
					break;
				}else if(annClass == DaoInsert.class 
						|| annClass == DaoUpdate.class
						|| annClass == DaoDelete.class){
					doCacherFirst = 1;
				}
			}
			
			
			//获取cacher中对应的方法
			String methodName = method.getName();
			Class<?> [] paramTypes = method.getParameterTypes();
			Method cacheMethod = cacher.getClass().getMethod(methodName, paramTypes);
			
			//cacher中有同名同参数的方法
			if(cacheMethod != null){
				//doCacherFirst == 0 先调用query方法 
				if(doCacherFirst == 0){
					result = cacheMethod.invoke(cacher, args);
				}
				//不为null时候 说明cacher中有数据，不用调用dao
				if(result == null){
					method.invoke(dao, args);					
				}
				//增 |改| 删 在处理完数据库后处理缓存
				if(doCacherFirst == 1){
					result = cacheMethod.invoke(cacher, args);
				}
				
			}else {
				result = method.invoke(dao, args);
			}
			

		} catch (Exception e) {
			result = null;
			e.printStackTrace();
		}
		
		return result;
	}

}

该类中有两个变量：testCacher和testDao。只要在getInstance()方法中将cacher对象和dao对象传入即可。

在调用dao的任意方法时，若该方法存在@DaoInsert,@DaoQuery,@DaoUpdate,@DaoDelete四个自定义注解中的任意一个，即会去testCacher对象中寻找同名同参数的方法(也就是说，cacher和dao之间方法的解耦方式，是两方法同名并且同参数。同时dao的方法记得加上注解)。同时根据注解，判断调用cacher的时机(详细见代码中注释)。

　

5）创建测试类

package com.tim.cacherAop.run;

import com.tim.cacherAop.Hanlder.DaoCglibHanlder;
import com.tim.cacherAop.cacher.TestCacher;
import com.tim.cacherAop.dao.TestDao;

public class GOGOGO {

	public GOGOGO() {
		// TODO Auto-generated constructor stub
	}

	public static void main(String[] args) {
		TestDao dao = new TestDao();
		TestCacher cacher = new TestCacher();
		TestDao d = (TestDao) DaoCglibHanlder.getInstance(cacher, dao);
		//插入操作
		System.out.println(d.doInsert("hihi"));
		System.out.println("/////////////////////////////");
		//更新操作
		System.out.println(d.doUpdate("双蛋龙", "001"));
		System.out.println("/////////////////////////////");
		//查询操作
		System.out.println(d.doQuery("001"));
		System.out.println("/////////////////////////////");
		//删除操作
		System.out.println(d.doDelete("001"));
		System.out.println("/////////////////////////////");
		
		
		
		/**
		 输出结果
		 	dao do insert :hihi
			cacher do insert :hihi
			1
			/////////////////////////////
			dao do doUpdate name :双蛋龙 and id :001
			cacher do doUpdate name :双蛋龙 and id :001
			1
			/////////////////////////////
			cacher do doQuery id :001
			001
			/////////////////////////////
			dao do doDelete id :001
			cacher do doDelete id :001
			1
			/////////////////////////////
		 */
	}

}

在测试时，通过DaoCglibHanlder的getInstance()方法，获取dao对象，然后直接调用即可。　　

遗留的问题：

1） 在Main方法的调用处，dao和cacher依然存在需要解耦的问题。(感觉可以使用配置文件)

2）是否考虑将dao的实例化步骤放入DaoCglibHanlder类处，对应的getInstance()方法只传Class对象或者类名。因为dao对象实例化的时候需传入Connection对象，若执行query时,在cacher中存在数据，则不需要再获取数据库链接。

源码，问题一已解决