面试之反射的机制和使用

一、什么是反射

反射赋予了我们在运行时分析类以及执行类中方法的能力，通过反射你可以获取任意一个类的所有属性和方法，你还可以调用这些方法和属性。

二、反射的应用场景

1、Spring/Spring Boot、MyBatis 等框架中都大量使用了动态代理，而动态代理的实现依赖反射。

比如下面是通过 JDK 实现动态代理的示例代码，其中就使用了反射类 Method 来调用指定的方法。

public class DebugInvocationHandler implements InvocationHandler {
    /**
     * 代理类中的真实对象
     */
    private final Object target;

    public DebugInvocationHandler(Object target) {
        this.target = target;
    }
    public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
        System.out.println("before method " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("after method " + method.getName());
        return result;
    }
}

2、 Java 中的一大利器 注解 的实现也用到了反射。下面通过一个例子说明。

我们自定义一个注解GPService

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface GPService {
    String value() default "";
}

我们的业务类QuerySerivce，这里就是模拟Spring的Service注解，我们用一个自定义注解。

@GPService
public class QuerySerivce implements IQueryService {
    public String query(String name) {
        return "query service result";
    }
}

然后我们在容器初始化的时候，我们需要扫描标有service注解的类，然后实例化后放进容器内。大概的代码如下：

//拿到全类名，用于定位类，这一步一般Spring是通过扫描项目路径来获取，这一步是动态获取的
String className = "com.demo.QueryService";
//反射获取类的Class对象
Class<?> clazz = Class.forName(className);
//如果该类标注有GPService注解，我们就实例化这个类
if(clazz.isAnnotationPresent(GPService.class){
   Object instance = clazz.newInstance();
   //用map来模拟容器
   map.put(clazz.getSimpleName(),instance);
}

3、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 = "";  
      
      
    public static void main(String[] args) throws Exception {  
        Connection con = null; 
        //1、使用CLASS 类加载驱动程序 ,反射机制的体现 
        Class.forName(DBDRIVER); 
        //2、连接数据库  
        con = DriverManager.getConnection(DBURL,DBUSER,DBPASS); 
        System.out.println(con);  
        // 3、关闭数据库  
        con.close(); 
    }  
}

4、Spring 框架的使用

在 Java的反射机制在做基础框架的时候非常有用，行内有一句这样的老话：反射机制是Java框架的基石。一般应用层面很少用，不过这种东西，现在很多开源框架基本都已经封装好了，自己基本用不着写。典型的除了hibernate之外，还有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;

            //遍历bean
            for (Iterator i = root.elementIterator("bean"); i.hasNext();) {  
                foo = (Element) i.next();
                //获取bean的属性id和class
                Attribute 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
}