一次项目中的反射机制的使用

---

什么是Java的反射机制

JAVA反射机制是在运行状态中, 对于任意一个类, 都能够知道这个类的所有属性和方法; 对于任意一个对象, 都能够调用它的任意一个方法和属性; 这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制.

主要作用有三：

1. 运行时取得类的方法和字段的相关信息。

2. 创建某个类的新实例(.newInstance())

3. 取得字段引用直接获取和设置对象字段，无论访问修饰符是什么。

用处如下：

1. 观察或操作应用程序的运行时行为。
2. 调试或测试程序，因为可以直接访问方法、构造函数和成员字段。
3. 通过名字调用不知道的方法并使用该信息来创建对象和调用方法

反射的应用场景

我在车管项目中遇到了一个应用场景，请先看界面：

在这个界面中，我要通过输入关键字来检索已经通过网络请求加载好的列表数据中，有哪些数据项是符合我的过滤条件的。

这个需求感觉很简单，只要遍历存放数据的List,然后每项都对比关键字即可，然后再将过滤后的数据存入一个新的List中，返回给RecyclerView的Adapter进行数据刷新即可。

但是在做的过程中我发现了两个问题：

1.第一个问题是我们的List获取的数据由于业务的不同，其泛型也是不同的,且泛型之间没有关联性；
2.每个泛型都是一个Bean,我们要过滤的是Bean中的属性，这个也是不确定的;

但是项目中大量的用到了这个功能，几乎每个列表项都会有本地过滤的功能，如果不将功能进行封装，每次都写硬编码，项目的复用性太低了，且整体项目不易维护。

一开始我想通过泛型进行处理，但是鉴于上边两个问题，泛型是没办法灵活处理的，尤其是第二个问题，泛型没有办法处理，于是想来想去，想到了反射机制。

闲话少说，先看代码：

public class ListFilter<T> {

    /**     * 过滤ArrayList中的关键字数据     * @param models 网络获取到的数据列表     * @param query 过滤关键字     * @param propertyName 泛型的数据过滤项     * @return 返回过滤后的数据     */
     * 过滤ArrayList中的关键字数据
     * @param models 网络获取到的数据列表
     * @param query 过滤关键字
     * @param propertyName 泛型的数据过滤项
     * @return 返回过滤后的数据
     */
    public ArrayList<T> filter(ArrayList<T> models, String query, String propertyName) {

        ArrayList<T> filteredModelList = null;
        //实例化这个类赋给o
        try {
            query = query.toLowerCase();
            filteredModelList = new ArrayList<>();
            for (T model : models) {
                final String text = getClassInfo(model,model.getClass().getName(),propertyName).toLowerCase();
                if (text.contains(query)) {
                    filteredModelList.add(model);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return filteredModelList;
    }

    /**     *  获取类的属性值     * @param obj 类实例     * @param classNameString 类名     * @param propertyNameString 获取的属性名     * @return  属性值     */
     *  获取类的属性值
     * @param obj 类实例
     * @param classNameString 类名
     * @param propertyNameString 获取的属性名
     * @return  属性值
     */
    private  String getClassInfo(Object obj,String classNameString,String propertyNameString) {
        String returnString="";
        try{
            Class classInfo = Class.forName(classNameString);
            if(!(classInfo.isInstance(obj))){
                L.e("传入的java实例与配置的java对象类型不符！");
                return returnString;
            }
            Field field = classInfo.getDeclaredField(propertyNameString);
            field.setAccessible(true);
            returnString=field.get(obj).toString();
        }catch(Exception e){
            e.printStackTrace();
        }
        return returnString;
    }
}

这段代码其实就是getClassInfo方法为核心的获取某个类的某个字段的字段值，这里涉及几个知识点大家可以自行百度学习一下：

1.getCanonicalName(), getName(), getSimpleName()三个方法的不同？
简答：
1、getCanonicalName() 是获取所传类从java语言规范定义的格式输出。
2、getName() 是返回实体类型名称
3、getSimpleName() 返回从源代码中返回实例的名称。

2.反射中获取类中的私有属性该如何操作？
简答：
field.setAccessible(true);
public void setAccessible(boolean flag) throws SecurityException
将此对象的 accessible 标志设置为指示的布尔值。值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。值为 false 则指示反射的对象应该实施 Java 语言访问检查。
实际上setAccessible是启用和禁用访问安全检查的开关,并不是为true就能访问为false就不能访问；

反射经典应用场景

以上就是我的项目中，使用反射的一个具体的实例了，其实在Java中还有很多地方都用到了反射，这里举两个比较常见的例子：

• JDBC 的数据库的连接

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

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

public class ConnectionJDBC {  
  
    /**      * @param args      */  
     * @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; //表示数据库的连接对象  
        Class.forName(DBDRIVER); //1、使用CLASS 类加载驱动程序 ,反射机制的体现 
        con = DriverManager.getConnection(DBURL,DBUSER,DBPASS); //2、连接数据库  
        System.out.println(con);  
        con.close(); // 3、关闭数据库  
    }

• Spring 框架的使用

  在 Java的反射机制在做基础框架的时候非常有用，行内有一句这样的老话：反射机制是Java框架的基石。一般应用层面很少用，不过这种东西，现在很多开源框架基本都已经封装好了，自己基本用不着写。典型的除了hibernate之外，还有spring也用到很多反射机制。最经典的就是xml的配置模式。

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

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

Spring这样做的好处是：

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

模拟 Spring 加载 XML 配置文件：

public class BeanFactory {
       private Map<String, Object> beanMap = new HashMap<String, Object>();
       /**       * bean工厂的初始化.       * @param xml xml配置文件       */
       * 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
}