spring的动态代理怎么实现的 • Worktile社区

不及物动词

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

Spring的动态代理是通过Java的动态代理机制实现的。在Java中，动态代理提供了一种机制，用于生成代理对象，并在代理对象中调用原始对象的方法。Spring利用这种机制，可以在运行时通过配置和编码的方式生成代理对象，从而实现AOP（面向切面编程）的功能。

Java的动态代理是基于接口实现的。即原始对象必须实现一个接口，代理对象通过生成这个接口的实现类来实现代理。这是因为Java的动态代理是通过生成一个实现指定接口的代理类来完成的。

Spring中的动态代理主要有两种实现方式：JDK动态代理和CGLIB动态代理。

JDK动态代理：
JDK动态代理是利用Java提供的java.lang.reflect.Proxy类实现的。具体步骤如下：
1）定义一个接口，该接口为原始对象和代理对象共同需要实现的方法；
2）定义一个InvocationHandler接口的实现类，该类用于处理代理对象的方法调用；
3）通过Proxy类的静态方法newProxyInstance()生成代理对象，需要传入参数：ClassLoader，该参数用于加载代理对象的类加载器；Class[]，该参数用于指定代理对象实现的接口；InvocationHandler，该参数用于指定处理代理对象方法调用的逻辑；
4）使用代理对象调用方法。
CGLIB动态代理：
CGLIB动态代理是通过生成目标类的子类来实现的，不需要目标类实现接口。具体步骤如下：
1）引入CGLIB的相关依赖；
2）定义一个类，作为目标对象；
3）定义一个MethodInterceptor接口的实现类，该类用于处理代理对象的方法调用；
4）通过Enhancer类的create()方法生成代理对象，需要传入参数：目标对象的Class对象；MethodInterceptor实例对象；
5）使用代理对象调用方法。

无论是JDK动态代理还是CGLIB动态代理，都是通过在代理对象的方法调用前后，插入一些额外的逻辑，从而实现AOP的功能，例如日志记录、事务管理等。

总之，Spring的动态代理是通过Java的动态代理机制实现的，可以方便地实现AOP的功能，提供了对业务逻辑的解耦和更灵活的控制能力。

1年前 0条评论

fiy

Worktile&PingCode市场小伙伴

Spring的动态代理实现是通过JDK的动态代理和CGLIB动态代理两种方式来实现的。下面将分别详细介绍这两种实现方式。

JDK动态代理：
JDK动态代理是基于接口的代理方式。具体的实现步骤如下：

创建一个InvocationHandler接口的实现类，该实现类负责实现代理对象的具体行为。
在代理类中使用Proxy类的newProxyInstance方法创建代理实例。该方法需要传入三个参数，分别是类加载器、代理接口数组以及InvocationHandler的实现类对象。
通过代理实例调用目标方法。

JDK动态代理的优点是只能代理接口，并且生成的代理类相对比较简单，不会生成过多的代理类。缺点是只能代理接口，如果目标对象没有实现接口，则不能使用JDK动态代理。

CGLIB动态代理：
CGLIB动态代理是基于继承的代理方式。具体的实现步骤如下：

导入cglib库。
创建一个MethodInterceptor接口的实现类，该实现类负责实现代理对象的具体行为。
使用Enhancer类的create方法创建代理实例。该方法需要传入目标类的Class对象以及MethodInterceptor的实现类对象。
通过代理实例调用目标方法。

CGLIB动态代理的优点是可以代理任意的对象，无需实现接口，生成的代理类对目标类进行了继承，拦截了目标类的方法，因此可以代理目标类的所有方法。缺点是生成的代理类相对复杂，且性能稍低于JDK动态代理。

除了上述两种方式，Spring还支持AspectJ的静态代理。AspectJ是一个开源的Java语言的面向切面编程(AOP)框架，可以通过静态编译，在编译阶段就将切面织入到目标类中。

综上所述，Spring的动态代理实现是通过JDK动态代理和CGLIB动态代理两种方式来实现的，分别适用于代理接口和任意对象的场景。而AspectJ提供了静态代理的方式，在编译阶段进行切面织入。

1年前 0条评论

worktile

Worktile官方账号

Spring的动态代理是通过Java反射机制来实现的。在Spring中，动态代理是通过两种方式来实现的：JDK动态代理和CGLib动态代理。

JDK动态代理：
JDK动态代理是基于接口的代理，即被代理的目标对象必须实现一个接口。JDK动态代理的核心是使用了Java的反射技术，通过动态生成的代理类和实现 InvocationHandler 接口的代理处理程序来实现动态代理的功能。

实现动态代理的主要步骤如下：
1）定义一个接口，该接口是需要被代理的目标对象的业务接口。
2）实现一个InvocationHandler接口的代理处理程序，该处理程序负责实际的代理逻辑。
3）使用Proxy类的静态方法newProxyInstance()创建代理实例。
4）通过代理实例调用目标对象的方法。

下面是一个示例代码：

public interface UserService {
    void addUser(String username);
}

public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String username) {
        System.out.println("添加用户：" + username);
    }
}

public class MyInvocationHandler implements InvocationHandler {
    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("调用前的处理");
        Object result = method.invoke(target, args);
        System.out.println("调用后的处理");
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        MyInvocationHandler handler = new MyInvocationHandler(userService);
        
        UserService proxy = (UserService) Proxy.newProxyInstance(
                userService.getClass().getClassLoader(),
                userService.getClass().getInterfaces(),
                handler
        );

        proxy.addUser("test");
    }
}

CGLib动态代理：
CGLib动态代理是通过继承被代理类来实现的，即不需要目标对象实现任何接口。CGLib动态代理的核心是使用了ASM字节码生成框架，它在运行时动态生成一个被代理类的子类，并重写父类中的方法，并添加额外的代理逻辑。

实现CGLib动态代理的主要步骤如下：
1）添加CGLib的依赖库。
2）定义一个类，该类是需要被代理的目标对象。
3）实现一个MethodInterceptor接口的代理拦截器，该拦截器负责实际的代理逻辑。
4）通过Enhancer类创建代理类的实例。
5）通过代理实例调用目标对象的方法。

下面是一个示例代码：

public class UserService {
    public void addUser(String username) {
        System.out.println("添加用户：" + username);
    }
}

public class MyMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("调用前的处理");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("调用后的处理");
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UserService.class);
        enhancer.setCallback(new MyMethodInterceptor());

        UserService proxy = (UserService) enhancer.create();
        proxy.addUser("test");
    }
}

总结：
Spring的动态代理是通过Java的反射机制实现的。JDK动态代理是基于接口的代理，使用InvocationHandler和Proxy类来实现，而CGLib动态代理是基于继承的代理，使用MethodInterceptor和Enhancer类来实现。两种动态代理方式都可以实现对目标对象的代理，并在代理过程中添加额外的逻辑处理。

1年前 0条评论