理解Java反射

一、反射简介

Java让我们在运行时识别对象和类的信息，主要有2种方式：一种是传统的RTTI，它假定我们在编译时已经知道了所有的类型信息；另一种是反射机制，它允许我们在运行时发现和使用类的信息。

1、反射的描述

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象

反射就是动态的从内存加载一个指定的类，把java类中的各种成分映射成一个个的Java对象，获取该类中的所有的内容。

2、反射的功能

1.在运行时判断任意一个对象所属的类；

2.在运行时构造任意一个类的对象；

3.在运行时判断任意一个类所具有的成员变量和方法（通过反射甚至可以调用private方法）；

4.在运行时调用任意一个对象的方法

重点：是运行时而不是编译时

反射的优点：增加程序的灵活性；增强了程序的扩展性。

反射的缺点：运用反射会使我们的软件的性能降低，复杂度增加。

二、反射的使用

1、获取Class对象

1：通过每个对象都具备的方法getClass来获取。弊端：必须要创建该类对象，才可以调用getClass方法。

2：每一个数据类型(基本数据类型和引用数据类型)都有一个静态的属性class。弊端：必须要先明确该类。

　　前两种方式不利于程序的扩展，因为都需要在程序使用具体的类来完成。

3：使用的Class类中的方法，静态的forName方法。指定什么类名，就获取什么类字节码文件对象，这种方式的扩展性最强，只要将类名的字符串传入即可。

示例代码如下：

package com.luis.test;
public class User {
	private long id;
	private String name;
	public int age;

	public long getId() {
		return id;
	}
	public void setId(long id) {
		this.id = id;
	}
	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;
	}

	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
}

public class GetClass {
	public static void main(String[] args) {
		//1、通过对象调用 getClass() 方法来获取,通常应用在：比如你传过来一个 Object
		//  类型的对象，而我不知道你具体是什么类，用这种方法
		User user = new User();
		Class c1 = user.getClass();

		//2、直接通过 类名.class 的方式得到,该方法最为安全可靠，程序性能更高
		//  这说明任何一个类都有一个隐含的静态成员变量 class
		Class c2 = User.class;

		//3、通过 Class 对象的 forName() 静态方法来获取，用的最多，
		//抛出 ClassNotFoundException 异常
		Class c3;
		try {
			c3 = Class.forName("com.luis.test.User");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
}

2、获取类中的方法，属性，构造函数。

public class GetClass {
	public static void main(String[] args) {
		try {
			Class clazz = Class.forName("com.luis.test.User");
			Constructor con = clazz.getConstructor(new Class[]{});
			User instance = (User) con.newInstance();
			instance.toString();
			//获得类完整的名字
			String className = clazz.getName();
			System.out.println("---------完整类名----------");
			System.out.println(className);

			//获得类的public类型的属性。
			Field[] fields = clazz.getFields();
			System.out.println("---------public属性----------");
			for(Field field : fields){
			   System.out.println("public类:"+field.getName());
			}

			//获得类的所有属性包括私有的
			Field [] allFields = clazz.getDeclaredFields();
			System.out.println("---------所有属性----------");
			for(Field field : allFields){
				System.out.println(field.getName());
			}

			//获得类的public类型的方法。这里包括 Object 类的一些方法
			Method [] methods = clazz.getMethods();
			System.out.println("---------public方法----------");
			for(Method method : methods){
				System.out.println(method.getName());
			}

			//获得类的所有方法。
			Method [] allMethods = clazz.getDeclaredMethods();
			System.out.println("---------所有方法----------");
			for(Method method : allMethods){
				System.out.println(method.getName());
			}

			//获得指定的属性
			Field f1 = clazz.getField("age");
			System.out.println("---------指定属性----------");
			System.out.println(f1);
			//获得指定的私有属性
			System.out.println("---------指定私有属性----------");
			Field f2 = clazz.getDeclaredField("name");
			//启用和禁用访问安全检查的开关，值为 true，则表示反射的对象在使用时应该取消 java 语言的访问检查；反之不取消
			f2.setAccessible(true);
			System.out.println(f2);

			//创建这个类的一个对象
			Object p2 =  clazz.newInstance();
			//将 p2 对象的  f2 属性赋值为 Bob，f2 属性即为 私有属性 name
			f2.set(p2,"luis");
			//使用反射机制可以打破封装性，导致了java对象的属性不安全。
			System.out.println("---------创建对象----------");
			System.out.println(f2.get(p2)); //Bob

			//获取构造方法
			Constructor [] constructors = clazz.getConstructors();
			System.out.println("---------获取构造方法----------");
			for(Constructor constructor : constructors){
				System.out.println(constructor.toString());
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

运行结果：

---------完整类名----------
com.luis.test.User
---------public属性----------
public类:age
---------所有属性----------
id
name
age
---------public方法----------
toString
getName
getId
setName
getAge
setId
setAge
wait
wait
wait
equals
hashCode
getClass
notify
notifyAll
---------所有方法----------
toString
getName
getId
setName
getAge
setId
setAge
---------指定属性----------
public int com.luis.test.User.age
---------指定私有属性----------
private java.lang.String com.luis.test.User.name
---------创建对象----------
luis
---------获取构造方法----------
public com.luis.test.User()

3、反射获取父类属性

可以通过反射获取父类的私有属性，代码如下：

public class Parent {
	public String publicField = "parent_publicField";
	protected String protectField = "parent_protectField";
	String defaultField = "parent_defaultField";
	private String privateField = "parent_privateField";
}

package com.luis.test;
public class Admin extends Parent{
}

public class GetClass {
	public static void main(String[] args) {
		try {
			Class clazz = Class.forName("com.luis.test.Admin");
			//获取父类私有属性值
			System.out.println(getFieldValue(clazz.newInstance(),"privateField"));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static Field getDeclaredField(Object obj,String fieldName) {
		Field field = null;
		Class c = obj.getClass();
			 for(; c != Object.class ; c = c.getSuperclass()){
				 try {
					 field = c.getDeclaredField(fieldName);
					 field.setAccessible(true);
					 return field;
				 }catch (Exception e){
					 //如果这里的异常打印或者往外抛，则就不会执行c = c.getSuperclass(),最后就不会进入到父类中了
				 }
			 }
		return null;
	}
	public static Object getFieldValue(Object object,String fieldName) throws Exception{
		  Field field = getDeclaredField(object,fieldName);
		  return field.get(object);
	}
}

运行结果：parent_privateField

要注意：直接通过反射获取子类的对象是不能得到父类的属性值的，必须根据反射获得的子类 Class 对象在调用 getSuperclass() 方法获取父类对象，然后在通过父类对象去获取父类的属性值。

三、动态代理

代理类在程序运行时创建的代理方式被成为动态代理。代理类并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指示”动态生成的。相比于静态代理， 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。

接口和实现类：

public interface Interface {
    void doSomething();
    void somethingElse(String arg);
}

public class RealObject implements Interface {

    @Override
    public void doSomething() {
        System.out.println("doSomething.");
    }

    @Override
    public void somethingElse(String arg) {
         System.out.println("somethingElse " + arg);
    }
}

动态代理对象处理器：

public class DynamicProxyHandler implements InvocationHandler {
    private Object proxyed;

    public DynamicProxyHandler(Object proxyed) {
        this.proxyed = proxyed;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         System.out.println("代理工作了.");
         return method.invoke(proxyed, args);
    }
}

测试类：

public class Main {
    public static void main(String[] args) {
        RealObject real = new RealObject();
        Interface proxy = (Interface) Proxy.newProxyInstance(Interface.class.getClassLoader(),
                new Class[] {Interface.class},new DynamicProxyHandler(real));
        proxy.doSomething();
        proxy.somethingElse("luis");
    }
}

反射极大地增强了代码的灵活性，广泛应用于各种框架中，因而对于反射的掌握是非常重要的。

本文参考了：

https://www.cnblogs.com/ysocean/p/6516248.html

https://www.cnblogs.com/luoxn28/p/5686794.html

https://blog.csdn.net/ShadowySpirits/article/details/79756259