spring如何引入动态代理的类 • Worktile社区

不及物动词

这个人很懒，什么都没有留下～

在 Spring 框架中，我们可以使用动态代理来实现 AOP（面向切面编程）。动态代理是指在程序运行过程中动态生成代理对象，并将目标对象的方法拦截，从而实现对目标对象的增强。

Spring 提供了两种方式来引入动态代理的类：JDK 动态代理和 CGLIB 动态代理。

JDK 动态代理

JDK 动态代理是通过被代理对象所实现的接口来生成代理对象的。Spring 使用了 JDK 的动态代理机制，通过反射和代理类生成机制创建代理对象。

使用 JDK 动态代理的步骤如下：

创建一个实现 InvocationHandler 接口的代理类，实现 invoke() 方法，在该方法中完成对目标方法的增强逻辑。
使用 Proxy 类的 newProxyInstance() 方法创建代理对象，传入目标对象的类加载器、目标对象实现的接口数组以及代理对象的 InvocationHandler 实例。

示例代码如下：

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

public class JDKDynamicProxy implements InvocationHandler {
    private Object target;

    public JDKDynamicProxy(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 在目标方法执行前的增强逻辑
        System.out.println("Before method execution");

        // 调用目标方法
        Object result = method.invoke(target, args);

        // 在目标方法执行后的增强逻辑
        System.out.println("After method execution");

        return result;
    }

    public static void main(String[] args) {
        // 创建目标对象
        TargetObject targetObject = new TargetObject();

        // 创建代理对象
        JDKDynamicProxy proxy = new JDKDynamicProxy(targetObject);
        TargetInterface proxyObject = (TargetInterface) Proxy.newProxyInstance(
            targetObject.getClass().getClassLoader(),
            targetObject.getClass().getInterfaces(),
            proxy
        );

        // 调用代理对象的方法
        proxyObject.targetMethod();
    }
}

interface TargetInterface {
    void targetMethod();
}

class TargetObject implements TargetInterface {
    @Override
    public void targetMethod() {
        System.out.println("Target method executed");
    }
}

CGLIB 动态代理

CGLIB（Code Generation Library）是一个开源的 Java 字节码增强框架，通过生成目标类的子类来实现代理。与 JDK 动态代理相比，CGLIB 动态代理不要求被代理对象实现任何接口，可以对类的任意方法进行代理。

使用 CGLIB 动态代理的步骤如下：

创建一个实现 MethodInterceptor 接口的拦截器类，实现 intercept() 方法，在该方法中完成对目标方法的增强逻辑。
使用 Enhancer 类的 create() 方法创建代理对象，设置目标对象作为父类和拦截器类作为回调。

示例代码如下：

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

import java.lang.reflect.Method;

public class CGLIBDynamicProxy implements MethodInterceptor {
    private Object target;

    public CGLIBDynamicProxy(Object target) {
        this.target = target;
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        // 在目标方法执行前的增强逻辑
        System.out.println("Before method execution");

        // 调用目标方法
        Object result = proxy.invoke(target, args);

        // 在目标方法执行后的增强逻辑
        System.out.println("After method execution");

        return result;
    }

    public static void main(String[] args) {
        // 创建目标对象
        TargetObject targetObject = new TargetObject();

        // 创建代理对象
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(targetObject.getClass());
        enhancer.setCallback(new CGLIBDynamicProxy(targetObject));
        TargetObject proxyObject = (TargetObject) enhancer.create();

        // 调用代理对象的方法
        proxyObject.targetMethod();
    }
}

class TargetObject {
    public void targetMethod() {
        System.out.println("Target method executed");
    }
}

以上就是使用 Spring 引入动态代理的类的方法。需要注意的是，JDK 动态代理只能代理接口，而 CGLIB 动态代理可以代理类和接口。根据实际情况选择合适的动态代理方式来实现目标对象的增强。

1年前 0条评论

worktile

Worktile官方账号

Spring框架提供了多种方式来引入动态代理的类。下面我将介绍5种常见的方式：

JDK动态代理：
JDK动态代理是基于接口的代理方式，它使用java.lang.reflect.Proxy类以及java.lang.reflect.InvocationHandler接口来生成动态代理类。在Spring中，我们可以使用Spring AOP来配置JDK动态代理。通过在配置文件中声明aop:config标签，并使用aop:aspect标签定义切面，我们可以指定目标类和切面类，然后Spring容器会自动创建代理。
CGLIB动态代理：
CGLIB动态代理是基于类的代理方式，它通过生成目标类的子类来实现代理。在Spring中，我们可以使用CGLIB库来生成动态代理类。与JDK动态代理不同，CGLIB动态代理不需要目标类实现接口。我们只需要在配置文件中声明aop:config标签，并使用aop:aspect标签定义切面，并选择使用CGLIB动态代理。
使用@AspectJ注解：
Spring的AOP模块集成了AspectJ框架，我们可以使用@AspectJ注解来创建切面类，并在配置文件中将其声明为Spring bean。切面类中的方法可以使用@Before、@After等注解定义前置和后置通知，从而实现动态代理。
使用XML配置文件：
除了使用注解的方式，Spring还支持通过XML配置文件来引入动态代理的类。我们可以在配置文件中使用aop:config标签来声明切面，然后在aop:aspect标签内配置切点、通知以及目标类，从而实现动态代理。
使用Spring Boot自动配置：
如果项目使用了Spring Boot，我们可以使用@EnableAspectJAutoProxy注解来开启自动代理功能。通过在配置类上添加@EnableAspectJAutoProxy注解，Spring Boot会自动为标记有@Aspect注解的切面类创建代理。

总结：Spring框架提供了多种方式来引入动态代理的类，包括JDK动态代理、CGLIB动态代理、使用@AspectJ注解、XML配置文件和Spring Boot自动配置。可以根据项目的需求选择合适的方式。

1年前 0条评论

fiy

Worktile&PingCode市场小伙伴

Spring框架通过AOP（面向切面编程）来支持动态代理。动态代理是指在运行时生成代理类，用于在目标对象的方法调用前后添加额外的功能。Spring框架使用动态代理来实现事务管理、日志记录等功能。

下面介绍Spring引入动态代理的类的方法和操作流程：

定义目标类（Target Class）：首先，需要定义一个目标类，即需要被代理的类。这个类通常是一个普通的Java类，包含业务逻辑代码。
实现切面逻辑（Aspect Class）：切面逻辑是指在目标类的方法调用前后执行的额外逻辑。这些逻辑通常包括日志记录、事务管理等。在Spring中，切面逻辑通常使用切面类（Aspect Class）来实现，切面类是一个普通的Java类，需要使用特定的注解来标识。切面类中的方法称为切面方法。
配置代理类（Proxy Class）：接下来，需要配置代理类。在Spring中，可以通过XML配置或注解配置来实现代理类的配置。配置主要包括指定目标类，切面类和代理类型等信息。
创建代理对象（Proxy Object）：Spring框架会根据配置生成代理对象，代理对象是目标类的一个子类或实现了目标接口的实现类。通过代理对象，可以访问该对象的方法，并在方法调用前后执行切面逻辑。
调用方法：通过代理对象，可以调用目标类的方法。在方法调用前后，会根据配置执行切面逻辑。切面逻辑可以是方法的前置通知、后置通知、异常通知、环绕通知等，具体执行顺序和方式可以在切面类中决定。
销毁代理对象：最后，需要手动销毁代理对象。在Spring中，可以使用ApplicationContext容器销毁代理对象，也可以通过JVM的垃圾回收机制自动销毁。

通过以上步骤，就可以实现在Spring中引入动态代理的类。Spring框架自动生成代理对象，并在方法调用前后执行切面逻辑，从而实现额外的功能。

1年前 0条评论