Java基础——Java反射机制

Reflection（反射）是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法

Java反射机制提供的功能
　　在运行时判断任意一个对象所属的类
　　在运行时构造任意一个类的对象
　　在运行时判断任意一个类所具有的成员变量和方法
　　在运行时调用任意一个对象的成员变量和方法
　　生成动态代理

反射相关的主要API：
　　java.lang.Class:代表一个类  是反射的源头，
　　java.lang.reflect.Method:代表类的方法
　　java.lang.reflect.Field:代表类的成员变量
　　java.lang.reflect.Constructor:代表类的构造方法

　　注：创建类时，尽量保留一个空参的构造器

Class实例的过程：源文件经过编译（javac.exe）以后，得到一个或多个.class文件
.class文件经过运行（java.exe）以后，就需要进行类的加载（通过JVM的类加载器）
加载到内存中，每一个放入缓存中的.class文件就是一个Class实例

如何获取class的实例
　　1）前提：若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高
　　　　实例：Class clazz = String.class;
　　2）前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象
　　　　实例：Class clazz = “www.atguigu.com”.getClass();
　　3）前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException
　　　　实例：Class clazz = Class.forName(“java.lang.String”);
　　4）其他方式(不做要求)
　　　　ClassLoader cl = this.getClass().getClassLoader();
　　　　Class clazz4 = cl.loadClass(“类的全类名”);

创建运行时类的对象：调用Class对象的newInstance()方法，实际就是调用了类的空参构造器
　　要 求：1）类必须有一个无参数的构造器。
　　　　　2）类的构造器的访问权限需要足够。

@Test
	public void test2() throws Exception{
		//----------获取class的实例-------------
		//*******1.已知具体的类，通过类的.class属性获取实例********
		Class clazz = Farmer.class;//为什么不能调用类的具体属性和方法
		//*******2.已知某个类的实例，调用该实例的getClass()方法获取Class对象********
		Farmer far = new Farmer();
		Class clazz = "far".getClass();
		//*******3.已知类的全类名，且该类在类路径下，可调用Class类的静态方法forName()********
		Class clazz = Class.forName("test.Farmer");
		//*******4.通过类加载器********
		ClassLoader cl = this.getClass().getClassLoader();
		Class clazz = cl.loadClass("test.Farmer");
		Object obj = clazz.newInstance();//调用缺省的构造函数（空参的构造器），返回一个该Class对象的一个实例
		
		//-------1.获取运行时类的属性-------
		Field field = clazz.getField("name");//获取运行时类的属性
		Field[] fields1 = clazz.getFields();	//返回此Class对象所表示的类及其父类（直接或间接）或接口的public的Field
		Field[] fields2 = clazz.getDeclaredFields();//返回此Class对象所表示的类或接口的全部Field
		
		System.out.println(field);//public java.lang.String test.Farmer.name

		for(Field i : fields1) {
			System.out.println(i);//public java.lang.String test.Farmer.name
		}						  //public int test.Person.life
	
		for(Field i : fields2) {	//private test.Person test.Farmer.adversary
			System.out.println(i);	//public java.lang.String test.Farmer.name
		}							//int test.Farmer.age
		System.out.println();
		
		//------2.获取运行时类的方法------
		Method method = clazz.getMethod("getAdversary");//返回运行时类的方法
		Method[] methods1 = clazz.getMethods();//返回此Class对象所表示的类及其父类或接口的public的Method
		Method[] methods2 = clazz.getDeclaredMethods();//返回此Class对象所表示的类或接口的全部Method
		
		System.out.println(method);//public test.Person test.Farmer.getAdversary()
		
		for(Method i : methods1) {
			System.out.println(i);
		}
		
		System.out.println();
		for(Method i : methods2) {
			System.out.println(i);
		}
	}

获取运行时类的属性
　　1.public Field[] getFields()
　　　　Class clazz = String.class;
　　　　Field[] fields = clazz.getFields(); 返回此Class对象所表示的类及其（直接和间接）父类或接口的public的Field。
　　2.public Field[] getDeclaredFields()
　　　　Field[] fields = clazz.getDeclaredFields(); 返回此Class对象所表示的类或接口的全部Field。

　　Field方法中：
　　　　public int getModifiers() 以整数形式返回此Field的修饰符
　　　　　　int i = f.getModifiers();
　　　　　　String str = Modifier.toString(i);
　　　　public Class<?> getType() 得到Field的属性类型
　　　　public String getName() 返回Field的名称。

使用反射可以取得：
　　1.获取运行时类的方法
　　　　public Method[] getDeclaredMethods() 返回此Class对象所表示的类或接口的全部方法
　　　　public Method[] getMethods() 返回此Class对象所表示的类及其（直接和间接）父类或接口的public的方法

　　Method类中：
　　　　public Class<?> getReturnType()取得全部的返回值
　　　　public Class<?>[] getParameterTypes()取得全部的参数
　　　　public int getModifiers()取得修饰符
　　　　public Class<?>[] getExceptionTypes()取得异常信息
　　　　Annotation[] ann = m.getAnnotations();

　　2.获取全部的构造器
　　　　public Constructor<T>[] getConstructors() 返回此 Class 对象所表示的类的所有public构造方法。
　　　　public Constructor<T>[] getDeclaredConstructors() 返回此 Class 对象表示的类声明的所有构造方法。

　　Constructor类中：
　　　　取得修饰符: public int getModifiers();
　　　　取得方法名称: public String getName();
　　　　取得参数的类型：public Class<?>[] getParameterTypes();


　　3.获得实现的全部接口
　　　　public Class<?>[] getInterfaces() 确定此对象所表示的类或接口实现的接口。

　　4.获得所继承的父类
　　　　public Class<? Super T> getSuperclass() 返回表示此 Class 所表示的实体（类、接口、基本类型）的父类的 Class。

　　5.获得Annotation相关
　　　　get Annotation(Class<T> annotationClass) getDeclaredAnnotations() 只有定义为RUNTIME的才能被反射获取到
　　6.获得泛型相关
　　　　获取父类泛型类型：Type type = clazz.getGenericSuperclass();
　　　　泛型类型：ParameterizedType param = (ParameterizedType)type;
　　　　获取实际的泛型类型参数数组：Type[] arg = param.getActualTypeArguments();
　　　　　　(Class)arg[0].getName()

　　7.获得类所在的包 Package getPackage()

通过反射调用类中的指定方法

	//调用运行时类中指定方法
	@Test
	public void test1() throws Exception {
		//调用运行时类中指定的方法, 设置此方法操作时所需要的参数类型
		Class clazz = Farmer.class;
		Method md = clazz.getDeclaredMethod("skills", int.class, int.class);//记得要写方法的参数类型
		md.setAccessible(true);//当方法为非public时，要写
		Farmer farmer = (Farmer)clazz.newInstance();
		//调用指定的方法:Object invoke(Object obj, Object ... obj)//记得除了实例还要写上调用的参数的值哦
		Object returnVal = md.invoke(farmer, 12, 100);//返回值为md中的的返回值	Hello,I`m skye
		
		
		System.out.println(returnVal);
		
	}

调用指定属性

	//调用运行时类中指定属性
	@Test
	public void test3() throws Exception {
		Class clazz = Farmer.class;
		
		//1.获取指定属性
		Field name = clazz.getDeclaredField("name");
		//由于属性权限修饰符的限制，为了保证可以给属性赋值，需要在操作前使得此属性可被操作
		name.setAccessible(true);
		//2.创建运行时类的对象
		Farmer farmer = (Farmer)clazz.newInstance();
		System.out.println(farmer);//Farmer [adversary=null, name=hello, age=10]
		//3.将运行时类的指定属性赋值
		name.set(farmer, "Skye");
		System.out.println(farmer);//Farmer [adversary=null, name=Skye, age=10]  name是修改了的
	}

　　

调用指定构造器创建运行时类的对象

	//调用指定的构造器创建运行时类的对象
	@Test
	public void test4() throws Exception {
		String className = "test.Farmer";
		Class clazz = Class.forName(className);
		
		Constructor cons = clazz.getDeclaredConstructor(int.class, int.class, int.class, int.class);
		cons.setAccessible(true);
		Farmer farmer = (Farmer)cons.newInstance(10, 10, 101, 12);//Farmer 生命值：10, 攻击值：10, 防御值：101, 金币：12
		System.out.println(farmer);
	}

　　

动态代理：动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。

Proxy ：专门完成代理的操作类，是所有动态代理类的父类。通过此类为一个或多个接口动态地生成实现类。
static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces) 创建一个动态代理类所对应的Class对象
static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 直接创建一个动态代理对象

package test;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//动态代理
interface Subject {
	void action();
}

class RealSubject implements Subject{
	public void action() {
		System.out.println("我是被代理类");
	}
}

class MyInvocationHandler implements InvocationHandler{
	//实现接口被代理类的对象的声明
	Object obj;
	
	//1.给被代理类对象实例化。2.返回一个代理类的对象
	public Object blind(Object obj) {
	　　this.obj = obj;
　　　　　　　//newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)  直接创建一个动态代理对象
	　　return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
	}
	
	//当通过代理类对象发起对重写方法的调用时，都会转换为对如下invoke()方法的调用
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Exception {
	//newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)  直接创建一个动态代理对象
		//method方法的返回值是returnVal
	　　Object returnVal = method.invoke(obj, args);
	　　return returnVal;
	}
}

public class TestProxy {
	public static void main(String[] args) {
		//1.被代理类对象
		RealSubject real = new RealSubject();
		//2.创建一个实现了InvocationHandler接口的类的对象
		MyInvocationHandler handler = new MyInvocationHandler();
		//3.调用blind方法，动态的返回一个同样实现了real所在类实现的接口Subject的代理类的对象
		Object obj = handler.blind(real);
		Subject sub = (Subject)obj;//此时sub就是代理类对象
		sub.action();//转到对InvocationHandler接口的实现类的invoke方法的调用
	}
}