反射
Q： 调用类对象.class 和 forName(类名)的区别？
Class<A> classA = A.class;
Class<A> classA = Class.forName("A");A： 仅使用.class不能进行第一次静态初始化， forname函数则可以
例如B是A的基类,下面这段代码如何？
假设有父子2个类，如下：
static class Parent { }
static class Son extends Parent{}Q： 用instanceof 可以和父类比较吗，且会返回true吗？
Son son = new Son();
if (son instanceof Parent) {
System.out.println("a instanof B");
}A： 可以比较，且返回true。
Q： 用getClass并用== 可以和父类比较吗，且会返回true吗
比如下面这样， 注意Son是Parent的子类。
Son son = new Son();
if (son.getClass() == Parent.class){
System.out.println("son class == Parent.class");
}A： 不可以，编译就会报错了。和Class<泛型>的 ==号比较有关。
因为getClass返回的是<? extends Son>， .class返回的是Class<Parent>
Q： 用getClass并用.equals可以和父类比较吗，且会返回true吗，下面这样：
Son son = new Son();
if (son.getClass().equals(Parent.class)){
System.out.println("son class.equals(Parent.class)");
}A： 可以比较，正常编译， 但是会返回false，即不相等！
Q： getDeclaredXXX 有哪几种？
A： 5种：
- 注解Annotation
- 内部类Classed
- 构造方法Construcotor
- 字段Field
- 方法Method
Q：getMethods()返回哪些方法， getDeclaredMethods()会返回哪些方法？
A：
- getMethods()返回 本类、父类、父接口 的public方法
- getDeclaredMethods()只 返回本类 的所有方法
其他getXXX和getDeclaredXXX的区别同理。
拿到Filed、Method、Constructor之后咋用
- Method可以invoke（object， args）
- Constructor可以newInstance(Object…)来做构造调用。
- Filed可以用get(object)、set(object)来设置属性值。
Q： 反射拿到Method对象后， 该对象.getModifiers() 是干嘛的？
A： 返回该方法的修饰符，并且是1个整数。将整数转换为二进制进行表示，参考修饰符对照表，可知道该方法用了哪些修饰符。
Q：下面这样对一个无默认构造的类执行newInstance会发生什么？
package com.huawei.test
public class A {
public A(int i) { // 默认构造器是没有入参的构造方法，class A缺少默认构造方法
System.out.printf("i=" +i);
}
public static void main(String[] args) {
try {
A a = (A)Class.forName("com.huawei.test.A").newInstance();
} catch (ClassNotFoundException e) {
System.out.printf("ClassNotFoundException");
} catch (InstantiationException e) {
System.out.printf("InstantiationException");
} catch (IllegalAccessException e) {
System.out.printf("IllegalAccessException");
}
}
}A:
打印InstantiationException初始化错误。
因为A没有默认构造器了，所以不可以用newInstance来构造。
应该改成这样,通过获取正确的构造器来进行构造。
A a = (A)Class.forName("A").getConstructor(int.class).newInstance(123);Q：如何提高反射的效率？
A：
- 使用高性能反射包，例如ReflectASM
- 缓存反射的对象，避免每次都要重复去字节码中获取。（缓存！缓存！）
- method反射可设置method.setAccessible(true)来关闭安全检查。
- 尽量不要getMethods()后再遍历筛选，而直接用getMethod(methodName)来根据方法名获取方法
- 利用hotspot虚拟机中的反射优化技术（jit技术）
参考资料：
https://segmentfault.com/q/1010000003004720
https://www.cnblogs.com/coding-night/p/10772631.html
Q：用反射获取到的method对象， 是返回一个method引用，还是返回1个拷贝的method对象？
A：
反射拿method对象时， 会做一次拷贝，而不是直接返回引用，因此最好对频繁使用的同一个method做缓存，而不是每次都去查找。
Q:getMethods()后自己做遍历获取方法和getMethod(methodName) 直接获取方法， 为什么性能会有差异？
A：
getMethods() 返回method数组时，每个method都做了一次拷贝。
getMethod(methodName)只会返回那个方法的拷贝， 性能的差异就体现在拷贝上。
Q:获取方法时，jvm内部其实有缓存，但是返回给外部时依然会做拷贝。那么该method的缓存是持久存在的吗？
A:
不是持久存在的，内存不足时会被回收。
源码如下：
private Class.ReflectionData<T> reflectionData() {
SoftReference<Class.ReflectionData<T>> reflectionData = this.reflectionData;
int classRedefinedCount = this.classRedefinedCount;
Class.ReflectionData rd;
return reflectionData != null && (rd = (Class.ReflectionData)reflectionData.get()) != null
&& rd.redefinedCount == classRedefinedCount ? rd : this.newReflectionData(reflectionData, classRedefinedCount);
}可以看到这是一个软引用。
软引用的定义：内存紧张时可能会被回收，不过也可以通过-XX:SoftRefLRUPolicyMSPerMB参数控制回收的时机，只要发生GC就会将其回收。如果reflectionData被回收之后，又执行了反射方法，那只能通过newReflectionData方法重新创建一个这样的对象了。
Q： 反射是线程安全的吗?
A:
是线程安全的。 获取反射的数据时，通过cas去获取。 cas概念可以见多线程一节。
Q: 反射的具体性能差异在哪？
A:
简单的数据比较：
- 普通方法调用10亿次：9ms
- 反射方法调用10亿次：5699ms
- 关闭安全检查调用10亿次：1959ms
安全检查的性能消耗在于SecurityManager.checkPermission(SecurityConstants.CHECK_MEMBER_ACCESS_PERMISSION); 这项检测需要运行时申请 RuntimePermission(“accessDeclaredMembers”)。所以如果不考虑安全检查， 对反射方法调用invoke时， 应当设置 Method.setAccessible(true)
普通方法和反射方法的性能差异在于：
- Method.invoke 方法会对参数做封装和解封操作
- 需要检查方法可见性
- 需要校验参数
- 反射方法难以内联
- JIT 无法优化
Q: 为什么反射没法做JIT优化呢？
A:
我们都知道 Java 代码是需要编译才能在虚拟机里运行的，但其实 Java 的编译期是一段不确定的操作过程。因为它可能是一个前端编译器（如 Javac）把 .java 文件编译成 .class 文件的过程；也可能是程序运行期的即时编译器（JIT 编译器，Just In Time Compiler）把字节码文件编译成机器码的过程；还可能是静态提前编译器（AOT 编译器，Ahead Of Time Compiler）直接把 *.java 文件编译成本地机器码的过程。
其中即时编译器（JIT）在运行期的优化过程对于程序运行来说更重要，Java虚拟机在编译阶段的代码优化就在这里进行，
由于反射涉及动态解析的类型，因此无法执行某些Java虚拟机优化。因此，反射操作的性能要比非反射操作慢，因此应该避免在对性能敏感的应用程序中频繁使用Java反射来创建对象。
动态代理
Q: 讲一下动态代理的作用 以及他和静态代理的区别（设计模式中的代理模式也有讲到静态代理和动态代理）
A:
作用
先弄一个原始接口类Info，里面提供一些接口例如dealInfo()、getInfo()之类的，然后可以有N个实现了这个接口的各种Info子类。我们希望这些Info字类做dealInfo的时候， 都能在调用前后打一下日志。但不希望每个子类里强制都添加这个过程。所以引入一个代理Proxy， 将Info类放进去代理种执行，无论你放什么info子类进去，调用dealInfo时，都会在调用前后打印日志。
和静态代理的区别
静态代理也是给代理传1个对象，然后执行方法时，执行代理对象的方法。但是有个执行问题：如果我们的类需要加100个方法，那么我们在代理中也要加100个方法，里面反复写“啊，我要调用代理对象的方法”， 这太蠢了。
所以引入动态代理，这样代理和所代理类之间实现了解耦，没有必要每次改实类时，也要改代理的内容，重复加方法之类的。动态代理可以直接根据method去调用，并且还能弄一个自己独有的处理。
Q: 讲一下动态代理怎么用的？
A:
参考资料：https://zhuanlan.zhihu.com/p/94159179
现有一个网络请求接口IHttp和Http请求工具类HttpUtil
public interface IHttp {
void request(String sendData);
void onSuccess(String receivedData);
}
public class HttpUtil implements IHttp {
@Override
public void request(String sendData) {
System.out.println("网络请求中...");
}
@Override
public void onSuccess(String receivedData) {
System.out.println("网络请求完成。");
}
}实现动态代理的代码，Java已经提供了一些类、接口和方法，帮助我们实现动态代理，不深究的话我们只需要把它当做是一种固定写法就行。代理类需要实现InvocationHandler接口，使用Proxy.newProxyInstance来创建一个代理的实例，并重写invoke方法，这样代理类调用httpUtil中的方法时都会通过这个invoke方法来间接调用。
public class HttpProxy implements InvocationHandler {
private HttpUtil httpUtil;
public IHttp getInstance(HttpUtil httpUtil) {
this.httpUtil = httpUtil;
return (IHttp) Proxy.newProxyInstance(httpUtil.getClass().getClassLoader(), httpUtil.getClass().getInterfaces(), this);
}
// 调用 httpUtil 的任意方法时，都要通过这个方法调用
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
if (method.getName().equals("request")) {
// 如果方法名是 request，打印日志，并调用 request 方法
System.out.println("发送数据:" + args[0]);
result = method.invoke(httpUtil, args);
} else if (method.getName().equals("onSuccess")) {
// 如果方法名是 onSuccess，打印日志，并调用 onSuccess 方法
System.out.println("收到数据:" + args[0]);
result = method.invoke(httpUtil, args);
}
return result;
}
}调用时，调用HttpProxy代理
public class Client {
@Test
public void test() {
HttpUtil httpUtil = new HttpUtil();
IHttp proxy = new HttpProxy().getInstance(httpUtil);
proxy.request("request data");
proxy.onSuccess("received result");
}
}Q: java动态代理的底层实现原理？
A:
我们可以对InvocationHandler看做一个中介类，代理类调用自己方法时，在invoke方法中调用了被代理对象的相应方法，在这个方法中持有被代理类对象的引用，把外部对invoke的调用最终都转为对被代理对象的调用。
本博客文章除特别声明外，均可自由转载与引用，转载请标注原文出处：http://www.yelbee.top/index.php/archives/230/
