Java19：反射

一：反射的理解

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

框架=反射+注解+设计模式

二：体会反射机制的“动态性”

// 创建一个指定类的对象，classpath：指定类的全类名
public  Object getInstance(String classpath) throws Exception {

    Class clazz = Class.forName(classpath);

    return clazz.newInstance();
}

@Test
public void test2()  {
    Random random = new Random();
    String classpath="";
    for (int i = 0; i < 100; i++) {
        int number = random.nextInt(3);
        switch (number) {
            case 0:
                classpath = "java.util.Date";
                break;

            case 1:
                classpath = "java.lang.Object";
                break;
            case 2:

                classpath = "com.cn.test.Person";
                break;

        }

        try {
      Object obj=getInstance(classpath);
            System.out.println(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

三：反射机制能提供的功能

》在运行时判断任意一个对象所属的类

》在运行时构造任意一个类的对象

》在运行时判断任意一个类所具有的成员变量和方法

》在运行时获取泛型信息

》在运行时调用任意一个对象的成员变量和方法

》在运行时处理注解

》生成动态代理

四：相关API

java.lang.Class  :反射的源头

java.lang.reflect.Method

java.lang.reflect.Field

java.lang.reflect.Constructor

五：关于Class类的理解

1.类的加载过程：

程序经过javac.exe命令以后，会生成一个或多个字节码文件(.class结尾)。

接着我们使用java.exe 命令 对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中，在此过程就称为类的加载。加载到内存中的类，我们称为运行时类，此运行时类，就作为Class 的一个实例。

2.换句话说，Class的实例 对应着 一个运行时类。

3.加载到内存中的运行时类会缓存一定的时间，在此时间之内，我们可以通过不同方式来获取此运行时类。

4.获取Class实例的几种方式：

@Test
public void test3() throws ClassNotFoundException {
    //1.调用类.class 属性,获取Class实例
    Class class1= Person.class;
    System.out.println(class1);
    Person p =new Person();
    //2.调用getClass(),获取Class实例
    Class class2= p.getClass();
    System.out.println(class2);
    //3.Class.forName,获取Class实例
    Class class3 = Class.forName("com.cn.test.Person");
    System.out.println(class3);
    //4.调用类的加载器getClassLoader(),获取Class实例
    ClassLoader classLoader = Reflection1Test.class.getClassLoader();
    Class class4= classLoader.loadClass("com.cn.test.Person");
    System.out.println(class4);
    //System.out.println(class1==class2);

5. 总结:创建类的对象的方式

方式一： new + 构造器

方式二：要创建Xxx类的对象，可以考虑：Xxx/Xxxs 类是否有静态方法存在，可以调用其静态方法，创建Xxx对象。

方式三：通过反射

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

1）class：外部类，成员（成员内部类，静态内部类）局部内部类，匿名内部类

2）interface:接口

3) []:数组

4）enum：枚举

5）annotation:注解@interface

6)primitive type:基本数据类型

7）void

7.类的加载器，加载配置文件

@Test
public void test3() throws IOException {
    //方式一
    Properties pro =new Properties();
    FileInputStream fis =new FileInputStream("jdbc.propertities");
    pro.load(fis);
    String name = pro.getProperty("name");
    String age = pro.getProperty("age");
    System.out.println(name+":"+age);


}
@Test
public void test4() throws IOException {
  //方式二，该方式文件放在src目录下
    ClassLoader classLoader = Reflection2Test.class.getClassLoader();
    InputStream resourceAsStream = classLoader.getResourceAsStream("jdbc2.propertities");
    Properties pro =new Properties();
    pro.load(resourceAsStream);
    String name = pro.getProperty("name");
    String age = pro.getProperty("age");
    System.out.println(name+":"+age);

}

六：反射的实例

1.获取所有的属性，方法，构造器

@Test
public void test2() {

    Class clazz = Person.class;
    //获取运行时类及其所有父类的public方法
    Method[] methods = clazz.getMethods();
    for (Method m : methods) {
        System.out.print(m + "\t");
        System.out.println(m.getName());
    }

    System.out.println();
    //获取运行时类所有方法
    Method[] declaredMethods = clazz.getDeclaredMethods();
    for (Method m : declaredMethods) {
        System.out.print(m + "\t");
        System.out.println(m.getName());
    }


}

@Test
public void test3() {

    Class clazz = Person.class;
    //获取运行时类所有public的构造器
    Constructor[] constructors = clazz.getConstructors();
    for(Constructor c:constructors){
        System.out.println(c);
    }
    System.out.println();
    //获取运行时类所有构造器
    Constructor[] constructors2 = clazz.getDeclaredConstructors();
    for(Constructor c:constructors2){
        System.out.println(c);
    }

}
@Test
public void test4() throws Exception {
    //获取当前运行时类父类的对象
    Class superclass = Person.class.getSuperclass();
    System.out.println(superclass);

}

2.获取指定的属性，方法，构造器

@Test
public  void filedTest() throws Exception {
    Class clazz=Person.class;
    Object obj = clazz.newInstance();
     Person per= (Person) obj;
     //获取指定属性
    Field name = clazz.getDeclaredField("name");
    //给指定对象属性复制
    name.set(per,"tom");
    System.out.println(name.get(per));
    //给静态属性赋值，并获取
    Field hobbies = clazz.getDeclaredField("hobbies");
    hobbies.set(clazz,"baskball");
    System.out.println(hobbies.get(clazz));
}


@Test
public  void methodTest() throws Exception {

    Class clazz=Person.class;
    Object obj = clazz.newInstance();
    Person per= (Person) obj;
    //获取public 无参方法 并调用
    Method info = clazz.getDeclaredMethod("info");
    info.invoke(per);
    //获取public 有参方法 并调用
    Method getNation = clazz.getDeclaredMethod("getNation",String.class);
    getNation.invoke(per,"china");
    //获取静态方法并调用
    Method study = clazz.getDeclaredMethod("study");
    study.invoke(clazz);
    //获取私有方法并调用
    Method getAge = clazz.getDeclaredMethod("getAge", int.class);
    //设置为可访问
    getAge.setAccessible(true);
    System.out.println(getAge.invoke(per, 20));


}

@Test
public  void ConstructTest() throws Exception {
   Class clazz= Person.class;
   //该方法为常用用法，具有通用性
    Object o = clazz.newInstance();
    System.out.println(o);
    //获取带有参数的构造器，不常用
    Constructor constructor = clazz.getDeclaredConstructor(int.class, String.class);
    constructor.setAccessible(true);
    Object jerry = constructor.newInstance(15, "jerry");
    System.out.println(jerry);


}

七：反射的应用：动态代理

1.静态代理：

interface ColthFactory{
   void  produceColth();
}
//代理类
class ProxyColthFactory implements ColthFactory{
    private ColthFactory factory;

    public ProxyColthFactory(ColthFactory factory){
        this.factory=factory;
    }

    @Override
    public void produceColth() {
        System.out.println("生产衣服之前的准备工作");
        factory.produceColth();
        System.out.println("生产衣服之后的收尾工作");

    }
}
//被代理类
class NIkeColthFactory implements  ColthFactory{

    @Override
    public void produceColth() {
        System.out.println("NIKE生产衣服");
    }
}

public class StaticProxyTest {
    public static void main(String[] args) {
        //创建被代理类对象
        NIkeColthFactory nike =new NIkeColthFactory();
        //创建代理类对象
        ProxyColthFactory proxy =new ProxyColthFactory(nike);
        //调用方法
        proxy.produceColth();
    }
}

2.动态代理：

class ProxyFactory{

    public static Object getInstance(Object obj){
        MyInvocationHandler hander= new MyInvocationHandler();
        hander.blind(obj);
        return  Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), hander);

    }
}

class MyInvocationHandler implements InvocationHandler{
    private Object obj; //赋值时必须传被代理类实例
    public void blind(Object obj){
        this.obj=obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object invoke = method.invoke(obj, args);// method为代理类调用的方法，此方法也作为被代理类对象要调用的方法
        return invoke;
    }
}

public class ProxyTest {
    public static void main(String[] args) {
        NIkeColthFactory nike = new NIkeColthFactory();
        ColthFactory  colthFactory= (ColthFactory) ProxyFactory.getInstance(nike);
        colthFactory.produceColth();

    }
}