Java 反射、代理

- 日理万妓 2023-02-14 13:10 31阅读 0赞

### 目录 ###

*   *   *  反射（reflect）
         *   *  获取class对象的三种方式
             *  使用反射创建对象
             *  使用反射操作字段
             *  使用反射调用方法
             *  使用反射动态创建、操作数组
         *  代理（proxy）
         *   *  静态代理
             *  jdk动态代理
             *  cglib动态代理
             *  静态代理、动态代理的区别
             *  jdk动态代理、cglib代理的区别
             *  代理与目标类的关系
             *  使用建议

### 反射（reflect） ###

反射：通过类的class对象来获取类的信息，动态操作类中的字段、调用类中的方法。

#### 获取class对象的三种方式 ####

// Class.forName("全限定类名")，类名是String形式，编译时并不知道Class对象的泛型，所以是？，需要强转
    Class<?> class1 = Class.forName("com.chy.mall.model.User");
    Class<User> class2 = (Class<User>)class1;
    
    
    //类名.class
    Class<User> class3=User.class;
    
    
    //对象名.getClass()
    Class<? extends User> class4=user.getClass();

#### 使用反射创建对象 ####

反射是通过类的Class对象调用构造方法创建实例

//类的Class对象
    Class<User> userClass = User.class;
    
    
    //可以直接通过Class对象的 newInstance() 方法创建实例：实质是调用无参构造器
    User user = userClass.newInstance();
    
    
    //也可以通过Class对象获取要使用的构造器 Constructor，调用构造器的 newInstance() 方法创建实例，这种方式可以调用任意构造器
    //获取要使用的构造器，参数指定形参表的各个参数类型
    Constructor<User> constructor = userClass.getConstructor(Integer.class, String.class, Integer.class);
    //调用构造方法创建实例，传入对应的实参
    User user = constructor.newInstance(1, "chy", 20);

#### 使用反射操作字段 ####

反射可以操作各种访问权限的成员字段、成员方法，但这也破坏了类的封装性

private成员不允许在类外操作，需要取消权限检查才能操作private成员；public成员默认不检查权限。

Class<User> userClass = User.class;
    
    //获取私有字段
    Field nameField = userClass.getDeclaredField("name");  
    //取消权限检查
    nameField.setAccessible(true);   
    
    User user = new User(1, "zhangsan", 20);
    
    //调用方法，传入实参，即要操作的对象，获取该字段的值，返回Object
    String name = (String) nameField.get(user);
    //设置对象该字段的值
    nameField.set(user, "lisi");

#### 使用反射调用方法 ####

Class<User> userClass = User.class;
    
    //获取带参的公有方法。后面是形参表的class对象，参数个数可变
    Method getNameMethod = userClass.getMethod("setName", String.class);  
    Method getNameMethod = userClass.getMethod("getName");
    
    
    User user = new User(1, "zhangsan", 20);
    
    //调用指定对象的该方法（无参），返回值是Object类型
    String name = (String) getNameMethod.invoke(user);
    //调用指定对象的该方法（带参），后面是实参表，参数个数可变
    setNameMethod.invoke(user, "lisi");

*  调用方法时需要指定形参的class对象，所以方法的形参不能使用基本类型，要使用基本类型对应的包装类型。
 *  getMethod()只能获取当前类的方法，不能获取从父类继承的方法，如果存在要获取从父类继承的方法的情况，可以新建一个私有方法，调用私有方法来获取

/** * 获取指定的方法 * * @param target 类的class对象 * @param methodName 方法名 * @param parameterTypes 形参的class对象 * @return Method * @throws NoSuchMethodException 在指定的类以及其父类中找不到指定的方法 */
    private Method getMethod(Class<?> target, String methodName, Class<?>... parameterTypes) throws NoSuchMethodException { 
        Method method = null;
        try { 
            method = target.getMethod(methodName, parameterTypes);
            //可能是私有方法，需要取消权限检查
            method.setAccessible(true);
            //当前类中没有指定的方法
        } catch (NoSuchMethodException e) { 
            //如果不是根类，则递归在父类中进行查找
            if (target != Object.class) { 
                method = getMethod(target.getSuperclass(), methodName, parameterTypes);
            } else { 
                throw e;
            }
        }
        return method;
    }

#### 使用反射动态创建、操作数组 ####

//动态创建数组
    Object obj = Array.newInstance(String.class, 10); //数组元素类型、元素个数，返回值是Object类型
    String[] arr= (String[]) obj;  //有需要的话可以强转
    
    //动态操作数组。传入数组的元素类型是无法预测的，所以参数是Object类型
    Object first = Array.get(obj, 0);  //获取数组指定位置（index）上的元素，返回Object
    Array.set(obj, 0, "zhangsan");  //设置数组指定位置上的元素

反射常见的应用场景

*  开发通用框架，比如spring 从配置文件中加载配置，动态创建对象、设置属性值。
 *  实现动态代理，动态创建代理对象；对原功能进行扩展、增强。
 *  实现注解。

反射的优点

*  动态操作，可以根据传入的参数或从配置文件中读取的配置，动态创建对象、设置属性，十分灵活。

反射的缺点

*  开销大，使用频率低时性能还行，频繁使用时严重影响性能
 *  通过反射可以操作类的私有成员，破坏了类的封装性，存在安全隐患

### 代理（proxy） ###

代理：在目标类的基础上进行扩展，做一些额外处理，增加一些额外功能，代替目标类进行工作。

#### 静态代理 ####

/** * 静态代理 */
    public class UserServiceProxy implements UserService { 
    
        /** * 把目标接口实例作为成员变量 */
        private UserService userService;
    
        /** * 提供构造方法或者setter方法注入目标接口实例 */
        public UserServiceProxy(UserService userService) { 
            this.userService = userService;
        }
    
        /** * 依次为：前增强、调用目标方法、后增强，前、后增强可选 */
        @Override
        public void login() { 
            System.out.println("前增强...");
            userService.login();
            System.out.println("后增强...");
        }
    
        /** * 如果不需要增强，直接调用目标方法即可 */
        @Override
        public void register() { 
            userService.register();
        }
    
    }

//目标对象
    UserService userServiceImpl = new UserServiceImpl();
    //代理
    UserService userServiceProxy = new UserServiceProxy(userServiceImpl);
    //使用代理代替目标对象进行工作
    userServiceProxy.login();

核心点

*  代理需要实现目标接口或继承目标类：以便重写目标接口、目标类中的方法，代替目标方法进行工作
 *  注入目标实例：可以通过带参构造器，或者无参构造器+setter方法进行注入
 *  重写目标方法

#### jdk动态代理 ####

/** * jdk动态代理 */
    public class UserServiceProxyFactory { 
    
        /** * 传入目标实例，获取代理 * jdk动态代理只能代理接口，所以声明的目标类型只能是目标接口 */
        public static UserService getProxyInstance(UserService userService) { 
            //获取目标的类加载器、接口
            ClassLoader classLoader = userService.getClass().getClassLoader();
            //因为要getInterfaces()获取接口，所以只能代理接口，目标必须要是实现了接口的
            Class<?>[] interfaces = userService.getClass().getInterfaces();
    
            //使用lambda表达式实现InvocationHandler接口，编写增强
            //参数依次为：Object proxy 将返回的代理, Method method 目标方法, Object[] args 实参表
            InvocationHandler invocationHandler = (proxy, method, args) -> { 
                System.out.println("前增强...");
                //调用目标方法，传入目标实例、实参表，returnValue是目标方法的返回值
                Object returnValue = method.invoke(userService, args);
                System.out.println("后增强...");
                //返回目标方法的返回值
                return returnValue;
            };
            //创建代理
            Object userDaoProxy = Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
            //返回值是Object，强转为目标类型返回
            return (UserService) userDaoProxy;
        }
    
    }

//目标实例
    UserService userServiceImpl = new UserServiceImpl();
    //代理
    UserService userServiceProxy = UserServiceProxyFactory.getProxyInstance(userServiceImpl);
    //使用代理代替目标对象进行工作
    userServiceProxy.login();

核心点

*  只能代理接口：这句话的意思是说声明的目标类型只能是接口、不能是类，可以代理目标接口的所有实例，只要目标继承了接口就可以被代理。
 *  不能代理 static 方法
 *  不需要实现目标接口或继承目标类
 *  需要把Object型的代理强转为目标接口类型返回：不然代理是Object类型，userServiceProxy.login() 通过代理调用目标方法，都通不过编译

看invoke()的参数，在编译时不能确定要增强的方法，运行时根据传入的参数进行增强，动态生成代理，所以叫做动态代理；静态代理在编译时就确定了要增强的方法。

使用jdk自带的反射机制实现的动态代理，叫做jdk动态代理；使用第三方的cglib库实现的代理叫做cglib代理。

#### cglib动态代理 ####

需要添加cglib的依赖

<dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
        <version>3.3.0</version>
    </dependency>

/** * cglib代理 */
    public class UserServiceProxyFactory implements MethodInterceptor { 
    
        /** * 目标实例，可以声明为目标接口或目标类 */
        private UserService userService;
    
        /** * 注入目标实例 */
        public UserServiceProxyFactory(UserService userService) { 
            this.userService = userService;
        }
    
        /** * 拦截目标方法进行增强 */
        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { 
            System.out.println("前增强...");
            //调用目标方法，传入目标实例、实参表，returnValue是目标方法的返回值
            Object returnValue = method.invoke(userService, objects);
            System.out.println("后增强...");
            //返回目标方法的返回值
            return returnValue;
        }
    
        /** * 获取代理，返回值是目标类型 */
        public UserService getProxyInstance() { 
            //Enhancer是操作字节码的工具类
            Enhancer en = new Enhancer();
            //设置基类，即会继承目标类
            en.setSuperclass(userService.getClass());
            //设置回调，即使用目标对象的方法时会使用当前对象（代理）的intercept()进行拦截，代替目标方法
            en.setCallback(this);
            //创建代理，强转为目标类型返回
            return (UserService) en.create();
        }
    
    }

//目标实例
    UserService userServiceImpl = new UserServiceImpl();
    //获取代理
    UserService userServiceProxy = new UserServiceProxyFactory(userServiceImpl).getProxyInstance();
    //使用代理代替目标对象进行工作
    userServiceProxy.login();

核心点

*  需要引入cglib的依赖
 *  可以代理接口、类，返回的代理属于目标接口、目标类的实例
 *  需要实现MethodInterceptor接口，注入目标实例

cglib代理的实现原理

*  借助ASM（一个短小精悍的字节码操作框架），在运行时动态修改目标类的字节码，根据修改后的字节码创建代理。并非修改.class文件中的字节码，只是修改jvm加载到内存中Class对象，本质仍是基于字节码操作，但织入时机是运行时。
 *  修改字节码时要setSuperclass()继承目标类，基于继承目标类实现，所以不能代理 final 类，不能代理 private 方法、static方法。

#### 静态代理、动态代理的区别 ####

静态代理

*  可以代理接口、类，在编译时就确定了要增强的方法
 *  需要编写代理类，代理是一个新的类，编译会生成代理类的.class文件；
 *  代理需要实现目标接口或继承目标类，代理本身属于目标接口、目标类的实例；
 *  优点是简单、灵活，缺点是代码侵入强、耦合度高，编码量大，不好维护

动态代理

*  不需要实现目标接口或继承目标类，在运行时根据传入的参数动态生成代理
 *  参数中包含了目标实例、Method、实参表，可根据这些参数对目标类、目标方法进行筛选
 *  优点是编码量小，对代码侵入小，好维护；缺点是性能比静态代理差。

#### jdk动态代理、cglib代理的区别 ####

jdk动态代理

*  基于jdk自带的反射机制实现，不需要引入第三方依赖
 *  只能代理接口，目标实现了接口才能被代理；
 *  不能代理 static 方法
 *  不需要实现目标接口或继承目标类，但需要把创建的Object型的代理强转为目标接口类型返回

cglib代理

*  需要引入cglib的依赖
 *  可以代理接口、类（不要求目标实现接口）
 *  基于运行时动态修改字节码、继承目标类实现，不能代理 final 类，不能代理 private 方法、static方法

#### 代理与目标类的关系 ####

*  静态代理：需要实现目标接口或继承目标类，代理属于目标接口|类的实例
 *  cglib代理基于继承目标类实现，代理自然也是目标类的实例
 *  jdk动态代理：虽然没有实现目标接口或继承目标类，但会把Object型的代理转换为目标接口类型，所以也是目标接口的实例。