java反射机制

在java的很多技术框架中，我们时常能看到函数的反射，回调等等。一开始感觉很高大上的东西，有木有？但是慢慢了解了之后，也就明白了其实就是一种很简单的方式，同时也是java设计中必不可少的机制。

一、反射机制及其作用

反射可以帮助我们在类动态运行的时候，对于任意一个类，可以获得其所有的方法（public private protected等），所有的变量（同上），然后对其进行操作。了解了反射机制的定义，我们其实可以很容易看出它的作用，获取某些类的一些私有变量。

二、代码实现

设定一个pojo类，里面含有一些私有成员变量，如下：

public class User {
    private String name;
    private String sex;


    public User() {
    }

    public String getName() {

        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("{");
        sb.append("\"name\":\"")
                .append(name).append('\"');
        sb.append(",\"sex\":\"")
                .append(sex).append('\"');
        sb.append('}');
        return sb.toString();
    }
}

java反射工具包（java.lang.reflect），利用反射来获取类的信息

public class Main {
    public static void main(String[] args) throws Exception {

        example5();
    }

    /**
     * 通过java反射机制得到类的信息
     */
    public static void example1() {
        User user = new User();
        System.out.println("例1：包名：" + user.getClass().getPackage().getName() + ","
                + "类名：" + user.getClass().getName());
    }

    /**
     * 验证所有类都是Class类的实例对象
     * @throws ClassNotFoundException
     */
    public static void example2() throws ClassNotFoundException {
        Class<?> class1 = null;
        Class<?> class2 = null;
        //动态加载类,这一步已经执行了该类中的静态代码段
        class1 = Class.forName("com.hust.reflect.User");
        System.out.println("例2.1：包名：" + class1.getClass().getPackage().getName() + ","
                + "类名：" + class1.getClass().getName());
        class2 = User.class;
        System.out.println("例2.2：包名：" + class2.getClass().getPackage().getName() + ","
                + "类名：" + class2.getClass().getName());
    }

    /**
     *通过java反射机制用Class创建类对象
     * @throws Exception
     */
    public static void example3() throws Exception{
        Class<?> class1 = null;
        class1 = Class.forName("com.hust.reflect.User");//动态加载类
        User user = (User) class1.newInstance(); //这两句相当于User user = new User();
        user.setName("钢铁侠");
        user.setSex("未知");
        System.out.println("例3："+user.getName()+"-"+user.getSex());
    }

    /**
     * 通过java反射机制得到一个类的构造函数，并实例化对象
     * @throws Exception
     */
    public static  void example4() throws Exception{
        Class<?> class1 = null;
        User user1 = null;
        User user2 = null;
        class1 = Class.forName("com.hust.reflect.User");//动态加载类
        //得到一系列构造函数集合
        Constructor<?>[] constructors = class1.getConstructors();
        user1 = (User) constructors[0].newInstance();
        user2 = (User) constructors[1].newInstance();
        user1.setName("black widow");
        user2.setName("doctor strange");
        System.out.println("例4："+user1.getName()+"-"+user2.getName());

    }

    /**
     * 通过反射操作成员变量
     * @throws Exception
     */
    public static  void example5() throws Exception {
        Class<?> class1 = null;
        class1 = Class.forName("com.hust.reflect.User");//动态加载类
        Object obj = class1.newInstance();
        Field userNameField = class1.getDeclaredField("name");
        userNameField.setAccessible(true);
        userNameField.set(obj,"groot");
        System.out.println("例5：获取成员变量并进行设置"+userNameField.get(obj));
    }

    /**
     * 通过反射得到类的一些属性：成员信息、函数信息；当然还可已获得父类、继承的接口等等
     * @throws Exception
     */
    public static void example6() throws Exception{
        Class<?> class1 = null;
        class1 = Class.forName("com.hust.reflect.User");//动态加载类
        Field[] fields = class1.getDeclaredFields();
        for (int i = 0; i <fields.length ; i++) {
            System.out.println("成员变量："+fields[i]);
        }
        Method[] methods = class1.getDeclaredMethods();
        for (int i = 0; i < methods.length ; i++) {
            System.out.println("取得User类的方法："+"\n"
                                +"函数名："+methods[i].getName()+"\n"
                                +"函数返回的类型："+methods[i]+"\n"
                                +"函数代码写法："+methods[i]);
        }

    }

    /**
     * 通过反射机制调用类方法
     * @throws Exception
     */
    public static void example7() throws Exception{
        Class<?> class1 = null;
        class1 = Class.forName("com.hust.reflect.User");//动态加载类

        System.out.println("调用无参方法toString()");
        Method method = class1.getMethod("toString");
        method.invoke(class1.newInstance());

    }

    /**
     * 通过反射机制得到类加载信息
     * @throws Exception
     */
    public static void example8() throws Exception{
        Class<?> class1 = null;
        class1 = Class.forName("com.hust.reflect.zcl");//动态加载类
        String loaderName = class1.getClassLoader().getClass().getName();
        System.out.println("例8：类加载类名："+loaderName);
    }
}

关于上述代码中Class.forName()的具体机制与用法，可以查看这篇博文