spring 什么是代理 • Worktile社区

不及物动词

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

Spring中的代理（Proxy）是一种设计模式，用于控制对象的访问和操作。在Spring框架中，代理主要用于实现AOP（Aspect-Oriented Programming，面向切面编程）和事务管理。

在AOP中，代理被用来将横切关注点（cross-cutting concern）与核心业务逻辑分离开来。横切关注点指的是那些会重复出现在不同业务逻辑中的功能，比如日志记录、事务管理、性能监控等等。通过使用代理，我们可以在不修改原始业务逻辑代码的情况下，对其进行增强或修改。

Spring中的代理分为两种主要类型：静态代理和动态代理。静态代理是通过手动编写代理类来实现的，需要为每个被代理对象编写一个对应的代理类。而动态代理则是在程序运行时生成代理类，不需要手动编写。Spring提供了两种动态代理的方式：基于接口的代理（JDK动态代理）和基于类的代理（CGLIB代理）。

JDK动态代理是通过反射机制来创建代理类和代理对象的，被代理的对象必须实现接口。在运行时，代理类会实现被代理对象所实现的接口，并通过MethodHandler来调用被代理对象的方法。

CGLIB代理是通过继承被代理类，并重写它的方法来实现的。由于CGLIB是通过生成子类的方式来创建代理对象，所以被代理的类不能是final修饰的。

Spring框架还提供了一种自动代理的机制，可以通过配置来实现自动代理。自动代理是基于bean的AspectJ风格的自动代理，通过在Spring配置文件中定义切面和切点来指定需要代理的类和方法。

总结来说，Spring中的代理是通过AOP来实现对横切关注点的控制。通过代理，我们可以在不修改原始业务逻辑代码的情况下，对其进行增强或修改。代理分为静态代理和动态代理，其中动态代理又分为基于接口的代理和基于类的代理。Spring框架还提供了自动代理的机制，可以通过配置来实现自动代理。

1年前 0条评论

fiy

Worktile&PingCode市场小伙伴

在Spring框架中，代理是一种设计模式，它可以在目标对象之前或之后增加额外的逻辑。代理模式是一种结构型模式，它允许我们创建一个代理对象来控制对其他对象的访问。

代理的类型：在Spring框架中，代理可以分为两种类型：静态代理和动态代理。静态代理是在编译时期就已经确定的，而动态代理是在运行时动态创建的。
静态代理：静态代理是通过在代码中显式地定义一个代理类来实现的。代理类和目标类实现相同的接口，代理类在方法调用前后添加额外的逻辑。静态代理的缺点是需要手动编写大量的代理类，如果需要代理的方法很多，会造成代码冗余。
动态代理：动态代理是在运行时动态生成代理对象的方式。Spring框架中使用的是Java动态代理机制，通过调用Java的反射机制，在运行时动态地创建代理对象。动态代理不需要手动编写代理类，提高了代码的复用性和可维护性。
JDK动态代理：JDK动态代理是基于接口的代理，它要求目标类实现一个或多个接口。JDK动态代理使用了Java的反射机制，通过在运行时创建一个实现了目标接口的匿名代理类来实现代理。
CGLIB动态代理：CGLIB动态代理是一个强大的第三方库，它可以在运行时创建目标类的子类，并重写目标类的方法以实现代理。CGLIB动态代理不需要目标类实现接口，可以代理目标类的所有方法。

总结来说，代理在Spring框架中被广泛应用于AOP（面向切面编程）和事务管理等方面。代理可以实现对目标对象的增加、修改或控制访问的额外逻辑，提高了系统的灵活性和可扩展性。同时，代理也可以提供额外的安全性和性能优化。

1年前 0条评论

worktile

Worktile官方账号

代理（Proxy）是Spring框架中一种常见的设计模式，也是AOP（面向切面编程）的基础之一。代理允许我们在执行方法之前或之后添加额外的逻辑，例如日志记录、事务管理等。

在Spring中，代理分为两种类型：静态代理和动态代理。

静态代理：
静态代理是由程序员手动创建代理类的过程。静态代理需要为每个业务类创建一个代理类，这样会导致代码结构膨胀，维护起来也比较困难。

下面是一个简单的静态代理示例：

首先，定义一个业务接口：

public interface BusinessService {
    void doSomething();
}

然后，创建一个实现业务接口的具体类：

public class BusinessServiceImpl implements BusinessService {
    @Override
    public void doSomething() {
        System.out.println("Doing something...");
    }
}

接下来，创建一个代理类，实现业务接口，并在对应方法前后添加额外的逻辑：

public class BusinessServiceProxy implements BusinessService {
    private BusinessService businessService;

    public BusinessServiceProxy(BusinessService businessService) {
        this.businessService = businessService;
    }

    @Override
    public void doSomething() {
        System.out.println("Before doing something...");
        businessService.doSomething();
        System.out.println("After doing something...");
    }
}

最后，使用代理类进行调用：

public static void main(String[] args) {
    BusinessService businessService = new BusinessServiceImpl();
    BusinessServiceProxy proxy = new BusinessServiceProxy(businessService);
    proxy.doSomething();
}

动态代理：
动态代理是在运行时动态地创建代理对象，而不需要手动创建代理类。Spring框架提供了两种动态代理的方式：JDK动态代理和CGLIB动态代理。

JDK动态代理：
JDK动态代理是通过java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口实现的。通过Proxy的newProxyInstance方法创建代理对象，并通过InvocationHandler的invoke方法实现对方法的增强。

首先，定义一个InvocationHandler接口的实现类：

public class BusinessServiceInvocationHandler implements InvocationHandler {
    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before doing something...");
        Object result = method.invoke(target, args);
        System.out.println("After doing something...");

        return result;
    }
}

然后，通过Proxy类的newProxyInstance方法创建代理对象：

BusinessService businessService = new BusinessServiceImpl();
BusinessServiceInvocationHandler handler = new BusinessServiceInvocationHandler(businessService);
BusinessService proxy = (BusinessService) Proxy.newProxyInstance(
                        businessService.getClass().getClassLoader(),
                        businessService.getClass().getInterfaces(),
                        handler);
proxy.doSomething();

CGLIB动态代理：
CGLIB动态代理是通过CGLIB库实现的，它允许在运行时动态生成字节码，创建代理对象。CGLIB动态代理不需要目标对象实现接口。

首先，引入CGLIB库：

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

然后，创建一个MethodInterceptor接口的实现类：

public class BusinessServiceMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Before doing something...");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("After doing something...");

        return result;
    }
}

最后，使用Enhancer类创建代理对象：

Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(BusinessServiceImpl.class);
enhancer.setCallback(new BusinessServiceMethodInterceptor());
BusinessService proxy = (BusinessService) enhancer.create();
proxy.doSomething();

总结：
代理是Spring框架中的一个重要组成部分，它允许我们在方法执行前后添加额外的逻辑。静态代理需要手动创建代理类，而动态代理是在运行时动态地创建代理对象。JDK动态代理需要目标对象实现接口，而CGLIB动态代理不需要。根据实际需求选择合适的代理方式，可以帮助我们更好地实现代码的解耦和功能的增强。

1年前 0条评论