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方法的调用
}
}