【JavaSE-11】：反射的应用-动态代理

最新推荐文章于 2024-06-25 15:18:35 发布

Camille丶

最新推荐文章于 2024-06-25 15:18:35 发布

阅读量147

点赞数 1

分类专栏： JavaSE 文章标签：反射 java

本文链接：https://blog.csdn.net/m0_49167443/article/details/114002882

版权

JavaSE 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

反射的应用：动态代理

一、静态代理
二、动态代理

代理模式是一种比较好理解的设计模式。简单来说就是 我们使用代理对象来代替对真实对象(real object)的访问，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。

代理模式的主要作用是扩展目标对象的功能，比如说在目标对象的某个方法执行前后你可以增加一些自定义的操作。
代理模式中的角色分析：
抽象角色：一般会使用接口或者抽象类解决
真实角色：被代理的角色
代理角色：代理真实角色，代理真实角色后，一般会有一些附属操作
客户：访问代理角色对象的人

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

代理模式的好处：

可以使真是角色的操作更加纯粹，不用去关注一些公共业务
公共业务交给代理角色，实现业务的分工
公共业务发生扩展时，便于集中管理

一、静态代理

静态代理，特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样会导致程序开发中产生过多的代理，代码量会翻倍，开发效率降低。
静态代理实现步骤:

定义一个接口及其实现类；
创建一个代理类同样实现这个接口
将目标对象注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。这样的话，我们就可以通过代理类屏蔽对目标对象的访问，并且可以在目标方法执行前后做一些自己想做的事情。

代码示例：
1.定义发送短信的接口

public interface SmsService {
    String send(String message);
}

2.实现发送短信的接口

public class SmsServiceImpl implements SmsService {
    public String send(String message) {
        System.out.println("send message:" + message);
        return message;
    }
}

3.创建代理类并同样实现发送短信的接口

public class SmsProxy implements SmsService {

    private final SmsService smsService;

    public SmsProxy(SmsService smsService) {
        this.smsService = smsService;
    }

    @Override
    public String send(String message) {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method send()");
        smsService.send(message);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method send()");
        return null;
    }
}

4.实际使用

public class Main {
    public static void main(String[] args) {
        SmsService smsService = new SmsServiceImpl();
        SmsProxy smsProxy = new SmsProxy(smsService);
        smsProxy.send("java");
    }
}

运行上述代码之后，控制台打印出：

before method send()
send message:java
after method send()

可以输出结果看出，我们已经增加了 SmsServiceImpl 的send()方法。

二、动态代理

相比于静态代理来说，动态代理更加灵活。我们不需要针对每个目标类都单独创建一个代理类，并且也不需要我们必须实现接口，我们可以直接代理实现类( CGLIB 动态代理机制)。

从 JVM 角度来说，动态代理是在运行时动态生成类字节码，并加载到 JVM 中的。
动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。

动态代理使用场合:
●调试
●远程方法调用

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

1.Java动态代理的相关API

Proxy ：专门完成代理的操作类，是所有动态代理类的父类。通过此类为一个或多个接口动态地生成实现类。

提供用于创建动态代理类和动态代理对象的静态方法
●static Class<?> getProxyClass(ClassLoader loader, Class<?>… interfaces) 创建一个动态代理类所对应的Class对象

●static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 直接创建一个动态代理对象

其中：
ClassLoader loader ——类加载器
Class<?>[] interfaces ——得到被代理类实现的全部接口
InvocationHandler h ——得到InvocationHandler接口的实现类实例

2.动态代理步骤

1.创建一个实现接口InvocationHandler的类，它必须实现invoke方法，以完成代理的具体操作。

//当你使用代理对象调用方法的时候实际会调用到这个方法
public Object invoke(Object theProxy, Method method, Object[] params) throws Throwable{ 
		try{ 
		Object retval = method.invoke(targetObj, params); 
		// Print out the result 
		System.out.println(retval); 
		return retval; 
		}catch (Exception exc){} 
	}

invoke() 方法有下面三个参数：

proxy :动态生成的代理类
method : 与代理类对象调用的方法相对应
args : 当前 method 方法的参数
2.创建被代理的类以及接口

在这里插入图片描述

3.通过Proxy的静态方法
newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) 创建一个Subject接口代理

RealSubject target = new RealSubject();
// Create a proxy to wrap the original implementation Debug
Proxy proxy = new DebugProxy(target);
// Get a reference to the proxy through the Subject interface
Subject sub = (Subject) Proxy.newProxyInstance( Subject.class.getClassLoader(),new Class[] { Subject.class }, proxy);

4.通过 Subject代理调用RealSubject实现类的方法

String info = sub.say(“Peter", 24);
System.out.println(info);

应用举例：

/**
 * 动态代理的举例
 *
 * @author Camille
 * @create 2021-02-23 21:12
 */



interface factory{

    String sell();
    void produce(String product);


}

//被代理类
 class NikeFactory implements factory{

    @Override
    public String sell() {
        return "Nike出售的运动产品";
    }

    @Override
    public void produce(String product) {
        System.out.println("Nike工厂生产"+product);

    }
}


//代理类
class ProxyFactory {

    public static Object getProxyInstance(Object obj){

        MyInvocationHandle Handle = new MyInvocationHandle();
        Handle.hind(obj);

       return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(), Handle);


    }
}

class MyInvocationHandle implements InvocationHandler{

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

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


    // 当我们通过代理类的对象，调用方法a时，就会自动调用如下的：invoke（）方法
    //将被代理类要执行的方法a的功能就声明在invoke（）方法中
    @Override
    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {

        //method方法：即为代理类对象调用的方法，此方法也作为了被代理类对象要调用的方法
        //obj：被代理类的对象   objects： 参数列表
        //该方法的返回值就作为当前类方法invoke（）的返回值
         Object returnValue=method.invoke(obj, objects);
        return returnValue;
    }
}

//测试
public class ProxyTest2 {
    public static void main(String[] args) {

        NikeFactory nikeFactory = new NikeFactory();

        //proxyInstance:代理类的对象
        factory proxyInstance = (factory) ProxyFactory.getProxyInstance(nikeFactory);

        String sell = proxyInstance.sell();
        System.out.println(sell);

        proxyInstance.produce("篮球鞋");
        
    }

}

3.动态代理和AOP

AOP (Aspect Orient Programming) 意为：面向切面编程，通过预编译方式和运行器件动态代理实现程序功能的统一维护一种技术。AOP是OOP 的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使业务逻辑各部分之间的耦合度提高，提高程序的可重用性，同事提高开发的效率。

在这里插入图片描述

3.2. CGLIB 动态代理机制

3.2.1. 介绍

JDK 动态代理有一个最致命的问题是其只能代理实现了接口的类。

为了解决这个问题，我们可以用 CGLIB 动态代理机制来避免。

CGLIB(Code Generation Library)是一个基于ASM的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB 通过继承方式实现代理。很多知名的开源框架都使用到了CGLIB，例如 Spring 中的 AOP 模块中：如果目标对象实现了接口，则默认采用 JDK 动态代理，否则采用 CGLIB 动态代理。

在 CGLIB 动态代理机制中 MethodInterceptor 接口和 Enhancer 类是核心。

你需要自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法。

public interface MethodInterceptor
extends Callback{
    // 拦截被代理类中的方法
    public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,
                               MethodProxy proxy) throws Throwable;
}

obj :被代理的对象（需要增强的对象）
method :被拦截的方法（需要增强的方法）
args :方法入参
methodProxy :用于调用原始方法

你可以通过 Enhancer类来动态获取被代理类，当代理类调用方法的时候，实际调用的是 MethodInterceptor 中的 intercept 方法。

3.2.2. CGLIB 动态代理类使用步骤

定义一个类；
自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法，和 JDK 动态代理中的 invoke 方法类似；
通过 Enhancer 类的 create()创建代理类；

3.2.3. 代码示例

不同于 JDK 动态代理不需要额外的依赖。CGLIB(Code Generation Library) 实际是属于一个开源项目，如果你要使用它的话，需要手动添加相关依赖。

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

1.实现一个使用阿里云发送短信的类

package github.javaguide.dynamicProxy.cglibDynamicProxy;

public class AliSmsService {
    public String send(String message) {
        System.out.println("send message:" + message);
        return message;
    }
}

2.自定义 MethodInterceptor（方法拦截器）

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * 自定义MethodInterceptor
 */
public class DebugMethodInterceptor implements MethodInterceptor {


    /**
     * @param o           被代理的对象（需要增强的对象）
     * @param method      被拦截的方法（需要增强的方法）
     * @param args        方法入参
     * @param methodProxy 用于调用原始方法
     */
    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method " + method.getName());
        Object object = methodProxy.invokeSuper(o, args);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method " + method.getName());
        return object;
    }

}

3.获取代理类

import net.sf.cglib.proxy.Enhancer;

public class CglibProxyFactory {

    public static Object getProxy(Class<?> clazz) {
        // 创建动态代理增强类
        Enhancer enhancer = new Enhancer();
        // 设置类加载器
        enhancer.setClassLoader(clazz.getClassLoader());
        // 设置被代理类
        enhancer.setSuperclass(clazz);
        // 设置方法拦截器
        enhancer.setCallback(new DebugMethodInterceptor());
        // 创建代理类
        return enhancer.create();
    }
}

4.实际使用

AliSmsService aliSmsService = (AliSmsService) CglibProxyFactory.getProxy(AliSmsService.class);
aliSmsService.send("java");

运行上述代码之后，控制台打印出：

before method send
send message:java
after method send

3.3. JDK 动态代理和 CGLIB 动态代理对比

JDK 动态代理只能只能代理实现了接口的类或者直接代理接口，而 CGLIB 可以代理未实现任何接口的类。 另外， CGLIB 动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，因此不能代理声明为 final 类型的类和方法。
就二者的效率来说，大部分情况都是 JDK 动态代理更优秀，随着 JDK 版本的升级，这个优势更加明显。

4. 静态代理和动态代理的对比

灵活性 ：动态代理更加灵活，不需要必须实现接口，可以直接代理实现类，并且可以不需要针对每个目标类都创建一个代理类。另外，静态代理中，接口一旦新增加方法，目标对象和代理对象都要进行修改，这是非常麻烦的！
JVM 层面 ：静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件。而动态代理是在运行时动态生成类字节码，并加载到 JVM 中的。

Camille丶

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
【JavaSE-11】：反射的应用-动态代理

反射的应用：动态代理一、静态代理二、动态代理1.Java动态代理的相关API2.动态代理步骤3.动态代理和AOP代理设计模式的原理:使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。一、静态代理静态代理，特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样会导致程序开发中产生过多的代理。二、动态代理动态代理是指客户通过代理类来调用其它对象
复制链接

扫一扫