Java 反射常用方法

Java 反射常用的方法

(1)把List 转化为Map

场景:系统中有一个字典类,是一个实体类,如下(省略了getter,setter方法):

Java代码  

  1. /** 
  2.  * Data Dictionary Entity 
  3.  */  
  4. @Entity  
  5. @Table(name = "t_dictionary")  
  6. public class CommonDictionary implements Cloneable, Serializable {  
  7.   
  8.     private static final long serialVersionUID = 0x33d260729eadd26eL;  
  9.   
  10.     /** 
  11.      * 主键id 
  12.      */  
  13.     private Long id;  
  14.     /** 
  15.      * 组id 
  16.      */  
  17.     private String groupId;  
  18.     /** 
  19.      * 键<br />不能取值为key,因为key是关键字 
  20.      */  
  21.     private String key2;  
  22.     /** 
  23.      * 值 
  24.      */  
  25.     private String value;  
  26.     /** 
  27.      * 描述 
  28.      */  
  29.     private String description;  
  30.  public CommonDictionary clone() throws CloneNotSupportedException {  
  31.         return (CommonDictionary) super.clone();  
  32.     }  

 从数据库中查出的结果是List<CommonDictionary> anticounterfeit,我想把它转化为List,CommonDictionary  中的key2作为map的key,CommonDictionary 中的value作为map的value.

方法如下 :

Java代码  

  1. /*** 
  2.      *  
  3.      * @param list 
  4.      * @param clazz 
  5.      * @param keyProperty : 该成员变量的值作为map的key 
  6.      * @param valueProperty : 该成员变量的值作为map的value 
  7.      * @return 
  8.      */  
  9.     public static Map<String,Object> parseObjectList(List list,Class clazz,String keyProperty,String valueProperty){  
  10.         Map<String,Object> map=new HashMap<String, Object>();  
  11.         for(int i=0;i<list.size();i++){  
  12.             Object obj=list.get(i);  
  13.             Field keyf =null;  
  14.             Field valuef =null;  
  15.             try {  
  16.                 keyf = clazz.getDeclaredField(keyProperty);  
  17.             } catch (NoSuchFieldException e) {  
  18.                 keyf= getSpecifiedField(clazz.getSuperclass()/* 
  19.                                                              * may be null if it is 
  20.                                                              * Object . 
  21.                                                              */, keyProperty);  
  22.                 // e.printStackTrace();  
  23.             }  
  24.             try {  
  25.                 valuef = clazz.getDeclaredField(valueProperty);  
  26.             } catch (NoSuchFieldException e) {  
  27.                 valuef= getSpecifiedField(clazz.getSuperclass()/* 
  28.                                                              * may be null if it is 
  29.                                                              * Object . 
  30.                                                              */, valueProperty);  
  31.                 // e.printStackTrace();  
  32.             }  
  33.             keyf.setAccessible(true);  
  34.             valuef.setAccessible(true);  
  35.             try {  
  36.                 map.put((String)keyf.get(obj), valuef.get(obj));  
  37.             } catch (IllegalArgumentException e) {  
  38.                 e.printStackTrace();  
  39.             } catch (IllegalAccessException e) {  
  40.                 e.printStackTrace();  
  41.             }  
  42.         }  
  43.         return map;  
  44.     }  

 依赖的方法:

Java代码  

  1. /*** 
  2.      * Get Specified Field 
  3.      *  
  4.      * @param clazz 
  5.      * @param fieldName 
  6.      * @return 
  7.      */  
  8.     public static Field getSpecifiedField(Class<?> clazz, String fieldName) {  
  9.         Field f = null;  
  10.         if (ValueWidget.isNullOrEmpty(clazz)) {  
  11.             return null;  
  12.         }  
  13.         try {  
  14.             f = clazz.getDeclaredField(fieldName);  
  15.         } catch (NoSuchFieldException e) {  
  16.             return getSpecifiedField(clazz.getSuperclass()/* 
  17.                                                          * may be null if it is 
  18.                                                          * Object . 
  19.                                                          */, fieldName);  
  20.             // e.printStackTrace();  
  21.         }  
  22.         return f;  
  23.     }  

 使用实例:

Java代码  

  1. List<CommonDictionary> anticounterfeit=DictionaryParam.getList(Constant2.DICTIONARY_GROUP_ANTICOUNTERFEIT_CODE);  
  2.         QrSettingsBean qrSettingsBean=new QrSettingsBean();  
  3.         Map<String,Object>map=ReflectHWUtils.parseObjectList(anticounterfeit, CommonDictionary.class, "key2", "value");  
  4. ReflectHWUtils.setObjectValue(qrSettingsBean, map);  
  5.         model.addAttribute("qrSettingsBean", qrSettingsBean);  

 

 

(2)把Map 转化为java对象,map的key对应对象的成员变量的名称

Java代码  

  1. /*** 
  2.      * 利用反射设置对象的属性值. 注意:属性可以没有setter 方法. 
  3.      *  
  4.      * @param obj 
  5.      * @param params 
  6.      * @throws SecurityException 
  7.      * @throws NoSuchFieldException 
  8.      * @throws IllegalArgumentException 
  9.      * @throws IllegalAccessException 
  10.      */  
  11.     public static void setObjectValue(Object obj, Map<String, Object> params)  
  12.             throws SecurityException, NoSuchFieldException,  
  13.             IllegalArgumentException, IllegalAccessException {  
  14.         if (ValueWidget.isNullOrEmpty(params)) {  
  15.             return;  
  16.         }  
  17.         Class<?> clazz = obj.getClass();  
  18.         for (Iterator it = params.entrySet().iterator(); it.hasNext();) {  
  19.             Map.Entry<String, Object> entry = (Map.Entry<String, Object>) it  
  20.                     .next();  
  21.             String key = entry.getKey();  
  22.             Object propertyValue = entry.getValue();  
  23.             if (ValueWidget.isNullOrEmpty(propertyValue)) {  
  24.                 continue;  
  25.             }  
  26.             Field name = getSpecifiedField(clazz, key);  
  27.             if (name != null) {  
  28.                 name.setAccessible(true);  
  29.                 name.set(obj, propertyValue);  
  30.             }  
  31.         }  
  32.   
  33.     }  
  34. /*** 
  35.      * Get Specified Field 
  36.      *  
  37.      * @param clazz 
  38.      * @param fieldName 
  39.      * @return 
  40.      */  
  41.     public static Field getSpecifiedField(Class<?> clazz, String fieldName) {  
  42.         Field f = null;  
  43.         if (ValueWidget.isNullOrEmpty(clazz)) {  
  44.             return null;  
  45.         }  
  46.         try {  
  47.             f = clazz.getDeclaredField(fieldName);  
  48.         } catch (NoSuchFieldException e) {  
  49.             return getSpecifiedField(clazz.getSuperclass()/* 
  50.                                                          * may be null if it is 
  51.                                                          * Object . 
  52.                                                          */, fieldName);  
  53.             // e.printStackTrace();  
  54.         }  
  55.         return f;  
  56.     }  

 

(3)把对象中 值为空字符串的成员变量 ,将其值改为null

Java代码  

  1. /*** 
  2.      * 把对象中空字符串改为null 
  3.      * @param obj : 要修改的对象:java bean 
  4.      * @throws SecurityException 
  5.      * @throws NoSuchFieldException 
  6.      * @throws IllegalArgumentException 
  7.      * @throws IllegalAccessException 
  8.      */  
  9.     public static void convertEmpty2Null(Object obj)   
  10.             throws SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException{  
  11.         List<Field> fieldsList =getAllFieldList(obj.getClass());  
  12.         for(int i=0;i<fieldsList.size();i++){  
  13.             Field f=fieldsList.get(i);  
  14.             Object vObj=getObjectValue(obj,f );  
  15.             if(f.getType().getName().equals("java.lang.String") && (vObj instanceof String) ){  
  16.                 String str=(String)vObj;  
  17.                 if(SystemHWUtil.EMPTY.equals(str)){  
  18. //                  System.out.println(f.getName());  
  19. //                  System.out.println(f.getType().getName());  
  20.                     f.setAccessible(true);  
  21.                     f.set(obj, null);  
  22.                 }  
  23.             }  
  24.         }  
  25.     }  

 依赖的方法:

Java代码  

  1. /*** 
  2.      * get all field ,including fields in father/super class 
  3.      *  
  4.      * @param clazz 
  5.      * @return 
  6.      */  
  7.     public static List<Field> getAllFieldList(Class<?> clazz) {  
  8.         List<Field> fieldsList = new ArrayList<Field>();// return object  
  9.         if (clazz == null) {  
  10.             return null;  
  11.         }  
  12.   
  13.         Class<?> superClass = clazz.getSuperclass();// father class  
  14.         if (!superClass.getName().equals(Object.class.getName()))/* 
  15.                                                                  * java.lang.Object 
  16.                                                                  */{  
  17.   
  18.             // System.out.println("has father");  
  19.             fieldsList.addAll(getAllFieldList(superClass));// Recursive  
  20.         }  
  21.         Field[] fields = clazz.getDeclaredFields();  
  22.         for (int i = 0; i < fields.length; i++) {  
  23.             Field field = fields[i];  
  24.             // 排除因实现Serializable 接口而产生的属性serialVersionUID  
  25.             if (!field.getName().equals("serialVersionUID")) {  
  26.                 fieldsList.add(field);  
  27.             }  
  28.         }  
  29.         return fieldsList;  
  30.     }  
  31. /*** 
  32.      * 获取指定对象的属性值 
  33.      *  
  34.      * @param obj 
  35.      * @param name 
  36.      *            :Field 
  37.      * @return 
  38.      * @throws SecurityException 
  39.      * @throws NoSuchFieldException 
  40.      * @throws IllegalArgumentException 
  41.      * @throws IllegalAccessException 
  42.      */  
  43.     public static Object getObjectValue(Object obj, Field name)  
  44.             throws SecurityException, NoSuchFieldException,  
  45.             IllegalArgumentException, IllegalAccessException {  
  46.   
  47.         // Field f = getSpecifiedField(obj.getClass(), name.getName());  
  48.         if (name == null) {  
  49.             System.out.println("[ReflectHWUtils.getObjectValue]"  
  50.                     + obj.getClass().getName() + " does not has field " + name);  
  51.             return null;  
  52.         }  
  53.         name.setAccessible(true);  
  54.         return name.get(obj);  
  55.     }  

 

(4)判断两个对象的属性值是否都相等.

Java代码  

  1. /*** 
  2.      * 判断两个对象的属性值是否都相等. 
  3.      *  
  4.      * @param obj1 
  5.      * @param obj2 
  6.      * @param exclusiveProperties 
  7.      *            : 要过滤的属性 
  8.      * @return 
  9.      * @throws SecurityException 
  10.      * @throws IllegalArgumentException 
  11.      * @throws NoSuchFieldException 
  12.      * @throws IllegalAccessException 
  13.      */  
  14.     public static boolean isSamePropertyValue(Object obj1, Object obj2,  
  15.             List<String> exclusiveProperties) throws SecurityException,  
  16.             IllegalArgumentException, NoSuchFieldException,  
  17.             IllegalAccessException {  
  18.         List<Field> fieldsList = getAllFieldList(obj1.getClass());  
  19.         for (int i = 0; i < fieldsList.size(); i++) {  
  20.             Field f = fieldsList.get(i);  
  21.             if ((!ValueWidget.isNullOrEmpty(exclusiveProperties))  
  22.                     && exclusiveProperties.contains(f.getName())) {// 过滤掉，不比较  
  23.                 continue;  
  24.             }  
  25.             Object propertyValue1 = getObjectValue(obj1, f);  
  26.             Object propertyValue2 = getObjectValue(obj2, f);  
  27.   
  28.             System.out.println(f.getName());  
  29.             if (propertyValue1 == propertyValue2) {// if propertyValue1 is null  
  30.                 continue;  
  31.             }  
  32.             if (!isSameBySimpleTypes(propertyValue1, propertyValue2)) {  
  33.                 return false;  
  34.             }  
  35.         }  
  36.         return true;  
  37.     }  
  38.   
  39. /*** 
  40.      * 比较java 基本类型的值是否相同. 
  41.      *  
  42.      * @param obj1 
  43.      *            : String,Integer,Double,Boolean 
  44.      * @param obj2 
  45.      * @return 
  46.      */  
  47.     public static boolean isSameBySimpleTypes(Object obj1, Object obj2) {  
  48.         if (obj1 == obj2) {  
  49.             return true;  
  50.         }  
  51.         if (obj1 instanceof Integer) {// int  
  52.             Integer int1 = (Integer) obj1;  
  53.             Integer int2 = (Integer) obj2;  
  54.             return int1.intValue() == int2.intValue();  
  55.         } else if (obj1 instanceof Double) {// double  
  56.             Double double1 = (Double) obj1;  
  57.             Double double2 = (Double) obj2;  
  58.             return double1.compareTo(double2) == 0;  
  59.         } else if (obj1 instanceof Boolean) {// double  
  60.             Boolean boolean1 = (Boolean) obj1;  
  61.             Boolean boolean2 = (Boolean) obj2;  
  62.             return boolean1.compareTo(boolean2) == 0;  
  63.         } else if (obj1 instanceof String) {  
  64.             String str1 = (String) obj1;  
  65.             String str2 = (String) obj2;  
  66.             return str1.equals(str2);  
  67.         } else if (obj1 instanceof Timestamp) {  
  68.             Timestamp time1 = (Timestamp) obj1;  
  69.             Timestamp time2 = (Timestamp) obj2;  
  70.             return time1.compareTo(time2) == 0;  
  71.         } else if (obj1 instanceof java.util.Date) {  
  72.             java.util.Date time1 = (java.util.Date) obj1;  
  73.             java.util.Date time2 = (java.util.Date) obj2;  
  74.             return time1.compareTo(time2) == 0;  
  75.         } else if (obj1 instanceof java.sql.Date) {  
  76.             java.sql.Date time1 = (java.sql.Date) obj1;  
  77.             java.sql.Date time2 = (java.sql.Date) obj2;  
  78.             return time1.compareTo(time2) == 0;  
  79.         }  
  80.         return obj1 == obj2;  
  81.     }  
  82.   
  83. /*** 
  84.      * 获取指定对象的属性值 
  85.      *  
  86.      * @param obj 
  87.      * @param name 
  88.      *            :Field 
  89.      * @return 
  90.      * @throws SecurityException 
  91.      * @throws NoSuchFieldException 
  92.      * @throws IllegalArgumentException 
  93.      * @throws IllegalAccessException 
  94.      */  
  95.     public static Object getObjectValue(Object obj, Field name)  
  96.             throws SecurityException, NoSuchFieldException,  
  97.             IllegalArgumentException, IllegalAccessException {  
  98.   
  99.         // Field f = getSpecifiedField(obj.getClass(), name.getName());  
  100.         if (name == null) {  
  101.             System.out.println("[ReflectHWUtils.getObjectValue]"  
  102.                     + obj.getClass().getName() + " does not has field " + name);  
  103.             return null;  
  104.         }  
  105.         name.setAccessible(true);  
  106.         return name.get(obj);  
  107.     }  
时间： 2024-02-20 03:33:29

Java 反射常用方法的相关文章

java反射机制剖析（一）—简介

    由之前动态代理的学习再次接触到反射这个知识点,第二次接触了所以做了一些稍微深入的了解.那么,对于反射这部分的内容我打算分三篇博客来总结.本篇博客先对反射做一个大概的了解,包括反射有关的RTTI.定义的理解以及涉及到的其他知识的简介. 回顾     java之前我接触反射这个知识,是在大话设计中的抽象工厂模式里,通过反射+配置文件来优化抽象工厂提高其应对需求变更的灵活性.当时对于反射的认知仅仅是它是一种技术,一种实例化对象的技术,一种实例化对象不依赖于写死的代码的技术.简单的说就是,它是一

Java反射机制（一）：认识Class类

一. 认识Class类 1.1 正常我们再使用一个类时,大多情况是先获取类的对象,然后通过对象去操作类中的属性或方法. 那,大家有没有想过,如果我们已经有了一个类的对象,我能否通过该对象去获取到类的信息呢?答案是肯定的. java允许通过对象来找到其所在类的信息,那么实际上就是Class类的功能. 接下来,我们先看一个例子,定义一个类Person,并实例化Person类的一个对象,我们通过该对象去寻找到该Person类 package com.chen.yuan.ref; class Perso

Java反射机制与应用

    JAVA反射机制     JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法:这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制.     JAVA反射应用     Java反射机制主要提供了以下功能:  在运行时判断任意一个对象所属的类: 在运行时构造任意一个类的对象: 在运行时判断任意一个类所具有的成员变量和方法: 在运行时调用任意一个对象的方法: 生成动态代理. 常用方法 ①. 判断对

Java反射机制：包括组成、结构和示例说明等内容

第1部分 Java 反射机制介绍 Java 反射机制.通俗来讲呢,就是在运行状态中,我们可以根据"类的部分已经的信息"来还原"类的全部的信息".这里"类的部分已经的信息",可以是"类名"或"类的对象"等信息."类的全部信息"就是指"类的属性,方法,继承关系和Annotation注解"等内容. 举个简单的例子:假设对于类ReflectionTest.java,我们知道的

java反射机制系列（二）例子

下面我以顾客买相机为例来说明Java反射机制的应用.例子中涉及的类和接口有: Camera接口:定义了takePhoto()方法. Camera01类:一种照相机的类型,实现Camera接口. Camera02类:另一种照相机的类型,实现Camera接口. Seller类:卖照相机. Customer类:买相机,有main方法. 所有类都放在com包里 程序如下: public interface Camera { //声明照相机必须可以拍照 public void takePhoto(); }

java 反射机制系列（一） 初识Java Reflection

Java 反射机制是指Java程序可以在执行期载入,探知,使用编译期间完全未知的classes.这句话可能有点难以理解,我们可以通过一个例子来看.在Java程序中我们经常会用到这样一条语句来创建一个对象.Date date = new Date();在这条语句中date的类型(Java.util.Date)在编译时 已经确定.那么,有没有办法使我们把对象类型的确定时间由编译转到运行,答案是肯定的.这就是Java反射机制所提供的便利.而且它不单单可以生成对象还可以获取Field,对Field设值,

使用Java反射机制确定基本数据类型属性

Java反射机制提供了一种强大的应用程序接口来帮助我们在运行时检测和执行对象上的操作.该机制允许程序员审视一个未知对象,并且获得它的属性,例如对象上的方法,JavaBean的属性以及继承关系等. Java中有两种类型的值,一种是类类型,它把对象的属性定义在一个类中.类类型是面向对象结构的基本组成部分.第二种类型的值是基本数据类型.反射类型通常用于类类型,但是,其实它也可以很方便应用到Java的基本类型上. Java中的基本类型继承自基于C的语法,其中包括boolean.byte.short.in

初学java反射的问题 一直抛出classnotfoundexception

问题描述 初学java反射的问题 一直抛出classnotfoundexception public class TestReflection { public static void main(String[] args) { try{ String str = ""T""; Class c = Class.forName(str); c.newInstance(); } catch (ClassNotFoundException e) { e.printStac

Java 反射之动态代理

利用Java反射机制你可以在运行期动态的创建接口的实现.java.lang.reflect.Proxy类就可以实现这一功能.这个类的名字(译者注:Proxy意思为代理)就是为什么把动态接口实现叫做动态代理.动态的代理的用途十分广泛,比如数据库连接和事物管理(transaction management)还有单元测试时用到的动态mock对象以及AOP中的方法拦截功能等等都使用到了动态代理. 创建代理你可以通过使用Proxy.newProxyInstance()方法创建动态代理.newProxyIn