什么是代理模式？
为其他对象提供一种代理以控制对这个对象的访问。——《Java设计模式》
image.png
■ 抽象主题（Subject）角色：该角色是真实主题和代理主题的共同接口，以便在任何可以使用真实主题的地方都可以使用代理主题。
■ 代理主题（Proxy Subject）角色：也叫做委托类、代理类，该角色
1)负责控制对真实主题的引用，
2)负责在需要的时候创建或删除真实主题对象
3)在真实主题角色处理完毕前后做预处理和善后处理工作。
■ 真实主题（Real Subject）角色：该角色也叫做被委托角色、被代理角色，是业务逻辑的具体执行者。
1.静态代理
Java中的静态代理要求代理类(ProxySubject)和委托类（RealSubject）都实现同一个接口（Subject）。
1)静态代理中代理类在编译期就已经确定。
2)静态代理的效率相对动态代理来说相对高一些
3)静态代理代码冗余大，一单需要修改接口，代理类和委托类都需要修改。
举例：
接口 Developer:
public interface Developer {
void coding();
void debug();
}
委托类 AndroidDeveloper：
public class AndroidDeveloper implements Developer{
private String name;
public AndroidDeveloper(String name){
this.name = name;
}
public String getDeveloperName(){
return name;
}
@Override
public void coding(){
System.out.println("Coding: "+this.name+" is developing Android!");
}
@Override
public void debug(){
System.out.println("Coding: "+this.name+" is debugging his APP!");
}
}
静态代理类 JavaStaticProxy
public class JavaStaticProxy implements Developer{
private Developer target;
public JavaStaticProxy(Developer developer){
this.target = developer;
}
@Override
public void coding() {
System.out.println("before!");
this.target.coding();
System.out.println("after!");
}
@Override
public void debug() {
System.out.println("before!");
this.target.debug();
System.out.println("after!");
}
}
测试：
public class Main {
public static void main(String[] args){
StaticProxyTest();
}
public static void StaticProxyTest(){
System.out.println("StaticProxy:");
Developer Breeze = new AndroidDeveloper("Breeze");
JavaStaticProxy staticProxy = new JavaStaticProxy(Breeze);
staticProxy.coding();
staticProxy.debug();
}
}
输出：
StaticProxy:
before!
Coding: Breeze is developing Android!
after!
before!
Coding: Breeze is debugging his APP!
after!
2.动态代理
Java中的动态代理依靠反射来实现，代理类和委托类不需要实现同一个接口。委托类需要实现接口，否则无法创建动态代理。代理类在JVM运行时动态生成，而不是编译期就能确定。
Java动态代理主要涉及到两个类：java.lang.reflect.Proxy和java.lang.reflect.InvocationHandler。代理类需要实现InvocationHandler接口或者创建匿名内部类，而Proxy用于创建动态动态。
特点：
1)不要求代理类与委托类实现统一接口，避免了静态代理生成大量代理类的问题，但比较消耗性能。
2)可以非常灵活地在某个类，某个方法，某个代码点上切入我们想要的内容，就是动态代理其中的内容。
2.1 例子：
动态代理类 JavaDynamicProxy
package java_proxy;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
public class JavaDynamicProxy {
private Developer target;
public JavaDynamicProxy(Developer target){
this.target = target;
}
public Object getDeveloperProxy(){
Developer developerProxy = (Developer) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().
getInterfaces(), (proxy, method, args1) -> {
Field field = target.getClass().getDeclaredField("name");
field.setAccessible(true);
String name = (String) field.get(target);
if(method.getName().equals("coding")){
beforeCoding(name);
method.invoke(target, args1);
afterCoding(name);
}
if(method.getName().equals("debug")){
beforeDebug(name);
method.invoke(target, args1);
afterDebug(name);
}
return null;
});
return developerProxy;
}
public void beforeCoding(String name){
System.out.println("Before coding: "+name+" is very happy!");
}
public void afterCoding(String name){
System.out.println("After coding: "+name+" is very tired!");
}
public void beforeDebug(String name){
System.out.println("Before debugging: "+name+"'s App has no bug! Nobody knows Android better than me!");
}
public void afterDebug(String name){
System.out.println("After debugging: What trash is "+name+"?");
}
}
测试：
package java_proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class Main {
public static void main(String[] args){
DynamicProxyTest();
}
public static void DynamicProxyTest(){
System.out.println("DynamicProxy:");
AndroidDeveloper target = new AndroidDeveloper("Breeze");
Developer proxy = (Developer)new JavaDynamicProxy(target).getDeveloperProxy();
proxy.coding();
proxy.debug();
}
}
输出：
DynamicProxy:
Before coding: Breeze is very happy!
Coding: Breeze is developing Android!
After coding: Breeze is very tired!
Before debugging: Breeze's App has no bug! Nobody knows Android better than me!
Coding: Breeze is debugging his APP!
After debugging: What trash is Breeze?
2.2 动态代理的原理
Proxy.newProxyInstance()
把接口复制出来，通过这些接口和类加载器，拿到这个代理类cl。然后通过反射的技术复制拿到代理类的构造函数（这部分代码在Class类中的getConstructor0方法），最后通过这个构造函数new个一对象出来，同时用InvocationHandler绑定这个对象。
/* @param loader the class loader to define the proxy class
* @param interfaces the list of interfaces for the proxy class
* to implement
* @param h the invocation handler to dispatch method invocations to
* @return a proxy instance with the specified invocation handler of a
* proxy class that is defined by the specified class loader
* and that implements the specified interfaces
* @throws IllegalArgumentException if any of the <a href="#restrictions">
* restrictions</a> on the parameters are violated
* @throws SecurityException if a security manager, <em>s</em>, is present
* and any of the following conditions is met:
* <ul>
* <li> the given {@code loader} is {@code null} and
* the caller's class loader is not {@code null} and the
* invocation of {@link SecurityManager#checkPermission
* s.checkPermission} with
* {@code RuntimePermission("getClassLoader")} permission
* denies access;</li>
* <li> for each proxy interface, {@code intf},
* the caller's class loader is not the same as or an
* ancestor of the class loader for {@code intf} and
* invocation of {@link SecurityManager#checkPackageAccess
* s.checkPackageAccess()} denies access to {@code intf};</li>
* <li> any of the given proxy interfaces is non-public and the
* caller class is not in the same {@linkplain Package runtime package}
* as the non-public interface and the invocation of
* {@link SecurityManager#checkPermission s.checkPermission} with
* {@code ReflectPermission("newProxyInPackage.{package name}")}
* permission denies access.</li>
* </ul>
* @throws NullPointerException if the {@code interfaces} array
* argument or any of its elements are {@code null}, or
* if the invocation handler, {@code h}, is
* {@code null}
*
* @see <a href="#membership">Package and Module Membership of Proxy Class</a>
* @revised 9
* @spec JPMS
*/
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h) {
Objects.requireNonNull(h);
final Class<?> caller = System.getSecurityManager() == null
? null
: Reflection.getCallerClass();
/*
* Look up or generate the designated proxy class and its constructor.
*/
Constructor<?> cons = getProxyConstructor(caller, loader, interfaces);
return newProxyInstance(caller, cons, h);
}
InvocationHandler
InvocationHandler作用就是，当代理对象的原本方法被调用的时候，会绑定执行一个方法，这个方法就是InvocationHandler里面定义的内容，同时会替代原本方法的结果返回。
InvocationHandler接收三个参数
- proxy，代理后的实例对象。
- method，对象被调用方法。
- args，调用时的参数。
public interface InvocationHandler {
/**
* Processes a method invocation on a proxy instance and returns
* the result. This method will be invoked on an invocation handler
* when a method is invoked on a proxy instance that it is
* associated with.
*
* @param proxy the proxy instance that the method was invoked on
*
* @param method the {@code Method} instance corresponding to
* the interface method invoked on the proxy instance. The declaring
* class of the {@code Method} object will be the interface that
* the method was declared in, which may be a superinterface of the
* proxy interface that the proxy class inherits the method through.
*
* @param args an array of objects containing the values of the
* arguments passed in the method invocation on the proxy instance,
* or {@code null} if interface method takes no arguments.
* Arguments of primitive types are wrapped in instances of the
* appropriate primitive wrapper class, such as
* {@code java.lang.Integer} or {@code java.lang.Boolean}.
*
* @return the value to return from the method invocation on the
* proxy instance. If the declared return type of the interface
* method is a primitive type, then the value returned by
* this method must be an instance of the corresponding primitive
* wrapper class; otherwise, it must be a type assignable to the
* declared return type. If the value returned by this method is
* {@code null} and the interface method's return type is
* primitive, then a {@code NullPointerException} will be
* thrown by the method invocation on the proxy instance. If the
* value returned by this method is otherwise not compatible with
* the interface method's declared return type as described above,
* a {@code ClassCastException} will be thrown by the method
* invocation on the proxy instance.
……
*/
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
}
