Java高级特性之反射学习总结

  1. 云栖社区>
  2. 博客>
  3. 正文

Java高级特性之反射学习总结

行者武松 2017-08-01 10:37:00 浏览534
展开阅读全文

Java高级特性之反射学习总结


老规矩我们还是先提出几个问题,一门技术必然要能解决一定的问题,才有去学习掌握它的价值

  • 一、 什么是反射?
  • 二、反射能做什么?

一、 什么是反射?

用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说,Java程序可以加载一个运行时才得知名称的class,获悉其完整构造(但不包括methods定义),并生成其对象实体、或对其fields设值、或唤起其methods。

如果你是一个Android Developer,前辈们都会教导你尽量少用反射,效率太低,太慢。“射”嘛,射的太快就不好了,所以反射虽然慢点,但是偶尔射一下还是很”爽”的。

二、反射能做什么?

1、新建类的实例

我们知道所有的类都继承子顶级父类Object,而Object中有hashCode()、equals()、clone()、toString()、getClass()等。其中getClass()返回一个Class 对象。我们这里就需要使用的Class对象,注意C是大写,我们可以通过一下方式来获取Class对象

  1. Class.forName(“类名字符串”) (注意:类名字符串必须是全称,包名+类名)
  2. 类名.class
  3. 实例对象.getClass()

在Class类中有一个非常重要的方法


  1. public T newInstance() throws InstantiationException, IllegalAccessException { 
  2.        return newInstanceImpl(); 
  3.    } 
  4.  
  5. private native T newInstanceImpl() throws IllegalAccessException, InstantiationException;  

查看Api可以看到调用newInstace方法可以返回当前class对应的实例对象。接下来看一个小的Demo


  1. public class Reflection { 
  2.  
  3.     public static void main(String[] args) { 
  4.  
  5.         // 普通创建类的实例 
  6.  
  7.         People p1 = new People(); 
  8.         System.out.println(p1.getName()); 
  9.         // 利用反射获取类的实例 
  10.         Class clazz = People.class; 
  11.         // 常用方式,注意括号中需要放类的全路径名 
  12.         // Class clazz = Class.forName("reflection.People"); 
  13.         // Class clazz = p1.getClass(); 
  14.         try { 
  15.             People p2 = (People) clazz.newInstance(); 
  16.             System.out.println(p2.getName()); 
  17.         } catch (Exception e) { 
  18.             e.printStackTrace(); 
  19.         } 
  20.  
  21.     } 
  22.  
  23.  
  24. class People { 
  25.  
  26.     private String name = "张三"
  27.     private int age; 
  28.  
  29.     public String getName() { 
  30.         return name
  31.     } 
  32.  
  33.     public void setName(String name) { 
  34.         this.name = name
  35.     } 
  36.  
  37.     public int getAge() { 
  38.         return age; 
  39.     } 
  40.  
  41.     public void setAge(int age) { 
  42.         this.age = age; 
  43.     } 
  44.  
  45. }  

输入结果:


  1. 张三 
  2.  张三  

2、获取成员变量和方法

在讲之前我们先来看这样一个小按理,JSON数据转JavaBaen对象,在不用解析库的情况下,一般我们会这样做


  1. private void analysisDate(JSONObject response) throws JSONException { 
  2.         int announceid = response.getInt("announceid"); 
  3.         String title = response.getString("title"); 
  4.         String hits = response.getString("hits"); 
  5.         String addtime = response.getString("addtime"); 
  6.         NewsNotifyItem newsNotifyItem = new NewsNotifyItem(announceid, 
  7.                 title, hits, addtime); 
  8.     } 
  9. }  

每当我们需要解析额时候,都需要根据不同javabean来进行相应的解析,我们每次进行的操作都是一样的,只是解析的数据不同而已,结合上篇帖子讲到的泛型,这里我们就可以再利用反射来自己做一个Json解析工具。

下面是我写的一个JsonObject对象转JavaBean的一个工具类,需要注意的是,JSON的key需要和字段名保持一致,先说下思路

①首先通过反射获取JavaBean中的所有字段值的名称

②拼接出set方法

③由于字段名和Json的key值相同,利用自动名获取Json中的值并填充的实例对象中


  1. public class Json2BeanUtils { 
  2.  
  3.     public static <T> T jsonToBean(JSONObject response, Class<T> clazz) { 
  4.         try { 
  5.             // 创建类的实例 
  6.             Object object = Class.forName(clazz.getName()).newInstance(); 
  7.             // 获取类中的所有成员变量 
  8.             Field[] fields = object.getClass().getDeclaredFields(); 
  9.             for (int i = 0; i < fields.length; i++) { 
  10.                 //设置权限 
  11.                 fields[i].setAccessible(true); 
  12.                 // 获取字段的名称 
  13.                 String fieldName = fields[i].getName(); 
  14.                 // 过滤掉UID 
  15.                 if (fieldName.endsWith("serialVersionUID")) { 
  16.                     continue
  17.                 } 
  18.                 // 获取字段的类型 
  19.                 String fieldType = fields[i].getGenericType().toString(); 
  20.                 // 拼接出JavaBean中的set方法 这里有一个坑 后面讲解 
  21.                 String methodName = "set" 
  22.                         + fieldName.substring(0, 1).toUpperCase() 
  23.                         + fieldName.substring(1); 
  24.                 try { 
  25.                     // 判断变量类型 
  26.                     if (fieldType.endsWith("class java.lang.String")) { 
  27.                         // 获取到set方法 
  28.                         Method m = object.getClass().getMethod(methodName, 
  29.                                 String.class); 
  30.                         String value = null
  31.                         try { 
  32.                             // 从JsonObj中取出相应的值 
  33.                             value = response.getString(fieldName); 
  34.                         } catch (Exception e) { 
  35.                             e.printStackTrace(); 
  36.                             value = ""
  37.                         } 
  38.                         if (TextUtils.isEmpty(value)) { 
  39.                             value = ""
  40.                         } else if (value.endsWith("null")) { 
  41.                             value = ""
  42.                         } 
  43.                         // 赋值 
  44.                         m.invoke(object, value); 
  45.                     } else if (fieldType.endsWith("int"
  46.                             || fieldType.endsWith("class java.lang.Integer")) { 
  47.                         // int 类型 
  48.                         System.out.println(); 
  49.                         Method m = object.getClass().getMethod(methodName, 
  50.                                 int.class); 
  51.                         int value = -1; 
  52.                         try { 
  53.                             value = response.getInt(fieldName); 
  54.                         } catch (Exception e) { 
  55.                             e.printStackTrace(); 
  56.                             value = -1; 
  57.                         } 
  58.                         m.invoke(object, value); 
  59.  
  60.                     } else if (fieldType.endsWith("boolean"
  61.                             || fieldType 
  62.                                     .endsWith("fieldType:class java.lang.Boolean")) { 
  63.                         // boolean 类型 
  64.                         Method m = object.getClass().getMethod(methodName, 
  65.                                 boolean.class); 
  66.                         boolean value = false
  67.                         try { 
  68.                             value = response.getBoolean(fieldName); 
  69.                         } catch (Exception e) { 
  70.                             e.printStackTrace(); 
  71.                             value = false
  72.                         } 
  73.                         m.invoke(object, value); 
  74.                     } else if (fieldType.endsWith("double"
  75.                             || fieldType 
  76.                                     .endsWith("fieldType:class java.lang.Double")) { 
  77.                         // double 类型 
  78.                         Method m = object.getClass().getMethod(methodName, 
  79.                                 double.class); 
  80.                         double value = -1D; 
  81.                         try { 
  82.                             value = response.getDouble(fieldName); 
  83.                         } catch (Exception e) { 
  84.                             e.printStackTrace(); 
  85.                             value = -1D; 
  86.                         } 
  87.                         m.invoke(object, value); 
  88.                     } else if (fieldType.endsWith("char")) { 
  89.                         // char类型 JSONObject 没有char 
  90.                         Method m = object.getClass().getMethod(methodName, 
  91.                                 String.class); 
  92.                         String value = ""
  93.                         try { 
  94.                             value = response.getString(fieldName); 
  95.                         } catch (Exception e) { 
  96.                             e.printStackTrace(); 
  97.                             value = ""
  98.                         } 
  99.                         m.invoke(object, value); 
  100.                     } else if (fieldType.endsWith("float"
  101.                             || fieldType 
  102.                                     .endsWith("fieldType:class java.lang.Float")) { 
  103.                         // float类型 
  104.                         Method m = object.getClass().getMethod(methodName, 
  105.                                 double.class); 
  106.                         double value = -1D; 
  107.                         try { 
  108.                             value = response.getDouble(fieldName); 
  109.                         } catch (Exception e) { 
  110.                             e.printStackTrace(); 
  111.                             value = -1D; 
  112.                         } 
  113.                         m.invoke(object, value); 
  114.  
  115.                     } else if (fieldType.endsWith("short"
  116.                             || fieldType 
  117.                                     .endsWith("fieldType:class java.lang.Short")) { 
  118.                         // short 
  119.                         Method m = object.getClass().getMethod(methodName, 
  120.                                 short.class); 
  121.                         int value = -1; 
  122.                         try { 
  123.                             value = response.getInt(fieldName); 
  124.                         } catch (Exception e) { 
  125.                             e.printStackTrace(); 
  126.                             value = -1; 
  127.                         } 
  128.                         m.invoke(object, value); 
  129.                     } else if (fieldType.endsWith("byte"
  130.                             || fieldType 
  131.                                     .endsWith("fieldType:class java.lang.Byte")) { 
  132.                         Method m = object.getClass().getMethod(methodName, 
  133.                                 byte.class); 
  134.                         int value = -1; 
  135.                         try { 
  136.                             value = response.getInt(fieldName); 
  137.                         } catch (Exception e) { 
  138.                             e.printStackTrace(); 
  139.                             value = -1; 
  140.                         } 
  141.                         m.invoke(object, value); 
  142.                     } else if (fieldType.endsWith("long"
  143.                             || fieldType 
  144.                                     .endsWith("fieldType:class java.lang.Long")) { 
  145.                         Method m = object.getClass().getMethod(methodName, 
  146.                                 long.class); 
  147.                         Long value = -1L; 
  148.                         try { 
  149.                             value = response.getLong(fieldName); 
  150.                         } catch (Exception e) { 
  151.                             e.printStackTrace(); 
  152.                             value = -1L; 
  153.                         } 
  154.                         m.invoke(object, value); 
  155.                     }   
  156.                 } catch (Exception e) { 
  157.                     // TODO: handle exception 
  158.                 } 
  159.             } 
  160.             return (T) object; 
  161.         } catch (Exception e) { 
  162.             e.printStackTrace(); 
  163.         } 
  164.  
  165.         return null
  166.     } 
  167.  
  168. }  

这里需要注意一个坑,先来看一段代码


  1. class People { 
  2.  
  3.     private String name
  4.     private int age; 
  5.     private String mSex; 
  6.  
  7.     public String getName() { 
  8.         return name
  9.     } 
  10.  
  11.     public void setName(String name) { 
  12.         this.name = name
  13.     } 
  14.  
  15.     public int getAge() { 
  16.         return age; 
  17.     } 
  18.  
  19.     public void setAge(int age) { 
  20.         this.age = age; 
  21.     } 
  22.  
  23.     public String getmSex() { 
  24.         return mSex; 
  25.     } 
  26.     // 这里就出了问题   
  27.     public void setmSex(String mSex) { 
  28.         this.mSex = mSex; 
  29.     } 
  30.  
  31. }  

当我们自动生成get set方法时,会将字段的首字母大写,我们在上面拼接set 方法时,也是基于这样的规则来拼装的。但是 当我们的字段名为 aAbbb 时,则生成的get set 方法则不会大写。解决方案也很简单,注意字段命名或者在拼接时对第二个自动进行大小写判断。这样我们自己写的Json解析工具就搞定, 以后每次解析只需一行代码即可OK。


作者:佚名

来源:51CTO

网友评论

登录后评论
0/500
评论
行者武松
+ 关注