Spring MVC 拦截器 HandlerInterceptor的简单应用

最新推荐文章于 2024-09-06 10:35:28 发布
最新推荐文章于 2024-09-06 10:35:28 发布
阅读量3k 收藏 5
点赞数 4
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wjavadog/article/details/92396722
版权
前言

SpringMVC是一种基于Java，实现了Web MVC设计模式，请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将Web层进行职责解耦。基于请求驱动指的就是使用请求-响应模型，框架的目的就是帮助我们简化开发，Spring MVC也是要简化我们日常Web开发。

MVC 模型

MVC设计模式的任务是将包含业务数据的模块与显示模块的视图解耦。这是怎样发生的？在模型和视图之间引入重定向层可以解决问题。此重定向层是控制器，控制器将接收请求，执行更新模型的操作，然后通知视图关于模型更改的消息。

Spring MVC 架构图

在这里插入图片描述
流程：

  1. 首先用户发送请求——>DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制；
  2. DispatcherServlet——>HandlerMapping，处理器映射器将会把请求映射为HandlerExecutionChain对象（包含一个Handler处理器对象、多个HandlerInterceptor拦截器）对象；
  3. DispatcherServlet——>HandlerAdapter，处理器适配器将会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器；
  4. HandlerAdapter——>调用处理器相应功能处理方法，并返回一个ModelAndView对象（包含模型数据、逻辑视图名）；
  5. ModelAndView对象（Model部分是业务对象返回的模型数据，View部分为逻辑视图名）——> ViewResolver， 视图解析器将把逻辑视图名解析为具体的View；
  6. View——>渲染，View会根据传进来的Model模型数据进行渲染，此处的Model实际是一个Map数据结构；
  7. 返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。
Spring MVC 源码分析

接下来看一下 DispatcherServlet 类的源码：

@SuppressWarnings("serial")
public class DispatcherServlet extends FrameworkServlet {
	...
	/**
	 * Exposes the DispatcherServlet-specific request attributes and delegates to {@link #doDispatch}
	 * for the actual dispatching.
	 */
	@Override
	protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
		logRequest(request);

		// Keep a snapshot of the request attributes in case of an include,
		// to be able to restore the original attributes after the include.
		Map<String, Object> attributesSnapshot = null;
		if (WebUtils.isIncludeRequest(request)) {
			attributesSnapshot = new HashMap<>();
			Enumeration<?> attrNames = request.getAttributeNames();
			while (attrNames.hasMoreElements()) {
				String attrName = (String) attrNames.nextElement();
				if (this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) {
					attributesSnapshot.put(attrName, request.getAttribute(attrName));
				}
			}
		}

		// Make framework objects available to handlers and view objects.
		request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
		request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
		request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
		request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());

		if (this.flashMapManager != null) {
			FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
			if (inputFlashMap != null) {
				request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
			}
			request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
			request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
		}

		try {
			doDispatch(request, response); // 开始分发请求
		}
		finally {
			if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
				// Restore the original attribute snapshot, in case of an include.
				if (attributesSnapshot != null) {
					restoreAttributesAfterInclude(request, attributesSnapshot);
				}
			}
		}
	}
	...
}

DispatcherServlet 继承了 FrameworkServlet，那么看一下 FrameworkServlet 的源码,FrameworkServlet 又继承了 HttpServletBean，HttpServletBean 又继承了 HttpServlet

看一下 FrameworkServlet 的 service 方法：

@SuppressWarnings("serial")
public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {

	/**
	 * Override the parent class implementation in order to intercept PATCH requests.
	 */
	@Override
	// 重写了父类的 service 方法，用来拦截 patch 方法，先不这里
	protected void service(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
		if (httpMethod == HttpMethod.PATCH || httpMethod == null) {
			processRequest(request, response);
		}
		else {
			super.service(request, response); // 看这，点进去看一下
		}
	}

}

调用了父类 HttpServlet 的方法

	/**
     * Receives standard HTTP requests from the public
     * <code>service</code> method and dispatches
     * them to the <code>do</code><i>XXX</i> methods defined in 
     * this class. This method is an HTTP-specific version of the 
     * {@link javax.servlet.Servlet#service} method. There's no
     * need to override this method.
     *
     * @param req   the {@link HttpServletRequest} object that
     *                  contains the request the client made of
     *                  the servlet
     *
     * @param resp  the {@link HttpServletResponse} object that
     *                  contains the response the servlet returns
     *                  to the client                                
     *
     * @throws IOException   if an input or output error occurs
     *                              while the servlet is handling the
     *                              HTTP request
     *
     * @throws ServletException  if the HTTP request
     *                                  cannot be handled
     * 
     * @see javax.servlet.Servlet#service
     */
    protected void service(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException
    {
        String method = req.getMethod();

        if (method.equals(METHOD_GET)) {
            long lastModified = getLastModified(req);
            if (lastModified == -1) {
                // servlet doesn't support if-modified-since, no reason
                // to go through further expensive logic
                doGet(req, resp);
            } else {
                long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
                if (ifModifiedSince < lastModified) {
                    // If the servlet mod time is later, call doGet()
                    // Round down to the nearest second for a proper compare
                    // A ifModifiedSince of -1 will always be less
                    maybeSetLastModified(resp, lastModified);
                    doGet(req, resp); // 点进去这里看一下
                } else {
                    resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                }
            }

        } else if (method.equals(METHOD_HEAD)) {
            long lastModified = getLastModified(req);
            maybeSetLastModified(resp, lastModified);
            doHead(req, resp);

        } else if (method.equals(METHOD_POST)) {
            doPost(req, resp);
            
        } else if (method.equals(METHOD_PUT)) {
            doPut(req, resp);
            
        } else if (method.equals(METHOD_DELETE)) {
            doDelete(req, resp);
            
        } else if (method.equals(METHOD_OPTIONS)) {
            doOptions(req,resp);
            
        } else if (method.equals(METHOD_TRACE)) {
            doTrace(req,resp);
            
        } else {
            //
            // Note that this means NO servlet supports whatever
            // method was requested, anywhere on this server.
            //

            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[1];
            errArgs[0] = method;
            errMsg = MessageFormat.format(errMsg, errArgs);
            
            resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
        }
    }

FrameworkServlet 重写了 doGet 方法：

/**
	 * Delegate GET requests to processRequest/doService.
	 * <p>Will also be invoked by HttpServlet's default implementation of {@code doHead},
	 * with a {@code NoBodyResponse} that just captures the content length.
	 * @see #doService
	 * @see #doHead
	 */
	@Override
	protected final void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		processRequest(request, response); // 点进这里看
	}

开始处理请求：

    /**
	 * Process this request, publishing an event regardless of the outcome.
	 * <p>The actual event handling is performed by the abstract
	 * {@link #doService} template method.
	 */
	protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		long startTime = System.currentTimeMillis();
		Throwable failureCause = null;

		LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
		LocaleContext localeContext = buildLocaleContext(request);

		RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
		ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);

		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
		asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());

		initContextHolders(request, localeContext, requestAttributes);

		try {
			doService(request, response); // 这里，调用 DisptcherServlet 的 doService 方法
		}
		catch (ServletException | IOException ex) {
			failureCause = ex;
			throw ex;
		}
		catch (Throwable ex) {
			failureCause = ex;
			throw new NestedServletException("Request processing failed", ex);
		}

		finally {
			resetContextHolders(request, previousLocaleContext, previousAttributes);
			if (requestAttributes != null) {
				requestAttributes.requestCompleted();
			}
			logResult(request, response, failureCause, asyncManager);
			publishRequestHandledEvent(request, response, startTime, failureCause);
		}
	}

调用 DisptcherServlet 的 doService 方法，回到第一段代码。
看一下 doDispatch 方法源码：

	/**
	 * Process the actual dispatching to the handler.
	 * <p>The handler will be obtained by applying the servlet's HandlerMappings in order.
	 * The HandlerAdapter will be obtained by querying the servlet's installed HandlerAdapters
	 * to find the first that supports the handler class.
	 * <p>All HTTP methods are handled by this method. It's up to HandlerAdapters or handlers
	 * themselves to decide which methods are acceptable.
	 * @param request current HTTP request
	 * @param response current HTTP response
	 * @throws Exception in case of any kind of processing failure
	 */
	protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HttpServletRequest processedRequest = request;
		HandlerExecutionChain mappedHandler = null;
		boolean multipartRequestParsed = false;

		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

		try {
			ModelAndView mv = null;
			Exception dispatchException = null;

			try {
				processedRequest = checkMultipart(request);
				multipartRequestParsed = (processedRequest != request);

				// Determine handler for the current request.
				mappedHandler = getHandler(processedRequest);
				if (mappedHandler == null) {
					noHandlerFound(processedRequest, response);
					return;
				}

				// Determine handler adapter for the current request.
				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

				// Process last-modified header, if supported by the handler.
				String method = request.getMethod();
				boolean isGet = "GET".equals(method);
				if (isGet || "HEAD".equals(method)) {
					long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
					if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
						return;
					}
				}
				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
					return;
				}

				// Actually invoke the handler.
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

				if (asyncManager.isConcurrentHandlingStarted()) {
					return;
				}

				applyDefaultViewName(processedRequest, mv);
				mappedHandler.applyPostHandle(processedRequest, response, mv);
			}
			catch (Exception ex) {
				dispatchException = ex;
			}
			catch (Throwable err) {
				// As of 4.3, we're processing Errors thrown from handler methods as well,
				// making them available for @ExceptionHandler methods and other scenarios.
				dispatchException = new NestedServletException("Handler dispatch failed", err);
			}
			processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
		}
		catch (Exception ex) {
			triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
		}
		catch (Throwable err) {
			triggerAfterCompletion(processedRequest, response, mappedHandler,
					new NestedServletException("Handler processing failed", err));
		}
		finally {
			if (asyncManager.isConcurrentHandlingStarted()) {
				// Instead of postHandle and afterCompletion
				if (mappedHandler != null) {
					mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
				}
			}
			else {
				// Clean up any resources used by a multipart request.
				if (multipartRequestParsed) {
					cleanupMultipart(processedRequest);
				}
			}
		}
	}
  1. 这里开始处理请求 applyPreHandle， adapter 之前
    applyPreHandle 会遍历所有的 HandlerInterceptor，并调用其 preHandle 方法
    看下 preHandle 注释 before HandlerAdapter invokes the handler
	 boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HandlerInterceptor[] interceptors = getInterceptors();
		if (!ObjectUtils.isEmpty(interceptors)) {
			for (int i = 0; i < interceptors.length; i++) {
				HandlerInterceptor interceptor = interceptors[i];
				if (!interceptor.preHandle(request, response, this.handler)) {
					triggerAfterCompletion(request, response, null);
					return false;
				}
				this.interceptorIndex = i;
			}
		}
		return true;
	}

  1. mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
    HandlerAdapter 获取对应的 Adapter，生成 ModelAndView

  2. mappedHandler.applyPostHandle(processedRequest, response, mv);
    postHandle 注释 before the DispatcherServlet renders the view.

	/**
	 * Apply postHandle methods of registered interceptors.
	 */
	void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv)
			throws Exception {

		HandlerInterceptor[] interceptors = getInterceptors();
		if (!ObjectUtils.isEmpty(interceptors)) {
			for (int i = interceptors.length - 1; i >= 0; i--) {
				HandlerInterceptor interceptor = interceptors[i];
				interceptor.postHandle(request, response, this.handler, mv);
			}
		}
	}
  1. processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
boolean errorView = false;

		if (exception != null) {
			if (exception instanceof ModelAndViewDefiningException) {
				logger.debug("ModelAndViewDefiningException encountered", exception);
				mv = ((ModelAndViewDefiningException) exception).getModelAndView();
			}
			else {
				Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
				mv = processHandlerException(request, response, handler, exception);
				errorView = (mv != null);
			}
		}

		// Did the handler return a view to render?
		if (mv != null && !mv.wasCleared()) {
			render(mv, request, response);
			if (errorView) {
				WebUtils.clearErrorRequestAttributes(request);
			}
		}
		else {
			if (logger.isTraceEnabled()) {
				logger.trace("No view rendering, null ModelAndView returned.");
			}
		}

		if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
			// Concurrent handling started during a forward
			return;
		}

		if (mappedHandler != null) {
			mappedHandler.triggerAfterCompletion(request, response, null);
		}

mappedHandler.triggerAfterCompletion(request, response, null);
afterCompletion 注释：after rendering the view. Will be called on any outcome of handler execution

	/**
	 * Trigger afterCompletion callbacks on the mapped HandlerInterceptors.
	 * Will just invoke afterCompletion for all interceptors whose preHandle invocation
	 * has successfully completed and returned true.
	 */
	void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable Exception ex)
			throws Exception {

		HandlerInterceptor[] interceptors = getInterceptors();
		if (!ObjectUtils.isEmpty(interceptors)) {
			for (int i = this.interceptorIndex; i >= 0; i--) {
				HandlerInterceptor interceptor = interceptors[i];
				try {
					interceptor.afterCompletion(request, response, this.handler, ex);
				}
				catch (Throwable ex2) {
					logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
				}
			}
		}
	}

好了，到这拦截器HandlerInterceptor的整个流程就走完了。其中还有

mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response); 处理异步的情况。

接下来就是如何使用 HandlerInterceptor 实现对请求的拦截，并进行处理了。

Spring MVC HandlerInterceptor 的应用
pom 依赖
		<!-- 增加Jackson的Hibernate类型支持 -->
		<dependency>
			<groupId>com.fasterxml.jackson.datatype</groupId>
			<artifactId>jackson-datatype-hibernate5</artifactId>
			<version>2.9.8</version>
		</dependency>
		<!-- 增加Jackson XML支持 -->
		<dependency>
			<groupId>com.fasterxml.jackson.dataformat</groupId>
			<artifactId>jackson-dataformat-xml</artifactId>
			<version>2.9.0</version>
		</dependency>
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-cache</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.joda</groupId>
			<artifactId>joda-money</artifactId>
			<version>1.0.1</version>
		</dependency>
		<dependency>
			<groupId>org.jadira.usertype</groupId>
			<artifactId>usertype.core</artifactId>
			<version>6.0.1.GA</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
			<scope>runtime</scope>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>com.h2database</groupId>
			<artifactId>h2</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
启动类
@SpringBootApplication
@EnableJpaRepositories
@EnableCaching
public class DemoApplication implements WebMvcConfigurer {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @Bean
    public Hibernate5Module hibernate5Module() {
        return new Hibernate5Module();
    }
	// 实现对返回结果的处理
    @Bean
    public Jackson2ObjectMapperBuilderCustomizer jacksonBuilderCustomizer() {
        return builder -> {
            builder.indentOutput(true);
            builder.timeZone(TimeZone.getTimeZone("Asia/Shanghai"));
        };
    }

    /**
     * 拦截接口为 /coffee 的请求，并用 PerformanceInteceptor 进行处理
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new PerformanceInteceptor()).addPathPatterns("/coffee/**");
    }
}
Controller 类
@Slf4j
@Controller
@RequestMapping("/coffee")
public class CoffeeController {
    @Autowired
    private CoffeeService coffeeService;
	/**
     * 可以返回xml; produces 定义返回结果 accept
     * 
     * @param name
     * @return
     */
    @GetMapping(path = "/get/{name}", produces = MediaType.ALL_VALUE)
    @ResponseBody
    public Coffee getCoffeeByName(@PathVariable(value = "name") String name) {
        return coffeeService.getCoffeeByName(name);
    }
}
拦截器
@Slf4j
public class PerformanceInteceptor implements HandlerInterceptor {

    /**
     * 利用 ThreadLocal，并使用了 StopWatch 计时器
     */
    private ThreadLocal<StopWatch> stopWatch = new ThreadLocal<>();

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        StopWatch sw = new StopWatch();
        stopWatch.set(sw);
        sw.start();
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
            ModelAndView modelAndView) throws Exception {
        stopWatch.get().stop();
        stopWatch.get().start();
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
        StopWatch sw = stopWatch.get();
        sw.stop();
        String method = handler.getClass().getSimpleName();
        if (handler instanceof HandlerMethod) {
            String beanType = ((HandlerMethod) handler).getBeanType().getName();
            String methodName = ((HandlerMethod) handler).getMethod().getName();
            method = beanType + "." + methodName;
        }
        log.info("{};{};{};{};{}ms;{}ms;{}ms", request.getRequestURI(), method, response.getStatus(),
                ex == null ? "-" : ex.getClass().getSimpleName(), sw.getTotalTimeMillis(),
                sw.getTotalTimeMillis() - sw.getLastTaskTimeMillis(), sw.getLastTaskTimeMillis());
        stopWatch.remove();
    }
}

测试结果:

2019-06-16 12:35:30.244  INFO 53392 --- [nio-8080-exec-1] c.b.c.inteceptor.PerformanceInteceptor   : /coffee/get/latte;com.beng.controller.CoffeeController.getCoffeeByName;200;-;221ms;221ms;0ms

完成！

打磨时光
关注
专栏目录
springMVC拦截器HandlerInterceptor用法代码示例
08-28
主要介绍了springMVC拦截器HandlerInterceptor用法代码示例，具有一定借鉴价值,需要的朋友可以参考下
通过Filter获取Http参数后，使用拦截器HandlerInterceptor读取参数进行相关操作
m0_50083902的博客
04-14 1157
*
Spring之拦截器（HandlerInterceptor）
最新发布
ToBeMaybe_的博客
09-06 1467
在web开发中，拦截器是经常用到的功能，用于拦截请求进行预处理和后处理，一般用于以下场景： 1. 日志记录，可以记录请求信息的日志，以便进行信息监控、信息统计、计算PV（Page View）等等。 2. 权限检查：如登陆检测，进入处理器检测是否登陆，如果没有直接返回到登陆页面。 3. 性能监控：有时候系统在某段时间莫名其妙的慢，可以通过拦截器在进入处理器之前记录开始时间，在处理完后记录结束时间，从而得到该请求的处理时间（如果有反向代理，如apache可以自动记录）； 4. 通用行为：读取cooki
Spring HandlerInterceptor的使用
热门推荐
Tomson Xu
05-25 2万+
HandlerInterceptor翻译过来就是spring拦截器，它在某些功能应用上特别有用：1. 用户是否登陆以及用户权限管理 （见http://www.ideawu.net/ideablog/category4/article174.html）2. 根据用户的选择来决定是用HTML还是用Excel来作为View （该应用后面会讲解）3. blackboard building b
SpringMVC教程（九）
qq_39825574的博客
12-08 232
概述 SpringMVC的处理器拦截器类似于Servlet开发中的过滤器Filter,用于对处理器进行预处理和后处理。开发者可以自己定义一些拦截器来实现特定的功能。 过滤器与拦截器的区别：拦截器是AOP思想的具体应用。 过滤器 servlet规范中的一部分，任何java web工程都可以使用 在url-pattern中配置了/*之后，可以对所有要访问的资源进行拦截 拦截器 拦截器是Sp...
JavaWeb中的SpringMVC概述
豆芽胡的博客
07-28 442
之前所说的Spring控制反转和面向切面，主要表达了代码之间解耦合的编程思想。 而现在说的SpringMVC则是一种web框架，跟Struts2一样，SpringMVCt同样可以借助xml的方式，对浏览器请求进行拦截并处理，使得开发人员在编写控制器时更加简单。 两者的相似之处都是通过反射，以及指定相关类，并加载到不同框架的键值对容器里，然后根据url映射，达到控制的目的。 和struts2相
详解Spring MVC拦截器实现session控制
08-31
Spring MVC拦截器是Spring Web框架的一个重要组成部分，它允许开发者在处理请求之前或之后执行自定义的操作，例如权限校验、日志记录等。在本篇文章中，我们详细探讨了如何通过Spring MVC拦截器实现session的控制，...
Spring拦截器HandlerInterceptor接口代码解析
08-28
本文将详细介绍Spring拦截器HandlerInterceptor接口代码解析的实现细节和应用场景。 一、HandlerInterceptor接口 HandlerInterceptor接口是Spring框架中的一种核心接口，它定义了拦截器的行为。该接口提供了三个...
Spring mvc拦截器实现原理解析
08-19
Spring MVC拦截器实现原理解析 Spring MVC拦截器是Spring MVC框架中的一种机制，可以对处理器进行...Spring MVC拦截器提供了一种灵活的机制，可以对处理器进行预处理和后处理，帮助开发者更好地控制应用程序的行为。
Spring MVC 拦截器实现代码
08-31
综上所述，Spring MVC 拦截器提供了一种高效且灵活的方式来增强应用程序的功能，通过简单的配置和实现，可以实现诸如权限控制、日志记录等多种实用功能。同时，了解拦截器与过滤器的区别有助于我们更好地理解和利用...
Spring MVC 拦截器 interceptor 用法详解
08-18
Spring MVC 拦截器 interceptor 用法详解 Spring MVC 中的拦截器（Interceptor）类似于 Servlet 中的过滤器（Filter），它主要用于拦截用户请求并作相应的处理。例如通过拦截器可以进行权限验证、记录请求信息的...
SpringMVC拦截器
weixin_45037981的博客
03-16 196
实现HandlerInterceptor接口不用重写方法的原因： JDK1.8已经进行了方法增强，允许有实现方法。 ctrl+o快捷键可实现某一具体的方法。 index.jsp <h3>拦截器</h3> <a href="user/testInterceptor">拦截器</a> UserController.java package cn.itcast.controller; import org.springframework.stereotype..
SpringMVC之HandlerInterceptor拦截器详解
敲代码的小小酥的博客
10-05 2867
HandlerInterceptor接口 总体注释翻译: 允许自定义处理程序执行链的工作流接口。应用程序可以为某些处理程序组注册任意数量的现有或自定义拦截器，以添加公共预处理行为，而无需修改每个处理程序实现。 在适当的HandlerAdapter触发处理程序本身的执行之前，会调用HandlerInterceptor。此机制可用于大量预处理方面，例如授权检查，或常见的处理程序行为，如区域设置或主题更改。它的主要目的是允许分解出重复的处理程序代码。 通常，拦截器链是根据HandlerMappingbean定义
SpringMVC-HandlerInterceptor拦截器的使用与参数详解
itzhuzhu的博客
01-18 3793
拦截器（ Interceptor）是一种动态拦截方法调用的机制，请求处理过程解析 核心原理： AOP思想 拦截器链：多个拦截器按照一定的顺序，对原始被调用功能进行增强
springMVC:HandlerInterceptor拦截器的使用
sunp823的专栏
06-16 1352
1.使用背景 Web项目中需要判断http接口用户Post上来的数据是否合法，如果不合法要另做处理，用户Post上来的数据是Json形式的，我们用了@RequestBody标记自动将json形式的提交封装为一个Model对象，这样一来，我们就不能判断在自动封装过程中是否出现了异常，此时便想起了springMVC中的interceptor，用于处理请求之前，做一些处理，我们可以取消@Reques...
【归纳总结】SpringMVC之HandlerInterceptor
Octavius_的博客
04-05 388
CharacterEncodingFilter 为了解决数据的中文乱码问题，需要引入Filter来设置编解码格式 在web.xml文件中进行如下配置： <filter> <filter-name>characterEncodingFilter</filter-name> <filter-class>org.springframework.web.filter.CharacterEncodingFilter</fil
Spring —— 拦截器（HandlerInterceptor、WebMvcConfigurer）
看了就会暴富的博客！
01-11 1160
问题 在项目开发过程中经常需要进行某些拦截：接口拦截以进行权限校验，参数校验等等。 解决 使用HandlerInterceptor定义拦截器，并把拦截器添加到WebMvcConfigurer配置器中。 HandlerInterceptor Springboot中的拦截器，里面共提供了三种方法。 方法名 作用 preHandle 在执行请求之前被调用 postHandle 在处理器处理完请求之后，渲染视图之前被调用 afterCompletion 在..
SpringMVC和SpringBoot的拦截器 HandlerInterceptor 入门
z2431435的博客
04-05 871
HandlerInterceptor 接口的三个方法 /** * 预处理回调实现处理器的预处理（如检查登陆），第三个参数为响应的处理器，自定义Controller * 返回值：true表示继续流程（如调用下一个拦截器或处理器）；false表示流程中断（如登录检查失败），不会继续调用其他的拦截器或处理器，此时我们需要通过response来产生响应； * 这个方法将在请求处理之前进行调用。 「注意」：如果该方法的返回值为false ，将视为当前请求结束，不仅自身的拦截器会失效，还会
Spring使用WebMvcConfigurer配置添加HandlerInterceptor拦截器实现权限访问控制等功能
进击的小白
11-25 1541
场景 使用spring boot项目实现web接口时，希望部分访问接口进行安全校验，如用户权限校验等。 方案一：比较low的方式就是在没个接口中增加一个权限校验的代码块，代码比较臃肿。 方案二：可以统一使用spring拦截器实现，合理使用设计模式，代码优雅，管理方便。 代码实现 自定义拦截器类，如需要对请求前后的统一处理 @Component @Slf4j public class CipherAuthInterceptor implements HandlerInterceptor {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值