`
阅读更多

JAVA 反射常用的方法

作者:1287789687@qq.com

(1)把List 转化为Map

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

/**
 * Data Dictionary Entity
 */
@Entity
@Table(name = "t_dictionary")
public class CommonDictionary implements Cloneable, Serializable {

    private static final long serialVersionUID = 0x33d260729eadd26eL;

    /**
     * 主键id
     */
    private Long id;
    /**
     * 组id
     */
    private String groupId;
    /**
     * 键<br />不能取值为key,因为key是关键字
     */
    private String key2;
    /**
     * 值
     */
    private String value;
    /**
     * 描述
     */
    private String description;
 public CommonDictionary clone() throws CloneNotSupportedException {
        return (CommonDictionary) super.clone();
    }

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

方法如下 :

/***
	 * 
	 * @param list
	 * @param clazz
	 * @param keyProperty : 该成员变量的值作为map的key
	 * @param valueProperty : 该成员变量的值作为map的value
	 * @return
	 */
	public static Map<String,Object> parseObjectList(List list,Class clazz,String keyProperty,String valueProperty){
		Map<String,Object> map=new HashMap<String, Object>();
		for(int i=0;i<list.size();i++){
			Object obj=list.get(i);
			Field keyf =null;
			Field valuef =null;
			try {
				keyf = clazz.getDeclaredField(keyProperty);
			} catch (NoSuchFieldException e) {
				keyf= getSpecifiedField(clazz.getSuperclass()/*
															 * may be null if it is
															 * Object .
															 */, keyProperty);
				// e.printStackTrace();
			}
			try {
				valuef = clazz.getDeclaredField(valueProperty);
			} catch (NoSuchFieldException e) {
				valuef= getSpecifiedField(clazz.getSuperclass()/*
															 * may be null if it is
															 * Object .
															 */, valueProperty);
				// e.printStackTrace();
			}
			keyf.setAccessible(true);
			valuef.setAccessible(true);
			try {
				map.put((String)keyf.get(obj), valuef.get(obj));
			} catch (IllegalArgumentException e) {
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			}
		}
		return map;
	}

 依赖的方法:

/***
	 * Get Specified Field
	 * 
	 * @param clazz
	 * @param fieldName
	 * @return
	 */
	public static Field getSpecifiedField(Class<?> clazz, String fieldName) {
		Field f = null;
		if (ValueWidget.isNullOrEmpty(clazz)) {
			return null;
		}
		try {
			f = clazz.getDeclaredField(fieldName);
		} catch (NoSuchFieldException e) {
			return getSpecifiedField(clazz.getSuperclass()/*
														 * may be null if it is
														 * Object .
														 */, fieldName);
			// e.printStackTrace();
		}
		return f;
	}

 使用实例:

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

 

 

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

/***
	 * 利用反射设置对象的属性值. 注意:属性可以没有setter 方法.
	 * 
	 * @param obj
	 * @param params
	 * @throws SecurityException
	 * @throws NoSuchFieldException
	 * @throws IllegalArgumentException
	 * @throws IllegalAccessException
	 */
	public static void setObjectValue(Object obj, Map<String, Object> params)
			throws SecurityException, NoSuchFieldException,
			IllegalArgumentException, IllegalAccessException {
		if (ValueWidget.isNullOrEmpty(params)) {
			return;
		}
		Class<?> clazz = obj.getClass();
		for (Iterator it = params.entrySet().iterator(); it.hasNext();) {
			Map.Entry<String, Object> entry = (Map.Entry<String, Object>) it
					.next();
			String key = entry.getKey();
			Object propertyValue = entry.getValue();
			if (ValueWidget.isNullOrEmpty(propertyValue)) {
				continue;
			}
			Field name = getSpecifiedField(clazz, key);
			if (name != null) {
				name.setAccessible(true);
				name.set(obj, propertyValue);
			}
		}

	}
/***
	 * Get Specified Field
	 * 
	 * @param clazz
	 * @param fieldName
	 * @return
	 */
	public static Field getSpecifiedField(Class<?> clazz, String fieldName) {
		Field f = null;
		if (ValueWidget.isNullOrEmpty(clazz)) {
			return null;
		}
		try {
			f = clazz.getDeclaredField(fieldName);
		} catch (NoSuchFieldException e) {
			return getSpecifiedField(clazz.getSuperclass()/*
														 * may be null if it is
														 * Object .
														 */, fieldName);
			// e.printStackTrace();
		}
		return f;
	}

 

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

/***
	 * 把对象中空字符串改为null
	 * @param obj : 要修改的对象:java bean
	 * @throws SecurityException
	 * @throws NoSuchFieldException
	 * @throws IllegalArgumentException
	 * @throws IllegalAccessException
	 */
	public static void convertEmpty2Null(Object obj) 
			throws SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException{
		List<Field> fieldsList =getAllFieldList(obj.getClass());
		for(int i=0;i<fieldsList.size();i++){
			Field f=fieldsList.get(i);
			Object vObj=getObjectValue(obj,f );
			if(f.getType().getName().equals("java.lang.String") && (vObj instanceof String) ){
				String str=(String)vObj;
				if(SystemHWUtil.EMPTY.equals(str)){
//					System.out.println(f.getName());
//					System.out.println(f.getType().getName());
					f.setAccessible(true);
					f.set(obj, null);
				}
			}
		}
	}

 依赖的方法:

/***
	 * get all field ,including fields in father/super class
	 * 
	 * @param clazz
	 * @return
	 */
	public static List<Field> getAllFieldList(Class<?> clazz) {
		List<Field> fieldsList = new ArrayList<Field>();// return object
		if (clazz == null) {
			return null;
		}

		Class<?> superClass = clazz.getSuperclass();// father class
		if (!superClass.getName().equals(Object.class.getName()))/*
																 * java.lang.Object
																 */{

			// System.out.println("has father");
			fieldsList.addAll(getAllFieldList(superClass));// Recursive
		}
		Field[] fields = clazz.getDeclaredFields();
		for (int i = 0; i < fields.length; i++) {
			Field field = fields[i];
			// 排除因实现Serializable 接口而产生的属性serialVersionUID
			if (!field.getName().equals("serialVersionUID")) {
				fieldsList.add(field);
			}
		}
		return fieldsList;
	}
/***
	 * 获取指定对象的属性值
	 * 
	 * @param obj
	 * @param name
	 *            :Field
	 * @return
	 * @throws SecurityException
	 * @throws NoSuchFieldException
	 * @throws IllegalArgumentException
	 * @throws IllegalAccessException
	 */
	public static Object getObjectValue(Object obj, Field name)
			throws SecurityException, NoSuchFieldException,
			IllegalArgumentException, IllegalAccessException {

		// Field f = getSpecifiedField(obj.getClass(), name.getName());
		if (name == null) {
			System.out.println("[ReflectHWUtils.getObjectValue]"
					+ obj.getClass().getName() + " does not has field " + name);
			return null;
		}
		name.setAccessible(true);
		return name.get(obj);
	}

 

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

/***
	 * 判断两个对象的属性值是否都相等.
	 * 
	 * @param obj1
	 * @param obj2
	 * @param exclusiveProperties
	 *            : 要过滤的属性
	 * @return
	 * @throws SecurityException
	 * @throws IllegalArgumentException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	public static boolean isSamePropertyValue(Object obj1, Object obj2,
			List<String> exclusiveProperties) throws SecurityException,
			IllegalArgumentException, NoSuchFieldException,
			IllegalAccessException {
		List<Field> fieldsList = getAllFieldList(obj1.getClass());
		for (int i = 0; i < fieldsList.size(); i++) {
			Field f = fieldsList.get(i);
			if ((!ValueWidget.isNullOrEmpty(exclusiveProperties))
					&& exclusiveProperties.contains(f.getName())) {// 过滤掉,不比较
				continue;
			}
			Object propertyValue1 = getObjectValue(obj1, f);
			Object propertyValue2 = getObjectValue(obj2, f);

			System.out.println(f.getName());
			if (propertyValue1 == propertyValue2) {// if propertyValue1 is null
				continue;
			}
			if (!isSameBySimpleTypes(propertyValue1, propertyValue2)) {
				return false;
			}
		}
		return true;
	}

/***
	 * 比较java 基本类型的值是否相同.
	 * 
	 * @param obj1
	 *            : String,Integer,Double,Boolean
	 * @param obj2
	 * @return
	 */
	public static boolean isSameBySimpleTypes(Object obj1, Object obj2) {
		if (obj1 == obj2) {
			return true;
		}
		if (obj1 instanceof Integer) {// int
			Integer int1 = (Integer) obj1;
			Integer int2 = (Integer) obj2;
			return int1.intValue() == int2.intValue();
		} else if (obj1 instanceof Double) {// double
			Double double1 = (Double) obj1;
			Double double2 = (Double) obj2;
			return double1.compareTo(double2) == 0;
		} else if (obj1 instanceof Boolean) {// double
			Boolean boolean1 = (Boolean) obj1;
			Boolean boolean2 = (Boolean) obj2;
			return boolean1.compareTo(boolean2) == 0;
		} else if (obj1 instanceof String) {
			String str1 = (String) obj1;
			String str2 = (String) obj2;
			return str1.equals(str2);
		} else if (obj1 instanceof Timestamp) {
			Timestamp time1 = (Timestamp) obj1;
			Timestamp time2 = (Timestamp) obj2;
			return time1.compareTo(time2) == 0;
		} else if (obj1 instanceof java.util.Date) {
			java.util.Date time1 = (java.util.Date) obj1;
			java.util.Date time2 = (java.util.Date) obj2;
			return time1.compareTo(time2) == 0;
		} else if (obj1 instanceof java.sql.Date) {
			java.sql.Date time1 = (java.sql.Date) obj1;
			java.sql.Date time2 = (java.sql.Date) obj2;
			return time1.compareTo(time2) == 0;
		}
		return obj1 == obj2;
	}

/***
	 * 获取指定对象的属性值
	 * 
	 * @param obj
	 * @param name
	 *            :Field
	 * @return
	 * @throws SecurityException
	 * @throws NoSuchFieldException
	 * @throws IllegalArgumentException
	 * @throws IllegalAccessException
	 */
	public static Object getObjectValue(Object obj, Field name)
			throws SecurityException, NoSuchFieldException,
			IllegalArgumentException, IllegalAccessException {

		// Field f = getSpecifiedField(obj.getClass(), name.getName());
		if (name == null) {
			System.out.println("[ReflectHWUtils.getObjectValue]"
					+ obj.getClass().getName() + " does not has field " + name);
			return null;
		}
		name.setAccessible(true);
		return name.get(obj);
	}

 

设置静态成员变量

    /***
     * 动态设置com.chanjet.gov.service.API 静态成员变量的值<br>
     *     注意:应用商店有多台主机进行负载均衡,所以设置完了不一定生效
     * @param key
     * @param val
     * @return
     */
    @RequestMapping(value = "/setAPIprops", produces = Constant.RESPONSE_CONTENTTYPE_PLAIN_UTF)
    @ResponseBody
    public String setAPIproperties(String key,String val) {
        if(!StringUtil.isNullOrEmpty(key)){
            try {
                Field field= API.class.getDeclaredField(key);
                field.setAccessible(true);
                try {
                    field.set(null,val);
                    return val;
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                    return e.getMessage();
                }
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
                return e.getMessage();
            }
        }
        return "failed";
    }

 

作者:1287789687@qq.com

源码见附件

1
0
分享到:
评论

相关推荐

    Java 反射常用方法及实例.pdf

    Java 反射机制是 Java 语言提供的一个重要功能,可以在运行时检查类、接口、方法和变量等信息,无需知道类的名字、方法名等。通过反射机制,可以在运行时实例化新对象、调用方法、设置和获取变量值等。 获取 Class...

    Java常用的反射方法

    反射获取Class类对象的三种方法 2.1 通过全类名的方式获取 2.2 类名.class 2.3 实例对象.getClass() 2.4 总结 3. 反射获取属性变量 3.1 获取所有public修饰符的成员变量 3.2 获取指定字段并赋值 3.3 获取...

    Java反射常用机制

    Java反射是Java编程语言中的一个强大工具,它允许程序在运行时检查并操作类、接口、字段和方法等对象。这个特性使得Java代码能够具备高度的动态性,能够在未知类结构的情况下进行操作,增强了程序的灵活性。在Java中...

    java反射 java反射 java反射java反射

    Java反射是Java编程语言中的一个重要特性,它允许程序在运行时动态地获取类的信息并操作类的对象。在Java中,反射机制提供了强大的能力,包括在运行时检查类的结构、创建对象实例、调用方法以及访问和修改字段值。...

    反射实例-JAVA反射机制

    在Java反射中,针对类的不同组成部分(构造函数、字段和方法),`java.lang.Class`类提供了多种反射调用方式来获取信息。以下是几种常用的反射调用: - **获取构造函数**:`Constructor getConstructor(Class[] ...

    java反射源代码

    Java反射是Java编程语言中的一个强大特性,它允许在运行时检查类、接口、字段和方法的信息,并且能够在运行时动态地创建对象和调用方法。这个特性使得Java具有高度的灵活性,尤其在处理框架、插件系统以及元数据驱动...

    Java中反射的常用方法总结

    以下是关于Java反射常用方法的详细说明: 1. **获取Class对象**: - `Class.forName(String className)`: 通过完全限定类名(包名+类名)获取对应的`Class`对象,常用于动态加载类。 - `类名.class`: 通过类名...

    java反射机制 字符串——java对象

    在Java反射机制中,字符串可以用来表示类名、方法名或参数类型,是连接代码与运行时类信息的桥梁。 在Java中,将Java对象的数据封装成XML格式的字符串,通常涉及到对象序列化的过程。对象序列化是将对象的状态转换...

    java程序各种常用方法集锦

    本资源"java程序各种常用方法集锦"正是为了解决这些问题而整理的一份综合性的代码库,包含了大量实用的代码示例。下面,我们将详细探讨这些关键知识点。 1. **集合操作**: - `ArrayList`与`LinkedList`:两种最...

    JAVA常用方法.rar

    这个压缩包"JAVA常用方法.rar"可能包含了各种常用的Java方法示例或者详细解释,涵盖了基础到进阶的各种功能。下面,我们将深入探讨一些Java中常见的方法,以及它们在实际编程中的应用。 1. **字符串操作方法** - `...

    java反射详解

    Java反射机制的强大之处在于其动态性,即能够在运行时处理类、方法和字段等。然而,过度依赖反射可能会导致代码难以理解和维护,因此应当谨慎使用。通过上述案例,我们已经了解了如何使用Java反射机制来获取和操作类...

    Java实验2 反射.doc

    本专栏主要为Java程序设计(基础)实验报告和Java程序设计(进阶)实验报告,基础篇有JAVA环境搭建、Java语言基础、方法和数组、面向对象基础、Java常用类、继承与接口、成员访问控制与异常、JavaFX程序设计、Java...

    反射常用方法整理(xmind)

    整理的Java反射的常用的一些方式,采用xmind的形式整理出来。希望有能够用到的。将java代码的各个组成部分封装为其他对象,可以在程序运行过程中操作这些对象,这就是java的反射机制;

    java常用代码方法

    在Java编程中,有一些常见的代码方法是每个开发者都需要掌握的。这些方法不仅提高了代码的可读性和可维护性,还能有效地解决日常编程问题。以下是一些关键的Java代码方法和相关知识点: 1. **字符串操作**: - `...

    java李兴华学习笔记之Java常用类库

    ### Java李兴华学习笔记之Java常用类库 #### 一、课程介绍及知识点...通过以上内容的学习,学习者不仅可以掌握Java常用类库的基本使用方法,还能进一步提高自己的编程能力,为今后更复杂的项目开发打下坚实的基础。

    利用java反射原理实现工厂模式

    Java反射机制是Java语言提供的一种强大的工具,允许程序在运行时检查类、接口、字段和方法的信息,并能动态地调用方法或访问和修改字段值。利用反射,我们可以在运行时才知道要创建哪个类的对象,从而极大地提高了...

    列举java语言中反射的常用方法及实例代码

    二、Class对象常用方法 1. `getName()`: 返回类的全限定名。 2. `getSimpleName()`: 返回类的简单名称,不包含包名。 3. `getConstructors()`: 获取类的所有公共构造器。 4. `getDeclaredConstructors()`: 获取类的...

    基于java反射的验证框架

    Java反射机制是在运行时分析类的能力,包括获取类的信息(如类名、属性、方法等)、创建对象、调用方法、访问和修改属性。通过Class类、Constructor类、Method类和Field类,我们可以动态地获取和操作类的信息。 1. ...

    java Map转换成bean,利用java反射以及java和bean包

    首先,Java反射是Java语言的一个重要特性,它允许程序在运行时检查类、接口、字段和方法的信息,甚至可以动态地调用方法和修改字段值。在Map到Bean的转换中,反射用于动态地创建Bean实例并设置其属性值。这需要使用`...

Global site tag (gtag.js) - Google Analytics