Java反射技术工具类

一、概述

　　在上一节详细介绍了Java的反射技术。例如：如何根据字符串获取一个Class对象，如何操作Method、Constructor、Filed等等。这一节针对上一节的内容做一个工具类的封装，让反射技术用起来更方便。

二、工具里：工具类中包含了所有必须的项，非常简单也非常的实用。

package com.yw.reflectlib;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * Java反射工具类
 * create by yangwei
 * on 2020-02-07 17:28
 */
public class ReflectUtil {
    private ReflectUtil() {
    }

    private static ReflectUtil instance;

    public static ReflectUtil getInstance() {
        synchronized (ReflectUtil.class) {
            if (instance == null) {
                instance = new ReflectUtil();
            }
        }
        return instance;
    }

    /**
     * 创建一个无参的构造函数
     *
     * @param className 类全名
     * @return
     */
    public Object createObject(String className) {
        Class[] classes = new Class[]{};
        Object[] objects = new Object[]{};
        return createObject(className, classes, objects);
    }

    /**
     * 创建一个无惨的构造函数
     *
     * @param clazz 类对象
     * @return
     */
    public Object createObject(Class clazz) {
        Class[] classes = new Class[]{};
        Object[] objects = new Object[]{};
        return createObject(clazz, classes, objects);
    }

    /**
     * 创建构造函数只有一个参数的对象
     *
     * @param className
     * @param paramType
     * @param paramValue
     * @return
     */
    public Object createObject(String className, Class paramType, Object paramValue) {
        Class[] classes = new Class[]{paramType};
        Object[] objects = new Object[]{paramValue};
        return createObject(className, classes, objects);
    }

    /**
     * 创建构造函数只有一个参数的对象
     *
     * @param clazz
     * @param paramType
     * @param paramValue
     * @return
     */
    public Object createObject(Class clazz, Class paramType, Object paramValue) {
        Class[] classes = new Class[]{paramType};
        Object[] objects = new Object[]{paramValue};
        return createObject(clazz, classes, objects);
    }

    /**
     * 创建一个多参数的对象
     *
     * @param className    类全名
     * @param paramsTypes  构造函数参数
     * @param paramsValues 默认构造函数要传的值
     * @return
     */
    public Object createObject(String className, Class[] paramsTypes, Object[] paramsValues) {
        try {
            Class clazz = Class.forName(className);
            Constructor constructor = clazz.getDeclaredConstructor(paramsTypes);
            constructor.setAccessible(true);
            return constructor.newInstance(paramsValues);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 创建一个多参数的的对象
     *
     * @param clazz        类对象
     * @param paramsTypes  构造函数参数集合
     * @param paramsValues 构造函数参数值
     * @return
     */
    public Object createObject(Class clazz, Class[] paramsTypes, Object[] paramsValues) {
        try {
            Constructor constructor = clazz.getDeclaredConstructor(paramsTypes);
            constructor.setAccessible(true);
            Object object = constructor.newInstance(paramsValues);
            return object;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /*以下是执行方法****/

    /**
     * 执行类的方法
     *
     * @param obj          方法所在的类对象
     * @param methodName   方法名称
     * @param paramsTypes  方法参数
     * @param paramsValues 方法参数值
     * @return
     */
    public Object invokeMethod(Object obj, String methodName, Class[] paramsTypes, Object[] paramsValues) {
        if (obj == null)
            return null;
        try {
            Method method = obj.getClass().getDeclaredMethod(methodName, paramsTypes);
            method.setAccessible(true);
            method.invoke(obj, paramsValues);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }

    /**
     * 执行只有一个参数的方法
     *
     * @param obj
     * @param methodName
     * @param paramType
     * @param paramValue
     * @return
     */
    public Object invokeMethod(Object obj, String methodName, Class paramType, Object paramValue) {
        Class[] classes = new Class[]{paramType};
        Object[] objects = new Object[]{paramValue};
        return invokeMethod(obj, methodName, classes, objects);
    }

    /**
     * 执行一个无惨的方法
     *
     * @param obj
     * @param methodName
     * @return
     */
    public Object invokeMethod(Object obj, String methodName) {
        Class[] classes = new Class[]{};
        Object[] objects = new Object[]{};
        return invokeMethod(obj, methodName, classes, objects);
    }


    /**
     * 执行一个多参数的静态方法
     *
     * @param className    类全名
     * @param methodName   方法名
     * @param paramsTypes  方法参数
     * @param paramsValues 方法参数值
     * @return
     */
    public Object invokeStaticMethod(String className, String methodName, Class[] paramsTypes, Object[] paramsValues) {
        try {
            Class clazz = Class.forName(className);
            Method method = clazz.getDeclaredMethod(methodName, paramsTypes);
            method.setAccessible(true);
            return method.invoke(null, paramsValues);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 执行一个无惨的静态方法
     *
     * @param className
     * @param methodName
     * @return
     */
    public Object invokeStaticMethod(String className, String methodName) {
        Class[] classes = new Class[]{};
        Object[] objects = new Object[]{};
        return invokeStaticMethod(className, methodName, classes, objects);
    }

    /**
     * 执行一个参数的静态方法
     *
     * @param className
     * @param methodName
     * @param paramType
     * @param paramValue
     * @return
     */
    public Object invokeStaticMethod(String className, String methodName, Class paramType, Object paramValue) {
        Class[] classes = new Class[]{paramType};
        Object[] objects = new Object[]{paramValue};
        return invokeStaticMethod(className, methodName, classes, objects);
    }

    /**
     * 执行一个多参数的静态方法
     *
     * @param methodName   方法名
     * @param paramsTypes  方法参数
     * @param paramsValues 方法参数值
     * @return
     */
    public Object invokeStaticMethod(Class clazz, String methodName, Class[] paramsTypes, Object[] paramsValues) {
        try {
            Method method = clazz.getDeclaredMethod(methodName, paramsTypes);
            method.setAccessible(true);
            return method.invoke(null, paramsValues);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 执行一个无惨的静态方法
     *
     * @param methodName
     * @return
     */
    public Object invokeStaticMethod(Class clazz, String methodName) {
        Class[] classes = new Class[]{};
        Object[] objects = new Object[]{};
        return invokeStaticMethod(clazz, methodName, classes, objects);
    }

    /**
     * 执行一个参数的静态方法
     *
     * @param methodName
     * @param paramType
     * @param paramValue
     * @return
     */
    public Object invokeStaticMethod(Class clazz, String methodName, Class paramType, Object paramValue) {
        Class[] classes = new Class[]{paramType};
        Object[] objects = new Object[]{paramValue};
        return invokeStaticMethod(clazz, methodName, classes, objects);
    }

    /**
     * 获取Field的值
     *
     * @param clazz     类的class
     * @param obj       类的实例对象
     * @param fieldName 属性名称
     * @return
     */
    public Object getField(Class clazz, Object obj, String fieldName) {
        try {
            Field field = clazz.getDeclaredField(fieldName);
            field.setAccessible(true);
            return field.get(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;

    }

    /**
     * 获取属性值
     *
     * @param obj
     * @param fieldName
     * @return
     */
    public Object getField(Object obj, String fieldName) {
        return getField(obj.getClass(), fieldName);
    }

    public Object getField(String className, Object obj, String fieldName) {
        try {
            Class clazz = Class.forName(className);
            return getField(clazz, obj, fieldName);
        } catch (Exception e) {
            e.printStackTrace();

        }
        return null;
    }

    /**
     * 设置属性的值
     *
     * @param clazz      类对象
     * @param obj        类实例对象
     * @param fieldName  属性名称
     * @param fieldValue 属性值
     * @return
     */
    public void setField(Class clazz, Object obj, String fieldName, Object fieldValue) {
        try {
            Field field = clazz.getDeclaredField(fieldName);
            field.setAccessible(true);
            field.set(obj, fieldValue);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void setField(String className, Object obj, String fieldName, Object fieldValue) {
        try {
            Class clazz = Class.forName(className);
            Field field = clazz.getDeclaredField(fieldName);
            field.setAccessible(true);
            field.set(obj, fieldValue);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void setField(Object obj, String fieldName, Object fieldValue) {
        setField(obj.getClass(), fieldName, fieldValue);
    }

    /**
     * 获取静态属性
     *
     * @param className
     * @param filedName
     * @return
     */
    public Object getStaticField(String className, String filedName) {
        return getField(className, null, filedName);
    }

    /**
     * 设置静态属性
     *
     * @param clazz
     * @param filedName
     * @return
     */
    public Object getStaticField(Class clazz, String filedName) {
        return getField(clazz, null, filedName);
    }

    /**
     * 设置静态属性
     *
     * @param classname
     * @param filedName
     * @param filedVaule
     */
    public void setStaticField(String classname, String filedName, Object filedVaule) {
        setField(classname, null, filedName, filedVaule);
    }

    /**
     * 获取静态属性
     *
     * @param clazz
     * @param filedName
     * @param filedVaule
     */
    public void setStaticField(Class clazz, String filedName, Object filedVaule) {
        setField(clazz, null, filedName, filedVaule);
    }

}

　总结：大家看过工具类后会发现，反射经过封装后操作起来还是很简单的，只需要调用单例类，然后写入指定的参数就能得到想要的内容。

　下一节将介绍如何对泛型进行反射，敬请期待。