JDK自从1.3版本开始，就引入了动态代理，并且经常被用来动态地创建代理,原理之前我已经讲过。JDK的动态代理用起来非常简单，但它有一个限制，就是使用动态代理的对象必须实现一个或多个接口。如果想代理没有实现接口的继承的类，该怎么办？现在我们可以使用CGLIB包。
PS:需要引入com.springsource.net.sf.cglib-2.2.0.jar包。
CGLIB是一个强大的高性能的代码生成包。它广泛的被许多AOP的框架使用，例如：Spring AOP和dynaop，为他们提供方法的interception（拦截）； 它的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。 （CGLIB可以生成目标类的子类，并重写父类非final修饰符的方法。）
使用Cglib包生成代理的模板
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
public class CGLIBProxy implements MethodInterceptor { private Object targetObject;//代理的目标对象 public Object createProxyInstance(Object targetObject){ this.targetObject = targetObject; Enhancer enhancer = new Enhancer();//该类用于生成代理对象 enhancer.setSuperclass(this.targetObject.getClass());//设置父类 enhancer.setCallback(this);//设置回调用对象为本身 return enhancer.create(); } public Object intercept(Object proxy, Method method, Object[] args,MethodProxy methodProxy) throws Throwable { return methodProxy.invoke(this.targetObject, args); } } |
第一个参数是代理对像，第二和第三个参数分别是拦截的方法和方法的参数。通过使用java.lang.reflect.Method对象的一般反射调用或者使用net.sf.cglib.proxy.MethodProxy对象调用都可以完成对原方法的调用，但是通常net.sf.cglib.proxy.MethodProxy对象被首选使用，因为它更快。
PS:net.sf.cglib.proxy.MethodProxy应该是cglib生成用来代替Method对象的一个对象，使用MethodProxy比调用JDK自身的Method直接执行方法效率会有提升。
示例：
Service类：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
package net.zmcheng.service; public class PersonService { private String name; public PersonService(){ super(); } public PersonService(String name){ this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } public void save(){ System.out.println("我是save方法"); } } |
Cglib动态代理工厂：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
package net.zmcheng.aop; import java.lang.reflect.Method; import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; import net.zmcheng.service.PersonService; public class CglibProxyFactory implements MethodInterceptor{ public Object targetObject; public Object createProxyIntance(Object targetObject){ this.targetObject = targetObject; Enhancer enhancer = new Enhancer();//该类用于生成代理对象 enhancer.setSuperclass(this.targetObject.getClass());//设置父类 enhancer.setCallback(this);//设置回调用对象为本身 return enhancer.create();//创建代理对象 } //MethodInterceptor接口类似于jdk中的java.lang.reflect.InvocationHandler接口 // MethodInterceptor中的intercept方法同java.lang.reflect.InvocationHandler接口中的 invoke方法类似 public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy){//环绕通知 PersonService bean = (PersonService)this.targetObject; Object result = null; if(bean.getName()!=null){ //....advice()--->前置通知 try { result = method.invoke(targetObject, args); //..afteradvice()--->后置通知 } catch (Exception e) { //....exceptionadvice()--->例外通知 e.printStackTrace(); }finally{ //finallyadvice();----->最终通知 } } return result; } } |
测试类：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
package net.zmcheng.test; import org.junit.BeforeClass; import org.junit.Test; import net.zmcheng.aop.CglibProxyFactory; import net.zmcheng.service.PersonService; public class aopTest { @BeforeClass public static void setUpBeforeClass() throws Exception { } @Test public void test() { CglibProxyFactory factory = new CglibProxyFactory (); PersonService service = (PersonService)factory.createProxyIntance(new PersonService("zmc")); service.save(); } } |
输出结果：我是save方法
AOP中的概念：
Aspect(切面):指横切性关注点的抽象即为切面,它与类相似,只是两者的关注点不一样,类是对物体特征的抽象,而切面横切性关注点的抽象.
joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点,实际上joinpoint还可以是field或类构造器)
Pointcut(切入点):所谓切入点是指我们要对那些joinpoint进行拦截的定义.
Advice(通知):所谓通知是指拦截到joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知
Target(目标对象):代理的目标对象
Weave(织入):指将aspects应用到target对象并导致proxy对象创建的过程称为织入.
Introduction(引入):在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.