【Java-Reflection】动态代理

一、静态代理

首先先了解一下静态代理：

interface Subject{
public void print(String s);
}

class RealSubject implements Subject{
public void print(String s){
System.out.println(s+"1");
}
}
class Proxy implements Subject{
private Subject subject;
public Proxy(Subject subject){
this.subject=subject;
}
public void print(String s){
//do something before
subject.print(s);
//do something after
}
}

Client 测试

public static void main(String[] args) {
RealSubject realSubject = new RealSubject();
Proxy proxy = new Proxy(realSubject1);
proxy.print("this is static proxy ");

}

个人理解：说白了，实际类和代理类同时实现了某个抽象的接口。实际调用的时候，调用代理类的方法，代理类内部有实际类的成员，代理类把请求转发给实际类执行。

二、动态代理

话不多说，先上代码：

public class DynamicProxy {

public static void main(String[] args) {

RealSubject realSubject = new RealSubject();

//第一个参数是类加载器,第二个参数是接口
Subject proxySubject = (Subject) Proxy.newProxyInstance(
Subject.class.getClassLoader(), //realSubject.getClass().getClassLoader(),
new Class[]{Subject.class},//realSubject.getClass().getInterfaces(),
new ProxyHandler(realSubject));

proxySubject.print("this is a dynamic proxy");

}

}

interface Subject{
public void print(String s);
}

class RealSubject implements Subject{
public void print(String s){
System.out.println(s);
}
}

class ProxyHandler implements InvocationHandler{

private Object proxied;
public ProxyHandler(Object o) {
proxied = o;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result;
result = method.invoke(proxied, args);
return result;
}

}

和静态最大的区别，用了反射实现了代理。
实际类：
同样，有一个抽象接口和实现了该接口的实际类。

代理处理类：
但是代理类不用实现这个接口，然是实现了InvocationHandler接口，里面仅有invoke方法。同样，代理类内部还是得有一个Object对象，也就是被代理的类（可以通过代理类的构造器传入)。然后invoke中必要的代码就是

Object result;
result = method.invoke(proxied, args);
return result;

在前后可以根据自己需求添加额外的功能。

client测试：
用Proxy.newProxyInstance返回一个接口类型的代理实体，后续只要调用这个代理实体就可以传请求给实际的功能类。
newProxyInstance()里面的三个参数：1.类加载器 2.接口class 3.代理处理类

三、动态代理优势

静态代理中，实际功能类和代理类是一一对应的，他们都实现了同样的功能接口。
但是动态代理则不是，上代码

public class DynamicProxy {

public static void main(String[] args) {

RealSubject realSubject = new RealSubject();

//第一个参数是类加载器,第二个参数是接口
Subject proxySubject = (Subject) Proxy.newProxyInstance(
Subject.class.getClassLoader(), //realSubject.getClass().getClassLoader(),
new Class[]{Subject.class},//realSubject.getClass().getInterfaces(),
new ProxyHandler(realSubject));

proxySubject.print("this is a dynamic proxy");
//代理第二个类
RealSayHello realSayHello = new RealSayHello();
SayHello helloProxy = (SayHello)Proxy.newProxyInstance(
realSayHello.getClass().getClassLoader(),
realSayHello.getClass().getInterfaces(),
new ProxyHandler(realSayHello));
helloProxy.say();

}

}

interface Subject{
public void print(String s);
}

class RealSubject implements Subject{
public void print(String s){
System.out.println(s);
}
}

interface SayHello{
public void say();
}

class RealSayHello implements SayHello{
public void say() {
System.out.println("real:hello!");
}
}

class ProxyHandler implements InvocationHandler{

private Object proxied;
public ProxyHandler(Object o) {
proxied = o;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result;
result = method.invoke(proxied, args);
return result;
}

}

代码和上面的例子多了一个接口和实际功能类，但是代理处理类ProxyHandler不用改变，也不用增加。
动态代理中，实现了InvocationHandler的类仅仅只是一个处理代理类的类，他并不和实际功能类一一对应，可以根据不用的实际类通过这个Handler生成对应的代理类。