java ClassUtil 反射工具类详解编程语言

常用java反射工具类

ppackage com.gentlesoft.ecm.sys; 
import cn.hutool.core.util.ObjectUtil; 
import java.lang.reflect.Field; 
import java.lang.reflect.Method; 
import java.math.BigDecimal; 
import java.text.SimpleDateFormat; 
import java.util.Date; 
import java.util.Locale; 
import java.util.Map; 
public class ClassUtils { 
/** 
* 取对象全部属性名 
* 
* @param o 对象 
* @return 
*/ 
public static String[] getFiledName(Object o) { 
Field[] fields = o.getClass().getDeclaredFields(); 
String[] fieldNames = new String[fields.length]; 
for (int i = 0; i < fields.length; i++) { 
fieldNames[i] = fields[i].getName(); 
} 
return fieldNames; 
} 
/** 
* 根据属性名获取值 
* 
* @param fieldName 
* @param o 
* @return 
*/ 
public static Object getFieldValueByName(String fieldName, Object o) { 
try { 
String firstLetter = fieldName.substring(0, 1).toUpperCase(); 
String getter = "get" + firstLetter + fieldName.substring(1); 
Method method = o.getClass().getMethod(getter, new Class[]{}); 
Object value = method.invoke(o, new Object[]{}); 
return value; 
} catch (Exception e) { 
return null; 
} 
} 
/** 
* 根据属性名称和对象转化成对应的值 
* 
* @param bean     对象 
* @param property 属性名称 
* @param var      原始值 
* @return 
*/ 
public static Object convertValueByPropertyAndObjcet(Object bean, String property, Object var) { 
try { 
String value = var.toString(); 
Class<?> cls = bean.getClass(); 
Field field = cls.getDeclaredField(property); 
String type = field.getType().getSimpleName(); 
if (null != type && !"".equals(type) && null != value && !"".equals(value)) { 
if ("String".equals(type)) { 
return value; 
} else if ("Date".equals(type)) { 
return parseDate(value); 
} else if ("Integer".equals(type) || "int".equals(type)) { 
return Integer.parseInt(value); 
} else if ("Long".equalsIgnoreCase(type)) { 
return Long.parseLong(value); 
} else if ("Double".equalsIgnoreCase(type)) { 
return Double.parseDouble(value); 
} else if ("Boolean".equalsIgnoreCase(type)) { 
return Boolean.parseBoolean(value); 
} else { 
return new NullPointerException("not supper type" + type); 
} 
} else { 
return new NullPointerException("Object does not have this property：" + property); 
} 
} catch (Exception e) { 
e.printStackTrace(); 
return e; 
} 
} 
/** 
* 为对象属性赋值 
* 
* @param bean   对象 
* @param valMap map：键—属性名，值-属性值 
*/ 
public static void setFieldValue(Object bean, Map<String, String> valMap) { 
Class<?> cls = bean.getClass(); 
// 取出bean里的所有方法 
Method[] methods = cls.getDeclaredMethods(); 
Field[] fields = cls.getDeclaredFields(); 
for (Field field : fields) { 
try { 
String fieldSetName = parSetName(field.getName()); 
if (!valMap.containsKey(field.getName())) { 
continue; 
} 
if (!checkSetMet(methods, fieldSetName)) { 
continue; 
} 
Method fieldSetMet = cls.getMethod(fieldSetName, field.getType()); 
String value = valMap.get(field.getName()); 
if (null != value && !"".equals(value)) { 
String fieldType = field.getType().getSimpleName(); 
setValue(fieldType, fieldSetMet, bean, value); 
} 
} catch (Exception e) { 
continue; 
} 
} 
} 
/** 
* 根据属性给对象赋值 
* 
* @param bean      对象 
* @param fieldName 属性名 
* @param var       值 
*/ 
public static void setFieldValueByFieldName(Object bean, String fieldName, Object var) { 
try { 
boolean falg = null != var && !var.equals(null); 
if (falg) { 
Class<?> cls = bean.getClass(); 
Field field = cls.getDeclaredField(fieldName); 
Method fieldSetMet = cls.getMethod(parSetName(fieldName), field.getType()); 
String fieldType = field.getType().getSimpleName(); 
if (null != fieldType && !"".equals(fieldType)) { 
setValue(fieldType, fieldSetMet, bean, var); 
} else { 
new NullPointerException("Object does not have this property：" + fieldName); 
} 
} 
} catch (Exception e) { 
e.printStackTrace(); 
} 
} 
/** 
* 格式化string为Date 
* 
* @param datestr 
* @return date 
*/ 
public static Date parseDate(String datestr) { 
if (null == datestr || "".equals(datestr)) { 
return null; 
} 
try { 
String fmtstr = null; 
if (datestr.indexOf(':') > 0) { 
fmtstr = "yyyy-MM-dd HH:mm:ss"; 
} else { 
fmtstr = "yyyy-MM-dd"; 
} 
SimpleDateFormat sdf = new SimpleDateFormat(fmtstr, Locale.UK); 
return sdf.parse(datestr); 
} catch (Exception e) { 
return null; 
} 
} 
/** 
* 日期转化为String 
* 
* @param date 
* @return date string 
*/ 
public static String fmtDate(Date date) { 
if (null == date) { 
return null; 
} 
try { 
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.US); 
return sdf.format(date); 
} catch (Exception e) { 
return null; 
} 
} 
/** 
* 判断是否存在某属性的 set方法 
* 
* @param methods 
* @param fieldSetMet 
* @return boolean 
*/ 
public static boolean checkSetMet(Method[] methods, String fieldSetMet) { 
for (Method met : methods) { 
if (fieldSetMet.equals(met.getName())) { 
return true; 
} 
} 
return false; 
} 
/** 
* 判断是否存在某属性的 get方法 
* 
* @param methods 
* @param fieldGetMet 
* @return boolean 
*/ 
public static boolean checkGetMet(Method[] methods, String fieldGetMet) { 
for (Method met : methods) { 
if (fieldGetMet.equals(met.getName())) { 
return true; 
} 
} 
return false; 
} 
/** 
* 拼接某属性的 get方法 
* 
* @param fieldName 
* @return String 
*/ 
public static String parGetName(String fieldName) { 
if (null == fieldName || "".equals(fieldName)) { 
return null; 
} 
return "get" + fieldName.substring(0, 1).toUpperCase() 
+ fieldName.substring(1); 
} 
/** 
* 拼接在某属性的 set方法 
* 
* @param fieldName 
* @return String 
*/ 
public static String parSetName(String fieldName) { 
if (null == fieldName || "".equals(fieldName)) { 
return null; 
} 
return "set" + fieldName.substring(0, 1).toUpperCase() 
+ fieldName.substring(1); 
} 
/** 
* 根据属性字段类型设置属性值 
* 
* @param fieldType 
* @param fieldSetMet 
* @param bean 
* @param var 
*/ 
public static void setValue(String fieldType, Method fieldSetMet, Object bean, Object var) { 
try { 
switch (fieldType) { 
case "String": 
fieldSetMet.invoke(bean, var.toString()); 
break; 
case "Date": 
Date date = parseDate(var.toString()); 
fieldSetMet.invoke(bean, date); 
break; 
case "Integer": 
Integer integerval = Integer.parseInt(var.toString()); 
fieldSetMet.invoke(bean, integerval); 
break; 
case "int": 
Integer intval = Integer.parseInt(var.toString()); 
fieldSetMet.invoke(bean, intval); 
break; 
case "Long": 
Long longval = Long.parseLong(var.toString()); 
fieldSetMet.invoke(bean, longval); 
break; 
case "Double": 
Double doubleval = Double.parseDouble(var.toString()); 
fieldSetMet.invoke(bean, doubleval); 
break; 
case "Boolean": 
Boolean booleanval = Boolean.parseBoolean(var.toString()); 
fieldSetMet.invoke(bean, booleanval); 
break; 
case "BigDecimal": 
BigDecimal decimal = new BigDecimal(var.toString()); 
fieldSetMet.invoke(bean, decimal); 
break; 
case "Float": 
Float flolt = Float.parseFloat(var.toString()); 
fieldSetMet.invoke(bean, flolt); 
break; 
default: 
new NullPointerException("not supper type" + fieldType); 
break; 
} 
} catch (Exception e) { 
e.printStackTrace(); 
} 
} 
}