JAVA反射

Java反射
一、概念
java反射机制是在运行状态中，对于任意一个类，都能够知道这个类中的所有属性和方法；对于任意一个对象，都能调用它的任意一个方法和属性；

二、通过Java反射查看类信息
每个类被加载后，系统就会为改类生成一个对于的Class对象。通过该Class对象就可以访问到JVM中的这个类。
获得Class对象通常有如下三种方式
(1)使用Class类的froName(String classname)静态方法。改方法需要传入字符串参数，该字符串参数的值是某个类的全限定名(必须添加完成包名)
class1 = Class.forName(“com.glc.test.Teacher”);
(2)调用某个类的class属性来获取对应的Class对象。
class1 = Teacher.class;
(3)调用某个对象的getClass方法。
Teacher teacher = new Teacher();
Class<?> class1 = teacher.getClass();
2.1 获取Class对象的成员变量

	Field[] allFields = class1.getDeclaredFields();		获取到Class对象的所有属性
	Field[] publicFields = class1.getFields();			获取到Class对象的所有public属性
	Field ageField = class1.getDeclaredField("age")		获取Class对象的指定属性
	Filed nameField = class1.getField("name")			获取Class对象的指定public属性

2.2 获取Class对象构造函数

	Constructor<?>[] allConstructors = class1.getDeclaredConstructors();//获取class对象的所有声明构造函数
	Constructor<?>[] publicConstructors = class1.getConstructors();//获取class对象public构造函数
	Constructor<?> constructor = class1.getDeclaredConstructor(String.class);//获取指定声明构造函数
	Constructor publicConstructor = class1.getConstructor(String.class);//获取指定声明的public构造函数

2.3 其他方法

	Annotation[] annotations = (Annotation[]) class1.getAnnotations();//获取class对象的所有注解
	Annotation annotation = (Annotation) class1.getAnnotation(Deprecated.class);//获取class对象指定注解
	Type genericSuperclass = class1.getGenericSuperclass();//获取class对象的直接超类的 Type
	Type[] interfaceTypes = class1.getGenericInterfaces();//获取class对象的所有接口的type集合

2.4 获取Class对象的信息

	boolean isPrimitive = class1.isPrimitive();//判断是否是基础类型
	boolean isArray = class1.isArray();//判断是否是集合类
	boolean isAnnotation = class1.isAnnotation();//判断是否是注解类
	boolean isInterface = class1.isInterface();//判断是否是接口类
	boolean isEnum = class1.isEnum();//判断是否是枚举类
	boolean isAnonymousClass = class1.isAnonymousClass();//判断是否是匿名内部类
	boolean isAnnotationPresent = class1.isAnnotationPresent(Deprecated.class);//判断是否被某个注解类修饰
	String className = class1.getName();//获取class名字 包含包名路径
	Package aPackage = class1.getPackage();//获取class的包信息
	String simpleName = class1.getSimpleName();//获取class类名
	int modifiers = class1.getModifiers();//获取class访问权限
	Class<?>[] declaredClasses = class1.getDeclaredClasses();//内部类
	Class<?> declaringClass = class1.getDeclaringClass();//外部类

三、通过反射生成并操作对象
3.1 生成类的实例对象
1.使用Class对象的newInstance()方法来创建该Class对象对应类的实例。这种方式要求该Class对象的对应类有默认构造器，而执行newInstance()方法时实际上是利用默认构造器来创建该类的实例。
2.先使用Class对象获取指定的Constructor对象，再调用Constructor对象的newInstance()方法来创建该Class对象对应类的实例。通过这种方式可以选择使用指定的构造器来创建实例。

	//第一种方式 Class对象调用newInstance()方法生成
	
	Object obj = class1.newInstance();
	
	//第二种方式 对象获得对应的Constructor对象，再通过该Constructor对象的newInstance()方法生成
	Constructor<?> constructor = class1.getDeclaredConstructor(String.class);//获取指定声明构造函数
	obj = constructor.newInstance("hello");

3.2 调用类的方法
1.通过Class对象的getMethods()方法或者getMethod()方法获得指定方法，返回Method数组或对象。
2.调用Method对象中的Object invoke(Object obj, Object… args)方法。第一个参数对应调用该方法的实例对象，第二个参数对应该方法的参数。
// 生成新的对象：用newInstance()方法
Object obj = class1.newInstance();
//首先需要获得与该方法对应的Method对象
Method method = class1.getDeclaredMethod(“setAge”, int.class);
//调用指定的函数并传递参数
method.invoke(obj, 28);
当通过Method的invoke()方法来调用对应的方法时，Java会要求程序必须有调用该方法的权限。如果程序确实需要调用某个对象的private方法，则可以先调用Method对象的如下方法。
setAccessible(boolean flag)：将Method对象的acessible设置为指定的布尔值。值为true，指示该Method在使用时应该取消Java语言的访问权限检查；值为false，则知识该Method在使用时要实施Java语言的访问权限检查。
3.3 访问成员变量值
1.通过Class对象的getFields()方法或者getField()方法获得指定方法，返回Field数组或对象。
2.Field提供了两组方法来读取或设置成员变量的值：
getXXX(Object obj):获取obj对象的该成员变量的值。此处的XXX对应8种基本类型。如果该成员变量的类型是引用类型，则取消get后面的XXX。

	setXXX(Object obj,XXX val)：将obj对象的该成员变量设置成val值。
	//生成新的对象：用newInstance()方法 
	Object obj = class1.newInstance();
	//获取age成员变量
	Field field = class1.getField("age");
	//将obj对象的age的值设置为10
	field.setInt(obj, 10);
	//获取obj对象的age的值
	field.getInt(obj);

四、代理模式
4.1 定义
给某个对象提供一个代理对象，并由代理对象控制对于原对象的访问，即客户不直接操控原对象，而是通过代理对象间接地操控原对象。
4.2 分类
静态代理：代理类是在编译时就实现好的。也就是说 Java 编译完成后代理类是一个实际的 class 文件。
动态代理：代理类是在运行时生成的。也就是说 Java 编译完之后并没有实际的 class 文件，而是在运行时动态生成的类字节码，并加载到JVM中。
4.3 代理模式的简单实现

		public class ProxyDemo {
			public static void main(String args[]){
				RealSubject subject = new RealSubject();
				Proxy p = new Proxy(subject);
				p.request();
			}
		}
		interface Subject{
			void request();
		}
		class RealSubject implements Subject{
			public void request(){
				System.out.println("request");
			}
		}
		class Proxy implements Subject{
			private Subject subject;
			public Proxy(Subject subject){
				this.subject = subject;
			}
			public void request(){
				System.out.println("PreProcess");
				subject.request();
				System.out.println("PostProcess");
			}
		}

目标对象(RealSubject )以及代理对象（Proxy）都实现了主题接口（Subject）。在代理对象（Proxy）中，通过构造函数传入目标对象(RealSubject )，然后重写主题接口（Subject）的request()方法，在该方法中调用目标对象(RealSubject )的request()方法，并可以添加一些额外的处理工作在目标对象(RealSubject )的request()方法的前后。

五、反射机制与动态代理
5.1 动态代理
动态代理是指在运行时动态生成代理类。即，代理类的字节码将在运行时生成并载入当前代理的 ClassLoader。与静态处理类相比，动态类有诸多好处。
①不需要为(RealSubject )写一个形式上完全一样的封装类，假如主题接口（Subject）中的方法很多，为每一个接口写一个代理方法也很麻烦。如果接口有变动，则目标对象和代理类都要修改，不利于系统维护；
②使用一些动态代理的生成方法甚至可以在运行时制定代理类的执行逻辑，从而大大提升系统的灵活性。
5.2 动态代理涉及的主要类
java.lang.reflect.Proxy:这是生成代理类的主类，通过Proxy类生成的代理类都继承了Proxy类。Proxy提供了用户创建动态代理类和代理对象的静态
方法，他是所有动态代理类的父类。
java.lang.reflect.invocationHandler:这里称他为“调用处理器”，它是一个接口。当调用动态代理类中的方法时，将会直接转接到执行自定义的
InvocationHandler中的invoke()方法。即我们动态生成的代理类需要完成的具体内容需要自己定义一个类，而这个类必须实现InvocationHandler接口
，通过重写invoke()方法来执行具体内容。
Proxy提供了如下两个方法来创建动态代理类和动态代理实例。
static Class<?> getProxyClass(ClassLoader loader, Class<?>… interfaces) 返回代理类的java.lang.Class对象。第一个参数是类加载器对象（即哪个类加载器来加载这个代理类到 JVM 的方法区），第二个参数是接口（表明你这个代理类需要实现哪些接口），第三个参数是调用处理器类实例（指定代理类中具体要干什么），该代理类将实现interfaces所指定的所有接口，执行代理对象的每个方法时都会被替换执行InvocationHandler对象的invoke方法。

			static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 返回代理类实例。参数与上述方法一致。
			//创建一个InvocationHandler对象
			InvocationHandler handler = new MyInvocationHandler(.args..);
			//使用Proxy生成一个动态代理类
			Class proxyClass = Proxy.getProxyClass(RealSubject.class.getClassLoader(),RealSubject.class.getInterfaces(), handler);
			//获取proxyClass类中一个带InvocationHandler参数的构造器
			Constructor constructor = proxyClass.getConstructor(InvocationHandler.class);
			//调用constructor的newInstance方法来创建动态实例
			RealSubject real = (RealSubject)constructor.newInstance(handler);
			//创建一个InvocationHandler对象
			InvocationHandler handler = new MyInvocationHandler(.args..);
			//使用Proxy直接生成一个动态代理对象
			RealSubject real =Proxy.newProxyInstance(RealSubject.class.getClassLoader(),RealSubject.class.getInterfaces(), handler);
		newProxyInstance这个方法实际上做了两件事：第一，创建了一个新的类【代理类】，这个类实现了Class[] interfaces中的所有接口，并通过你指定的ClassLoader将生成的类的字节码加载到JVM中，创建Class对象；第二，以你传入的InvocationHandler作为参数创建一个代理类的实例并返回。
		Proxy 类还有一些静态方法，比如：
			InvocationHandler getInvocationHandler(Object proxy):获得代理对象对应的调用处理器对象。
			Class getProxyClass(ClassLoader loader, Class[] interfaces):根据类加载器和实现的接口获得代理类。
		InvocationHandler 接口中有方法：
			invoke(Object proxy, Method method, Object[] args)

这个函数是在代理对象调用任何一个方法时都会调用的，方法不同会导致第二个参数method不同，第一个参数是代理对象（表示哪个代理对象调用了method方法），第二个参数是 Method 对象（表示哪个方法被调用了），第三个参数是指定调用方法的参数。
5.3 动态代理模式的简单实现

	public class DynamicProxyDemo {
		public static void main(String[] args) {
			//1.创建目标对象
			RealSubject realSubject = new RealSubject();    
			//2.创建调用处理器对象
			ProxyHandler handler = new ProxyHandler(realSubject);    
		   //3.动态生成代理对象
			Subject proxySubject = (Subject)Proxy.newProxyInstance(RealSubject.class.getClassLoader(),
															RealSubject.class.getInterfaces(), handler);   
			//4.通过代理对象调用方法   
			proxySubject.request();    
		}
	}
	/**
	 * 主题接口
	 */
	interface Subject{
		void request();
	}
	/**
	 * 目标对象类
	 */
	class RealSubject implements Subject{
		public void request(){
			System.out.println("====RealSubject Request====");
		}
	}
	/**
	 * 代理类的调用处理器
	 */
	class ProxyHandler implements InvocationHandler{
		private Subject subject;
		public ProxyHandler(Subject subject){
			this.subject = subject;
		}
		@Override
		public Object invoke(Object proxy, Method method, Object[] args)
				throws Throwable {
			//定义预处理的工作，当然你也可以根据 method 的不同进行不同的预处理工作
			System.out.println("====before====");
		   //调用RealSubject中的方法
			Object result = method.invoke(subject, args);
			System.out.println("====after====");
			return result;
		}
	}

可以看到，我们通过newProxyInstance就产生了一个Subject 的实例，即代理类的实例，然后就可以通过Subject .request()，就会调用InvocationHandler中的invoke()方法，传入方法Method对象，以及调用方法的参数，通过Method.invoke调用RealSubject中的方法的request()方法。同时可以在InvocationHandler中的invoke()方法加入其他执行逻辑。