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

比眉伴天荒 2024-04-16 04:31 81阅读 0赞

#### 文章目录 ####

*   *  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. 总结

![在这里插入图片描述][579a429daf314744b995f37351b46548.gif_pic_center]

> ?欢迎来到架构设计专栏~Spring Boot拦截器与动态代理深度剖析
> 
> --------------------
> 
>  *  ☆\* o(≧▽≦)o \*☆嗨~我是IT·陈寒?
>  *  ✨博客主页：[IT·陈寒的博客][IT]
>  *  ?该系列文章专栏：[架构设计][Link 1]
>  *  ?其他专栏：[Java学习路线][Java] [Java面试技巧][Java 1] [Java实战项目][Java 2] [AIGC人工智能][AIGC] [数据结构学习][Link 2]
>  *  ?文章作者技术和水平有限，如果文中出现错误，希望大家能指正?
>  *  ? 欢迎大家关注！ ❤️

--------------------

### 1. 引言 ###

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

### 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`接口实现对目标方法的增强。

#### 4.2 执行时机 ####

*  **拦截器：** 拦截器在请求处理的前后生效，可以在请求被处理之前、处理中、以及处理完后执行相应的操作。
 *  **动态代理：** 动态代理主要用于对方法的调用进行拦截和增强，通常在方法执行前后添加额外的逻辑。

#### 4.3 范围 ####

*  **拦截器：** 主要用于处理Web请求，能够拦截Controller中的方法。
 *  **动态代理：** 主要用于实现AOP，可以对类的方法进行拦截，增强其功能。

### 5. 拓展：如何选择使用拦截器还是动态代理？ ###

在实际项目中，选择使用拦截器还是动态代理取决于具体的业务需求和实现方式。

#### 5.1 使用拦截器的场景 ####

*  **全局功能增强：** 当需要在所有请求中执行一些公共的操作时，如日志记录、权限验证、性能监控等，拦截器是一种很好的选择。
 *  **Web请求处理：** 拦截器是Spring MVC框架的一部分，用于拦截Web请求，可以方便地实现对Controller中方法的拦截和增强。

#### 5.2 使用动态代理的场景 ####

*  **AOP实现：** 当需要实现面向切面编程时，例如在方法执行前后执行额外逻辑，记录日志、事务管理等，动态代理是一种常用的实现方式。
 *  **无侵入性增强：** 动态代理不需要修改原始对象的代码，通过代理对象对方法进行增强，使得代码更加清晰，不侵入原有逻辑。

### 6. 总结 ###

拦截器和动态代理都是在Spring Boot中处理请求和增强业务逻辑的重要组件，各自有着不同的实现方式和适用场景。拦截器主要用于Web请求的处理，在Controller层实现全局的功能增强；而动态代理则更适用于实现AOP，对方法的调用进行拦截和增强，提高代码的可维护性和可扩展性。

在实际项目中，根据具体需求选择合适的实现方式非常重要。合理使用拦截器和动态代理，可以使代码更加清晰、可维护，提高系统的可扩展性和灵活性。希望通过本文的介绍，读者能更好地理解和应用拦截器和动态代理在Spring Boot中的使用。

--------------------

> ?结尾 ❤️ 感谢您的支持和鼓励！ ??  
> ?您可能感兴趣的内容：
> 
>  *  【[Java面试技巧][Java 1]】[Java面试八股文 - 掌握面试必备知识（目录篇）][Java_ -]
>  *  【[Java学习路线][Java]】[2023年完整版Java学习路线图][2023_Java]
>  *  【[AIGC人工智能][AIGC]】[Chat GPT是什么，初学者怎么使用Chat GPT，需要注意些什么][Chat GPT_Chat GPT]
>  *  【[Java实战项目][Java 2]】[SpringBoot+SSM实战：打造高效便捷的企业级Java外卖订购系统][SpringBoot_SSM_Java]
>  *  【[数据结构学习][Link 2]】[从零起步：学习数据结构的完整路径][Link 3]
> 
> > ![在这里插入图片描述][d7565cfc032647bfb69e7971731a06a2.gif_pic_center]

[579a429daf314744b995f37351b46548.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/61a5aaf0213048f5a4e7b51579b31e1d.gif
[IT]: https://blog.csdn.net/qq_43546721?type=blog
[Link 1]: https://blog.csdn.net/qq_43546721/category_12435443.html?spm=1001.2014.3001.5482
[Java]: https://blog.csdn.net/qq_43546721/category_12367981.html
[Java 1]: https://blog.csdn.net/qq_43546721/category_12384780.html?spm=1001.2014.3001.5482
[Java 2]: https://blog.csdn.net/qq_43546721/category_12378614.html?spm=1001.2014.3001.5482
[AIGC]: https://blog.csdn.net/qq_43546721/category_12369819.html?spm=1001.2014.3001.5482
[Link 2]: https://blog.csdn.net/qq_43546721/category_12417284.html?spm=1001.2014.3001.5482
[2591674ac3b74e10afcc67594cbb66a0.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/498144dbd0e941d7bd253b177dac057f.png
[Java_ -]: https://blog.csdn.net/qq_43546721/article/details/131832856
[2023_Java]: https://blog.csdn.net/qq_43546721/article/details/131550605
[Chat GPT_Chat GPT]: https://blog.csdn.net/qq_43546721/article/details/131866932
[SpringBoot_SSM_Java]: https://blog.csdn.net/qq_43546721/article/details/132119791
[Link 3]: https://blog.csdn.net/qq_43546721/article/details/132404477
[d7565cfc032647bfb69e7971731a06a2.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/dc46f76a667e484da49b6fb3dc39c10f.gif