Java 反射机制

1.如何创建Class的实例（重点）

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

• Class的一个对象，对应着一个运行时类，相当于一个运行时类本身充当了Class的一个实例。

• java.lang.Class是反射的源头。接下来涉及到反射的类都在java.lang.reflect子包下。如Field  Method  Constructor  Type  Package....

                   当通过Class的实力调用getMethod() - - ->Method，getConstructors() - - ->Constructor

• 实例化Class的方法（三种）

•         //1.调用运行时类本身的.class属性
          Class clazz1 = Person.class;
          System.out.println(clazz1.getName());
          
          Class clazz2 = String.class;
          System.out.println(clazz2.getName());
          
          //2.通过运行时类的对象获取
          Person p = new Person();
          Class clazz3 = p.getClass();
          System.out.println(clazz3.getName());
          
          //3.通过Class的静态方法获取.通过此方式，体会一下，反射的动态性。
          String className = "com.atguigu.java.Person";
          Class clazz4 = Class.forName(className);
  //        clazz4.newInstance();
          System.out.println(clazz4.getName());

2.有了Class实例以后，可以做什么？ 应用一：可以创建对应的运行时类的对象 （重点）

//法一：
        ClassLoader loader = this.getClass().getClassLoader();
        InputStream is = loader.getResourceAsStream("com\\atguigu\\java\\jdbc.properties");
        //法二：
//        FileInputStream is = new FileInputStream(new File("jdbc1.properties"));
        
        Properties pros = new Properties();
        pros.load(is);
        String name = pros.getProperty("user");
        System.out.println(name);
        
        String password = pros.getProperty("password");
        System.out.println(password);

3.有了Class实例以后，可以做什么？应用二：获取对应的运行时类的完整的类的结构：属性、方法、构造器、包、父类、接口、泛型、注解、异常、内部类。

        如：Method[]  m1=classzz.getMethids():获取到对应的运行时类中声明的权限为public的方法（包含其父类的声明的public）

                Method[]  m2=chasszz.getDeclaredMethods():获取到对应的运行时类中声明的所有方法（①任何权限修饰符修饰都能获取 ②不含父类中的）

4.有了Classl实例以后，可以做什么？应用三：调用对应的运行时类中指定的结构（某个指定的属性、方法、构造器）（重点）

• 调用运行时类中指定的属性
  

• @Test
      public void test3() throws Exception{
          Class clazz = Person.class;
          //1.获取指定的属性
          //getField(String fieldName):获取运行时类中声明为public的指定属性名为fieldName的属性
          Field name = clazz.getField("name");
          //2.创建运行时类的对象 
          Person p = (Person)clazz.newInstance();
          System.out.println(p);
          //3.将运行时类的指定的属性赋值
          name.set(p,"Jerry");
          System.out.println(p);
          System.out.println("%"+name.get(p));
          
          System.out.println();
          //getDeclaredField(String fieldName):获取运行时类中指定的名为fieldName的属性
          Field age = clazz.getDeclaredField("age");
          //由于属性权限修饰符的限制，为了保证可以给属性赋值，需要在操作前使得此属性可被操作。
          age.setAccessible(true);
          age.set(p,10);
          System.out.println(p);
          
  //        Field id = clazz.getField("id");
          
      }
      
  }

• 调用运行时类中指定的方法 

•     @Test
      public void test3() throws Exception{
          Class clazz = Person.class;
          //getMethod(String methodName,Class ... params):获取运行时类中声明为public的指定的方法
          Method m1 = clazz.getMethod("show");
          Person p = (Person)clazz.newInstance();
          //调用指定的方法：Object invoke(Object obj,Object ... obj)
          Object returnVal = m1.invoke(p);//我是一个人
          System.out.println(returnVal);//null
          
          Method m2 = clazz.getMethod("toString");
          Object returnVal1 = m2.invoke(p);
          System.out.println(returnVal1);//Person [name=null, age=0]
          //对于运行时类中静态方法的调用
          Method m3 = clazz.getMethod("info");
          m3.invoke(Person.class);
          
          //getDeclaredMethod(String methodName,Class ... params):获取运行时类中声明了的指定的方法
          Method m4 = clazz.getDeclaredMethod("display",String.class,Integer.class);
          m4.setAccessible(true);
          Object value = m4.invoke(p,"CHN",10);//我的国籍是：CHN
          System.out.println(value);//10
      }
  }

• 调用运行中类中指定的构造器：

• @Test
      public void test3() throws Exception{
          String className = "com.atguigu.java.Person";
          Class clazz = Class.forName(className);
          
          Constructor cons = clazz.getDeclaredConstructor(String.class,int.class);
          cons.setAccessible(true);
          Person p = (Person)cons.newInstance("罗伟",20);
          System.out.println(p);
      }
  }

5.动态代理-- - - -反射的应用，体会反射的动态性

代理设计模式的原理：

        使用一个代理将对象包装起来，然后用该代理对象取代原始对象，任何对原始对象的调用都要通过 代理 . 代理对象 决定是否以及何时将方法调用转到原始对象上，

静态代理：

        要求被代理类和代理类同时实现相应的一套接口；通过被代理类的对象调用重写接口的方法时，实际上执行的是被代理类的同样的方法的调用。

动态代理：
        在程序运行时，根据被代理类及其实现的接口，动态的创建一个代理类。当调用代理类的实现的抽象方法时，就发起对被代理类同样的方法的调用。

涉及到的技术点：①提供一个实现了InvocationHandler接口实现类，并重写其invoke（）方法

                           ②Proxy.newInstance(obj.getClass().getClassLoader() , obj.getClass().getInterfaces() , h);

                            注：obj：被代理类对象；h：实现了InvocationHandler接口的实现类的对象

栗子：

package com.atguigu.java1;

import java.lang.reflect.InvocationHandler;
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;// 实现了接口的被代理类的对象的声明

    // ①给被代理的对象实例化②返回一个代理类的对象
    public Object blind(Object obj) {
        this.obj = obj;
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
                .getClass().getInterfaces(), this);
    }
    //当通过代理类的对象发起对被重写的方法的调用时，都会转换为对如下的invoke方法的调用
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        //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.创建一个实现了InvacationHandler接口的类的对象
        MyInvocationHandler handler = new MyInvocationHandler();
        //3.调用blind()方法，动态的返回一个同样实现了real所在类实现的接口Subject的

代理类的对象。
        Object obj = handler.blind(real);
        Subject sub = (Subject)obj;//此时sub就是代理类的对象
        
        sub.action();//转到对InvacationHandler接口的实现类的invoke()方法的调用
        
        //再举一例
        NikeClothFactory nike = new NikeClothFactory();
        ClothFactory proxyCloth = (ClothFactory)handler.blind(nike);//proxyCloth即

为代理类的对象
        proxyCloth.productCloth();
        
        
        
    }
}