Java反射面试总结（二）

为什么引入反射概念？反射机制的应用有哪些？

我们来看一下 Oracle 官方文档中对反射的描述：

从 Oracle 官方文档中可以看出，反射主要应用在以下几方面：

反射让开发人员可以通过外部类的全路径名创建对象，并使用这些类，实现一些扩展的功能。
反射让开发人员可以枚举出类的全部成员，包括构造函数、属性、方法。以帮助开发者写出正确的代码。
测试时可以利用反射 API 访问类的私有成员，以保证测试代码覆盖率。

也就是说，Oracle 希望开发者将反射作为一个工具，用来帮助程序员实现本不可能实现的功能。

引入反射的概念是为了让程序能够在运行时获取类的信息，并且可以动态地创建对象、调用方法、获取字段等操作，具有很高的灵活性和扩展性。

反射机制的应用有以下几个方面：

动态加载类：在程序运行时可以根据需要动态加载类，而不必提前知道该类的名称，从而实现更加灵活的编程。
动态创建对象：反射可以在运行时根据类信息动态创建对象，从而实现更加灵活的对象构建，比如通过读取配置文件来创建对象。
动态调用方法：反射可以在运行时动态地调用任意方法，无论是公共方法还是私有方法，从而实现更加灵活的方法调用。
动态获取和设置属性：反射可以在运行时动态地获取和设置对象属性的值，从而实现对对象属性的灵活操作。
JavaBean内省：反射可以自动识别JavaBean的属性以及对应的get和set方法，从而快速获取或设置对象的属性值。

总之，反射机制可以很好地增强Java程序的灵活性和可扩展性，但是由于反射操作比较耗时，因此需要谨慎使用。

其中第一点我不是很理解，这里举一个例子：

一个常用的例子是读取配置文件的方式动态加载指定的类。假设我们有一个配置文件，包含了需要加载的类的全路径名，比如：

# 配置文件 classes.properties
com.example.MyClass1=com.example.impl.MyClass1Impl
com.example.MyClass2=com.example.impl.MyClass2Impl

其中，左边的是我们在程序中指定的类名，右边是实际需要加载的类的全路径名。我们可以在程序中读取该配置文件，并使用反射机制加载右边的类。示例代码如下：

Properties props = new Properties();
props.load(new FileInputStream("classes.properties"));
String className = props.getProperty("com.example.MyClass1");Class<?> clazz = Class.forName(className);
Object instance = clazz.newInstance();
MyClass1 obj = (MyClass1) instance;

在上面的示例代码中，我们读取了配置文件，获取到了需要加载的类名，并使用 Class.forName() 方法加载类。然后，使用 newInstance() 方法创建类的实例，并将其转换成了 MyClass1 类型的对象。这样，我们就成功地动态加载了需要的类，无需在代码中手动指定该类的名称。

这里的根据需要动态加载类，而不必提前知道类名，我一开始是不太理解的，现在想想，应该类似占位符或者形参之类的，只不过这个是把类全路径名卸载了配置文件里（方便更改，有种动态替换的感觉）。大抵如此吧，如果有更好的理解，大家可以在评论区@我。

第一种：JDBC 的数据库的连接

在JDBC 的操作中，如果要想进行数据库的连接，则必须按照以上的几步完成

通过Class.forName()加载数据库的驱动程序（通过反射加载，前提是引入相关了Jar包）；
通过 DriverManager 类进行数据库的连接，连接的时候要输入数据库的连接地址、用户名、密码；
通过Connection 接口接收连接。

public class ConnectionJDBC {  /** * @param args */  //驱动程序就是之前在classpath中配置的JDBC的驱动程序的JAR 包中  public static final String DBDRIVER = "com.mysql.jdbc.Driver";  //连接地址是由各个数据库生产商单独提供的，所以需要单独记住  public static final String DBURL = "jdbc:mysql://localhost:3306/test";  //连接数据库的用户名  public static final String DBUSER = "root";  //连接数据库的密码  public static final String DBPASS = "root";  public static void main(String[] args) throws Exception {  Connection con = null; //表示数据库的连接对象  Class.forName(DBDRIVER); //1、使用CLASS 类加载驱动程序 ,反射机制的体现 con = DriverManager.getConnection(DBURL,DBUSER,DBPASS); //2、连接数据库  System.out.println(con);  con.close(); // 3、关闭数据库  }

第二种：Spring 框架的使用，最经典的就是xml的配置模式。

Spring 通过 XML 配置模式装载 Bean 的过程：

将程序内所有 XML 或 Properties 配置文件加载入内存中；
Java类里面解析xml或properties里面的内容，得到对应实体类的字节码字符串以及相关的属性信息；
使用反射机制，根据这个字符串获得某个类的Class实例；
动态配置实例的属性。

Spring这样做的好处是：

不用每一次都要在代码里面去new或者做其他的事情；
以后要改的话直接改配置文件，代码维护起来就很方便了；
有时为了适应某些需求，Java类里面不一定能直接调用另外的方法，可以通过反射机制来实现。

模拟 Spring 加载 XML 配置文件：

public class BeanFactory {private Map<String, Object> beanMap = new HashMap<String, Object>();/*** bean工厂的初始化.* @param xml xml配置文件*/public void init(String xml)  {try {//读取指定的配置文件SAXReader reader = new SAXReader();ClassLoader classLoader = Thread.currentThread().getContextClassLoader();//从class目录下获取指定的xml文件InputStream ins = classLoader.getResourceAsStream(xml);Document doc = reader.read(ins);Element root = doc.getRootElement();  Element foo;//遍历beanfor (Iterator i = root.elementIterator("bean"); i.hasNext();) {  foo = (Element) i.next();//获取bean的属性id和classAttribute id = foo.attribute("id");  Attribute cls = foo.attribute("class");//利用Java反射机制，通过class的名称获取Class对象Class bean = Class.forName(cls.getText());//获取对应class的信息java.beans.BeanInfo info = java.beans.Introspector.getBeanInfo(bean);//获取其属性描述java.beans.PropertyDescriptor pd[] = info.getPropertyDescriptors();//设置值的方法Method mSet = null;//创建一个对象Object obj = bean.newInstance();//遍历该bean的property属性for (Iterator ite = foo.elementIterator("property"); ite.hasNext();) {  Element foo2 = (Element) ite.next();//获取该property的name属性Attribute name = foo2.attribute("name");String value = null;//获取该property的子元素value的值for(Iterator ite1 = foo2.elementIterator("value"); ite1.hasNext();) {Element node = (Element) ite1.next();value = node.getText();break;}for (int k = 0; k < pd.length; k++) {if (pd[k].getName().equalsIgnoreCase(name.getText())) {mSet = pd[k].getWriteMethod();//利用Java的反射极致调用对象的某个set方法，并将值设置进去mSet.invoke(obj, value);}}}//将对象放入beanMap中，其中key为id值，value为对象beanMap.put(id.getText(), obj);}} catch (Exception e) {System.out.println(e.toString());}}//other codes
}

反射机制的原理是什么？

Class actionClass=Class.forName(“MyClass”);
Object action=actionClass.newInstance();
Method method = actionClass.getMethod(“myMethod”,null);
//普通成员方法是属于对象的，只有类方法才属于类，所以这里执行方法需要对象参数，以确定是哪一个对象实例的方法
method.invoke(action,null);

上面就是最常见的反射使用的例子，前两行实现了类的装载、链接和初始化（newInstance方法实际上也是使用反射调用了方法），后两行实现了从class对象中获取到method对象然后执行反射调用。

反射原理简要描述如下：

反射获取类实例 Class.forName()，并没有将实现留给了java,而是交给了jvm去加载！主要是先获取 ClassLoader, 然后调用 native 方法，获取信息，加载类则是回调 java.lang.ClassLoader。最后，jvm又会回调 ClassLoader 进类加载！
newInstance() 主要做了三件事：
- 权限检测，如果不通过直接抛出异常；
- 查找无参构造器，并将其缓存起来；
- 调用具体方法的无参构造方法，生成实例并返回。
获取Method对象

上面的Class对象是在加载类时由JVM构造的，JVM为每个类管理一个独一无二的Class对象，这份Class对象里维护着该类的所有Method，Field，Constructor的cache，这份cache也可以被称作根对象。

每次getMethod获取到的Method对象都持有对根对象的引用，因为一些重量级的Method的成员变量（主要是MethodAccessor），我们不希望每次创建Method对象都要重新初始化，于是所有代表同一个方法的Method对象都共享着根对象的MethodAccessor，每一次创建都会调用根对象的copy方法复制一份：

 Method copy() { Method res = new Method(clazz, name, parameterTypes, returnType,exceptionTypes, modifiers, slot, signature,annotations, parameterAnnotations, annotationDefault);res.root = this;res.methodAccessor = methodAccessor;return res;}

调用invoke()方法。调用invoke方法的流程如下：

调用Method.invoke之后，会直接去调MethodAccessor.invoke。MethodAccessor就是上面提到的所有同名method共享的一个实例，由ReflectionFactory创建。

创建机制采用了一种名为inflation的方式（JDK1.4之后）：如果该方法的累计调用次数<=15，会创建出NativeMethodAccessorImpl，它的实现就是直接调用native方法实现反射；如果该方法的累计调用次数>15，会由java代码创建出字节码组装而成的MethodAccessorImpl。（是否采用inflation和15这个数字都可以在jvm参数中调整）以调用MyClass.myMethod(String s)为例，生成出的MethodAccessorImpl字节码翻译成Java代码大致如下：

public class GeneratedMethodAccessor1 extends MethodAccessorImpl {    public Object invoke(Object obj, Object[] args)  throws Exception {try {MyClass target = (MyClass) obj;String arg0 = (String) args[0];target.myMethod(arg0);} catch (Throwable t) {throw new InvocationTargetException(t);}}
}

解释一下这句话：每次getMethod获取到的Method对象都持有对根对象的引用，因为一些重量级的Method的成员变量（主要是MethodAccessor），我们不希望每次创建Method对象都要重新初始化，于是所有代表同一个方法的Method对象都共享着根对象的MethodAccessor，每一次创建都会调用根对象的copy方法复制一份。

这句话描述的是为什么在Java反射机制中，每次调用getMethod方法都会返回一个新的Method对象，但是这些Method对象共享一个MethodAccessor对象。

在Java反射机制中，每个Method对象包含了一些重要的成员变量，其中一个是MethodAccessor。MethodAccessor通常由JVM自动生成且是比较重量级的对象。因此，为了提高性能，我们不希望每当调用getMethod方法时都重新创建一个MethodAccessor对象。

为了实现MethodAccessor对象的共享，Java反射机制采用了一种策略：每个Method对象都会持有对根对象的引用。这个根对象是在第一次调用getMethod方法时创建的，它包含了所有该类的方法的MethodAccessor对象。

因此，每当我们调用同一个类的不同方法时，虽然返回的Method对象是不同的，但是它们都共享着这个根对象的MethodAccessor对象。这样，当我们通过Method对象调用方法时，就不用每次都重新创建MethodAccessor，从而提高了性能。

注意，每当我们创建一个新的Method对象时，会调用根对象的copy方法，这样就可以复制一个新的MethodAccessor对象。这保证了不同的Method对象之间修改MethodAccessor对象时不会相互影响。

解释一下这句话：注意，每当我们创建一个新的Method对象时，会调用根对象的copy方法，这样就可以复制一个新的MethodAccessor对象。这保证了不同的Method对象之间修改MethodAccessor对象时不会相互影响。

这句话指出，为了确保不同的Method对象之间修改MethodAccessor对象时不会相互影响，每次创建新的Method对象时，都需要调用根对象的copy方法来复制一个新的MethodAccessor对象。

在Java反射机制中，每个Method对象都持有一个对根对象的引用，而根对象包含了所有方法的MethodAccessor对象。当我们通过Method对象调用方法时，实际上是使用MethodAccessor对象来执行方法。因此，如果多个Method对象共享同一个MethodAccessor对象，它们之间可能会相互影响，导致程序出现异常。

为了避免这种情况，Java反射机制在创建新的Method对象时就会复制一个新的MethodAccessor对象。这个过程是通过调用根对象的copy方法实现的，所以每个Method对象都会有一个独立的MethodAccessor对象，不会相互影响。

总之，通过调用根对象的copy方法来复制新的MethodAccessor对象，可以确保不同的Method对象之间修改MethodAccessor对象时不会相互影响，从而保障程序的正确性和稳定性。