JavaSE 笔记【十四】反射

最新推荐文章于 2023-09-11 23:36:31 发布

geyiwei-suzhou

最新推荐文章于 2023-09-11 23:36:31 发布

阅读量100

点赞数

分类专栏： Java 文章标签： java java 8 java se 反射 reflect

本文链接：https://blog.csdn.net/REX1129/article/details/116020011

版权

Java 专栏收录该内容

23 篇文章 1 订阅

订阅专栏

视频链接：Java零基础教程

反射机制概述

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

加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。

正常方式：引入需要的“包类”名称 --> 通过new实例化 --> 取得实例化对象
反射方式：实例化对象 --> getClass()方法 --> 得到完整的“包类”名称

补充：动态语言 vs 静态语言

动态语言
是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。
主要动态语言：Object-C、C#、JavaScript、PHP、Python、Erlang
静态语言
与静态语言相比，运行时结构不变的语言就是静态语言。如Java、C、C++。

Java不是动态语言，但Java可以称为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。
Java的动态性让编程的时候更加灵活。

Java反射机制提供的功能：

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

反射相关的主要API：

java.lang.Class：代表一个类
java.lang.reflect.Method：代表类的方法
java.lang.reflect.Filed：代表类的成员变量
java.lang.reflect.Constructor：代表类的构造器
… …

调用类的私有结构

Person.java：

public class Person {

    private String name;
    public int age;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    private Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void show() {
        System.out.println("你好，我是一个人");
    }

    private String showNation(String nation) {
        System.out.println("我的国籍是：" + nation);
        return nation;
    }
}

反射的使用：

// 反射之前，对于Person的操作
@Test
public void test1() {
    // 1. 创建Person类的对象
    Person p1 = new Person("Tom", 12);

    // 2. 通过对象，调用其内部的属性、方法
    p1.age = 10;
    System.out.println(p1.toString());

    p1.show();

    // 在Person类外部，不可以通过Person类的对象调用其内部私有结构
    // 比如：name、showNation() 以及私有构造器
}

// 反射之后，对于Person的操作
@Test
public void test2() throws Exception {
    Class clazz = Person.class;
    // 1. 通过反射，创建Person类的对象
    Constructor cons = clazz.getConstructor(String.class, int.class);
    Object obj = cons.newInstance("Tom", 12);
    Person p = (Person) obj;
    System.out.println(obj);
    System.out.println(p);
    // 2. 通过反射，调用对象指定的属性、方法
    // 调用属性
    Field age = clazz.getDeclaredField("age");
    age.set(p, 10);
    System.out.println(p);
    // 调用方法
    Method show = clazz.getDeclaredMethod("show");
    show.invoke(p);

    // 通过反射，可以调用Person类的私有结构的。比如：私有的构造器、方法、属性

    // 调用私有的构造器
    Constructor cons1 = clazz.getDeclaredConstructor(String.class);
    cons1.setAccessible(true);
    Person p1 = (Person) cons1.newInstance("Jerry");
    System.out.println(p1);

    // 调用私有的属性
    Field name = clazz.getDeclaredField("name");
    name.setAccessible(true);
    name.set(p1, "HanMeiMei");
    System.out.println(p1);

    // 调用私有的方法
    Method showNation = clazz.getDeclaredMethod("showNation", String.class);
    showNation.setAccessible(true);
    String nation = (String) showNation.invoke(p1, "中国"); // 相当于String nation = p1.showNation("")
    System.out.println(nation);
}

疑问：通过直接new的方式或反射的方式都可以调用公共的结构，开发中到底用哪个？建议：直接new的方式。什么时候会使用反射的方式？反射的特征：动态性
疑问：反射机制与面向对象中的封装性是不是矛盾的？如何看待这两个技术？不矛盾。

Class的理解

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

获取Class的实例的方式（前三种方式需要掌握）：

// 方式一：调用运行时类的属性：.class
Class clazz1 = Person.class;
System.out.println(clazz1);
// 方式二：通过运行时类的对象
Person p1 = new Person();
Class clazz2 = p1.getClass();
System.out.println(clazz2);
// 方式三：调用Class的静态方法：forName(String classPath)
Class clazz3 = Class.forName("com.antherd.java.Person");
System.out.println(clazz3);
System.out.println(clazz1 == clazz2); // true
// 方式四：使用类的加载器：ClassLoader（了解）
ClassLoader classLoader = ReflectionTest.class.getClassLoader();
Class clazz4 = classLoader.loadClass("com.antherd.java.Person");
System.out.println(clazz1 == clazz4);

哪些类型可以有Class对象

class：外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类
interface：接口
[]：数组
enum：枚举
annotation：注解@interface
primitive type：基本数据类型
void

@Test
public void test() {
    Class c1 = Object.class;
    Class c2 = Comparable.class;
    Class c3 = String[].class;
    Class c4 = int[][].class;
    Class c5 = ElementType.class;
    Class c6 = Override.class;
    Class c7 = int.class;
    Class c8 = void.class;
    Class c9 = Class.class;
    
    int[] a = new int[10];
    int[] b = new int[101];
    Class c10 = a.getClass();
    Class c11 = b.getClass();
    // 只要数组的元素类型与维度一样，就是同一个Class
    System.out.println(c10 == c11);
}

类的加载过程（了解）

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化
类的加载过程

加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口（即引用地址）。所有需要访问和使用类数据只能通过这个Class对象。这个加载的过程需要类加载器参与
链接：将Java类的二进制代码合并到JVM的运行状态中的过程
- 验证：确保加载的类信息符合JVM规范，例如：以cafe开头，没有安全方面的问题
- 准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配
- 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程
初始化
- 执行类构造器< clinit>() 方法的过程。类构造器< clint>()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。
- 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化
- 虚拟机会保证一个类的< cinit>()方法在多线程中被正确加锁和同步

ClassLoader
类加载器的作用：

类加载器的作用：将class字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口
类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象

类加载器作用是用来把类（class）装载进内存的。JVM规范定义了如下类型的类加载器：

@Test
public void classloaderTest() {
    // 对于自定义类，使用系统类加载器进行加载
    ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
    System.out.println(classLoader); // sun.misc.Launcher$AppClassLoader

    // 调用系统类加载器的getParent()：获取拓展类加载器
    ClassLoader classLoader1 = classLoader.getParent();
    System.out.println(classLoader1); // sun.misc.Launcher$ExtClassLoader

    // 调用拓展类加载器的getParent()：无法获取引导类加载器
    // 引导类加载器主要负责加载java的核心类库，无法加载自定义类的
    ClassLoader classLoader2 = classLoader1.getParent();
    System.out.println(classLoader2); // null

    ClassLoader classLoader3 = String.class.getClassLoader();
    System.out.println(classLoader3); // null
}

@Test
public void classloaderTest2() throws IOException {
    Properties pros = new Properties();
    // 读取配置文件的方式一
    // 此时的文件默认在当前的module下
    FileInputStream fis = new FileInputStream("jdbc.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);
}

创建运行时类的对象

@Test
public void test1() throws IllegalAccessException, InstantiationException {
    Class<Person> clazz = Person.class;
    // newInstance() 调用此方法，创建对应的运行时类的对象。内部调用了运行时类的空参的构造器
    // 想要此方法正常的创建运行时类的对象，要求：
    // 1. 运行时类必须提供空参的构造器
    // 2. 空参的构造器的访问权限得够。通常设置为public
    Person obj = clazz.newInstance();
    System.out.println(obj);

    // 在java bean中要求提供一个public的空参构造器。原因：
    // 1. 便于通过反射，创建运行时类的对象
    // 2. 便于子类继承运行时类时，通过调用super()时，保证父类有次构造器
}

获取运行时类的完整结构

Creature.java

import java.io.Serializable;

public class Creature<T> implements Serializable {

    private char gender;
    public double weight;

    private void breath() {
        System.out.println("生物呼吸");
    }
    public void eat() {
        System.out.println("生物吃东西");
    }
}

MyAnnotation.java

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.ElementType.LOCAL_VARIABLE;

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value() default "hello";
}

Person.java

@MyAnnotation(value = "hi")
public class Person extends Creature<String> implements Comparable<String>, MyInterface {

    private String name;
    int age;
    public int id;

    public Person() {}

    @MyAnnotation(value = "abc")
    private Person(String name) {
        this.name = name;
    }

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @MyAnnotation
    private String show(String nation) {
        System.out.println("我的国籍是：" + nation);
        return nation;
    }

    public String display(String interests, int age) throws NullPointerException, ClassCastException {
        return interests + age;
    }

    @Override
    public void info() {
        System.out.println("我是一个人");
    }

    @Override
    public int compareTo(String o) {
        return 0;
    }
    
    private static void showDesc() {
        System.out.println("我是一个可爱的人");
    }
    
	@Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id=" + id +
                '}';
    }
}

获取运行时类的属性结构及其内部结构

@Test
public void test1() {
    Class clazz = Person.class;
    // 获取属性结构
    // getField()：获取当前运行时类及其父类中声明为public访问权限的属性
    Field[] fields = clazz.getFields();
    for (Field field: fields) {
        System.out.println(field);
    }
    System.out.println();

    // getDeclaredFields()：获取当前运行时类中声明的所有属性。（不包含父类中声明的属性）
    Field[] declaredFields = clazz.getDeclaredFields();
    for (Field field: declaredFields) {
        System.out.println(field);
    }
}

@Test
public void test2() {
    Class clazz = Person.class;
    Field[] declaredFields = clazz.getDeclaredFields();
    for (Field field: declaredFields) {
        // 1. 权限修饰符
        int modifier = field.getModifiers();
        System.out.print(Modifier.toString(modifier) + " ");
        // 2. 数据类型
        Class type = field.getType();
        System.out.print(type.getName() + " ");
        // 3. 变量名
        String name = field.getName();
        System.out.print(name);

        System.out.println();
    }
}

获取运行时类的方法

@Test
public void test1() {
    Class clazz = Person.class;
    // getMethods()：获取运行时类及其所有父类中声明为public权限的方法
    Method[] methods = clazz.getMethods();
    for (Method method : methods) {
        System.out.println(method);
    }

    // getDeclaredMethods()：获取当前运行时类中声明的所有方法。（不包含父类中声明的方法）
    Method[] declaredMethods = clazz.getDeclaredMethods();
    for (Method m : declaredMethods) {
        System.out.println(m);
    }
}

获取运行时类的方法的内部结构

@Test
public void test2() {
    Class clazz = Person.class;
    Method[] declaredMethods = clazz.getDeclaredMethods();
    for (Method m : declaredMethods) {
        // 1. 获取方法声明的注解
        Annotation[] annos = m.getDeclaredAnnotations();
        for (Annotation a : annos) {
            System.out.println(a);
        }

        // 2. 权限修饰符
        System.out.print(Modifier.toString(m.getModifiers()) + " ");

        // 3. 返回值类型
        System.out.print(m.getReturnType().getName() + " ");

        // 4. 方法名
        System.out.print(m.getName());
        System.out.print("(");

        // 5. 形参列表
        Class[] parameterTypes = m.getParameterTypes();
        if (!(parameterTypes == null || parameterTypes.length == 0)) {
            for (int i = 0; i < parameterTypes.length; i++) {
                if (i == parameterTypes.length - 1) {
                    System.out.print(parameterTypes[i].getName() + " args_" + i);
                    break;
                }
                System.out.print(parameterTypes[i].getName() + " args_" + i + ", ");
            }
        }
        System.out.print(") ");

        // 6. 抛出的异常
        Class[] exceptionTypes = m.getExceptionTypes();
        if (exceptionTypes.length > 0) {
            System.out.print("throws ");
            for (int i = 0; i < exceptionTypes.length; i++) {
                if (i == exceptionTypes.length - 1) {
                    System.out.println(exceptionTypes[i].getName());
                    break;
                }
                System.out.println(exceptionTypes[i].getName() + ", ");
            }
        }
        System.out.println();
    }
}

获取运行时类的构造器结构

@Test
public void test1() {
    Class clazz = Person.class;
    // getConstructors()：获取当前运行时类中声明为public的构造器
    Constructor[] constructors = clazz.getConstructors();
    for (Constructor c : constructors) {
        System.out.println(c);
    }
    System.out.println();
    // getDeclaredConstructors()：获取当前运行时类中声明的所有的构造器
    Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
    for (Constructor c : declaredConstructors) {
        System.out.println(c);
    }
}

获取运行时类的父类及父类的泛型

@Test
public void test2() {
    Class clazz = Person.class;

    Class superclass = clazz.getSuperclass();
    System.out.println(superclass);
}

@Test
public void test3() {
    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].getTypeName().getClass());
}

获取运行时类实现的接口、所在包、注解等

@Test
public void test5() {
    Class clazz = Person.class;
    // 获取运行时类实现的接口
    Class[] interfaces = clazz.getInterfaces();
    for (Class c : interfaces) {
        System.out.println(c);
    }
    // 获取运行时类的父类实现的接口
    Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
    for (Class c : interfaces1) {
        System.out.println(c);
    }
    // 获取运行时类所在的包
    Package pack = clazz.getPackage();
    System.out.println(pack);

    // 获取运行时类声明的注解
    Annotation[] annotations = clazz.getAnnotations();
    for (Annotation annos : annotations) {
        System.out.println(annos);
    }
}

调用运行时类的指定结构

/**
 * 不需要掌握
 * @throws Exception
 */
@Test
public void testFiled() throws Exception {
    Class clazz = Person.class;
    // 获取指定的属性：要求运行时类中的属性声明为public
    // 通常不采用此方法
    Field id = clazz.getField("id");

    Person p = (Person) clazz.newInstance();
    // 设置当前属性的值
    // set()：参数1：指明设置哪个对象的属性 参数2：将此属性值设置为多少
    id.set(p, 1001);
    // 获取当前属性的值
    // get()：参数1：获取哪个对象的当前属性值
    int pid = (int) id.get(p);
    System.out.println(pid);
}

/**
 * 如何操作运行时类中的指定属性 -- 需要掌握
 * @throws Exception
 */
@Test
public void testFiled1() 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));
}

调用运行时类的指定方法

/**
 * 如何操作运行时类中的指定方法 -- 需要掌握
 * @throws Exception
 */
@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 obj = show.invoke(p, "CHN"); // String nation = p.show();
    System.out.println(obj);

    System.out.println("******************如何调用静态方法******************");
    // private static void showDesc()
    Method showDesc = clazz.getDeclaredMethod("showDesc");
    showDesc.setAccessible(true);
    // 如果调用的运行时类中的方法没有返回值，则此invoke()返回null
    // Object invoke = showDesc.invoke(Person.class);
    Object invoke = showDesc.invoke(null);
    System.out.println(invoke); // null
}

调用运行时类的指定构造器

/**
* 如何操作运行时类中的构造器
 * @throws Exception
 */
@Test
public void testConstructor() throws Exception {
    Class clazz = Person.class;

    // private Person(String name)
    // 1. 获取指定的构造器
    // getConstructor()：参数：指明构造器的参数列表
    Constructor constructor = clazz.getConstructor(String.class);
    // 2. 保证此构造器是可访问的
    constructor.setAccessible(true);
    // 3. 调用此构造器创建运行时类的对象
    Person per = (Person) constructor.newInstance("Tom");
    System.out.println(per);
}

反射的应用：动态代理

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

之前为大家讲解过代理机制的操作，属于静态代理，特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的拓展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。最好可以通过一个代理类完成全部的代理功能

动态代理是指客户通过代理类来调用其他对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象

动态代理使用场合：

调试
远程方法调用

动态代理相比于静态代理的优点：

抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法

静态代理举例

package com.antherd.java8;

/**
 * 静态代理举例
 * 特点：代理类和被代理类在编译期间，就确定下来了
 */
interface ClothFactory {
    void produceCloth();
}

// 代理类
class ProxyClothFactory implements ClothFactory {

    private ClothFactory factory; // 用被代理类对象进行实例化

    public ProxyClothFactory(ClothFactory factory) {
        this.factory = factory;
    }

    @Override
    public void produceCloth() {
        System.out.println("代理工厂做一些准备工作");
        factory.produceCloth();
        System.out.println("代理工厂做一些后续的收尾工作");
    }
}

// 被代理类
class NikeClothFactory implements ClothFactory {

    @Override
    public void produceCloth() {
        System.out.println("Nike工厂生产一批运动服");
    }
}

public class StaticProxyTest {
    public static void main(String[] args) {
        // 创建被代理类对象
        ClothFactory nike = new NikeClothFactory();
        // 创建代理类对象
        ClothFactory proxyClothFactory = new ProxyClothFactory(nike);

        proxyClothFactory.produceCloth();
    }
}

动态代理举例

package com.antherd.java8;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 动态代理举例
 */
interface Human {
    String getBelief();

    void eat(String food);
}

// 被代理类
class SuperMan implements Human {

    @Override
    public String getBelief() {
        return "I believe I can fly!";
    }

    @Override
    public void eat(String food) {
        System.out.println("我喜欢吃" + food);
    }
}

/**
 * 想要实现动态代理，需要解决的问题
 * 问题一：如果根据加载到内存中的被代理类，动态的创建一个代理类及其对象
 * 问题二：当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a
 */
class ProxyFactory {
    // 调用此方法，返回一个代理类的对象。解决问题一
    public static Object getProxyInstance(Object obj) { // obj:被代理类对象
        MyInvocationHandler handler = new MyInvocationHandler();
        handler.bind(obj);
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handler); // 返回代理类对象
    }
}

class MyInvocationHandler implements InvocationHandler {

    private Object obj; // 需要使用被代理类的对象进行赋值

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

    // 当我们通过代理类的对象，调用方法a时，就会自动的调用如下的方法：invoke()
    // 将被代理类要执行的方法a的功能就声明在invoke() 中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // method：即为代理类对象调用的方法，此方法也就作为了被代理类调用的方法
        // obj：被代理类的对象
        Object returnValue = method.invoke(obj, args);
        // 上述方法的返回值就作为当前类中的invoke()的返回值
        return returnValue;
    }
}


public class ProxyTest {

    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();
        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
        // 当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
        String belief = proxyInstance.getBelief();
        System.out.println(belief);
        proxyInstance.eat("四川麻辣烫");

        System.out.println("***************************************");
        NikeClothFactory nikeClothFactory = new NikeClothFactory();
        ClothFactory proxyClothFactory = (ClothFactory) ProxyFactory.getProxyInstance(nikeClothFactory);
        proxyClothFactory.produceCloth();
    }
}

动态代理与AOP（Aspect Orient Programming）

前面介绍的Proxy和InvocationHandler，很难看出这种动态代理的优势，下面介绍一种更实用的动态代理机制
AOP

class HumanUtil {
    public void method1() {
        System.out.println("------------------通用方法一------------------");
    }
    public void method2() {
        System.out.println("------------------通用方法二------------------");
    }
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    HumanUtil util = new HumanUtil();
    util.method1();
    // method：即为代理类对象调用的方法，此方法也就作为了被代理类调用的方法
    // obj：被代理类的对象
    Object returnValue = method.invoke(obj, args);
    // 上述方法的返回值就作为当前类中的invoke()的返回值
    util.method2();
    return returnValue;
}

geyiwei-suzhou

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
JavaSE 笔记【十四】反射

视频链接：Java零基础教程反射机制概述Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。正常方式：引入需要的“包类”名称 -->.
复制链接

扫一扫