spring怎么代理对象的

Spring框架提供了一种称为AOP（面向切面编程）的机制来代理对象。代理对象可以在不修改源代码的情况下增强它们的功能，例如添加日志、事务管理等。

在Spring中，有两种方式来代理对象：

1. 基于JDK动态代理：当被代理的对象实现了至少一个接口时，可以使用JDK动态代理来创建代理对象。JDK动态代理基于接口进行代理，通过实现InvocationHandler接口来创建代理对象。具体步骤如下：

   • 创建一个实现InvocationHandler接口的类，该类负责拦截所有方法调用并在该方法调用之前或之后执行相关逻辑。
   • 使用Proxy.newProxyInstance()方法来创建代理对象，该方法需要三个参数：ClassLoader、被代理的接口数组、InvocationHandler对象。

2. 基于CGLIB动态代理：当被代理的对象没有实现任何接口时，可以使用CGLIB动态代理来创建代理对象。CGLIB动态代理是通过继承被代理的类并重写其方法来实现的。具体步骤如下：

   • 引入CGLIB库的依赖。
   • 创建一个MethodInterceptor接口的实现类，该类负责拦截所有方法调用并在该方法调用之前或之后执行相关逻辑。
   • 使用Enhancer类的create()方法来创建代理对象，该方法需要两个参数：被代理的类的Class对象、MethodInterceptor对象。

无论是基于JDK动态代理还是CGLIB动态代理，都需要在Spring配置文件中声明代理相关的Bean。Spring提供了两种方式来声明代理：

• 使用xml配置文件声明代理对象：通过 <aop:config> 元素和 <aop:aspect> 元素来声明切面和通知。
• 使用注解声明代理对象：通过在目标类上添加 @Aspect 注解和在通知方法上添加 @Before 、 @After 等注解来声明切面和通知。

通过以上方式，可以实现对象的动态代理，并根据需求增强对象的功能。

在Spring中，代理对象是通过使用面向切面编程（AOP）实现的。Spring框架提供了两种方式来创建代理对象：基于接口的代理和基于类的代理。

1. 基于接口的代理：
   基于接口的代理是使用Java的动态代理机制实现的，它要求目标类必须实现一个接口。在Spring中，可以使用JDK的动态代理来创建代理对象。通过动态代理，可以为目标对象创建一个代理对象，在调用目标方法的前后增加额外的逻辑，比如记录日志、统计执行时间等。

2. 基于类的代理：
   基于类的代理是使用CGLIB（Code Generation Library）实现的。CGLIB是一个强大的代码生成库，使用它可以动态生成目标类的子类来作为代理对象，并重写目标类的方法，在重写的方法中加入增强逻辑。与基于接口的代理不同，基于类的代理不要求目标类必须实现接口，因此更加灵活，可以代理没有实现接口的类。

Spring框架使用代理对象的方式主要有两种：

3. JDK动态代理：
   JDK动态代理是基于接口的代理，通过java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口来实现。首先，创建一个实现InvocationHandler接口的代理类，然后使用Proxy类的静态方法newProxyInstance()来创建代理对象。在InvocationHandler的invoke()方法中，可以实现额外的逻辑，并调用目标方法。

4. CGLIB动态代理：
   CGLIB动态代理是基于类的代理，通过创建目标类的子类来实现。首先，引入CGLIB库，然后创建一个MethodInterceptor接口的实现类作为代理类，在intercept()方法中实现额外的逻辑，并调用目标方法。使用Enhancer类的create()方法创建代理对象。

5. 配置代理：
   在Spring中配置代理对象通常使用AOP（面向切面编程）的方式。通过在Spring的配置文件中添加AOP相关的配置，可以指定要拦截的目标方法，以及提供代理对象的实现类或接口，Spring将自动使用适当的方式创建代理对象。可以使用XML配置文件或注解来配置代理。

Spring可以通过两种方式代理对象：基于接口的代理和基于类的代理。

1、基于接口的代理：
基于接口的代理是使用JDK动态代理来创建代理对象，该代理对象实现了目标接口，在运行时拦截对目标对象方法的调用，并可以在方法调用前后进行额外的操作。JDK动态代理要求目标对象实现一个或多个接口。

步骤：
（1）首先，定义目标接口，声明需要代理的方法。
（2）创建目标对象，实现目标接口。
（3）创建InvocationHandler接口的实现类，重写invoke方法，在该方法中实现额外的操作。
（4）使用Proxy类的newProxyInstance方法创建代理对象，需要指定ClassLoader、目标对象的接口、InvocationHandler对象。
（5）通过代理对象调用目标对象的方法。

示例代码：
1）定义目标接口：

public interface UserService {
    void addUser(String username, String password);
    void deleteUser(int userId);
}

2）创建目标对象：

public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String username, String password) {
        // 添加用户的具体实现逻辑
    }
    @Override
    public void deleteUser(int userId) {
        // 删除用户的具体实现逻辑
    }
}

3）创建InvocationHandler实现类：

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

public class UserServiceProxy implements InvocationHandler {
    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 在目标方法调用前进行额外操作
        System.out.println("Before method " + method.getName());
        
        // 调用目标方法
        Object result = method.invoke(target, args);
        
        // 在目标方法调用后进行额外操作
        System.out.println("After method " + method.getName());

        return result;
    }
}

4）创建代理对象：

public class App {
    public static void main(String[] args) {
        UserService target = new UserServiceImpl();
        // 创建代理对象
        UserService proxy = (UserService) Proxy.newProxyInstance(
                                    target.getClass().getClassLoader(),
                                    target.getClass().getInterfaces(),
                                    new UserServiceProxy(target));
        // 通过代理对象调用目标对象的方法
        proxy.addUser("admin", "123456");
    }
}

执行结果：

Before method addUser
After method addUser

2、基于类的代理：
基于类的代理是使用CGLib库来创建代理对象，该代理对象继承了目标类，在运行时拦截对目标对象方法的调用，并可以在方法调用前后进行额外的操作。CGLib代理不要求目标对象实现接口。

步骤：
（1）首先，创建目标类，定义需要代理的方法。
（2）创建MethodInterceptor接口的实现类，重写intercept方法，在该方法中实现额外的操作。
（3）使用Enhancer类创建代理对象，需要指定目标类、MethodInterceptor对象。
（4）通过代理对象调用目标对象的方法。

示例代码：
1）创建目标类：

public class UserService {
    public void addUser(String username, String password) {
        // 添加用户的具体实现逻辑
    }
    public void deleteUser(int userId) {
        // 删除用户的具体实现逻辑
    }
}

2）创建MethodInterceptor实现类：

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

import java.lang.reflect.Method;

public class UserServiceProxy implements MethodInterceptor {
    @Override
    public Object intercept(Object target, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        // 在目标方法调用前进行额外操作
        System.out.println("Before method " + method.getName());

        // 调用目标方法
        Object result = methodProxy.invokeSuper(target, args);
        
        // 在目标方法调用后进行额外操作
        System.out.println("After method " + method.getName());

        return result;
    }
}

3）创建代理对象：

public class App {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UserService.class); // 指定目标类
        enhancer.setCallback(new UserServiceProxy()); // 指定MethodInterceptor对象
        
        UserService proxy = (UserService) enhancer.create(); // 创建代理对象
        
        proxy.addUser("admin", "123456"); // 通过代理对象调用目标对象的方法
    }
}

执行结果：

Before method addUser
After method addUser

总结：
无论是基于接口的代理还是基于类的代理，Spring都可以通过配置来自动为Bean创建代理对象，以提供额外的功能和逻辑。这种代理机制在AOP（面向切面编程）中广泛应用，可以实现诸如事务管理、日志记录等共性功能的复用。同时，Spring还提供了多种代理模式的选择，在使用代理时可以根据具体的需求进行配置和选择。