前言
什么是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)）
第一次写文章，有写的不好的地方大家可以题出来。
