反射

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

反射

• 反射的概念
  • 简介
    • 1.Reflection（反射)是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。 2.加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。 通常的方式：引入需要的“包类”名称---->通过“new”实例化---->获得实例化对象 反射的方式：实例化对象---->getClass()方法---->得到完整的“包类”名称 框架 = 注解 + 反射 + 设计模式
  • 反射机制提供的功能
    • 在运行时判断任意一个对象所属的类 在运行时构造任意一个类的对象 在运行时判断任意一个类所具有的成员变量和方法 在运行时获取泛型信息 在运行时调用任意一个对象的成员变量和方法 在运行时处理注解 生成动态代理
  • 相关的API
    • java.lang.Class:反射的源头 java.lang.reflect.Method java.lang.reflect.Field java.lang.reflect.Constructor
• Class类
  • 简述
    • 对象使用反射后可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE都为其保留一个不变的Class类型的对象。一个Class对象包含了特定某个结构（ class/interface/enum/annotation/primitive type/void/[]）的有关信息。 Class本身也是一个类 Class对象只能由系统建立对象 一个加载的类在JVM中只会有一个Class实例 一个Class对象对应的是一个加载到JVM中的一个.class文件 每个类的实例都会记得自己是由哪个Class实例所生成 通过Class可以完整地得到一个类中的所有被加载的结构 Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象
    • 类加载的过程
      • 程序经过javac.exe命令以后，会生成一个或多个字节码文件(.class结尾)。接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程就称为类的加载。加载到内存中的类，我们就称为运行时类，此运行时类，就作为Class的一个实例。 换句话说，Class的实例就对应着一个运行时类。 加载到内存中的运行时类，会缓存一定的时间。在此时间之内，我们可以通过不同的方式来获取此运行时类。
  • 获取Class实例的几种方式
    • 1）已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高 实例：Class clazz = String.class; 2）已知某个类的实例，调用该实例的getclass()方法获取Class对象 实例：Class clazz=person.getclass(); 3）已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取， 可能抛出 ClassNotFoundException（比较常用） 实例：Class clazz = Class.forName(String classPath) 4）通过类加载器 ClassLoader cl = this.getclass().getClassLoader(); Class clazz = cl.loadClass("类的全类名");
  • 创建类的对象的方式
    • 方式一：new + 构造器 方式二：要创建Xxx类的对象，可以考虑：Xxx、Xxxs、XxxFactory、XxxBuilder类中查看是否有静态方法的存在。可以调用其静态方法，创建Xxx对象。 方式三：通过反射
  • Class实例可以代表的结构
    • （1）class：外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类 （2）interface：接口 （3）[]：数组 （4）enum：枚举 （5）annotation：注解@interface （6）primitive type：基本数据类型 （7）void 在Java中万事万物皆对象
• 类的加载
  • 加载过程
  • 类的加载器的作用
    • 将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。 类缓存：标准的 JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象
  • 类的加载器的分类
  • 使用Classloader加载src目录下的配置文件
    • • @Test public void test3(){ Properties pros = new Properties(); // //读取配置文件的方式一： // //此时的文件默认在当前的module下。 // FileInputStream fis = null; // try { // fis = new FileInputStream("jdbc1.properties"); // pros.load(fis); // } catch (IOException e) { // e.printStackTrace(); // } finally { // if (fis != null) { // try { // fis.close(); // } catch (IOException e) { // e.printStackTrace(); // } // } // } //读取配置文件的方式二：使用ClassLoader //配置文件默认识别为：当前module的src下 ClassLoader classLoader = ClassLoaderTest.class.getClassLoader(); InputStream is = classLoader.getResourceAsStream("jdbc1.properties"); try { pros.load(is); } catch (IOException e) { e.printStackTrace(); } String user = pros.getProperty("user"); String password = pros.getProperty("password"); System.out.println("user = " + user + " password =" + password); }
• 反射的应用
  • 创建运行时类的对象
    • Class<Person> clazz1 = Person.class;
    • 说明
      • newInstance():调用此方法，创建对应的运行时类的对象。内部调用了运行时类的空参的构造器。 要想此方法正常的创建运行时类的对象，要求： 运行时类必须提供空参的构造器 空参的构造器的访问权限得够。通常，设置为public。 在javabean中要求提供一个public的空参构造器。原因： 便于通过反射，创建运行时类的对象 便于子类继承此运行时类时，默认调用super()时，保证父类此构造器
  • 获取运行时类的完整结构
    • • 实现的全部接口： public Class<?>[] getInterfaces() 确定此对象所表示的类或接口实现的接口。 所继承的父类： public Class<? Super T> getSuperclass() 返回表示此Class所表示的实体（类、接口、基本类型）的父类的Class。 全部的构造器： public Constructor<T>[] getConstructors() 返回此Class对象所表示的类的所有public构造方法。 public Constructor<T>[] getDeclaredConstructors() 返回此Class对象表示的类声明的所有构造方法。 在Constructor类中: 取得修饰符：public int getModifiers(); 取得方法名称： public String getName(); 取得参数的类型： public Class<?> getParameterTypes(); 全部的方法： public Method[] getDeclaredMethods() 返回此Class对象所表示的类或接口的全部方法 public Method[] getMethods() 返回此Class对象所表示的类或接口的public的方法 Method类中： public Class<?> getReturnType()取得全部的返回值 public Class<?>[] getParameterTypes()取得全部的参数 public int getModifiers()取得修饰符 public Class<?> [] getEXceptionTypes()取得异常信息 全部的Field: public Field[] getFields() 返回此Class对象所表示的类或接口的public的Field。 public Field[] getDeclaredFields() 返回此Class对象所表示的类或接口的全部Field Field方法中 public int getModifiers()以整数形式返回此Field的修饰符 public Class<?> getType()得到Field的属性类型 public String getName()返回Field的名称。 Annotation相关 get Annotation(Class<T> annotationClass) getDeclaredAnnotations() 泛型相关 获取父类泛型类型：Type getGenericSuperclass() 泛型类型：ParameterizedType 获取实际的泛型类型参数数组：getActualTypeArguments() 类所在的包 Package getPackage()
  • 调用运行时类的指定结构
    • 调用指定的属性
      • 在反射机制中，可以直接通过Field类操作类中的属性，通过Field类提供的set()和get()方法就可以完成设置和取得属性内容的操作。 public Field getField(String name)返回此Class对象表示的类或接口的指定的public的Field。 public Field getDeclaredField(String name)返回此Class对象表示的类或接口的指定的Field。 在Field中: public Object get(object obj)取得指定对象obj上此 Field的属性内容 public void set(Object obj,Object value)设置指定对象obj上此Field的属性内容
    • 调用指定的方法（常用）
      • • @Test public void testMethod() throws Exception { Class<Person> clazz = Person.class; //创建运行时类的对象 Person person = clazz.newInstance(); /* 1.获取指定的某个方法 getDeclaredMethod():参数1 ：指明获取的方法的名称 参数2：指明获取的方法的形参列表 */ Method show = clazz.getDeclaredMethod("show", String.class); //2.保证当前方法是可访问的 show.setAccessible(true); /* 3. 调用方法的invoke():参数1：方法的调用者 参数2：给方法形参赋值的实参 invoke()的返回值即为对应类中调用的方法的返回值。 */ Object returnValue = show.invoke(person, "CHN"); System.out.println(returnValue); System.out.println("*************如何调用静态方法*****************"); Method showDesc = clazz.getDeclaredMethod("showDesc"); showDesc.setAccessible(true); //如果调用的运行时类中的方法没有返回值，则此invoke()返回null //Object returnVal = showDesc.invoke(null); Object returnVal = showDesc.invoke(Person.class); System.out.println(returnVal); }
    • 调用指定的构造器
      • • @Test public void testConstructor() throws Exception { Class clazz = Person.class; //private Person(String name) /* 1.获取指定的构造器 getDeclaredConstructor():参数：指明构造器的参数列表 */ Constructor constructor = clazz.getDeclaredConstructor(String.class); //2.保证此构造器是可访问的 constructor.setAccessible(true); //3.调用此构造器创建运行时类的对象 Person per = (Person) constructor.newInstance("Tom"); System.out.println(per); }
  • 动态代理
    • 代理模式
      • 使用一个代理将对象（被代理类）包装起来，然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。
    • 静态代理
      • 举例
        • 多线程中的实现Runnable方式就是个静态代理模式
      • 缺点
        • ① 代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。 ② 每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。
    • 动态代理
      • 特点
        • 动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。 相比于静态代理的优点： 抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。
      • 动态代理的实现
        • interface Human{ String belief(); void eat(String str); } //被代理类 class superMan implements Human{ @Override public String belief() { return "我相信我自己"; } @Override public void eat(String str) { } } //问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象。 //（通过Proxy.newProxyInstance()实现） // 问题二：当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a。 //（通过InvocationHandler接口的实现类及其方法invoke()) class ProxyFactory{ //调用此方法，将会返回一个代理类的对象，来解决问题一 public static Object getProxyInstance(Object obj){//创建obj是被代理类的对象 MyInvocationHandler invocationHandler=new MyInvocationHandler(); invocationHandler.bind(obj); //根据括号提示的最后的一个参数引出MyInvocationHandler实现InvocationHandler接口类 return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(), invocationHandler); } } //解决方法二 class MyInvocationHandler implements InvocationHandler{ //创建个被代理类简易规范，添加属性，构造器 private Object obj; public void bind(Object obj){ this.obj=obj; } @Override public Object invoke(Object o, Method method, Object[] objects) throws Throwable { //这里的method方法是和代理类调用的与代理类的同名方法 Object invoke = method.invoke(obj, objects); //invoke()的返回值，返到ProxyFactory类充到invocationHandler值 return invoke; } } public class ProxyTest { public static void main(String[] args) { superMan sup = new superMan(); //Human原型是Object，把他改成Human才能实现目的，不过Object还可以加别的类，这就是动态性 Human proxyInstance = (Human) ProxyFactory.getProxyInstance(sup); String belief = proxyInstance.belief(); System.out.println(belief); proxyInstance.eat("woxihuanchi1huoguo"); }
        • 1 需要解决的两个主要问题： 问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象。 （通过Proxy.newProxyInstance()实现） 问题二：当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a。 （通过InvocationHandler接口的实现类及其方法invoke()) 2 动态代理相关的API： Proxy：专门完成代理的操作类，是所有动态代理类的父类。通过此类为一个或多个接口动态地生成实现类。 提供用于创建动态代理类和动态代理对象的静态方法 static Class<?> getProxyClass(ClassLoader loader, Class<?>...interface) 创建一个动态代理类所对应的Class对象 static Object newProxyInstance(ClassLoader loader, Class<?>...interface, InvocationHandler h) 直接创建一个动态代理对象 3 动态代理实现步骤： 创建一个实现接口 InvocationHandler的类，它必须实现invoke方法，以完成代理的具体操作。 创建被代理类以及接口 通过Proxy的静态方法newProxyInstance(ClassLoader loader, Class<?>...interface, InvocationHandler h)创建一个接口代理 通过代理类的实例调用被代理类的方法
      • 动态代理与AOP
        • 使用 Proxy生成一个动态代理时，往往并不会凭空产生一个动态代理，这样没有太大的意义。通常都是为指定的目标对象生成动态代理。 这种动态代理在AOP中被称为AOP代理，AOP代理可代替目标对象，AOP代理包含了目标对象的全部方法。但AOP代理中的方法与目标对象的方法存在差异： AOP代理里的方法可以在执行目标方法之前、之后插入一些通用处理