今天想阅读Retrofit的源码，发现一开始就是一个代理。对代理的模式又不是很了解。学习了一波。
什么是代理
我们买衣服有代理商，存在于我们和厂家之间。厂家是卖衣服的，代理商也是卖衣服的，我们去买衣服，一般不
能直接找厂家，所以我们找代理商买衣服，代理商找厂家买衣服，代理商进行提价，就是我们需要
让代理，进行的操作。
代理的理解
代理模式需要3个角色。
- 抽象角色 声明真实对象和代理对象共有的操作
- 代理对象 代理对象持有真实对象的引用，从而可以对真实对象进行操作，同时代理对象和真实对象实现相同的接口，可以在任何时刻替换掉真实对象。
代理对象调用真实对象的操作是，可以加上自己的操作，相当于对真实对象进行封装。 - 真实对象 代理对象代表的对象，是我们最终引用的对象。
代理模式对外部提供统一的接口方法，，而代理类在接口中实现对真实类的附加操作行为，从而可以在不影响外部调用情况下，进行系统扩展。也就是说，我要修改真实角色的操作的时候，尽量不要修改他，而是在外部在“包”一层进行附加行为，即代理类。
从而达到对修改关闭，对扩展开放,保证系统的稳定性。
与真实对象不存在联系，降低耦合
静态代理
在编码过程中对代理进行指定。和生活中的代理商一样。
抽象对象 卖衣服
public interface ClothingSell {
void sellClothes();
}
代理对象 代理商
package staticProxy;
/**
* Created by azezer0 on 16/10/21.
*/
public class ClothingFactor implements ClothingSell {
private ClothingFactory clothingFactory;
public ClothingFactor(ClothingFactory clothingFactory) {
this.clothingFactory = clothingFactory;
}
public ClothingFactor() {
this.clothingFactory = new ClothingFactory();
}
@Override
public void sellClothes() {
System.out.println("我是一个买衣服的代理商,先涨价3倍");
clothingFactory.sellClothes();
System.out.println("衣服卖好了,再见");
}
}
真实对象
package staticProxy;
/**
* Created by azezer0 on 16/10/21.
*/
public class ClothingFactory implements ClothingSell {
@Override
public void sellClothes() {
System.out.println("我是一个衣服厂家");
}
}
执行
package staticProxy;
/**
* Created by azezer0 on 16/10/21.
*/
public class Main {
public static void main(String str[])
{
ClothingFactor clothingFactor = new ClothingFactor();
System.out.println("我要买衣服");
clothingFactor.sellClothes();
System.out.println("衣服买好了");
}
}
结果
我要买衣服
我是一个买衣服的代理商,先涨价3倍
我是一个衣服厂家
衣服卖好了,再见
衣服买好了
动态代理
在程序运行过程中，才生出代理类，并执行.由于是在执行过程中，才会身材代理类。如果大规模采用静态代理，产生大量的类同时代理角色与真实角色功能重复，是系统臃肿复制。
代理原理
java编译器编译完成以后，生成class文件，虚拟机读取字节码文件，加载内存，解析，生成Class对象。而动态代理就是在程序运行过程中直接生成新的class字节码二进制数据，由jvm加载执行，从而完成动态代理的操作。
但是在动态生成代码的过程，如果完成一行一行的实现一个新的类，是十分繁琐而且容易出错，我们使用代理模式是系统在不影响系统稳定是的前提下，对系统进行扩展。
代理模式中，Proxy角色，在执行代理操作时，也就是在执行真实对象的操作之前和之后执行了”新添加的逻辑“,所以我们完全可以这一部分抽象出来。这就有了
InvocationHandler
动态代理架构
JDK动态代理创建机制
代理类有java动态生成，所以将会执行以下操作
- 获取真实对象的接口
- 生成代理名称
- 动态创建代理对象的字节码
- 创建InvocationHanlder的实例Handler，出来代理对象的方法调用。
- 实例化代理对象。
场景
电动汽车的特点，能开，能充电。
真实对象 电动车
代理独享 （动态生成）
抽象对象 驾驶接口 充电接口
InVocationHandler handler
电动车
package proxyTest;
/**
* Created by azezer0 on 16/10/21.
*/
public class ElectricCar implements Rechargable, Vehicle {
public static final String Tag = ElectricCar.class.getSimpleName();
@Override
public void recharge() {
System.out.println(Tag+"__"+"recharge");
}
@Override
public void driver() {
System.out.println(Tag + "__" + "driver");
}
}
驾驶接口
package proxyTest;
/**
* Created by azezer0 on 16/10/21.
*/
public interface Vehicle {
void driver();
}
充电接口
package proxyTest;
/**
* Created by azezer0 on 16/10/21.
*/
public interface Rechargable {
void recharge();
}
handler 实现 InvocationHandler接口
package proxyTest;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
* Created by azezer0 on 16/10/21.
*/
public class InvocationHandlerImpl implements InvocationHandler {
private ElectricCar car;
public InvocationHandlerImpl(ElectricCar car) {
this.car = car;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Handler" + "___" + method.getName() + "___Start");
method.invoke(car, null);
System.out.println("Handler" + "___" + method.getName() + "___Stop");
return null;
}
}
生成代理类，并执行
package proxyTest;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
/**
* Created by azezer0 on 16/10/21.
*/
public class TestMain {
public static void main(String args[]) {
//电动车实体类
ElectricCar car = new ElectricCar();
//获取车的类加载器
ClassLoader classLoader = car.getClass().getClassLoader();
Class[] interfacess = car.getClass().getInterfaces();
InvocationHandler handler = new InvocationHandlerImpl(car);
//拿到代理类
Object o = Proxy.newProxyInstance(classLoader, interfacess, handler);
//执行操作
Vehicle vehicle = (Vehicle) o;
vehicle.driver();
Rechargable rechargable = (Rechargable) o;
rechargable.recharge();
//保存到本地 class 文件
// ProxyUtils.generateClassFile(car.getClass(),"ElectirCarProxy");
}
}
执行结果
Handler___driver___Start
ElectricCar__driver
Handler___driver___Stop
Handler___recharge___Start
ElectricCar__recharge
Handler___recharge___Stop
/Users/azezer0/x603/study/HTTPS/out/production/HTTPS/proxyTest/
保存生成的字节码工具到本地
package proxyTest;
import sun.misc.ProxyGenerator;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* Created by azezer0 on 16/10/21.
*/
public class ProxyUtils {
public static void generateClassFile(Class clazz, String proxyName) {
byte[] bytes = ProxyGenerator.generateProxyClass(proxyName, clazz.getInterfaces());
String paths = clazz.getResource(".").getPath();
System.out.println(paths);
FileOutputStream out = null;
try {
out = new FileOutputStream(paths + proxyName + ".class");
out.write(bytes);
out.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
总结
程序只是对生活的抽象，又一次真实的感受到了，设计模式是对程序的抽象，所以是所有的设计模式，都是可以在生活中找到实例的。
1.远程代理 Remote Proxy
通过代理来表示另一个地址空间中的对象
2.虚代理 Virtual Proxy
按需创建开销很大的对象. 常用于延迟加载.
3.保护代理 Protection Proxy
-控制对原始对象的访问.
-在访问对象时可以附加一些操作
4.智能指引 Smart Reference
-充当智能指针: 能自动释放所引用的对象
-在访问对象时可以附加一些操作
在面向对象中称之为： 职责分明。
很不错的解释
打个比喻，明星为什么需要经纪人来代理他呢？因为明星的专职是唱歌或演戏，如果把除此以外的其他事情比如演出费用谈判等等都揽在身上，他会累死。
这就是体现一个思想：专业分工，用面向对象术语说：就是职责分明。
所以，代理类一般是做些除原始类核心功能以外的其他功能，比如权限 事务等等都要专门的代理来实现。
当我们的代码每个类代表一个主要功能，而不是将所有功能混在一个类中，那么代码无疑清晰有条理的，易于维护，比如我要修改权限，就不必打开原始类代码，直接修改权限代理类就可以了。就很少发生修改一个BUG，带来一个新BUG的烦恼问题。
No matter how slow you are writing clean code, you will always be slower if you make a mess 写干净的代码无论有多慢，总是快于把代码写得一团糟。
