import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.*;
/**
* 通过反射获取某个对象下的属性值，或通过父类获取
* User: wangyongfei
* Date: 2016/8/10
* Time: 9:56
*/
public class TestObjectRef {
private static final Logger LOGGER = LoggerFactory.getLogger(TestObjectRef.class);
/**
* 对象相同
* 对象属性name相同
* @param list
*/
public static Object object2Fields(List<Object>list,Object targetObject, String filteFieldName){
for(Object sourceObject: list){
Object rtnVal = getObjectProprityValue(sourceObject, targetObject, filteFieldName);
if(rtnVal == null){
continue;
}
return rtnVal;
}
return null;
}
/**
* 如果当前类查找不到，则从父类属性中查找
* @param object 当前类
* @param filteFieldName 查找字段
* @return
*/
public static Object getSupperClassPropertity(Object object,String filteFieldName){
Class<?>clazz = object.getClass();
if(clazz != null && clazz.getGenericSuperclass()!=null){
Class claSupper = clazz.getSuperclass();
return getProperty(claSupper, object,filteFieldName);
}
return null;
}
/**
* 过滤父类中字段
* @param _class
* @param bean
* @param filteFieldName
* @return
*/
private static Object getProperty(Class _class, Object bean, String filteFieldName) {
Object obj = null;
Field[] fields = _class.getDeclaredFields();
//private调整为public
Field.setAccessible(fields, true);
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
if (filteFieldName.equals(field.getName())) {
try {
obj = field.get(bean);
} catch (IllegalArgumentException e) {
LOGGER.error(e.getMessage());
} catch (IllegalAccessException e) {
LOGGER.error(e.getMessage());
}
break;
}
}
if (obj == null && _class.getGenericSuperclass() != null) {
obj = getProperty(_class.getSuperclass(), bean, filteFieldName);
}
return obj;
}
/**
* 获取过滤对象对应属性值
* // TODO: 2016/8/10 集合类型处理 list, map等 --待完善，目前已满足需求
* @param sourceObject 数据源对象
* @param targetObject 过滤目标对象
* @param filteFieldName 过滤目标对象对应熟悉字段
* @return
*/
private static Object getObjectProprityValue(Object sourceObject, Object targetObject, String filteFieldName) {
if(sourceObject == null || sourceObject.getClass() == null || filteFieldName == null || "".equalsIgnoreCase(filteFieldName)){
return null;
}
Boolean flag = sameObjectInstance(sourceObject, targetObject);
Field[] fields = sourceObject.getClass().getDeclaredFields();
for(Field field: fields){
String str = field.getName();
Method m = null;
try {
m = sourceObject.getClass().getMethod("get" + str.substring(0, 1).toUpperCase()+""+str.substring(1, str.length()));
try {
Object object = m.invoke(sourceObject);
if (!flag && validProperityType(field.getType().getName())) {//不是同一对象且类型为class,则继续迭代
Object rtnVal = getObjectProprityValue(object, targetObject, filteFieldName);
if(rtnVal == null){
continue;
}
return rtnVal;
} else {
if(flag){
if(filteFieldName.equalsIgnoreCase(field.getName())){
return object;
}
}
continue;
}
} catch (IllegalAccessException e) {
LOGGER.info("对象转换处理异常, e:{}", e.getMessage());
} catch (InvocationTargetException e) {
LOGGER.info("对象转换处理异常, e:{}", e.getMessage());
}
} catch (NoSuchMethodException e) {
LOGGER.info("没有找到对应方法, e:{}", e.getMessage());
}
}
//如果没找到，则从父类中查找
if(flag){
return getSupperClassPropertity(sourceObject,filteFieldName);
}
return null;
}
/**
* 校验两个对象是否属于同一对象实例
* @param sourceObject
* @param targetObject
* @return
*/
public static Boolean sameObjectInstance(Object sourceObject, Object targetObject){
if(sourceObject == null || targetObject == null) return Boolean.FALSE;
if(sourceObject.getClass().getName().equals(((Class) targetObject).getName())){
return Boolean.TRUE;
}
return Boolean.FALSE;
}
/**
* 类型校验方法
* 1.以后如果出现特殊类型，在此方法中追加过滤即可
* 2.目前只区分类与普通属性
* 3.如果有特殊逻辑，可根据具体需要扩展此方法
* @param type 类型值
* @return
*/
public static Boolean validProperityType(String type){
if (type.equals("java.lang.String")) {
return Boolean.FALSE;
}
if (type.equals("java.lang.Integer") || type.equals("int")) {
return Boolean.FALSE;
}
if (type.equals("java.lang.Short")) {
return Boolean.FALSE;
}
if (type.equals("java.lang.Double") || type.equals("double")) {
return Boolean.FALSE;
}
if (type.equals("java.lang.Boolean") || type.equals("boolean")) {
return Boolean.FALSE;
}
if (type.equals("java.util.Date")) {
return Boolean.FALSE;
}
if (type.equals("java.util.List")) {
return Boolean.FALSE;
}
if (type.equals("java.lang.Long") || type.equals("long")) {
return Boolean.FALSE;
}
return Boolean.TRUE;
}
public static Map<String, String> templateFormat(
Map<String, List<String>> hashMap,
Object... object) {
if(hashMap == null || hashMap.size() <=0 ){
return null;
}
List<Object>list = new ArrayList<>();
Collections.addAll(list, object);
Map<String, String> map = new HashMap<>();
for(String key: hashMap.keySet()){
try {
Class<?> classType = Class.forName(key);
for(String str: hashMap.get(key)) {
System.out.println(str+":" + object2Fields(list, classType, str));
}
} catch (ClassNotFoundException e) {
LOGGER.warn("[模板格式转换]类查询异常，error：{}", e.getMessage());
}
}
return null;
}
}
