前言

什么是java代理，为什么要学习java代理。在很多框架中都会用到，如Spring中的AOP、Hadoop中的RPC等

什么是JAVA代理

给某一个对象提供一个代理，并由代理对象控制对原对象的引用。

代理的种类

代理分为静态代理和动态代理，静态代理是在编译时就将接口、实现类、代理类全部由程序员手动完成，且代理的类在程序运行之前就已经存在了。但如果我们需要很多的代理，每一个都这么手动的去创建实属浪费时间，而且会有大量的重复代码，此时我们就可以采用动态代理，动态代理可以在程序运行期间根据需要动态的创建代理类及其实例，来完成具体的功能。

静态代理

定义一个PersonEntity实体

public class  PersonEntity{
    private String name;
    private Integer age;
    get,set方法省略
}

定义一个Person接口

public interface PersonService {
    public PersonEntity getPerson();
    public void personInfo(PersonEntity entity);
}

实现PersonService接口

public class PersonServiceImpl implements PersonService {
    private static PersonEntity entity=null;
    @Override
    public PersonEntity getPerson() {
        return createPerson();
    }
    @Override
    public void personInfo(PersonEntity entity) {
        System.out.println("person_name:"+entity.getName()+",person_age:"+entity.getAge());
    }
    public static PersonEntity createPerson(){
        if(entity==null){
            entity=new PersonEntity();
            return entity;
        }else{
            return entity;
        }
    }
}

调用PersonServiceImpl

public class Test{
    public static void main(String[] args) {
        PersonService pService = new PersonServiceImpl();
        PersonEntity entity=new PersonEntity();
        entity.setAge(22);
        entity.setName("youshh");
        pService.personInfo(entity);
    }
}

运行结果:

person_name:youshh,person_age:22

动态代理

动态代理的基础代码同静态代码一致，但是并不是通过new 的方式来获取接口而是通过重写InvocationHandler的invoke接口来实现代理功能（InvocationHandler是JDK的动态代理接口里面只有一个invoke方法，返回值为Object）
代理PersonProxyHandler的代码：

public class PersonProxyHandler implements InvocationHandler {
    private Object object;
    public PersonProxyHandler(Object object) {
        super();
        this.object = object;
    }
    /**
    * 继承InvocationHandler 代理接口， 实现invoke方法
    */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
        System.out.println("before proxy ");
        Object p=method.invoke(object, args);
        System.out.println("after proxy");
        return p;
    }
}

调用

public class Test {
    public static void main(String[] args) {
        PersonService pService = new PersonServiceImpl();
        InvocationHandler handler =new PersonProxyHandler(pService);
        PersonService pService2 = (PersonService) Proxy.newProxyInstance(handler.getClass().getClassLoader(), pService.getClass().getInterfaces(), handler);
        PersonEntity entity=pService2.getPerson();
        entity.setAge(24);
        entity.setName("youshh");
        pService2.personInfo(entity);
    }
}

运行结果:

person_name:youshh,person_age:22

值得注意的是在invoke中如果return null，那么在调用有返回值的方法时就获取不到其返回值，而最终获取到的是null，例如PersonEntity entity=pService2.getPerson();在调用时
entity最终为null，所以在实际业务中invoke的是否需要返回值更具实际来定义。
从上面代码中可以看出 PersonService 是通过Proxy.newProxyInstance 生成的，

在proxy中的代码有什么样的呢？

为什么能通过Proxy的静态方法newProxyInstance获取到PersonService的实例呢？这个是通过JAVA的反射机制实现的。

//由于 Proxy 内部从不直接调用构造函数，所以 private 类型意味着禁止任何调用private Proxy() {}

//由于 Proxy 内部从不直接调用构造函数，所以 protected 意味着只有子类可以调用

protectedProxy(InvocationHandler h) {this.h = h;}

Proxy静态方法newProxyInstance

public static Object newProxyInstance(ClassLoader loader, Class[]interfaces,InvocationHandler h)    throwsIllegalArgumentException {//检查 h 不为空，否则抛异常if(h ==null) {thrownewNullPointerException();
}//获得与指定类装载器和一组接口相关的代理类类型对象Class cl =getProxyClass(loader, interfaces);//通过反射获取构造函数对象并生成代理类实例try{
    Constructor cons=cl.getConstructor(constructorParams);return(Object) cons.newInstance(newObject[] { h });
    }catch(NoSuchMethodException e) {thrownewInternalError(e.toString());
    }catch(IllegalAccessException e) {thrownewInternalError(e.toString());
    }catch(InstantiationException e) {thrownewInternalError(e.toString());
    }catch(InvocationTargetException e) {thrownewInternalError(e.toString());
    }
}

动态代理还有一种实现方式：cglib动态代理实现，据说它的运行速度要远远快于JDK的Proxy动态

这个目前还没进行深入研究

总结

一个典型的动态代理创建对象过程可分为以下四个步骤：

1、通过实现InvocationHandler接口创建自己的调用处理器

 IvocationHandler handler = new InvocationHandlerImpl(...);

2、通过为Proxy类指定ClassLoader对象和一组interface创建动态代理类

Class clazz = Proxy.getProxyClass(classLoader,new Class[]{...});

3、通过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型

Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});

4、通过构造函数创建代理类实例，此时需将调用处理器对象作为参数被传入

Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler));

为了简化对象创建过程，Proxy类中的newInstance方法封装了2~4，只需两步即可完成代理对象的创建。

生成的ProxySubject继承Proxy类实现Subject接口，实现的Subject的方法实际调用处理器的invoke方法，而invoke方法利用反射调用的是被代理对象的的方法（Object result=method.invoke(proxied,args)）

第一次写文章，有写的不好的地方大家可以题出来。