JAVA自定义反射工具类

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


public class SmartObject {

    /************************获取类信息***********************************************/
    /**
     * @dercription 获取类名（包括包名）
     * @return String
     * */
    public static String getClassName(Class<?> object) {
        return object.getName();
    }

    /**
     * @dercription 获取类名（不包括包名）
     * @return String
     * */
    public static String getClassSimpleName(Class<?> object) {
        return object.getSimpleName();
    }

    /************************获取字段类信息***********************************************/
    /**
     * @dercription 获取一个类的成员属性名称列表
     * @return List<String>
     * */
    public static List<String> getClassFieldList(Class<?> object,Boolean ignoreSerialVersionUID) {

        //设置忽略序列化Id默认值
        if(null==ignoreSerialVersionUID){
            ignoreSerialVersionUID=true;
        }
        //推断类型
        List<String> objectFiledList = new ArrayList<>();

        //获取类信息
        Class<?> classInfo;
        try {
            //加载类信息
            classInfo = Class.forName(object.getName());
            //使用反射获取该类的成员属性
            Field[] fieldList = classInfo.getDeclaredFields();

            for (int i = 0; i < fieldList.length; i++) {
                //忽略获取序列化ID
                if(ignoreSerialVersionUID){
                    //如果字段是序列化字段，则忽略
                    if (!fieldList[i].getName().equals("serialVersionUID")) {
                        objectFiledList.add(fieldList[i].getName());
                    }
                }else{
                    //序列化ID不忽略作为类的属性返回到结果中
                    objectFiledList.add(fieldList[i].getName());
                }
            }
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return objectFiledList;
    }
    /**
     * @dercription 获取一个类的成员属性类型列表
     * @return List<String>
     * */
    public static List<String> getClassFieldTypeList(Class<?> object,Boolean ignoreSerialVersionUID) {

        //设置忽略序列化Id默认值
        if(null==ignoreSerialVersionUID){
            ignoreSerialVersionUID=true;
        }
        //推断类型
        List<String> objectFiledList = new ArrayList<>();

        //获取类信息
        Class<?> classInfo;
        try {
            //加载类信息
            classInfo = Class.forName(object.getName());
            //使用反射获取该类的成员属性
            Field[] fieldList = classInfo.getDeclaredFields();

            for (int i = 0; i < fieldList.length; i++) {
                //忽略获取序列化ID
                if(ignoreSerialVersionUID){
                    //如果字段是序列化字段，则忽略
                    if (!fieldList[i].getName().equals("serialVersionUID")) {
                        objectFiledList.add(fieldList[i].getType().getName());
                    }
                }else{
                    //序列化ID不忽略作为类的属性返回到结果中
                    objectFiledList.add(fieldList[i].getType().getName());
                }
            }
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return objectFiledList;
    }

    public static List<String> getClassSimpleFieldTypeList(Class<?> object,Boolean ignoreSerialVersionUID) {

        //设置忽略序列化Id默认值
        if(null==ignoreSerialVersionUID){
            ignoreSerialVersionUID=true;
        }
        //推断类型
        List<String> objectFiledList = new ArrayList<>();

        //获取类信息
        Class<?> classInfo;
        try {
            //加载类信息
            classInfo = Class.forName(object.getName());
            //使用反射获取该类的成员属性
            Field[] fieldList = classInfo.getDeclaredFields();

            for (int i = 0; i < fieldList.length; i++) {
                //忽略获取序列化ID
                if(ignoreSerialVersionUID){
                    //如果字段是序列化字段，则忽略
                    if (!fieldList[i].getName().equals("serialVersionUID")) {
                        objectFiledList.add(fieldList[i].getType().getSimpleName());
                    }
                }else{
                    //序列化ID不忽略作为类的属性返回到结果中
                    objectFiledList.add(fieldList[i].getType().getSimpleName());
                }
            }
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return objectFiledList;
    }
    /**
     * 获取一个类的成员属性的名称和类型Map集合(包括包名)
     * @return Map<String,String>
     * **/
    public static Map<String,String> getClassFieldMap(Class<?> object,Boolean ignoreSerialVersionUID) {

        //设置忽略序列化Id默认值
        if(null==ignoreSerialVersionUID){
            ignoreSerialVersionUID=true;
        }
        //推断类型
        Map<String,String> classFiledMap = new HashMap<>();

        //获取类信息
        Class<?> classInfo;
        try {
            //加载类信息
            classInfo = Class.forName(object.getName());
            //使用反射获取该类的成员属性
            Field[] fieldList = classInfo.getDeclaredFields();

            for (int i = 0; i < fieldList.length; i++) {
                //忽略获取序列化ID
                if(ignoreSerialVersionUID){
                    //如果字段是序列化字段，则忽略
                    if (!fieldList[i].getName().equals("serialVersionUID")) {
                        classFiledMap.put(fieldList[i].getName(),fieldList[i].getType().getName());
                    }
                }else{
                    //序列化ID不忽略作为类的属性返回到结果中
                    classFiledMap.put(fieldList[i].getName(),fieldList[i].getType().getName());
                }
            }
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return classFiledMap;
    }
    /**
     * 获取类中所有成员属性的名称和类型Map集合(不包括包名)
     * @return Map<String,String>
     * **/
    public static Map<String,String> getClassSimpleFieldMap(Class<?> object,Boolean ignoreSerialVersionUID) {

        //设置忽略序列化Id默认值
        if(null==ignoreSerialVersionUID){
            ignoreSerialVersionUID=true;
        }
        //推断类型
        Map<String,String> classFiledMap = new HashMap<>();

        //获取类信息
        Class<?> classInfo;
        try {
            //加载类信息
            classInfo = Class.forName(object.getName());
            //使用反射获取该类的成员属性
            Field[] fieldList = classInfo.getDeclaredFields();

            for (int i = 0; i < fieldList.length; i++) {
                //忽略获取序列化ID
                if(ignoreSerialVersionUID){
                    //如果字段是序列化字段，则忽略
                    if (!fieldList[i].getName().equals("serialVersionUID")) {
                        classFiledMap.put(fieldList[i].getName(),fieldList[i].getType().getSimpleName());
                    }
                }else{
                    //序列化ID不忽略作为类的属性返回到结果中
                    classFiledMap.put(fieldList[i].getName(),fieldList[i].getType().getSimpleName());
                }
            }
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return classFiledMap;
    }


    /************************获取方法类信息***********************************************/
    /**
     * 获取类中所有方法的名称列表
     * @return List<String>
     * **/
    public static List<String> getClassMethodNameList(Class<?> object) {

        List<String> classMethodNameList = new ArrayList<String>();

        Class<?> classInfo;
        try {
            //获取类信息
            classInfo = Class.forName(object.getName());
            //根据反射获取类的方法
            Method[] methodList = classInfo.getDeclaredMethods();
            for (int i = 0; i < methodList.length; i++) {
                classMethodNameList.add(methodList[i].getName());
            }
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return classMethodNameList;
    }
    /**
     * @description 获取类中所有方法返回类型列表（包括包名）
     * @return List<String>
     * **/
    public static List<String> getClassMethodReturnTypeList(Class<?> object) {

        List<String> classMethodReturnTypeList = new ArrayList<String>();

        Class<?> classInfo;
        try {
            classInfo = Class.forName(object.getName());
            Method[] methodList = classInfo.getDeclaredMethods();
            for (int i = 0; i < methodList.length; i++) {
                classMethodReturnTypeList.add(methodList[i].getReturnType().getName());
            }
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return classMethodReturnTypeList;
    }
    /**
     * @description 获取类中所有方法返回类型列表（不包括包名）
     * @return List<String>
     * **/
    public static List<String> getClassMethodSimpleReturnTypeList(Class<?> object) {

        List<String> classMethodReturnTypeList = new ArrayList<String>();

        Class<?> classInfo;
        try {
            classInfo = Class.forName(object.getName());
            Method[] methodList = classInfo.getDeclaredMethods();
            for (int i = 0; i < methodList.length; i++) {
                classMethodReturnTypeList.add(methodList[i].getReturnType().getSimpleName());
            }
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return classMethodReturnTypeList;
    }

    /**
     * @description 获取类中所有方法名称和方法返回类型(包括包名)
     * @return Map<String,String>
     * **/
    public static Map<String,String> getClassMethodInfoMap(Class<?> object) {

        Map<String,String> classMethodInfoMap = new HashMap<>();
        Class<?> classInfo;
        try {
            classInfo = Class.forName(object.getName());
            Method[] methodList = classInfo.getDeclaredMethods();
            for (int i = 0; i < methodList.length; i++) {
                classMethodInfoMap.put(methodList[i].getName(),methodList[i].getReturnType().getName());
            }
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return classMethodInfoMap;
    }

    /**
     * @description 获取类中所有方法名称和方法返回类型(不包括包名)
     * @return Map<String,String>
     * **/
    public static Map<String,String> getClassSimpleMethodInfoMap(Class<?> object) {

        Map<String,String> classMethodInfoMap = new HashMap<>();
        Class<?> classInfo;
        try {
            classInfo = Class.forName(object.getName());
            Method[] methodList = classInfo.getDeclaredMethods();
            for (int i = 0; i < methodList.length; i++) {
                classMethodInfoMap.put(methodList[i].getName(),methodList[i].getReturnType().getSimpleName());
            }
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return classMethodInfoMap;
    }
}