静态代理
基本概念
目标对象为其对象提供一种代理对象，其他对象通过代理对象来控制对目标对象的访问。
角色划分
Proxy（美['prɑksi]）：代理对象,其他对象直接控制的对象。
Subject（[ˈsʌbdʒɪkt]）：目标接口，目标对象的抽象。
RealSubject：具体目标对象，目标接口的实现，即真正控制的对象。
简单理解：
当其他对象对某个目标对象进行操作且需要对目标对象进行更改时，若目标对象被多个对象引用，或目标对象不可以更改，此时使用代理模式，通过对代理对象的修改，而完成最终的业务需求。
来源于生活的案例
- 案例描述： 我通过代购，买了一台iphone X。
我想要买一台港版的iphone X，但是我在大陆，不能直接购买港版的iphone X。于是，我找到了代购公司，代购公司帮我买一个iphoneX。
目标接口：买手机动作，行为抽象
目标对象：我->买手机的人->买手机的行为
代理对象：代购的人->同学或者朋友->代理买手机的行为
其他对象：调用购买手机的对象
-
案例理解: 我为什么是目标对象？
在考虑整个案例之后，大多数人一定会主观认为目标对象应该是手机，但是将每个对象进行行为划分，即可理解为目标对象是我，即我买手机的这个行为。
整个案例的核心，是我想要买手机，代购的核心是帮我买手机，而手机却是具有其他行为的，与买手机行为无关的对象。
所以，以买手机的行为方向，进行思考，可以得出以下结论：
目标接口：买手机动作，行为抽象
目标对象：我->买手机的人->买手机的行为
代理对象：代购的人->同学或者朋友->代理买手机的行为
其他对象：调用购买手机的对象
- 案例代码实现： 代码实现三步走；
1.将行为抽象，实现目标接口
目标接口：IShopPhone（购物->手机）
2.实现行为，完成购买动作
目标对象：ShopPhone
特点：实现目标接口
3.实现代理对象，改变由代理对象完成。
代理对象：WJProxy
特点一：实现目标接口（可有可无）
特点二：持有目标对象的引用（必需）
源码展示
/**
* 目标接口，抽象购买行为
*/
public interface IShopPhone {
/**
* 购买手机
* @param str
*/
void shopPhone(String str);
}
/**
* 目标接口的实现类，实现具体的行为
*/
public class ShopPhone implements IShopPhone {
@Override
public void shopPhone(String str) {
System.out.println(str);
}
}
/**
* 代理类，代理购买手机的行为。
*/
public class ProxyShopPhone implements IShopPhone {
IShopPhone mTarget;
/**
* 目标
*/
public ProxyShopPhone(IShopPhone target) {
this.mTarget = target;
}
@Override
public void shopPhone(String str) {
System.out.println("-----start----");
mTarget.shopPhone(str);
System.out.println("-----end----");
}
}
/**
* 用户类，用户进行买手机的操作
*/
public class User {
public static void main(String[] args) {
/*在大陆买手机*/
ShopPhone shopPhone = new ShopPhone();
shopPhone.shopPhone("在大陆买了一个iPhone X，一共花了8888元");
/*在香港买手机*/
ProxyShopPhone proxyShopPhone = new ProxyShopPhone(shopPhone);
proxyShopPhone.shopPhone("通过代购，在香港买了一个iphone X，一共花了6666元");
}
}
————————————————————控制台显示的结果—————————————————————
在大陆买了一个iPhone X，一共花了8888元
-----start----
通过代购，在香港买了一个iphone X，一共花了6666元
-----end----
Process finished with exit code 0
——————————————END——————————————
动态代理
与静态代理的区别
动态创建代理类（虚拟机->框架、系统帮助我们来完成创建过程）
动态代理的特点
1.代理对象不需要实现接口。
2.不需要自己实现代理对象，由虚拟机动态生成（内部通过java反射实现）。
3.动态代理也叫做JDK代理或接口代理。
代码实现
将动态代理中，不使用静态代理中的代理对象，通过jdk中自带的代理方法实现动态代理。
/**
* 操作类---测试类
*/
public class Main {
public static void main(String[] args) {
/*在大陆买手机*/
ShopPhone shopPhone = new ShopPhone();
shopPhone.shopPhone("在大陆买了一个iPhone X，一共花了8888元");
/*动态代理---在香港买手机*/
IShopPhone proxy = (IShopPhone) Proxy.newProxyInstance(shopPhone.getClass().getClassLoader(), shopPhone.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("-----动态代理 start----");
Object returnValue = method.invoke(shopPhone, args);
System.out.println("-----动态代理 end----");
return returnValue;
}
});
proxy.shopPhone("通过代购，在香港买了一个iphone X，一共花了6666元");
}
- newProxyInstance详解：
ClassLoader loader: 指定当前目标对象使用类加载器,即目标对象的类加载器。获取方法是固定的：[shopPhone.getClass().getClassLoader()]。
Class[] interfaces: 目标对象实现的接口的类型,使用泛型方式确认类型。获取方法是固定的：[shopPhone.getClass().getInterfaces()]。
InvocationHandler h: 事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入。即动态代理类接口的实现，通过JAVA反射实现。
封装动态代理工厂代码实现
/**
* 动态代理工厂
*/
public class ProxyFactory {
private Object mTarget;
/**
* 维护一个目标对象
*/
public ProxyFactory(Object target) {
this.mTarget = target;
}
/**
* 获取动态代理对象
*
* @return
*/
public Object getProxyInstance() {
return Proxy.newProxyInstance(mTarget.getClass().getClassLoader(), mTarget.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("--------start-------");
Object returnValue = method.invoke(mTarget,args);
System.out.println("---------end--------");
return returnValue;
}
});
}
}
——————————————————————使用方法—————————————————————
proxy.shopPhone("通过代购，在香港买了一个iphone X，一共花了6666元");
IShopPhone proxy2 = (IShopPhone) new ProxyFactory(shopPhone).getProxyInstance();
proxy2.shopPhone("通过代购商店，在香港买了一个iphone X，一共花了6666元");
——————————————————————控制台输出结果—————————————————————
在大陆买了一个iPhone X，一共花了8888元
--------start-------
通过代购商店，在香港买了一个iphone X，一共花了6666元
---------end--------
Process finished with exit code 0
cglib动态代理
基本概述
可继承式的动态代理（java仅允许单继承，而JDK中的代理类，自身就会继承Proxy），在android开发中，一般不会使用。
使用该方式实现动态代理，需要倒入cglib.jar，或使用spring框架，即该方式的动态代理，大多在后台服务器中使用，在本片文章中不会过多讲解；
代码实现
/**
/**
* 通过继承实现的动态代理类
*/
public class CGLibProxy implements MethodInterceptor {
private Enhancer enhancer = new Enhancer();
public Object getProxy(Class clazz){
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
return enhancer.create();
}
/**
* 拦截所有目标类方法的调用
* 参数：
* obj目标实例对象
*method 目标方法的反射对象
* args方法的参数
* proxy代理类的实例
*/
public Object intercept(Object obj, Method method, Object[] args,
MethodProxy proxy) throws Throwable {
//代理类调用父类的方法
System.out.println("日志开始");
proxy.invokeSuper(obj, args);
System.out.println("日志结束");
return null;
}
}
——————————————————————使用方法—————————————————————
/*通过cglib.jar实现可继承的动态代理*/
IShopPhone proxy3 = (IShopPhone) new CGLibProxy().getProxy(ShopPhone.class);
proxy3.shopPhone("通过代购，在香港买了一个iphone X，一共花了6666元");
使用场景
例如：开发当中->类似框架（代理模式）
XUtils框架、Retrofit框架、MVP架构设计、插件化架构设计等等...
最后，为自己留一个作业：如何通过java反射自己实现JDK动态代理？