Java反射机制

关于java.lang.Class类的理解

• 类的加载过程：程序经过javac.exe命令以后，会生成一个或者多个字节码文件（.class），接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程就称为类的加载。加载到内存中的类，被称作运行时类，此运行时类就称作Class的一个实例。
• Class的实例对应一个运行时类。

person.java

package com.pan;

public class Person {
    private String name;
    public int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    private Person(String name) {
        this.name = name;
    }
    public Person() {
        this.name = null;
        this.age = 0;
    }
    public void show() {
        System.out.println("你好,我是一个人");
    }
    private String showNation(String nation) {
        System.out.println("我的国籍是" + nation);
        return nation;
    }
    public String toString() {
        return "Person{" +
                "name = '" + name + '\'' +
                ", age = " + age +
                '}';
    }
}

ReflectionTest.java

package com.pan;
import org.junit.Test;
import java.lang.reflect.*;
public class ReflectionTest {
	//反射之前，对于Person的操作
    @Test
    public void test1(){
        //1.创建Person类的对象
        Person p1 = new Person("Tom",12);

        //2.通过对象，调用其内部的属性和方法
        p1.age = 18;
        System.out.println(p1.toString());//Person{name = 'Tom', age = 18}
        p1.show();//你好,我是一个人
        //在Person外部，不可以通过Person类的对象调用其内部的私有结构。
        //比如：name，showNation()以及私有的构造方法
    }
    //反射之后，对于Person操作
    @Test
    public void test2() throws Exception{
        Class clazz = Person.class;
        //1.通过反射，创建Person类的对象
        Constructor cons = clazz.getConstructor(String.class,int.class);
        Object obj = cons.newInstance("Tom",18);
        System.out.println(obj);//Person{name = 'Tom', age = 18}
        Person p = (Person)obj;
        System.out.println(p.toString());//Person{name = 'Tom', age = 18}
        //通过反射，调用对象指定的属性、方法
        Field age = clazz.getDeclaredField("age");
        age.set(p,10);
        System.out.println(p.toString());//Person{name = 'Tom', age = 10}

        //调用方法
        Method show = clazz.getDeclaredMethod("show");
        show.invoke(p);//你好,我是一个人

        /*通过反射，可以调用Person类的私有结构（方法，属性，构造方法）*/
        System.out.println("***********************************");
        Constructor cons1 = clazz.getDeclaredConstructor(String.class);
        cons1.setAccessible(true);
        Person p1 = (Person)cons1.newInstance("Jerry");
        System.out.println(p1.toString());//Person{name = 'Jerry', age = 0}

        //调用私有属性
        Field name = clazz.getDeclaredField("name");
        name.setAccessible(true);
        name.set(p1,"James");
        System.out.println(p1.toString());//Person{name = 'James', age = 0}
        //调用私有方法
        Method showNation = clazz.getDeclaredMethod("showNation", String.class);
        showNation.setAccessible(true);
        showNation.invoke(p1,"China");//我的国籍是China --相当于p1.showNation("China");
        String nation = (String)showNation.invoke(p1,"China");//相当于String nation = p1.showNation("China");
        System.out.println(nation);//China

    }

获取Class实例的四种方式

@Test
    public void test3() throws ClassNotFoundException{
        //方式一，调用运行时类属性
        Class clazz1 = Person.class;
        System.out.println(clazz1);//class com.pan.person
        //方式二，通过运行时类对象，调用getClass（）
        Person p1 = new Person();
        Class clazz2 = p1.getClass();
        System.out.println(clazz2);//class com.pan.person
        //方式三，调用Class的静态方法：forName(String classpath)
        Class clazz3 = Class.forName("com.pan.person");
        System.out.println(clazz3);//class com.pan.person
        System.out.println(clazz1 == clazz2);//true
        System.out.println(clazz1 == clazz3);//true
        /*
        * 1.Class的实例就对应着一个运行时类
        * 2.加载到内存中的运行时类，会缓存一段时间，
        *   在此时间内，我们可以通过不同的方式来获取此运行时类
        * */
    }

ClassLoader的理解

public void test4() {
		//对于自定义类，使用系统类加载器进行加载
		ClassLoader classloader = ReflectionTest.class.getClassLoader();
		System.out.println(classloader);//sun.misc.Launcher$AppClassLoader@73d16e93
		//调用系统类加载器的getParent()：获取扩展类加载器
		ClassLoader classloader1 = classloader.getParent();
		System.out.println(classloader1);//sun.misc.Launcher$ExtClassLoader@15db9742
		//调用扩展类加载器的getParent()：无法获取引导类加载器
		//引导类加载器主要负责加载java的核心类库，无法加载自定义类的
		ClassLoader classloader2 = classloader1.getParent();
		System.out.println(classloader2);//null
		
		ClassLoader classloader3  = String.class.getClassLoader();
		System.out.println(classloader3);//null
	}

读取配置文件
方式一（配置文件默认识别为Module下（IDEA））

@Test
    public void test5() throws Exception{
        Properties pros = new Properties();
        FileInputStream fis = new FileInputStream("jdbc.properties");
        //FileInputStream fis = new FileInputStream("src\\jdbc1.properties");
        pros.load(fis);
        String user = pros.getProperty("user");
        String password = pros.getProperty("password");
        System.out.println("user = " + user + ", password = " + password);
    }

方式二
配置文件默认识别为src下（IDEA）

@Test
    public void test6() throws Exception {
        Properties pros = new Properties();
        ClassLoader classloader = ReflectionTest.class.getClassLoader();
        InputStream is = classloader.getResourceAsStream("jdbc1.properties");
        pros.load(is);
        String user = pros.getProperty("user");
        String password = pros.getProperty("password");
        System.out.println("user = " + user + ", password = " + password);
    }	
	}

通过反射，创建运行时类对象

class.getDeclaredConstructor().newInstance()
getDeclaredConstructor()方法会根据他的参数对该类的构造函数进行搜索并返回对应的构造函数，没有参数就返回该类的无参构造函数，然后再通过newInstance进行实例化。

//通过反射创建运行时类的对象
public class NewInstanceTest  {
	public void test1() throws Exception{
		Class clazz = Person.class;
		/*
		 利用反射机制，调用此方法，创建对应的运行时类对象
		 必须构造函数存在且保证权限满足
		 */
        Object obj = clazz.newInstance();
        System.out.println(obj);//Person{name = 'null', age = 0}
		Person  obj = (Person)clazz.getDeclaredConstructor().newInstance();
		Person obj1 = (Person)clazz.getDeclaredConstructor(String.class, int.class).newInstance("张三",19);
		System.out.println(obj);
		System.out.println(obj1);
	}
	//反射的动态性
	public void test2() throws Exception{
		int num = new Random().nextInt(3);
		String classpath = "";
		switch(num) {
		case 0:
			classpath = "java.util.Date";
			break;
		case 1:
			classpath = "java.lang.Object";
			break;
		case 2:
			classpath = "com.pan.Person";
			break;
		}
		try {
			Object obj = getInstance(classpath);
			System.out.println(obj);
		}catch(Exception e) {
			e.printStackTrace();
		}
		
	}
	
	public Object getInstance(String classpath) throws Exception{
		Class clazz = Class.forName(classpath);
		return clazz.getDeclaredConstructor().newInstance();
	}	
}

获取运行时类的属性及其内部结构

Creature.java

package com.hai;
import java.io.Serializable;
public class Creature<T> implements Serializable {
    private char gender;
    public double weight;

    private void breath(){
        System.out.println("生物呼吸");
    }
    public void eat(){
        System.out.println("生物吃东西");
    }
}

Person.java

package com.hai;
@MyAnnotition
public class Person extends Creature<String> implements Comparable<String>,MyInterface{
    private String name;
    int age;
    public int id;

    public Person(){
    }
    @MyAnnotition("panhaichen")
    private Person(String name){
        this.name = name;
    }
    Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    @MyAnnotition("panpan")
    private String show(String nation){
        System.out.println("我的国籍是：" + nation);
        return nation;
    }
    public String display(String interests,int age)throws NullPointerException,ClassCastException{
        return interests + age;
    }
	public static void showDesc(){
        System.out.println("i am a cute person");
    }（操作运行时类中的指定的方法时加入的）
    @Override
    public int compareTo(String o) {
        return 0;
    }
    @Override
    public void info() {
        System.out.println("I am a Person");
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id=" + id +
                '}';
    }（调用运行时类中指定的构造方法时加入的）
}

Myinterface.java

package com.hai;
public interface MyInterface {
    void info();
}

MyAnnotition.java

package com.hai;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.ElementType.LOCAL_VARIABLE;

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotition {
    String value() default "hello";
}

FieldTest.java

package com.hai;

import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.reflect.*;

public class FieldTest {
    @Test
    public void test1(){
        Class clazz = Person.class;

        //获取属性结构
        //getFields():获取当前运行时类及其父类中声明为public访问权限的属性
        Field[] fields = clazz.getFields();
        for(Field f : fields){
            System.out.println(f);
        }
//        public int com.hai.Person.id
//        public double com.hai.Creature.weight
        System.out.println("************************************");
        //getDeclaredFields():获取当前运行时类中声明的所有的属性（无论什么权限），不包含父类中声明的权限
        Field[] declaredFields = clazz.getDeclaredFields();
        for(Field f : declaredFields){
            System.out.println(f);
        }
//        private java.lang.String com.hai.Person.name
//        int com.hai.Person.age
//        public int com.hai.Person.id
    }

    /*通过反射获取权限修饰符 数据类型 变量名*/
    @Test
    public void test2(){
        Class clazz = Person.class;
        Field[] declaredFields = clazz.getDeclaredFields();
        //1.权限修饰符
        for(Field f : declaredFields){
            int modifier = f.getModifiers();
            System.out.println(Modifier.toString(modifier));
        }
//        private
//                  //默认修饰权限
//        public
        System.out.println("********************************");

        //2.数据类型
        for(Field f : declaredFields){
            Class type = f.getType();
            System.out.println(type.getName());
        }
//        java.lang.String
//        int
//        int
        System.out.println("************************************");

        //3.变量名
        for(Field f : declaredFields){
            String fname = f.getName();
            System.out.println(fname);
        }
//        name
//        age
//        id
    }

    /*获取运行时类的方法结构*/
    @Test
    public void test3(){
        Class clazz = Person.class;
        //getMethods():获取当前运行时类及其所有父类中声明为public权限的方法
        Method[] methods = clazz.getMethods();
        for(Method m : methods){
            System.out.println(m);
        }
//        public int com.hai.Person.compareTo(java.lang.String)
//        public int com.hai.Person.compareTo(java.lang.Object)
//        public void com.hai.Person.info()
//        public java.lang.String com.hai.Person.display(java.lang.String)
//        public void com.hai.Creature.eat()
//        public final void java.lang.Object.wait() throws java.lang.InterruptedException
//        public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
//        public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
//        public boolean java.lang.Object.equals(java.lang.Object)
//        public java.lang.String java.lang.Object.toString()
//        public native int java.lang.Object.hashCode()
//        public final native java.lang.Class java.lang.Object.getClass()
//        public final native void java.lang.Object.notify()
//        public final native void java.lang.Object.notifyAll()
        System.out.println("********************************");
        //getDeclaredMethods():获取当前运行时类中声明的所有方法。（不包含父类中声明的的所有方法）
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for(Method m : declaredMethods){
            System.out.println(m);
        }
//        public int com.hai.Person.compareTo(java.lang.String)
//        public int com.hai.Person.compareTo(java.lang.Object)
//        public void com.hai.Person.info()
//        private java.lang.String com.hai.Person.show(java.lang.String)
//        public java.lang.String com.hai.Person.display(java.lang.String)


        //getDeclaredConstructor()//获取构造方法
    }

    /*获取运行时类的方法的内部结构*/
    /*
    * @XXX
    * 权限修饰符 返回值类型 方法名(参数类型1 形参名1,...) throws XXXException
    * */
    @Test
    public void test4(){
        Class clazz = Person.class;
        Method[] declaredmethods = clazz.getDeclaredMethods();
        //1.获取方法声明的注解
        for(Method m : declaredmethods){
            Annotation[] annos = m.getAnnotations();
            for(Annotation a : annos){
                System.out.print(a);//@com.hai.MyAnnotition(value=panpan)
            }
        }
        System.out.println("");
        //2.获取权限修饰符
        for(Method m : declaredmethods){
            Annotation[] annos = m.getAnnotations();
            System.out.print(Modifier.toString(m.getModifiers()) + '\t');//public	public volatile	public(compareTo)	private	public
        }
        System.out.println("");
        //3.返回值类型
        for(Method m : declaredmethods){
            System.out.print(m.getReturnType().getName() + '\t');//int	int	void	java.lang.String	java.lang.String
        }
        System.out.println("\n*****************************************************");
        //4.方法名
        for(Method m : declaredmethods){
            System.out.print(m.getName() + '(');
            //形参列表
            Class[] parameterTypes = m.getParameterTypes();
            if(!(parameterTypes == null && parameterTypes.length == 0)){
                for(int i = 0; i < parameterTypes.length; i++){
                    if(i == parameterTypes.length - 1) {
                        System.out.print(parameterTypes[i].getName() + " args_" + i);
                        break;
                    }
                    System.out.print(parameterTypes[i].getName() + " args_" + i + ",");
                }
            }
            System.out.println(")");
           }
//        compareTo(java.lang.String args_0)
//        compareTo(java.lang.Object args_0)
//        info()
//        show(java.lang.String args_0)
//        display(java.lang.String args_0,int args_1)

        //6.抛出的异常
        for(Method m : declaredmethods) {
            Class[] exceptionTypes = m.getExceptionTypes();
            if (exceptionTypes.length > 0) {
                System.out.print("throws ");
                for (int i = 0; i < exceptionTypes.length; i++) {
                    if (i == exceptionTypes.length - 1) {
                        System.out.print(exceptionTypes[i].getName() + " ");
                        break;
                    }
                    System.out.print(exceptionTypes[i].getName() + ", ");
                }
//                throws java.lang.NullPointerException, java.lang.ClassCastException
                System.out.println();
            }
        }
    }


    /*获取构造方法结构,获取形参列表，权限修饰符等跟方法类似，这里不再赘述*/
    @Test
    public void test5(){
        Class clazz = Person.class;
        //getConstructors():获取当前运行时类中声明为public的构造方法
        Constructor[] constructors = clazz.getConstructors();
        for(Constructor c :constructors){
            System.out.println(c);
        }
        System.out.println();
        //public com.hai.Person()

        //getDeclaredConstructors():获取当前运行时类中声明的所有构造方法
        Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
        for(Constructor c : declaredConstructors){
            System.out.println(c);
        }
//        com.hai.Person(java.lang.String,int)
//        private com.hai.Person(java.lang.String)
//        public com.hai.Person()
    }
    /*获取运行时类的父类*/
    @Test
    public void test6(){
        Class clazz = Person.class;

        //获取运行时类的父类
        Class superclass = clazz.getSuperclass();
        System.out.println(superclass);//class com.hai.Creature

        //获取运行时类的带泛型的父类
        Type genericsuperclass = clazz.getGenericSuperclass();
        System.out.println(genericsuperclass);//com.hai.Creature<java.lang.String>

        //获取运行时类的带泛型的父类的泛型
        Type genericsuperclass1 = clazz.getGenericSuperclass();
        ParameterizedType paramType = (ParameterizedType) genericsuperclass1;

        //获取泛型类型
        Type[] actualTypeArguments = paramType.getActualTypeArguments();
        System.out.println(actualTypeArguments[0].getTypeName());//java.lang.String
        System.out.println(((Class)actualTypeArguments[0]).getName());//java.lang.String
    }

    /*获取运行时类实现的接口*/
    public void test7(){
        Class clazz = Person.class;
        Class[] interfaces = clazz.getInterfaces();
        for(Class c : interfaces){
            System.out.println(c);
        }
        System.out.println();
        //获取运行时类的父类实现的接口
        Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
        for(Class c : interfaces1){
            System.out.println(c);
        }
    }
    /*获取运行时类所在的包*/
    @Test
    public void test8(){
        Class clazz = Person.class;

        Package pack = clazz.getPackage();
        System.out.println(pack);

        //获取运行时类声明的注解
        Annotation[] annotations = clazz.getAnnotations();
        for(Annotation annotation : annotations){
            System.out.println(annotation);
        }
    }
}

调用运行时类中指定属性

//该方法只能获取public权限
    @Test
    public void test9() throws Exception {
        Class clazz = Person.class;
        //创建运行时类对象
        Person p = (Person)clazz.newInstance();
        //获取指定的属性
        Field id = clazz.getField("id");
        //设置当前属性值，set():参数一：指明设置哪个对象的属性，参数二：将此属性值设置为多少
        id.set(p,1001);
        //获取当前属性的值
        int pid = (int)id.get(p);
        System.out.println(pid);//1001
    }
    @Test
    public void test10() throws Exception{
        Class clazz = Person.class;
        //创建运行时类对象
        Person p = (Person)clazz.newInstance();
        //1.getDeclaredField(String fieldName):获取运行时类中指定变量名的属性
        Field name = clazz.getDeclaredField("name");
        //2.保证当前属性是可见的
        name.setAccessible(true);
        name.set(p,"Tom");
        System.out.println(name.get(p));//Tom
    }

调用运行时类中指定方法

/*如何操作运行时类中的指定的方法*/
    @Test
    public void test12() throws Exception {
        Class clazz = Person.class;
        //创建运行时类对象
        Person p = (Person)clazz.newInstance();
        //获取指定的某个方法
        //getDeclaredMethod():参数一：指明获取方法的名称 参数二：指明获取的方法的形参列表
        Method show = clazz.getDeclaredMethod("show",String.class);

        //invoke():参数一：方法的调用者  参数二：给方法形参赋值的实参
        //invoke()的返回值即为对应类中调用的方法的返回值
        show.setAccessible(true);
        Object returnValue = show.invoke(p,"CHN");//我的国籍是：CHN
        System.out.println(returnValue);//CHN

        /*调用静态方法*/
        Method showDesc = clazz.getDeclaredMethod("showDesc");
        showDesc.setAccessible(true);
        //如果调用的运行时类中的方法没有返回值，则invoke()返回null
//        Object returnVal = showDesc.invoke(Person.class);
        Object returnVal = showDesc.invoke(null);//i am a cute person
        System.out.println(returnVal);//null
    }

调用运行时类中指定构造方法

/*调用运行时类中指定的构造方法*/
    @Test
    public void test13() throws Exception{
        Class clazz = Person.class;
        //1.获取指定的构造方法。getDeclaredConstructor():参数:指明构造方法的参数列表
        Constructor constructor = clazz.getDeclaredConstructor(String.class);
        constructor.setAccessible(true);
        //2.保证此构造方法是可访问的
        Person per = (Person)constructor.newInstance("Tom");
        //3.调用此构造方法创建运行时类对象
        System.out.println(per);//Person{name='Tom', age=0, id=0}
    }

参考视频