Spring Boot拦截器与动态代理深度剖析

IT_陈寒

发布于 2024-01-13 10:13:28

1150

发布于 2024-01-13 10:13:28

文章被收录于专栏：开发经验开发经验

文章目录
1. 引言
2. Spring Boot拦截器
2.1 拦截器的概念
2.2 实现一个简单的拦截器
2.3 配置拦截器
3. Spring Boot动态代理
3.1 动态代理的概念
3.2 使用动态代理实现AOP
4. 区别与适用场景
4.1 实现方式
4.2 执行时机
4.3 范围
5. 拓展：如何选择使用拦截器还是动态代理？
5.1 使用拦截器的场景
5.2 使用动态代理的场景
6. 总结

🎉欢迎来到架构设计专栏~Spring Boot拦截器与动态代理深度剖析

☆* o(≧▽≦)o *☆嗨~我是IT·陈寒🍹
✨博客主页：IT·陈寒的博客
🎈该系列文章专栏：架构设计
📜其他专栏：Java学习路线 Java面试技巧 Java实战项目 AIGC人工智能数据结构学习
🍹文章作者技术和水平有限，如果文中出现错误，希望大家能指正🙏
📜 欢迎大家关注！ ❤️

1. 引言

在Spring Boot应用程序中，拦截器（Interceptor）和动态代理（Dynamic Proxy）都是用于处理请求和执行业务逻辑的关键组件。尽管它们的目标相似，但在实现和使用上存在显著的区别。本文将深入探讨Spring Boot中拦截器和动态代理的异同，通过实例代码演示它们的使用方式，并分析何时使用哪种方式以及如何根据具体需求选择合适的方法。

2. Spring Boot拦截器

2.1 拦截器的概念

拦截器是Spring框架中的一个关键组件，用于在处理请求之前和之后执行一些操作。在Spring Boot中，拦截器通常用于实现一些全局的、与业务逻辑无关的功能，例如日志记录、权限验证、性能监控等。

2.2 实现一个简单的拦截器

下面是一个简单的Spring Boot拦截器的实现示例，用于记录请求的处理时间：

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class TimingInterceptor implements HandlerInterceptor {

    private static final ThreadLocal<Long> startTimeThreadLocal = new ThreadLocal<>();

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        long startTime = System.currentTimeMillis();
        startTimeThreadLocal.set(startTime);
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
        long endTime = System.currentTimeMillis();
        long startTime = startTimeThreadLocal.get();
        long executeTime = endTime - startTime;

        // 记录执行时间
        System.out.println("Request URL: " + request.getRequestURL());
        System.out.println("Execution Time: " + executeTime + "ms");
    }
}

2.3 配置拦截器

在Spring Boot中配置拦截器通常需要实现WebMvcConfigurer接口，例如：

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new TimingInterceptor()).addPathPatterns("/**");
    }
}

在上述代码中，addInterceptors方法用于注册拦截器，这里将TimingInterceptor拦截器应用于所有路径。

3. Spring Boot动态代理

3.1 动态代理的概念

动态代理是一种在运行时创建代理对象的机制，它允许在不修改源代码的情况下增强或扩展原始对象的功能。在Spring Boot中，动态代理通常用于实现面向切面编程（AOP）的目标对象增强。

3.2 使用动态代理实现AOP

下面是一个使用动态代理实现AOP的简单示例，该示例在目标方法执行前后打印日志：

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

interface HelloService {
    void sayHello();
}

class HelloServiceImpl implements HelloService {
    @Override
    public void sayHello() {
        System.out.println("Hello, Dynamic Proxy!");
    }
}

class LogInvocationHandler implements InvocationHandler {

    private final Object target;

    public LogInvocationHandler(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;
    }
}

public class DynamicProxyExample {

    public static void main(String[] args) {
        HelloService helloService = new HelloServiceImpl();
        HelloService proxy = (HelloService) Proxy.newProxyInstance(
                helloService.getClass().getClassLoader(),
                helloService.getClass().getInterfaces(),
                new LogInvocationHandler(helloService)
        );

        proxy.sayHello();
    }
}

在上述代码中，LogInvocationHandler是一个实现了InvocationHandler接口的代理处理器，它在目标方法执行前后打印日志。使用Proxy.newProxyInstance方法创建代理对象，将代理对象应用于HelloService接口，从而实现了AOP的功能。

4. 区别与适用场景

4.1 实现方式

拦截器： 拦截器是基于Java的反射机制实现的，它通过实现HandlerInterceptor接口，并配置在Spring MVC中，可以拦截Controller中的请求方法。
动态代理： 动态代理是通过Proxy.newProxyInstance方法生成代理对象，该代理对象实现了指定接口，并通过InvocationHandler接口实现对目标方法的增强。