Java 动态代理的理解与Cglib动态代理实现

　　什么是动态代理?

　　先说下静态代理：

　　也即是说，在程序运行前，已经有了编译好的类，这个就是静态代理，

　　动态代理：

　　也即，在程序运行前， 代理类并不存在，而是在程序运行时，动态生成的类是动态代理类。

　　可能会有如下思考

　　代理模式是怎样的?用什么技术实现?

　　为什么要使用代理模式呢?有什么好处?

　　动态代理的应用场景有哪些?

　　先说说动态代理的实现吧：

　　动态代理主要使用的是Java 反射技术：

　　JavaAPI 中关于InvocationHandler有大致这么一段描述，每个代理类都要实现InvocationHandler这个接口,每个代理类都会关联到一个handle,

　　当一个代理类调用方法时，会转到InvocationHandler的Invoke方法进行调用。

　　以下代码有引用以为牛人代码

　　看下InvocationHandler源码，我这就不再写一遍了。

　　public interface InvocationHandler

　　{

　　public abstract Object invoke(Object obj, Method method, Object aobj[])

　　throws Throwable;

　　}

　　这个invoke方法中有几个参数 ：

　　obj:表示我们要调用的真实对象

　　method:表示我们要调用的真实对象的某个方法。

　　aobj[] :表示真实对象某个方法接受的参数。

　　怎么用这个InvocationHandler 这个接口，主要看proxy这个类：

　　Proxy是创建一个代理对象的类

　　Proxy这个类有这个一个方法：是用的最多的方法

　　public static Object newProxyInstance(ClassLoader classloader, Class aclass[], InvocationHandler invocationhandler)

　　throws IllegalArgumentException

　　参数：

　　classloader: 定义了由那个ClassLoader对对象进行加载

　　aclass[]: 是为代理对象提供了哪些接口，表示代理对象实现了这些接口，

　　invocationhandler: 表示代理对象调用方法时会关联到那个invocationhandler

　　主要通过类Proxy与接口invocationhandler实现动态代理：

　　看下具体动态代理实现加深理解：

　　1.首先肯定是需要一个接口的：

　　public interface UserService {

　　public String getName(int id);

　　public Integer getAge(int id);

　　}

　　还需要这个接口的实现，也就是代理对象：

　　public class UserServiceImpl implements UserService {

　　@Override

　　public String getName(int id) {

　　System.out.println("------getName------");

　　return "Tom";

　　}

　　@Override

　　public Integer getAge(int id) {

　　System.out.println("------getAge------");

　　return 10;

　　}

　　}

　　还需要自定义一个invocationhandler ，自己实现invoke方法：

　　import java.lang.reflect.InvocationHandler;

　　import java.lang.reflect.Method;

　　public class MyInvocationHandler implements InvocationHandler {

　　private Object target;

　　MyInvocationHandler() {

　　super();

　　}

　　MyInvocationHandler(Object target) {

　　super();

　　this.target = target;

　　}

　　@Override

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

　　if("getName".equals(method.getName())){

　　System.out.println("++++++before " + method.getName() + "++++++");

　　Object result = method.invoke(target, args);

　　System.out.println("++++++after " + method.getName() + "++++++");

　　return result;

　　}else{

　　Object result = method.invoke(target, args);

　　return result;

　　}

　　}

　　}

　　最后再看下proxy是怎样的使用这个接口，还有invocationhandler的

　　import java.lang.reflect.InvocationHandler;

　　import java.lang.reflect.Proxy;

　　public class TestProxy {

　　public static void main(String[] args) {

　　UserService userService = new UserServiceImpl();

　　InvocationHandler invocationHandler = new MyInvocationHandler(userService);

　　UserService userServiceProxy = (UserService)Proxy.newProxyInstance(userService.getClass().getClassLoader(),

　　userService.getClass().getInterfaces(), invocationHandler);

　　System.out.println(userServiceProxy.getName(1));

　　System.out.println(userServiceProxy.getAge(1));

　　}

　　}

　　以上可以看到可以清晰理解proxy的newproxyInstance是用来生成代理对象的， userService是指向具体 的实现

　　UserServiceImpl

　　给newproxyInstance方法传入实际的classLoader，实际类对应的接口，与调用类方法的invocationhandler即可实现：

　　System.out.println("++++++before " + method.getName() + "++++++");

　　其实上面这个一行代码就有***性质，aop时再详细讨论.

　　上面可以看到 使用这个反射技术实现动态代理，需要定义一个接口，但是有时候其实不想定义接口，只希望定义好实现类，然后你再在方法运行前，运行后加些内容即可。

　　这个就考虑了一个CGLIB这个可是不错的使用CGLIB实现动态代理很方便。

　　Cglib 采用的是ASM字节码技术，利用字节码生成代理类。效率比反射要高，但是不能代理final修身的类，clglib元素是集成被代理的类。final类不能被继承。

　　下面看下cglib具体实现：

　　下载 cglib包和asm包，你的工程需要依赖这两个包：

　　首先需要一个非final类，不再和反射一样需要一个接口了

　　public class StudentService {

　　public String getName(){

　　System.out.println("------getName------");

　　return "Tom";

　　}

　　public Integer getID(){

　　System.out.println("------getID------");

　　return 10;

　　}

　　}

　　接下来就看怎么代理上面的类了，需要定义一个拦截器：

　　import net.sf.cglib.proxy.MethodInterceptor;

　　import net.sf.cglib.proxy.MethodProxy;

　　import java.lang.reflect.Method;

　　public class CglibProxy implements MethodInterceptor {

　　@Override

　　public Object intercept(Object o, Method method, Object[] args,

　　MethodProxy methodProxy) throws Throwable {

　　System.out.println("++++++before " + methodProxy.getSuperName()

　　+ "++++++");

　　System.out.println(method.getName());

　　Object o1 = methodProxy.invokeSuper(o, args);

　　System.out.println("++++++before " + methodProxy.getSuperName()

　　+ "++++++");

　　return o1;

　　}

　　}

　　上面的interceptf方法和invocationhandler中的invoke方法类似，通过interceptf来真正调用方法invokeSuper:

　　最后看下Cglb具体怎么代理StudentService这个类吧：

　　import net.sf.cglib.proxy.Enhancer;

　　public class TestCglib {

　　public static void main(String[] args) {

　　CglibProxy cglibProxy = new CglibProxy();

　　Enhancer enhancer = new Enhancer();

　　enhancer.setSuperclass(StudentService.class);

　　enhancer.setCallback(cglibProxy);

　　StudentService o = (StudentService)enhancer.create();

　　System.out.println(o.getName());

　　// System.out.println(o.getID());

　　}

　　}

　　上面的o即是 代理类，该类可以访问真实的Studentservice方法：

　　运行结果：无锡妇科检查多少钱 http://www.120csfkyy.com/

　　++++++before CGLIB$getName$1++++++

　　getName

　　------getName------

　　++++++before CGLIB$getName$1++++++

　　Tom

　　使用Cglib 有啥好处?

　　看下面代码：

　　public class TestCglib {

　　public static void main(String[] args) {

　　CglibProxy cglibProxy = new CglibProxy();

　　Enhancer enhancer = new Enhancer();

　　enhancer.setSuperclass(StudentService.class);

　　enhancer.setCallback(cglibProxy);

　　StudentService o = (StudentService)enhancer.create();

　　System.out.println(o.getName());

　　// System.out.println(o.getID());

　　Enhancer enhancer1 = new Enhancer();

　　enhancer1.setSuperclass(UserServiceImpl.class);

　　enhancer1.setCallback(cglibProxy);

　　UserServiceImpl obj = (UserServiceImpl)enhancer1.create();

　　System.out.println(obj.getName(1));

　　// System.out.println(o.getID());

　　}

　　}

　　只要写一个

　　cglibProxy

　　就可以是实现

　　对UserServiceImpl 与 StudentService进行代理

　　减少了代码的繁琐，只有有这么一个代理就够了，其次方便维护，解耦合，要是有问题，只要去找 原始类就可以了