目录
- 1.动态代理需要了解的知识
- 类反射机制
- 2.动态代理例子
- 3.疑惑解析
- 1.关于newProxyInstance()的三个参数
- 2.由始至终没有调用invoke()方法，而会走它呢？
- 3.为什么用Job接收代理类对象
- 4.区分method.invoke()和重写的public Object invoke()
1.动态代理需要了解的知识
类反射机制
Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
实例化Class类对象
1、前提：若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高
java">Class cl = String.class;
2、前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象
java">Class cl ="abcabc".getClass();
3、前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出 ClassNotFoundException
java">Class cla= Class.forName("java.lang.String");
了解以下几个包下的类
2.动态代理例子
要用到的几类和方法在如下包：
-java.lang.reflect.proxy
-java.lang.reflect.InvocationHandler
1.public interface InvocationHandler
参数
loader ：类加载器来定义代理类
interfaces ： 代理类实现的接口列表
h ：调度方法调用的调用处理函数
动态代理模拟图
1.Job接口
java">//抽象角色（要被代理的）
public interface Job {
public void request();
}
2.Job的实现类
java">//真实角色
public class Company implements Job {
public void request() {
System.out.println("要招聘人才");
}
}
3.动态生成类
java">用这个类自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {
//Setter被代理的接口
private Job job;
public void setJob(Job job){
this.job=job;
}
//核心就在这个方法了，它返回的是一个代理对象
public Object getProxy(){
Job proxy = (Job)Proxy.newProxyInstance(this.getClass().getClassLoader(), job.getClass().getInterfaces(), this);
System.out.println(proxy.getClass().toString());
return proxy;
}
//处理代理实例，执行Job的方法，也就是说实现“要招聘人才”需求
//重写InvocationHandler，invoke的方法
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("before calling " + method);
method.invoke(job, args);
System.out.println("after calling " + method);
return null;
}
}
测试类
java">public class Client {
public static void main(String[] args) {
//真实角色，
Company company = new Company();
pih.setJob(company);
//实例化动态生成代理的类
ProxyInvocationHandler pih = new ProxyInvocationHandler();
//动态生成代理
//System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
Job proxy = (Job)pih.getProxy();
proxy.request();
}
}
结果：
只看第三行，输出"要招聘人才"，确实通过代理模式把它输出了。其他不用看是我测试用的
3.疑惑解析
1.关于newProxyInstance()的三个参数
java">Proxy.newProxyInstance(this.getClass().getClassLoader(),
job.getClass().getInterfaces(), this);
1.this.getClass().getClassLoader()这个是类加载器，用来定义代理类
拓展：因为每个编写的”.java”拓展名类文件都存储着需要执行的程序逻辑，这些”.java”文件经过Java编译器编译成拓展名为”.class”的文件，”.class”文件中保存着Java代码经转换后的虚拟机指令，当需要使用某个类时，虚拟机将会加载它的”.class”文件，并创建对应的class对象。而将class文件加载到虚拟机的内存，这个过程称为类加载
（如果在深入就要去了解Java虚拟机）
2.job.getClass().getInterfaces()就是获得这个接口
3.因为第三个参数需要传InvocationHandler对象，而我们当前类继承了这个接口，所以用this
2.由始至终没有调用invoke()方法，而会走它呢？
可以看到，在测试类中或者生成代理类中，我们并没有显示的调用invoke()方法。
1.我们newProxyInstance这个方法作为突破口，查看源代码如下
java">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});
}
看点：
1.Class<?> cl = getProxyClass0(loader, intfs);
2.final Constructor<?> cons = cl.getConstructor(constructorParams)
看点1中，泛型不用管，我们没有用到，这个两个参数loader，intfs就是我们刚刚传的类加载和接口（抽象角色）并且返回一个Class类对象cl，这个类就是我们要的创建代理类。
其实这个代理类的真实类名叫$Proxy0，在代码中我已经将这个代理类名输出了。
class com.sun.proxy.$Proxy0
这个.Clss类（所谓代理类）是Java虚拟机帮我们生成的，在虚拟机内存。我们现在把这个.class文件输出，反编译后，继续查看底层代码
java">//如果想看$Proxy0源码，可以在测试类上加这句话
//.class文件会生成在idea/当前项目/com/下
//（不是用Idea自己找,差不多，idea可以帮我们将.class文件反编译）
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
看点：
1.构造方法
2.方法 public final void request()
java">public final class $Proxy0 extends Proxy implements Job {
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
......
public final void request() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
...........
当执行proxy.request()方法时，就调用了$Proxy0类中的request()方法，进而调用父类Proxy中的h的invoke()方法.即InvocationHandler.invoke()。就是代理类中实现的接口下的方法哦。
如果还不是不懂，继续看下面~~~
（这还是没return代理类对象前的那段代码…）
final Constructor<?> cons = cl.getConstructor(constructorParams);
将实例化$Proxy0并在构造方法中把类名为(ProxyInvocationHandler，这个类实现了InvocationHandler接口)传过去,接着$Proxy0调用父类Proxy的构造器,为h赋值,如下：
java">class Proxy{
InvocationHandler h=null;
protected Proxy(InvocationHandler h) {
this.h = h;
}
....
}
3.为什么用Job接收代理类对象
在查看完 $Proxy0 源码，就知道啦，它实现了Job接口，并且继承了Proxy 类
java">public final class $Proxy0 extends Proxy implements Job{
}
4.区分method.invoke()和重写的public Object invoke()
1.method.invoke()是method类下的方法：
public final class Method extends Executable {
public Object invoke(Object obj, Object… args)
}
2.InvocationHandler接口下的方法
public interface InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args)
}
