反射

反射的概述

反射的理解：Reflection(反射)是被视为动态语言的关键,反射机制允许程序在执行期借助于Reflection API取得任何对象的内部属性及方法(框架 = 反射 + 注解 + 设计模式)

反射机制的动态性的体现

@Test
public void test2(){
    for(int i = 0;i < 100;i++){
        int num = new Random().nextInt(3);//0,1,2
        String classPath = "";
        switch(num){
            case 0:
                classPath = "java.util.Date";
                break;
            case 1:
                classPath = "java.lang.Object";
                break;
            case 2:
                classPath = "com.atguigu.java.Person";
                break;
        }
        try {
            Object obj = getInstance(classPath);
            System.out.println(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

反射机制能提供的功能：

1. 在运行时判断任意一个对象所属的类
2. 在运行时构造任意一个类的对象
3. 在运行时判断任意一个类所具有的成员变量和方法
4. 在运行时获取泛型信息
5. 在运行时调用任意一个对象的成员变量和方法
6. 在运行时处理注解
7. 生成动态代理

Class类的理解与获取Class的实例

Class类的理解

1. 程序经过 javac.exe 命令以后，会生成一个或多个字节码文件(.class结尾)。接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程就称为类的加载。加载到内存中的类，我们就称为运行时类，次运行时类，就作为Class的一个实例
2. Class的实例就对应着一个运行时类
3. 加载到内存中的运行时类，会缓存一定的时间。在此时间之内，我们可以通过不同的方式来获取此运行时类。

获取Class实例的几种方式：

1. 调用运行时类的属性：Class clazz1 = Person.class;
2. 通过运行时类的对象，调用getClass()：

     Person p1 = new Person();
     Class clazz2 = p1.getClass();
   

3. 调用Class的静态方法：forName(String classPath)： Class clazz3 = Class.forName("com.java.Person");
4. 使用类的加载器：ClassLoader

    ClassLoader classLoader = ReflectionTest.class.getClassLoader();
    Class clazz4 = classLoader.loadClass("com.java.Person");
   

Class实例可以是哪些结构的说明

1. class：外部类，成员（成员内部类、静态内部类），局部内部类，匿名内部类
2. interface：接口
3. []:数组
4. enum：枚举
5. annotation：注解@interface
6. primitive type：基本数据类型
7. void

使用Classloader加载src目录下的配置文件

public void test2() throws Exception {
    Properties pros =  new Properties();
    //此时的文件默认在当前的module下。
    //读取配置文件的方式一：
    //FileInputStream fis = new FileInputStream("jdbc.properties");
    //FileInputStream fis = new FileInputStream("src\jdbc1.properties"); 
   //pros.load(fis);
    //读取配置文件的方式二：使用ClassLoader
    //配置文件默认识别为：当前module的src下
    ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
    InputStream is = classLoader.getResourceAsStream("jdbc1.properties");
    pros.load(is);
    String user = pros.getProperty("user");
    String password = pros.getProperty("password");
    System.out.println("user = " + user + ",password = " + password);
    }
}

创建运行时类的对象

说明：

1. newInstance():调用此方法，创建对应的运行时类的对象。内部调用了运行时类的空参的构造器。
2. 想要此方法正常的创建运行时类的对象的要求：
   运行时类必须提供空参的构造器
   空参的构造器的访问权限得够。通常设置为 public
3. 在 javaBean 中要求提供一个 public 的空参构造器的原因：
   便于通过反射创建运行时类的对象
   便于子类继承此运行时类时，默认调用 super() 时，保证父类有此构造器

Class<Person> clazz = Person.class;
Person obj = clazz.newInstance();
System.out.println(obj);

获取运行时类的指定结构

//获取运行时类的带泛型的父类的泛型
@Test
public void test4(){
    Class clazz = Person.class;
    Type genericSuperclass = clazz.getGenericSuperclass();
    ParameterizedType paramType = (ParameterizedType) genericSuperclass;
    //获取泛型类型
    Type[] actualTypeArguments = paramType.getActualTypeArguments();
    //System.out.println(actualTypeArguments[0].getTypeName());
    System.out.println(((Class)actualTypeArguments[0]).getName());
}

//如何操作运行时类中的指定的属性 
@Test
public void testField1() throws Exception {
    Class clazz = Person.class;
    //创建运行时类的对象
    Person p = (Person) clazz.newInstance();
    //1. getDeclaredField(String fieldName):获取运行时类中指定变量名的属性
    Field name = clazz.getDeclaredField("name");
    //2.保证当前属性是可访问的
    name.setAccessible(true);
    //3.获取、设置指定对象的此属性值
    name.set(p,"Tom");
    System.out.println(name.get(p));
}

//如何操作运行时类中的指定的方法
@Test
public void testMethod() throws Exception {
    Class clazz = Person.class;
    //创建运行时类的对象
    Person p = (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(p,"CHN"); //String nation = p.show("CHN");
    System.out.println(returnValue);
    System.out.println("*************如何调用静态方法*****************");
    // private static void showDesc()
    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);//null
}

//如何调用运行时类中的指定的构造器
@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);
}

动态代理

interface Human{
    String run();
    void eat();
}
//被代理类
class SuperMan implements Human{
    @Override
    public String run() {
        return "我想跑步";
    }
    @Override
    public void eat() {
        System.out.println("我想吃饭了");
    }
}
class ProxyInstance{
    public static Object getInstance(Object obj){//被代理类的对象
        MyInvocationHandler handler = new MyInvocationHandler();
        handler.bind(obj);
        
        Object instance = Proxy.newProxyInstance(obj.getClass().getClassLoader(),
        	obj.getClass().getInterfaces(),handler);
        	
        return instance;
    }
}
class MyInvocationHandler implements InvocationHandler {

    //被代理对象
    private Object obj;

    public void bind(Object obj){
        this.obj = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        Object returnValue = method.invoke(obj, args);

        return returnValue;
    }
}
//测试类
public class ProxyTest {
    public static void main(String[] args) {
        Human superMan = new SuperMan();
        Human proxyInstance= (Human) ProxyInstance.getInstance(superMan);
        proxyInstance.eat();
    }
}