编程语言通常有各种不同的分类角度，动态类型和静态类型就是其中一种分类角度，简单区分就是语言类型信息是在运行时检查，还是在编译期检查。
与其近似的还有一个对比，就是所谓强类型和弱类型，就是不同类型变量赋值时，是否需要显式地(强制)进行类型转换。
通常认为Java是静态的强类型语言，但是因为提供了类似反射等机制，也具备了部分动态类型语言的能力。
一、反射
反射机制的使用
反射机制是Java语言提供的一种基础功能，赋予程序在运行时自省(introspect)的能力，通过反射我们可以直接操作类或者对象，比如获取某个对象的类定义，获取类声明的属性和方法，调用方法或者构造对象，甚至可以运行时动态修改类定义。
反射提供的AccessibleObject.setAccessible(boolean flag)方法，它的子类也大都重写了这个方法，这里的所谓accessible可以理解成修饰成员的pulib、protected、private、这意味着我们可以在运行时修改成员访问限制，入参为true时表示反射对象禁止权限检查，
入参为fasle时表示开启反射对象权限检查。
setAccessible的应用场景非常普遍，遍布我们的开发、测试、依赖注入等各种框架中，比如在O/R Mapping框架中，我们为一个Java实体对象运行时自动生成setter、getter的逻辑，这是加载或持久化数据非常必要的，框架通常可以利用反射实现这个功能而不需要开发者手动写类似的代码。
在Java9以后，这个方法的使用可能会存在一些争议，因为Jigsaw项目新增的模块化系统，出于强封装性的考虑，对反射访问进行了限制。Jigsaw引入了所谓Opend概念，只有当被反射的模块和指定的包对反射调用者模块Open，才能使用setAccessible，否则被认为是不合法的操作，如果我们的实体类是
定义在模块里面，我们需要在模块描述符中明确声明：
module MyEntities {
// Open for reflection
opens com.mycorp to java.persistence;
}
可以使用下面参数显式设置是否需要校验Open权限：
--illegal-access={ permit | warn | deny }
另外一个典型场景就是绕过API访问限制，比如使用反射绕开ArrayList泛型限制：
ArrayList<Integer> integerArrayList = new ArrayList<Integer>();
integerArrayList.add(1);
integerArrayList.add(2);
Method method = integerArrayList.getClass().getMethod("add", Object.class);
method.invoke(integerArrayList, "hello");
System.out.println(JSON.toJSONString(integerArrayList));
反射的常见用法：
public class Apple {
private int price;
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public Apple(int price) {
this.price = price;
}
public Apple() {
}
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//正常调用
Apple apple = new Apple();
apple.setPrice(5);
System.out.println("Apple Price:" + apple.getPrice());
//使用反射调用，无参构造器
Class appleClass = Class.forName("math.foundation.job.java.core.reflect.Apple");
Constructor constructor = appleClass.getConstructor();
Object reflectApple = constructor.newInstance();
Method setMethod = appleClass.getMethod("setPrice", int.class);
setMethod.invoke(reflectApple, 6);
Method getMethod = appleClass.getMethod("getPrice");
System.out.println("reflectApple price:" + getMethod.invoke(reflectApple));
//有参构造器
Constructor constructor1 = appleClass.getConstructor(int.class);
Apple apple1 = (Apple) constructor1.newInstance(7);
System.out.println("有参构造器apple:" + JSON.toJSONString(apple1));
//getFields()可以获取类的共有属性，但是无法获取类的私有属性.与获取类属性一样，当我们去获取类方法、类构造器时，如果要获取私有方法或私有构造器，则必须使用有 declared 关键字的方法。
Field[] fields = appleClass.getFields();
for (Field field : fields) {
System.out.println(field.getName());
}
Field[] declaredFields = appleClass.getDeclaredFields();
for (Field field : declaredFields) {
System.out.println(field.getName());
}
}
}
反射源码解析
java.lang.reflect.Method#invoke(Object obj, Object... args)方法表示在指定的对象上使用指定的参数来调用指定的方法，个别参数会自动展开去匹配原始参数。
- 如果底层方法是静态方法，那么第一个入参obj会被忽略，可以为null
- 如果底层方法的参数个数为0，args的长度可以为0或者null
- 如果底层方法的返回值是原始类型则会被包装成对象，如果返回值是一个由原始类型组成的数组则不会进行包装。
invoke方法最终会调用sun.reflect.MethodAccessor#invoke方法，MethodAccessor是从java.lang.reflect.Method#acquireMethodAccessor方法中获取到的：
public Object invoke(Object obj, Object... args)
throws IllegalAccessException, IllegalArgumentException,
InvocationTargetException
{
if (!override) {
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
Class<?> caller = Reflection.getCallerClass();
checkAccess(caller, clazz, obj, modifiers);
}
}
MethodAccessor ma = methodAccessor; // read volatile
if (ma == null) {
ma = acquireMethodAccessor();
}
return ma.invoke(obj, args);
}
private MethodAccessor acquireMethodAccessor() {
// First check to see if one has been created yet, and take it
// if so
MethodAccessor tmp = null;
if (root != null) tmp = root.getMethodAccessor();
if (tmp != null) {
methodAccessor = tmp;
} else {
// Otherwise fabricate one and propagate it up to the root
tmp = reflectionFactory.newMethodAccessor(this);
setMethodAccessor(tmp);
}
return tmp;
}
在这里又会调用sun.reflect.ReflectionFactory#newMethodAccessor方法：
public MethodAccessor newMethodAccessor(Method var1) {
checkInitted();
if(noInflation && !ReflectUtil.isVMAnonymousClass(var1.getDeclaringClass())) {
return (new MethodAccessorGenerator()).generateMethod(var1.getDeclaringClass(), var1.getName(), var1.getParameterTypes(), var1.getReturnType(), var1.getExceptionTypes(), var1.getModifiers());
} else {
NativeMethodAccessorImpl var2 = new NativeMethodAccessorImpl(var1);
DelegatingMethodAccessorImpl var3 = new DelegatingMethodAccessorImpl(var2);
var2.setParent(var3);
return var3;
}
}
在这个方法中会有一个判断条件首先会判断noInflation && !ReflectUtil.isVMAnonymousClass(var1.getDeclaringClass())是否为true，noInflation为true表示配置了，
sun.reflect.noInflation=true
这个配置表示不开启类膨胀，且当class不是匿名类时就直接使用sun.reflect.MethodAccessorGenerator#generateMethod方法来生成一个代理类，否则就使用sun.reflect.NativeMethodAccessorImpl#invoke方法：
public Object invoke(Object var1, Object[] var2) throws IllegalArgumentException, InvocationTargetException {
if(++this.numInvocations > ReflectionFactory.inflationThreshold() && !ReflectUtil.isVMAnonymousClass(this.method.getDeclaringClass())) {
MethodAccessorImpl var3 = (MethodAccessorImpl)(new MethodAccessorGenerator()).generateMethod(this.method.getDeclaringClass(), this.method.getName(), this.method.getParameterTypes(), this.method.getReturnType(), this.method.getExceptionTypes(), this.method.getModifiers());
this.parent.setDelegate(var3);
}
return invoke0(this.method, var1, var2);
}
这个方法中会判断调用次数是否超过了阈值(numInvocations)，如果超过该阈值则调用MethodAccessorGenerator.generateMethod()来生成代理类，否则使用native方式，阈值可以通过如下参数来进行配置：
sun.reflect.inflationThreshold
这个阈值默认为15，源码注释上解释这个JVM所做的一个优化，通常初次加载字节码实现反射，使用Method.invoke() 和 Constructor.newInstance() 加载花费的时间是使用原生代码加载花费的3-4倍，这使得那些频繁使用反射的应用启动会花费更长的时间。为了避免这种痛苦所以在第一次加载
的时候使用JVM本地实现，之后超过阈值才会切换到字节码方式实现。
二、动态代理
动态代理是一种方便运行时动态构建代理，动态处理代理方法调用的机制，很多场景都是利用类似机制做到的，比如用来包装RPC调用，面向切面的编程(AOP)。实现动态代理的方式很多，比如JDK自身提供的动态代理，就是主要利用了上面提到的反射机制。还有其他的实现方式，比如利用传说中更高性能的字节码操作机制，类似ASM、cglig(基于ASM)、Javassist等。通过代理可以让调用者和实现者之间解耦，比如RPC调用，框架内部的寻址、序列化、反序列化等，对于调用者往往没有太大意义，通过代理可以更加优雅，例如：
JDK动态代理：
public class MyJDKDynamicProxy {
public static void main(String[] args) {
HelloImpl helloImpl = new HelloImpl();
MyInvocationHandler myInvocationHandler = new MyInvocationHandler(helloImpl);
Hello hello = (Hello) Proxy.newProxyInstance(HelloImpl.class.getClassLoader(), HelloImpl.class.getInterfaces(), myInvocationHandler);
hello.sayHello();
}
}
interface Hello {
void sayHello();
}
class HelloImpl implements Hello {
@Override
public void sayHello() {
System.out.println("Hello World");
}
}
class MyInvocationHandler implements InvocationHandler {
private Object target;
public MyInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Invoking sayHello");
Object result = method.invoke(target, args);
return result;
}
}
上面的JDK 动态代理的例子，非常简单地实现了动态代理的构建和代理操作，从API设计和实现的角度，这种实现仍然具有局限性，因为它是以接口为中心的，相当于添加了一种对于调用者没有太大意义的限制。我们实例化的是Proxy对象，而不是真正的被调用类型，这在实践中还是可能带来各种不便和能力退化。
如果被调用者没有实现接口，而我们还是希望利用动态代理机制，那么可以考虑其他方式。我们知道Spring AOP支持两种模式的动态代理，JDK Proxy或者cglib，如果我们选择cglib方式就会发现对接口的依赖被克服了，cglib动态代理采用的是创建目标类的子类的方式，因为是子类化，我们可以达到近似使用被调用者本身的效果，但是需要注意的是final方法不能被代理。
JDK动态代理原理简单分析：
我们上面的例子中创建动态代理类的入口为：
Hello hello = (Hello) Proxy.newProxyInstance(HelloImpl.class.getClassLoader(), HelloImpl.class.getInterfaces(), myInvocationHandler);
方法注释说明这个方法的作用是返回一个指定接口的代理类实例，并将方法调用分派给指定的调用处理程序。指定接口对应的就是我们程序中的Hello，方法调用指的就是sayHello()方法，指定的调用处理程序对应的是程序中的MyInvocationHandler。
方法声明如果开启securityManager，会去校验getClassLoader、checkPackageAccess、ReflectPermission这三个权限是否满足条件。
可以看到真正生成代理类的代码为：
/*
* Look up or generate the designated proxy class.
*/
Class<?> cl = getProxyClass0(loader, intfs);
生成代理类之后会通过使用以入参为InvocationHandler.class类型的构造器，将myInvocationHandler作为入参创建一个代理类的实例，这个实例就是我们程序中使用到的hello对象。下面我们来看一下java.lang.reflect.Proxy#getProxyClass0方法：
/**
* a cache of proxy classes
*/
private static final WeakCache<ClassLoader, Class<?>[], Class<?>> proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
/**
* Generate a proxy class. Must call the checkProxyAccess method
* to perform permission checks before calling this.
*/
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
// If the proxy class defined by the given loader implementing
// the given interfaces exists, this will simply return the cached copy;
// otherwise, it will create the proxy class via the ProxyClassFactory
return proxyClassCache.get(loader, interfaces);
}
这个方法强调自己的作用是用来生成代理类的，但是需要确保在调用自己之前一定要先调用checkProxyAccess通过权限验证，内部使用弱引用的缓存来缓存代理类，如果代理类在缓存中存在就直接返回，如果不存在于缓存中就使用ProxyClassFactory来创建代理类。
WeakCache内部实现了一个弱引用的二级缓存，java.lang.reflect.WeakCache.get(K key, P parameter)方法有两个参数，第一个参数表示一级缓存的key，第二个参数表示二级缓存的key。
首先会使用
Object cacheKey = CacheKey.valueOf(key, refQueue);
根据一级缓存的入参key构建一个CacheKey对象作为一级缓存真正的key，通过使用
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
来构建二级缓存的key，subKeyFactory实际上对应的是java.lang.reflect.Proxy.KeyFactory：
/**
* A function that maps an array of interfaces to an optimal key where
* Class objects representing interfaces are weakly referenced.
*/
private static final class KeyFactory
implements BiFunction<ClassLoader, Class<?>[], Object>
{
@Override
public Object apply(ClassLoader classLoader, Class<?>[] interfaces) {
switch (interfaces.length) {
case 1: return new Key1(interfaces[0]); // the most frequent
case 2: return new Key2(interfaces[0], interfaces[1]);
case 0: return key0;
default: return new KeyX(interfaces);
}
}
}
apply方法会根据被代理的接口生成一个特殊的key，大部分的被代理类都只实现了一个接口，所以大部分情况都会进入
case 1: return new Key1(interfaces[0]); // the most frequent
分支。二级缓存中如果没有指定的key，会使用循环获取的方式初始化一个java.lang.reflect.WeakCache.Factory对象，直到初始化成功为止：
if (supplier == null) {
supplier = valuesMap.putIfAbsent(subKey, factory);
if (supplier == null) {
// successfully installed Factory
supplier = factory;
}
// else retry with winning supplier
}
初始化成功之后会调用java.lang.reflect.WeakCache.Factory.get方法获取代理类，内部会调用java.lang.reflect.Proxy.ProxyClassFactory.apply来生成、定义给定代理类的Class。
生成的代理类如下：
public final class $proxy4 extends Proxy implements Hello {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
public $proxy4(InvocationHandler var1) throws {
super(var1);
}
public final boolean equals(Object var1) throws {
try {
return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final void sayHello() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
从生成代理类可以看到代理类已经继承了Proxy类，实现了Hello接口，由于Java语言是单继承的，所以JDK动态代理要求必须被代理类必须实现接口。
代理类的sayHello方法实现是：
super.h.invoke(this, m3, (Object[])null);
super.h对应的正是MyInvocationHandler，所以实际调用的是MyInvocationHandler.invoke方法。
cglib动态代理：
public class MyCGLIBDynamicProxy {
public static void main(String[] args) {
//在指定目录下生成代理类，我们可以反编译看一下里面到底是什么东西
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\java\\java_workapace");
//使用Enhancer对象，类似于JDK动态代理的Proxy类
Enhancer enhancer = new Enhancer();
//设置目标类的字节码文件
enhancer.setSuperclass(Boy.class);
//设置回调函数
enhancer.setCallback(new MyMethodInterceptor());
//create方法就是正式创建代理类
Boy boy = (Boy) enhancer.create();
//调用代理类的play方法
boy.play();
boy.work();
}
}
class Boy {
public void play() {
System.out.println("boy play");
}
final public void work() {
System.out.println("boy work");
}
}
class MyMethodInterceptor implements MethodInterceptor {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("使用cglib对目标类进行增强");
//这里的方法调用不是使用反射
Object o1 = methodProxy.invokeSuper(o, objects);
return o1;
}
}
除了上面例子中的MethodInterceptor回调类型之外，cglib还支持一下集中回调类型：
InvocationHandler(与JDK动态代理InvocationHandler功能一样)
NoOp(什么都不会做，被代理类方法正常被执行)
LazyLoader(只在第一次调用的时候会调用loadObject()方法，之后调用不会进入loadObject()方法)
Dispatcher(功能与LazyLoader相似，不同的是每次调用都会进入loadObject()方法)
ProxyRefDispatcher(与Dispatcher类似，不同的是会将代理对象作为入参传递进来)
FixedValue(调用代理类每次返回的都是固定的值)
JDK Proxy优势：
- 最小化依赖关系，减少依赖意味着简化开发和维护，JDK本身的支持，可能比cglib更加可靠。
- 平滑进行JDK版本升级，而字节码类库通常需要进行更新以保证在新版Java上能够使用
- 代码实现简单
cglib优势：
- 某些调用目标可能不便实现额外接口，从某种角度看，限定调用者实现接口是有些侵入性的实践，类似cglib动态代理没有这种限制。
- 只操作我们关心的类，不必为其他相关类增加工作量。
- 高性能
动态代理的应用非常广泛，比如在不同模块的特定阶段做特定的事情，比如类似日志、用户鉴权、全局异常处理、性能监控等。
目前在我们的应用中使用了JDK动态代理进行Rpc服务的容灾机房切换、以及服务降级的功能，因为Rpc服务天然实现了接口，使用JDK动态代理依赖较少，维护相对来说也比较简单。
