java基础----反射

1.如何创建Class的实例（每个Class实例都对应一个运行时类）

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

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

  1.3 java.lang.Class是反射的源头。接下来涉及到反射的类都在java.lang.reflect子包下。如：Field Method Constructor Type                 Pacakge...当通过Class的实例调用getMethods()--->Method, getConstructors--->Constructor

  1.4 实例化Class的方法（三种）：

         //1.调用运行时类本身的.class属性
       Class clazz1 = Person.class;
  
       //2.通过运行时类的对象，调用其getClass()方法
       Person p = new Person();
       Class clazz3 = p.getClass();
       
       //3.通过Class的静态方法forName（String className）
       String className = "TestReflact.Person";
       Class clazz4 = Class.forName(className);
       
       //4. 通过类的加载器
       ClassLoader classloader = this.getClass().getClassLoader();
       Class clazz5 = classloader.loadClass(className);

2.有了Class实例后：应用一：可以创建对应的运行时类的对象；

    //获取运行时类的对象：方法一
    @Test
    public void test1() throws Exception {
        Class clazz1 = Class.forName("ReviewReflect.Animal");
        Object obj = clazz1.getDeclaredConstructor().newInstance();
        Animal a = (Animal)obj;
        System.out.println(a);
        
    }
    //调用指定的构造器创建运行时类的对象
        @Test
        public void test2() throws Exception{
            Class clazz = Animal.class;
            Constructor cons = clazz.getDeclaredConstructor(String.class,int.class);
            cons.setAccessible(true);
            Animal a = (Animal)cons.newInstance("花花",20);
            System.out.println(a);
        }

 

应用二：获取对应的运行时类的完整的类的结构（属性、方法、构造器、包、接口、注解、异常、泛型、父类等）；

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

       Method[] m2=clazz.getDeclaredMethods():获取到对应的运行时类中所有声明的方法（任何权限都有、不包含父类中的方法）

应用三：可以调用对应的运行时类中指定的结构（某个指定的属性、方法、构造器）；

//调用指定的属性
        @Test
        public void test3() throws Exception {
            Class clazz1 = Class.forName("ReviewReflect.Animal");
            Object obj = clazz1.getDeclaredConstructor().newInstance();//默认构造器
            Animal a = (Animal)obj;//创建了运行时类的对象
            
            //调用非public的属性
            Field field = clazz1.getDeclaredField("name");
            field.setAccessible(true);
            field.set(a, "Jerry");
            System.out.println(a);
            
            //调用public的属性
            Field field2 = clazz1.getDeclaredField("age");
            field2.set(a, 9);
            System.out.println(a);
            
            //调用静态的属性
            Field field3 = clazz1.getDeclaredField("desc");
            System.out.println(field3.get(Animal.class));
    
        }

    //调用指定的方法
        @Test
        public void test4() throws Exception {
            Class clazz1 = Class.forName("ReviewReflect.Animal");
            Object obj = clazz1.getDeclaredConstructor().newInstance();//默认构造器
            Animal a = (Animal)obj;//创建了运行时类的对象
            
            //调用非public的方法
            Method m1 = clazz1.getDeclaredMethod("getAge");
            m1.setAccessible(true);
            int age = (Integer)m1.invoke(a);
            System.out.println(age);
            //调用public的方法
            
            Method m2 = clazz1.getMethod("show", String.class);
            Object returnVal = m2.invoke(a, "花花");
            System.out.println(returnVal);
            
            //调用静态的方法
            Method m3 = clazz1.getDeclaredMethod("info");
            m3.setAccessible(true);
            m3.invoke(Animal.class);            
            
        }
        

应用四：动态代理。

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

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

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

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

                            proxy.newInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),h)；//obj是被代理类的对象, h是实现了InvocationHandler接口的实现类的对象。

动态代理与AOP