反射工具类——ReflectUtils

蔚落 2022-03-27 04:43 391阅读 0赞

测试方法：根据已知的方法名，来反射调用方法

package com.redmoon.forum.job;
    
    import java.util.ArrayList;
    import java.util.List;
    
    import com.common.utils.ReflectUtils;
    
    public class Test
    {
        private String name;
        public String getName()
        {
            return name;
        }
        public void setName(String name)
        {
            this.name = name;
        }
        public List<String> ff()
        {
            List<String> list = new ArrayList<String>();
            list.add("111");
            list.add("222");
            return list;
        }
        public static void main(String[] args)
        {
            Test test = new Test();
            Object list = ReflectUtils.invokeMethodByName(test, "ff", null);
            List<String> list2 = (List<String>)list;
            System.out.println(list);
            ReflectUtils.setFieldValue(test,"name","panie");
            String name = (String)ReflectUtils.getFieldValue(test,"name");
            System.out.println(name);
        }
    }

结果：

[111, 222]
    panie

反射工具类

package com.common.utils;
    
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.lang.reflect.Modifier;
    import java.lang.reflect.ParameterizedType;
    import java.lang.reflect.Type;
    import java.util.Date;
    
    import org.apache.commons.lang3.StringUtils;
    import org.apache.commons.lang3.Validate;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    /**
     * 反射工具类.
     * 提供调用getter/setter方法, 访问私有变量, 调用私有方法, 获取泛型类型Class, 被AOP过的真实类等工具函数.
     * @author 
     * @version 
     */
    public class ReflectUtils {
        
        private static final String SETTER_PREFIX = "set";
    
        private static final String GETTER_PREFIX = "get";
    
        private static final String CGLIB_CLASS_SEPARATOR = "$$";
        
        private static Logger logger = LoggerFactory.getLogger(ReflectUtils.class);
    
        /**
         * 调用Getter方法.
         * 支持多级，如：对象名.对象名.方法
         */
        public static Object invokeGetter(Object obj, String propertyName) {
            Object object = obj;
            for (String name : StringUtils.split(propertyName, ".")){
                String getterMethodName = GETTER_PREFIX + StringUtils.capitalize(name);
                object = invokeMethod(object, getterMethodName, new Class[] {}, new Object[] {});
            }
            return object;
        }
    
        /**
         * 调用Setter方法, 仅匹配方法名。
         * 支持多级，如：对象名.对象名.方法
         */
        public static void invokeSetter(Object obj, String propertyName, Object value) {
            Object object = obj;
            String[] names = StringUtils.split(propertyName, ".");
            for (int i=0; i<names.length; i++){
                if(i<names.length-1){
                    String getterMethodName = GETTER_PREFIX + StringUtils.capitalize(names[i]);
                    object = invokeMethod(object, getterMethodName, new Class[] {}, new Object[] {});
                }else{
                    String setterMethodName = SETTER_PREFIX + StringUtils.capitalize(names[i]);
                    invokeMethodByName(object, setterMethodName, new Object[] { value });
                }
            }
        }
    
        /**
         * 直接读取对象属性值, 无视private/protected修饰符, 不经过getter函数.
         */
        public static Object getFieldValue(final Object obj, final String fieldName) {
            Field field = getAccessibleField(obj, fieldName);
    
            if (field == null) {
                throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + obj + "]");
            }
    
            Object result = null;
            try {
                result = field.get(obj);
            } catch (IllegalAccessException e) {
                logger.error("不可能抛出的异常{}", e.getMessage());
            }
            return result;
        }
    
        /**
         * 直接设置对象属性值, 无视private/protected修饰符, 不经过setter函数.
         */
        public static void setFieldValue(final Object obj, final String fieldName, final Object value) {
            Field field = getAccessibleField(obj, fieldName);
    
            if (field == null) {
                throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + obj + "]");
            }
    
            try {
                field.set(obj, value);
            } catch (IllegalAccessException e) {
                logger.error("不可能抛出的异常:{}", e.getMessage());
            }
        }
    
        /**
         * 直接调用对象方法, 无视private/protected修饰符.
         * 用于一次性调用的情况，否则应使用getAccessibleMethod()函数获得Method后反复调用.
         * 同时匹配方法名+参数类型，
         */
        public static Object invokeMethod(final Object obj, final String methodName, final Class<?>[] parameterTypes,
                final Object[] args) {
            Method method = getAccessibleMethod(obj, methodName, parameterTypes);
            if (method == null) {
                throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + obj + "]");
            }
    
            try {
                return method.invoke(obj, args);
            } catch (Exception e) {
                throw convertReflectionExceptionToUnchecked(e);
            }
        }
    
        /**
         * 直接调用对象方法, 无视private/protected修饰符，
         * 用于一次性调用的情况，否则应使用getAccessibleMethodByName()函数获得Method后反复调用.
         * 只匹配函数名，如果有多个同名函数调用第一个。
         */
        public static Object invokeMethodByName(final Object obj, final String methodName, final Object[] args) {
            Method method = getAccessibleMethodByName(obj, methodName);
            if (method == null) {
                throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + obj + "]");
            }
    
            try {
                return method.invoke(obj, args);
            } catch (Exception e) {
                throw convertReflectionExceptionToUnchecked(e);
            }
        }
    
        /**
         * 循环向上转型, 获取对象的DeclaredField, 并强制设置为可访问.
         * 
         * 如向上转型到Object仍无法找到, 返回null.
         */
        public static Field getAccessibleField(final Object obj, final String fieldName) {
            Validate.notNull(obj, "object can't be null");
            Validate.notBlank(fieldName, "fieldName can't be blank");
            for (Class<?> superClass = obj.getClass(); superClass != Object.class; superClass = superClass.getSuperclass()) {
                try {
                    Field field = superClass.getDeclaredField(fieldName);
                    makeAccessible(field);
                    return field;
                } catch (NoSuchFieldException e) {//NOSONAR
                    // Field不在当前类定义,继续向上转型
                    continue;// new add
                }
            }
            return null;
        }
    
        /**
         * 循环向上转型, 获取对象的DeclaredMethod,并强制设置为可访问.
         * 如向上转型到Object仍无法找到, 返回null.
         * 匹配函数名+参数类型。
         * 
         * 用于方法需要被多次调用的情况. 先使用本函数先取得Method,然后调用Method.invoke(Object obj, Object... args)
         */
        public static Method getAccessibleMethod(final Object obj, final String methodName,
                final Class<?>... parameterTypes) {
            Validate.notNull(obj, "object can't be null");
            Validate.notBlank(methodName, "methodName can't be blank");
    
            for (Class<?> searchType = obj.getClass(); searchType != Object.class; searchType = searchType.getSuperclass()) {
                try {
                    Method method = searchType.getDeclaredMethod(methodName, parameterTypes);
                    makeAccessible(method);
                    return method;
                } catch (NoSuchMethodException e) {
                    // Method不在当前类定义,继续向上转型
                    continue;// new add
                }
            }
            return null;
        }
    
        /**
         * 循环向上转型, 获取对象的DeclaredMethod,并强制设置为可访问.
         * 如向上转型到Object仍无法找到, 返回null.
         * 只匹配函数名。
         * 
         * 用于方法需要被多次调用的情况. 先使用本函数先取得Method,然后调用Method.invoke(Object obj, Object... args)
         */
        public static Method getAccessibleMethodByName(final Object obj, final String methodName) {
            Validate.notNull(obj, "object can't be null");
            Validate.notBlank(methodName, "methodName can't be blank");
    
            for (Class<?> searchType = obj.getClass(); searchType != Object.class; searchType = searchType.getSuperclass()) {
                Method[] methods = searchType.getDeclaredMethods();
                for (Method method : methods) {
                    if (method.getName().equals(methodName)) {
                        makeAccessible(method);
                        return method;
                    }
                }
            }
            return null;
        }
    
        /**
         * 改变private/protected的方法为public，尽量不调用实际改动的语句，避免JDK的SecurityManager抱怨。
         */
        public static void makeAccessible(Method method) {
            if ((!Modifier.isPublic(method.getModifiers()) || !Modifier.isPublic(method.getDeclaringClass().getModifiers()))
                    && !method.isAccessible()) {
                method.setAccessible(true);
            }
        }
    
        /**
         * 改变private/protected的成员变量为public，尽量不调用实际改动的语句，避免JDK的SecurityManager抱怨。
         */
        public static void makeAccessible(Field field) {
            if ((!Modifier.isPublic(field.getModifiers()) || !Modifier.isPublic(field.getDeclaringClass().getModifiers()) || Modifier
                    .isFinal(field.getModifiers())) && !field.isAccessible()) {
                field.setAccessible(true);
            }
        }
    
        /**
         * 通过反射, 获得Class定义中声明的泛型参数的类型, 注意泛型必须定义在父类处
         * 如无法找到, 返回Object.class.
         * eg.
         * public UserDao extends HibernateDao<User>
         *
         * @param clazz The class to introspect
         * @return the first generic declaration, or Object.class if cannot be determined
         */
        @SuppressWarnings("unchecked")
        public static <T> Class<T> getClassGenricType(final Class clazz) {
            return getClassGenricType(clazz, 0);
        }
    
        /**
         * 通过反射, 获得Class定义中声明的父类的泛型参数的类型.
         * 如无法找到, 返回Object.class.
         * 
         * 如public UserDao extends HibernateDao<User,Long>
         *
         * @param clazz clazz The class to introspect
         * @param index the Index of the generic ddeclaration,start from 0.
         * @return the index generic declaration, or Object.class if cannot be determined
         */
        public static Class getClassGenricType(final Class clazz, final int index) {
    
            Type genType = clazz.getGenericSuperclass();
    
            if (!(genType instanceof ParameterizedType)) {
                logger.warn(clazz.getSimpleName() + "'s superclass not ParameterizedType");
                return Object.class;
            }
    
            Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
    
            if (index >= params.length || index < 0) {
                logger.warn("Index: " + index + ", Size of " + clazz.getSimpleName() + "'s Parameterized Type: "
                        + params.length);
                return Object.class;
            }
            if (!(params[index] instanceof Class)) {
                logger.warn(clazz.getSimpleName() + " not set the actual class on superclass generic parameter");
                return Object.class;
            }
    
            return (Class) params[index];
        }
        
        public static Class<?> getUserClass(Object instance) {
            Validate.notNull(instance, "Instance must not be null");
            Class clazz = instance.getClass();
            if (clazz != null && clazz.getName().contains(CGLIB_CLASS_SEPARATOR)) {
                Class<?> superClass = clazz.getSuperclass();
                if (superClass != null && !Object.class.equals(superClass)) {
                    return superClass;
                }
            }
            return clazz;
    
        }
        
        /**
         * 将反射时的checked exception转换为unchecked exception.
         */
        public static RuntimeException convertReflectionExceptionToUnchecked(Exception e) {
            if (e instanceof IllegalAccessException || e instanceof IllegalArgumentException
                    || e instanceof NoSuchMethodException) {
                return new IllegalArgumentException(e);
            } else if (e instanceof InvocationTargetException) {
                return new RuntimeException(((InvocationTargetException) e).getTargetException());
            } else if (e instanceof RuntimeException) {
                return (RuntimeException) e;
            }
            return new RuntimeException("Unexpected Checked Exception.", e);
        }
        
        /**
         * 判断属性是否为日期类型
         * 
         * @param clazz
         *            数据类型
         * @param fieldName
         *            属性名
         * @return 如果为日期类型返回true，否则返回false
         */
        public static <T> boolean isDateType(Class<T> clazz, String fieldName) {
            boolean flag = false;
            try {
                Field field = clazz.getDeclaredField(fieldName);
                Object typeObj = field.getType().newInstance();
                flag = typeObj instanceof Date;
            } catch (Exception e) {
                // 把异常吞掉直接返回false
            }
            return flag;
        }
     
        /**
         * 根据类型将指定参数转换成对应的类型
         * 
         * @param value
         *            指定参数
         * @param type
         *            指定类型
         * @return 返回类型转换后的对象
         */
        public static <T> Object parseValueWithType(String value, Class<?> type) {
            Object result = null;
            try { // 根据属性的类型将内容转换成对应的类型
                if (Boolean.TYPE == type) {
                    result = Boolean.parseBoolean(value);
                } else if (Byte.TYPE == type) {
                    result = Byte.parseByte(value);
                } else if (Short.TYPE == type) {
                    result = Short.parseShort(value);
                } else if (Integer.TYPE == type) {
                    result = Integer.parseInt(value);
                } else if (Long.TYPE == type) {
                    result = Long.parseLong(value);
                } else if (Float.TYPE == type) {
                    result = Float.parseFloat(value);
                } else if (Double.TYPE == type) {
                    result = Double.parseDouble(value);
                } else {
                    result = (Object) value;
                }
            } catch (Exception e) {
                // 把异常吞掉直接返回null
            }
            return result;
        }
    }