AOP实现--JDK中的动态代理和cglib代理

java.lang.reflect  Interface InvocationHandler

可参考http://www.gznc.edu.cn/yxsz/jjglxy/book/Java_api/java/lang/reflect/InvocationHandler.html

http://www.gznc.edu.cn/yxsz/jjglxy/book/Java_api/java/lang/reflect/Proxy.html

invocation是“调用”的意思。这个类可以让我们在JVM调用某个类的方法时动态的为些方法做些什么事.InvocationHandler接口把我们的代理对象和被代理对象解耦了.动态代理类可以对任何实现某一接口的类进行功能性的增强。

关于Method对象的invoke方法,根据java的反射机制可以获得某个对象的某个方法,也可以动态调用,假设已经获取了这个方法method.那么method.invoke(owner,args)就是动态调用,owner表示方法所属的对象,args为Object[]类型的方法参数。

接口InvocationHandler的方法

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable

proxy:在其上调用方法的代理实例(Proxy类型的对象)。

method:对应于在代理实例上调用的接口方法的 Method 实例。。

args:为方法的参数

 1 package proxy;
2
3 import java.lang.reflect.InvocationHandler;
4 import java.lang.reflect.Method;
5 import java.lang.reflect.Proxy;
6 public class DynProxy implements InvocationHandler{
7 private Object src;//被代理对象
8 //bind为自定义方法,将src绑定到某个代理中
9 //把当前对象(实现了InvocationHandler接口)传递给代理对象
10 //返回代理对象
11 public Object bind(Object src){
12 this.src=src;
13 Object proxy=Proxy.newProxyInstance(
14 src.getClass().getClassLoader(),//被代理对象的类加载器
15 src.getClass().getInterfaces(),//被代理对象实现的接口们,代理对象可以实现全部接口
16 this //当前对象(实现了InvocationHandler接口) 回调,拦截到一个方法后可以触发哪个类中的哪个方法。
17 );
18 //返回的是一个带有代理类的指定调用处理程序的代理实例,它由指定的类加载器定义,并实现指定的接口
19 return proxy;
20 }
21 //InvocationHandler接口方法
22 //src(目标对象)中的每个方法会被此方法送去JVM调用,也就是说,src的方法只能通过此方法调用
23 //此方法不能自己调用
24 public Object invoke(Object proxy, Method method, Object[] args)
25 throws Throwable {
26 // TODO Auto-generated method stub
27 System.out.println(method.getName()+"调用前");
28 Object result=method.invoke(src, args);
29 return result;
30 }
31 public static void main(String[] args) {
32 Login src=new Login(); //被代理对象
33 DynProxy dp=new DynProxy();
34 ILogin proxy=(ILogin)dp.bind(src); //返回代理对象
35 String username="tazi",password="123";
36 proxy.login(username, password); //在代理实例上调用接口方法
37 }
38 }

代理对象实现了目标对象的接口,使用时要用接口来引用代理对象。

以上的代码改个名字更好理解:

 1 package com.tazi.aop;
2
3 import java.lang.reflect.InvocationHandler;
4 import java.lang.reflect.Method;
5 import java.lang.reflect.Proxy;
6 //JDK方式的动态代理对象的创建工厂
7 public class JDKProxyFactory implements InvocationHandler{
8 private Object target;//目标对象
9 //创建代理对象的方法
10 //返回的是已经实现了目标对象所有接口的代理对象
11 public Object createProxy(Object target){
12 this.target=target;
13 //以下前两个参数跟目标对象有关
14 //第三个参数是一个包含回调方法(invoke)的对象(实现InvocationHandler接口)
15 return Proxy.newProxyInstance(target.getClass().getClassLoader()
16 , target.getClass().getInterfaces(),this);
17 }
18 //当拦截到目标对象某个方法时的回调方法
19 public Object invoke(Object proxy, Method method, Object[] args)
20 throws Throwable {
21 // TODO Auto-generated method stub
22 System.out.println("方法执行前");
23 Object result=method.invoke(target, args);
24 System.out.println("方法执行后");
25
26 return result;
27 }
28 }

测试用例:

 

package junit.test;

import static org.junit.Assert.*;

import org.junit.BeforeClass;
import org.junit.Test;



import com.tazi.aop.JDKProxyFactory;
import com.tazi.aop.PersonService;
import com.tazi.aop.PersonServiceBean;

public class ProxyTest {
private static JDKProxyFactory proxyFactory;
@BeforeClass
public static void setUpBeforeClass() throws Exception {
proxyFactory=new JDKProxyFactory();
}
@Test
public void proxy() throws Exception {
PersonService pService=(PersonService)proxyFactory.createProxy(new PersonServiceBean());
pService.save("xxx");
}
}

CGLIB实现动态代理

但实际中情况会比较复杂,有可能目标对象没有实现接口。如果没有就不能创建代理对象。此时用到第三方的jar包来创建代理对象。cglib.jar。这时目标对象可以不实现接口。

cglib的实现方式是创建被代理对象的子类,这个子类覆盖了目标对象的所有的非final的所有方法。然后设置回调方法。

 1 package com.tazi.aop;
2
3 import java.lang.reflect.Method;
4
5 import net.sf.cglib.proxy.Enhancer;
6 import net.sf.cglib.proxy.MethodInterceptor;
7 import net.sf.cglib.proxy.MethodProxy;
8
9 public class CglibProxyFactory implements MethodInterceptor{
10 private Object target;
11 public Object createProxy(Object target){
12 this.target=target;
13 Enhancer enhancer=new Enhancer();
14 enhancer.setSuperclass(target.getClass());
15 enhancer.setCallback(this);
16 return enhancer.create();
17 }
18 public Object intercept(Object proxy, Method method, Object[] args,
19 MethodProxy methodProxy) throws Throwable {
20 System.out.println("方法执行前00");
21 Object result=method.invoke(target, args);
22 System.out.println("方法执行后00");
23 return result;
24 }
25 }

你可能感兴趣的:(cglib)