通过java的反射机制获取一个类的属性和方法

通过java的反射机制获取一个类的属性以及方法，不包含方法体的内容

类中大致包括属性部分，构造方法和其他方法三部分，为了方便测试以及代码的不冗余封装了三个方法分别获取三部分内容，基本都是相同的步骤，拿方法举例，获取修饰符，返回值类型，方法名以及参数列表，重点是字符串的拼接过程，需要不断测试去找到如何拼接出和类中相同的书写形式。

代码如下：

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

public class ReflectDemo {
    public static void main(String[] args) {
        //创建一个Class对象接收要获取的类
        Class class_Demo = null;
        try {
            //这里获取了java.lang包下的String进行测试
            class_Demo = Class.forName("java.lang.String");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        //字符串拼接出类的头部
        //通过修饰符通过getModifiers方法获取，然后Modifier类的静态方法toString转化成字符串
        //getSimpleName方法获取到类名
        System.out.println(Modifier.toString(class_Demo.getModifiers()) + " class " + class_Demo.getSimpleName()+ " {\n");
        //为了方便测试和代码的不冗余，分别把属性，构造方法，其他方法封装起来直接调用
        //返回包含属性的buffer并输出到控制台
        System.out.println(class_Fields(class_Demo));
        //返回包含构造方法的buffer并输出到控制台
        System.out.println(class_Constructors(class_Demo));
        //返回包含其他方法的buffer并输出到控制台
        System.out.println(class_Methods(class_Demo));
        System.out.println("}");

    }
    /**
    返回一个属性部分的StringBuffer字符串
    包括修饰符，数据类型，变量名
     */
    public static StringBuffer class_Fields(Class class_Demo){
        //创建一个字符串buffer拼接并返回字符串
        StringBuffer buffer = new StringBuffer();
        //获取到该类的所有属性
        Field[] fields = class_Demo.getDeclaredFields();
        //for循环拼接输出
        for (Field field:fields) {
            buffer.append("\t");
            //修饰符部分
            buffer.append(Modifier.toString(field.getModifiers()));
            buffer.append(" ");
            //属性类型
            buffer.append(field.getType().getSimpleName());
            buffer.append(" ");
            //属性名
            buffer.append(field.getName());
            buffer.append(";\n");
        }
        return buffer;
    }

    /**
    返回一个构造方法部分的StringBuffer字符串
    包括修饰符，构造方法名也就是类名，参数列表
     */
    public static StringBuffer class_Constructors(Class class_Demo){
        StringBuffer buffer = new StringBuffer();
        //获取该类的所有构造方法
        Constructor[] constructors = class_Demo.getConstructors();
        //for循环拼接输出
        for (Constructor constructor:constructors) {
            buffer.append("\t");
            //修饰符部分
            buffer.append(Modifier.toString(class_Demo.getModifiers()));
            buffer.append(" ");
            //构造方法名，也就是类名
            buffer.append(class_Demo.getSimpleName());
            buffer.append("(");
            //参数列表部分
            Class[] parameterTypes = constructor.getParameterTypes();
            for (Class parameterType:parameterTypes) {
                buffer.append(parameterType.getSimpleName());
                buffer.append(" ");
                buffer.append("参数,");
            }
            //这个判断是如果参数不为0，即有参数的话，最后一个参数部分会多拼接出一个逗号，直接去掉就好了
            if(parameterTypes.length>0){
                buffer.deleteCharAt(buffer.length()-1);
            }
            buffer.append("){}\n");
        }
        return buffer;
    }

    /**
    返回一个其他方法部分的StringBuffer字符串
    包括修饰符，返回值类型，方法名，参数列表
     */
    public static StringBuffer class_Methods(Class class_Demo){
        StringBuffer buffer = new StringBuffer();
        //获取此类的构造方法外所有方法
        Method[] methods = class_Demo.getDeclaredMethods();
        for (Method method:methods) {
            buffer.append("\t");
            //修饰符部分
            buffer.append(Modifier.toString(method.getModifiers()));
            buffer.append(" ");
            //返回值类型
            buffer.append(method.getReturnType().getSimpleName());
            buffer.append(" ");
            //方法名
            buffer.append(method.getName());
            buffer.append("(");
            //参数列表
            Class[] parameterTypes = method.getParameterTypes();
            for (Class parameterType:parameterTypes) {
                buffer.append(parameterType.getSimpleName());
                buffer.append(" ");
                buffer.append("形参");
                buffer.append(" ");
                buffer.append(",");
            }
            if(parameterTypes.length>0){
                buffer.deleteCharAt(buffer.length()-1);
            }
            buffer.append("){}\n");
        }
        return buffer;
    }
}

我这里是测试了java.lang包下的String类库，运行结果如下

为了看的更明显三部分换行符分割了一下，可以明显看出已经成功获取到了String类中的内容

ps：返回值类型和属性的类型如果是引用数据类型的或需要使用getSimpleName方法，不然会把引用数据类型的包名一块拼接到字符串里

总结：反射机制可以让程序变得更加灵活，配合流的使用可以在不修改代码的情况下对程序进行业务的变更，总的来说虽然代码复杂了些，但是灵活性大大提升。