Java反射实战

一、背景

　　最近的项目中需要使用到Java 反射的知识，以前不怎么了解，也基本没怎么用过，抽出一片时间，来具体学习和实战下Java的反射！拿来和大家分享以及记录方便以后学习！

二、反射相关概念解析

1.Class类

　　Class类：Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是Class。

　　如何得到各个类的字节码即Class类呢？

　　　　[1].类名.class:直接通过类.class获得。

　　　　[2].对象.getClass()：通过对象调用其getClass方法获得。　　

　　　　[3].Class.forName("类全路径"):通过类加载器加载获得

　　注：Java中的原始基本类型：boolean, byte, char, short, int, long, float,double和关键词 void同样都有Class类，通过.class可获得它们的类字节码。

2.反射的概念

　　反射就是把Java类中的各种成分映射成相应的Java类，例如一个Java类中用一个Class类的对象表示一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，例如人是一个类，那么人的大脑、双手等也是一个个类。表示Java的Class类显然要提供一系列的方法，来获得其中的变量、方法、构造方法，修饰符、包等信息，这些信息就是用相应的类的实例对象来表示，他们是Field、Method、Contructor、Package等等。

　　一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示。

三、反射实战

测试Bean：Person.java

package com.hafiz.zhang.Bean;

public class Person {
    public Integer id;
    private String name;
    
    public Person() {
    }
    public Person(Integer id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Person [id=" + id + ", name=" + name + "]";
    }
    
    public void sayHello() throws Exception{
        System.out.println("Hello Reflect!");
    }
}

1.使用反射获取对象所属类的全路径（包括报名和类名）

package com.hafiz.zhang.test;

import com.hafiz.zhang.Bean.Person;

/**
 * @author hafiz.Zhang
 * @Date 2016年5月18日 下午4:28:35
 * @Description 测试通过一个对象获取该对象所属于的类的全路径（包括完整包名和类名）
 */
public class ReflectTest1 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("ClassName = " + person.getClass().getName());
    }
}

测试结果：

ClassName = com.hafiz.zhang.Bean.Person

2.测试使用反射实例化Class类对象

package com.hafiz.zhang.test;

import com.hafiz.zhang.Bean.Person;

/**
 * @author hafiz.Zhang
 * @Date 2016年5月18日 下午4:31:36
 * @Description 测试获取Class类的三种方式
 */
public class ReflectTest2 {
    public static void main(String[] args) {
        Class<?> obj1 = null;
        Class<?> obj2 = null;
        Class<?> obj3 = null;
        try {
            //一般尽量要采用这种方式进行实例化Class类对象
            obj1 = (Class<?>) Class.forName("com.hafiz.zhang.Bean.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        obj2 = new Person().getClass();
        obj3 = Person.class;
        
        System.out.println("ClassName:" + obj1.getName());
        System.out.println("ClassName:" + obj2.getName());
        System.out.println("ClassName:" + obj3.getName());
    }
}

测试结果：

ClassName:com.hafiz.zhang.Bean.Person
ClassName:com.hafiz.zhang.Bean.Person
ClassName:com.hafiz.zhang.Bean.Person

3.测试通过Class类对象实例化其他类

package com.hafiz.zhang.test;

import com.hafiz.zhang.Bean.Person;

/**
 * @author hafiz.Zhang
 * @Date 2016年5月18日 下午4:38:15
 * @Description 测试通过Class类对象实例化其他类
 */
public class ReflectTest3 {
    public static void main(String[] args) {
        Class<?> clazz = null;
        try {
            clazz = Class.forName("com.hafiz.zhang.Bean.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Person person = null;
        try {
            person = (Person) clazz.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        if(null != person) {
            person.setId(1);
            person.setName("Hafiz.Zhang");
            System.out.println("person=" + person);
        }else{
            System.out.println("实例化对象失败");
        }
    }
}

测试结果：

person=Person [id=1, name=Hafiz.Zhang]

4.测试通过Class调用其他类中的构造函数 （也可以通过这种方式通过Class创建其他类的对象）

package com.hafiz.zhang.test;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

import com.hafiz.zhang.Bean.Person;

/**
 * @author hafiz.Zhang
 * @Date 2016年5月18日 下午4:42:08
 * @Description 测试通过Class调用其他类中的构造函数 （也可以通过这种方式通过Class创建其他类的对象）
 */
public class ReflectTest4 {
    public static void main(String[] args) {
        Class<?> clazz = null;
        try {
            clazz = Class.forName("com.hafiz.zhang.Bean.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Person p1 = null;
        Person p2 = null;
        Constructor<?>[] cs = clazz.getConstructors();
        try {
            p1 = (Person) cs[0].newInstance();//通过无参构造获得对象
            p2 = (Person) cs[1].newInstance(1, "Hafiz.Zhang");//通过有参构造获得对象
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        System.out.println("Person1=" + p1);
        System.out.println("Person2=" + p2);
    }
}

测试结果：

Person1=Person [id=null, name=null]
Person2=Person [id=1, name=Hafiz.Zhang]

5.测试使用反射获取一个类实现的接口

接口Animal.java

package com.hafiz.zhang.Bean;

/**
 * @author hafiz.Zhang
 * @Date 2016年5月19日 下午6:13:37
 * @Description 动物接口
 */
public interface Animal {
    public abstract void eat();
    public abstract void sleep();
}

接口Skill.java

package com.hafiz.zhang.Bean;

/**
 * @author hafiz.Zhang
 * @Date 2016年5月19日 下午6:14:06
 * @Description 技能接口
 */
public interface Skill {
    public abstract void sayMiao();
}

实现类：Cat.java

package com.hafiz.zhang.Bean;

public class Cat implements Animal, Skill  {
    private Integer num;
    private String desc;
    public Integer getNum() {
        return num;
    }

    public void setNum(Integer num) {
        this.num = num;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    @Override
    public void eat() {
        System.out.println("cat eat fish");
    }

    @Override
    public void sleep() {
        System.out.println("cat sleep in the day");
    }

    @Override
    public void sayMiao() {
        System.out.println("cat say miao");
    }
    
    public void sayHello(String name){
        System.out.println("Hello " + name);
    }
}

测试类

package com.hafiz.zhang.test;

/**
 * @author hafiz.Zhang
 * @Date 2016年5月18日 下午4:51:29
 * @Description 测试使用反射获取一个类实现的接口
 */
public class ReflectTest5 {
    public static void main(String[] args) {
        Class<?> clazz = null;
        try {
            clazz = Class.forName("com.hafiz.zhang.Bean.Cat");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Class<?>[] interfaces = clazz.getInterfaces();
        System.out.println("Cat实现的接口有");
        for(Class<?> cl : interfaces) {
            System.out.println(cl.getName());
        }
    }
}

测试结果：

Cat实现的接口有
com.hafiz.zhang.Bean.Animal
com.hafiz.zhang.Bean.Skill

6.测试通过反射取得指定类的父类

package com.hafiz.zhang.test;

/**
 * @author hafiz.Zhang
 * @Date 2016年5月18日 下午5:03:25
 * @Description 测试通过反射取得指定类的父类
 */
public class ReflectTest6 {
    public static void main(String[] args) {
        Class<?> clazz = null;
        try {
            clazz = Class.forName("com.hafiz.zhang.Bean.Cat");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Class<?> superClass = clazz.getSuperclass();
        System.out.println("SuperClass=" + superClass);
    }
}

测试结果：SuperClass=class com.hafiz.zhang.Bean.Person

7.测试通过反射获得其他类中的全部构造函数

package com.hafiz.zhang.test;

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

/**
 * @author hafiz.Zhang
 * @Date 2016年5月18日 下午5:06:02
 * @Description 测试通过反射获得其他类中的全部构造函数
 */
public class ReflectTest7 {
    public static void main(String[] args) {
        Class<?> clazz = null;
        try {
            clazz = Class.forName("com.hafiz.zhang.Bean.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Constructor<?>[] cs = clazz.getConstructors();
        //实现方式1
        /*for(Constructor<?> item : cs) {
            System.out.println("构造方法:" + item.getName());
        }*/
        //实现方式2
        for(Constructor<?> item : cs) {
            System.out.print("构造方法:");
            System.out.print(Modifier.toString(item.getModifiers()) + " ");
            System.out.print(item.getName() + "(");
            Class<?>[] paramterTypes = item.getParameterTypes();
            for(int i = 0; i < paramterTypes.length; i++) {
                System.out.print(paramterTypes[i].getName() + " arg" + i);
                if(i < paramterTypes.length-1) {
                    System.out.print(",");
                }
            }
            System.out.println(")");
        }
    }
}

测试结果：

构造方法:public com.hafiz.zhang.Bean.Person()
构造方法:public com.hafiz.zhang.Bean.Person(java.lang.Integer arg0,java.lang.String arg1)

8. 测试通过反射获取类中的所有方法（包括方法包含的异常）

package com.hafiz.zhang.test;

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

/**
 * @author hafiz.Zhang
 * @Date 2016年5月18日 下午5:22:51
 * @Description 测试通过反射获取类中的所有方法
 */
public class ReflectTest8 {
    public static void main(String[] args) {
        Class<?> clazz = null;
        try {
            clazz = Class.forName("com.hafiz.zhang.Bean.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Method[] methods = clazz.getDeclaredMethods();
        for(Method method : methods) {
            Class<?> returnType = method.getReturnType();
            System.out.print(Modifier.toString(method.getModifiers()) + " ");
            System.out.print(returnType.getName() + " " + method.getName() + "(");
            Class<?>[] paras = method.getParameterTypes();
            for(int i = 0 ; i < paras.length ; i++) {
                System.out.print(paras[i].getName() + " arg" + i);
                if(i < paras.length - 1) {
                    System.out.print(",");
                }
            }
            Class<?>[] exces = method.getExceptionTypes();
            if(exces.length > 0) {
                System.out.print(") throws ");
                for(int j = 0; j < exces.length; j++) {
                    System.out.print(exces[j].getName());
                    if(j < exces.length - 1) {
                        System.out.print(", ");
                    }
                }
            }else{
                System.out.print(")");
            }
            System.out.println();
        }
    }
}

测试结果：

public java.lang.String toString()
public java.lang.String getName()
public void setName(java.lang.String arg0)
public java.lang.Integer getId()
public void sayHello() throws java.lang.Exception
public void setId(java.lang.Integer arg0)

9.测试通过反射获取类中所有的属性

package com.hafiz.zhang.test;

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

/**
 * @author hafiz.Zhang
 * @Date 2016年5月18日 下午5:38:09
 * @Description 测试通过反射获取类中所有的属性
 */
public class ReflectTest9 {
    public static void main(String[] args) {
        Class<?> clazz = null;
        try {
            clazz = Class.forName("com.hafiz.zhang.Bean.Cat");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Field[] fields = clazz.getDeclaredFields();
        System.out.println("=========通过反射获取指定类中所有的属性=========");
        for(Field field : fields) {
            System.out.println(Modifier.toString(field.getModifiers()) + " " + field.getType().getName() + " " + field.getName());
        }
        System.out.println("=========通过反射获取指定类实现的接口或者父类中所有的属性=========");
        Field[] fields2 = clazz.getSuperclass().getDeclaredFields();
        for(Field item : fields2) {
            System.out.println(Modifier.toString(item.getModifiers()) + " " + item.getType() + " " + item.getName());
        }
    }
}

测试结果：

=========通过反射获取指定类中所有的属性=========
private java.lang.Integer num
private java.lang.String desc
=========通过反射获取指定类实现的接口或者父类中所有的属性=========
public class java.lang.Integer id
private class java.lang.String name

10.测试使用反射调用指定类的方法

package com.hafiz.zhang.test;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @author hafiz.Zhang
 * @Date 2016年5月19日 下午3:22:33
 * @Description 测试使用反射调用指定类的方法
 */
public class ReflectTest10 {
    public static void main(String[] args) {
        Class<?> clazz = null;
        try {
            clazz = Class.forName("com.hafiz.zhang.Bean.Cat");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        try {
            //调用Cat类中的eat无参方法
            Method method = clazz.getMethod("eat");
            method.invoke(clazz.newInstance());
            //调用Cat类中的sayHello有参方法
            Method method2 = clazz.getDeclaredMethod("sayHello", String.class);
            method2.invoke(clazz.newInstance(), "Hafiz.Zhang");
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }
}

测试结果：

cat eat fish
Hello Hafiz.Zhang

11.测试通过反射调用其他类中的setter和getter方法

package com.hafiz.zhang.test;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @author hafiz.Zhang
 * @Date 2016年5月19日 下午3:29:34
 * @Description 测试通过反射调用其他类中的setter和getter方法
 */
public class ReflectTest11 {
    public static void main(String[] args) {
        Class<?> clazz = null;
        Object obj = null;
        try {
            clazz = Class.forName("com.hafiz.zhang.Bean.Cat");
            obj = clazz.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        getter(obj,"Desc");
        setter(obj,"Desc","测试调用set方法",String.class);
        getter(obj,"Desc");
    }

    private static void getter(Object obj, String name) {
        try {
            Method method = obj.getClass().getMethod("get"+name);
            System.out.println(name + ":" + method.invoke(obj));
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    private static void setter(Object obj, String name, String desc, Class<?> type) {
        try {
            Method method = obj.getClass().getMethod("set" + name, type);
            method.invoke(obj, desc);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

测试结果：

Desc:null
Desc:测试调用set方法

12.测试通过反射操作属性

package com.hafiz.zhang.test;

import java.lang.reflect.Field;

/**
 * @author hafiz.Zhang
 * @Date 2016年5月19日 下午3:41:59
 * @Description 测试通过反射操作属性
 */
public class ReflectTest12 {
    public static void main(String[] args) {
        Class<?> clazz = null;
        Object obj = null;
        try {
            clazz = Class.forName("com.hafiz.zhang.Bean.Cat");
            obj = clazz.newInstance();
            Field field = clazz.getDeclaredField("desc");
            //若要设置private属性，需要设置
            field.setAccessible(true);//设置成员变量可访问，包括private成员变量（暴力反射）,private成员通过这步操作才能被访问
            field.set(obj, "this is test demo");
            System.out.println("Desc=" + field.get(obj));
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        }
        
    }
}

测试结果：Desc=this is test demo

13.测试通过反射进行数组操作

package com.hafiz.zhang.test;

import java.lang.reflect.Array;

/**
 * @author hafiz.Zhang
 * @Date 2016年5月19日 下午4:52:21
 * @Description 测试通过反射进行数组操作
 * 
 */
public class ReflectTest13 {
    public static void main(String[] args) {
        Integer[] array = {1,2,3,4,5,6};
        Class<?> clazz = array.getClass().getComponentType();
        System.out.println("数组类型：" + clazz.getName());
        System.out.println("数组长度：" + Array.getLength(array));
        System.out.println("数组第一个元素：" + Array.get(array, 0));
        Array.set(array, 0, 8);
        System.out.println("修改之后数组第一个元素：" + Array.get(array, 0));
        System.out.println("=============反射修改数组长度=================");
        Integer[] arr2 = (Integer[])changeLength(array, 10);
        print(arr2);
    }
    private static void print(Object obj) {
        Class<?> clazz = obj.getClass();
        if(!clazz.isArray()) {
            return;
        }
        System.out.println("数组长度为：" + Array.getLength(obj));
        for(int i = 0; i < Array.getLength(obj); i++){
            System.out.print(Array.get(obj, i) + " ");
        }
    }
    public static Object changeLength(Object obj, Integer length){
        Class<?> clazz = obj.getClass().getComponentType();
        Object newArr = Array.newInstance(clazz, length);
        Integer len = Array.getLength(obj);
        System.arraycopy(obj, 0, newArr, 0, len);
        return newArr;
    }
}

测试结果：

数组类型：java.lang.Integer
数组长度：6
数组第一个元素：1
修改之后数组第一个元素：8
=============反射修改数组长度=================
数组长度为：10
8 2 3 4 5 6 null null null null