代理模式的定义
由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。换种方式来说我们对实际目标对象的访问是通过访问代理对象，然后代理对象去访问实际对象来实现的。代理对象的作用主要是预处理消息、把消息转发给目标对象、对消息进行事后处理。代理模式在访问目标对象时能够引入一定的间接性，通过此简介性使得我们能够完成一些事情。
使用场景
假如现在有这样一个需求，你有一个接口，这个接口下有很多实现类。你需要统计这个接口下面的所有方法的执行时间，要在不破坏原先代码的结构下如何实现这个需求，那么使用java代理如何来实现这个功能呢？
实现
代理有静态代理和动态代理两种方式，静态代理的代理类是由我们所创建的，在编译的时候就已经确定了访问对象、代理对象、目标对象。在程序运行之前，代理对象的.class文件就已经生成了；动态代理是指，代理对象是在程序运行的时候才将代理对象的.class文件生成。下面将使用静态代理和动态代理的两种方式分别来实现上面的功能。
静态代理
创建的接口
public interface MyInterface {
void method1(String var1);
}
接口的实现
public class MyInterfaceImpl1 implements MyInterface {
@Override
public void method1(String param) {
System.out.println("进入了method1方法");
System.out.println(param);
try {
Thread.sleep((long) (1000+ (Math.random()*100)));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("退出了method1方法");
}
}
接口实现的代理类
public class MyInterfaceImpl1Proxy implements MyInterface{
MyInterface myInterface;
public MyInterfaceImpl1Proxy() {
this.myInterface = new MyInterfaceImpl1();
}
@Override
public void method1(String param) {
MonitorUtil.start();
this.myInterface.method1(param);
MonitorUtil.finish("method1");
}
}
测试
public class Test {
public static void main(String[] args) {
MyInterface myInterface = new MyInterfaceImpl1Proxy();
myInterface.method1("pcy");
}
}
执行结果
从上面的例子我们可以看到，代理类也实现了MyInterface接口，对MyInterfaceImpl1的访问是通过MyInterfaceImpl1Proxy类的访问间接进行的。MyInterfaceImpl1Proxy通过持有一个MyInterfaceImpl1的对象，当访问对象访问目标对象的某个方法时，通过代理对象来调用目标对象的方法来实现目标对象方法的调用。但这种方式也有一定的弊端，当新建一个接口的实现类的时候，我们又需要创建一个新实现类的一个代理对象，当实现类过多的时候就会造成类爆炸。还有当我们需要在代理方法中修改一些逻辑的时候我们需要去每个代理类中修改代码。当使用动态代理的时候我们就能有效的解决这些问题，在牺牲一些性能的情况下来换取一些灵活性。
动态代理
在Java中我们可以通过实现InvocationHandler接口的方式来实现动态代理，MyInterface代理类
public class MyInterfaceProxy<T> implements InvocationHandler {
T target;
public MyInterfaceProxy(T target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
MonitorUtil.start();
Object result = method.invoke(target, args);
MonitorUtil.finish(method.getName());
return result;
}
}
调用方式
public class Test {
public static void main(String[] args) {
MyInterface myInterface = new MyInterfaceImpl1();
InvocationHandler invocationHandler = new MyInterfaceProxy<MyInterface>(myInterface);
MyInterface proxyObject = (MyInterface) Proxy.newProxyInstance(MyInterface.class.getClassLoader(), new Class[]{MyInterface.class}, invocationHandler);
proxyObject.method1("pcy");
}
执行结果
MyInterface proxyObject = (MyInterface) Proxy.newProxyInstance(MyInterface.class.getClassLoader(), new Class[]{MyInterface.class}, invocationHandler);
从上面这行代码我们可以看出，代理对象就是通过Proxy.newProxyInstance()方法类创建的，进入此方法我们
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
Objects.requireNonNull(h);
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
/*
* Look up or generate the designated proxy class.
*/
Class<?> cl = getProxyClass0(loader, intfs);
/*
* Invoke its constructor with the designated invocation handler.
*/
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
return cons.newInstance(new Object[]{h});
} catch (IllegalAccessException|InstantiationException e) {
throw new InternalError(e.toString(), e);
} catch (InvocationTargetException e) {
Throwable t = e.getCause();
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new InternalError(t.toString(), t);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString(), e);
}
}
下面这行代码就是查找或产生设计的代理class对象
第729行代码的意思是获取代理类class的构造器，第739行代码的意思则是创建一个代理类的对象
那我们来看一下虚拟机帮我们自动生成的代理类，在下面这行代码处打上断点并运行
执行此行代码之后在调试窗口查看变量cl
可以看到其实此生成的class对象是一个名为Proxy0一个class对象，反编译出此对象（省略了hashcode等方法）
public final class $Proxy0 extends Proxy implements MyInterface {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
public final void method1(String var1) throws {
try {
super.h.invoke(this, m3, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m3 = Class.forName("proxy.MyInterface").getMethod("method1", Class.forName("java.lang.String"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
从上面的代码我们可以看出生成的代理对象继承了Proxy类且实现了MyInterface接口，当调用method1方法的时候，实际上调用的是父类里面的InvocationHandler中的invoke方法，也就是我们MyInterfaceProxy中的invoke方法。由于此类已经继承了Proxy类，所以动态代理只能代理接口，不能代理一个类。
参考文章：https://www.cnblogs.com/gonjan-blog/p/6685611.html
原创作品，如需转载请标明出处
