使用java反射机制读取任意类内部细节

首先我们模拟一个学生类来做一个实验，接下来部分是源码：

package com.sise.lh.reflect.domain;

/**
 * @author：idea
 * @date：2018/1/4
 * @version： 1.0
 */
public class Student{
    public int age;

    public Student(){}

    public Student(String name,int age){
        this.age=age;
    }

    public String test01(){
        return "null";
    }
    public String test02(){
        return "null";
    }
    public String test03(){
        return "null";
    }
    public String test04(){
        return "null";
    }

}
然后便是通过java的一系列反射来读取这个类的信息：
闲话不多说，直接上源码：
package com.sise.lh.reflect;

import java.lang.reflect.*;
import java.lang.reflect.Field;
import java.util.Date;
/**
 * @author：idea
 * @date：2018/1/4
 * @version： 1.0
 */
public class FieldTest {

    //打印出一个类里面的所有属性和属性修饰符，以及构造函数和构造函数的修饰符及参数，还有所有方法的修饰符和所有方法的名称及参数
    public static void getField(Class c){
        getParameter(c);
        getConstruction(c);
        getDeclaredFields(c);
    }

    //获取构造函数的所有内容
    public static void getConstruction(Class c){
        Constructor[] constructors=c.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            System.out.print(Modifier.toString(constructor.getModifiers())+" ");//后去构造函数的修饰符
            System.out.print(constructor.getName()+"(");  //获取构造函数的名称
            Class[] p=constructor.getParameterTypes();
            for(int k=0;k<p.length;k++){
                System.out.print(p[k].getName()+" ");
            }
            System.out.println(" );");
        }
    }

    //获取相应类的所有属性
    public static void getParameter(Class c){
        Field field[]=c.getDeclaredFields();
        for (Field field1 : field) {
            System.out.print(Modifier.toString(field1.getModifiers())+ " "); //修饰符
            System.out.print(field1.getType()+" "+field1.getName()); //属性类型和属性名称
        }
        System.out.println("");
    }

    //获取相应类里面的所有申明的方法
    public static void getDeclaredFields(Class c){
        Method field[]=c.getDeclaredMethods();
        for (Method method : field) {
            System.out.print(Modifier.toString(method.getModifiers())+" "); //获取函数的修饰符权限
            System.out.print(method.getReturnType()+" "+method.getName()+"("); //获取函数的名称
            Class type[]= method.getParameterTypes();
            for (Class aClass : type) {
                System.out.print(aClass.getName()+" ");
            }
            System.out.println(");");
        }

    }





    public static void main(String[] args) throws ClassNotFoundException {
        System.out.println("获取类里面的所有信息");
        String name="com.sise.lh.reflect.domain.Student";
        Class c1=Class.forName(name);
        System.out.println("class "+name+"\n{");
        getField(c1);
        System.out.println("}");
    }
}
最后检测获取内容：
	获取类里面的所有信息
class com.sise.lh.reflect.domain.Student
{
public int age
public com.sise.lh.reflect.domain.Student( );
public com.sise.lh.reflect.domain.Student(java.lang.String int  );
public class java.lang.String test02();
public class java.lang.String test01();
public class java.lang.String test03();
public class java.lang.String test04();
}

虽然java的反射机制在web应用中出现的影子并不是很多，但是在商业的java组件里面的开发过程中，反射机制是众多流行框架实行的基础，其中就包括了spring，hibernate等