webapi自定义异常拦截器没作用_webapi 自定义拦截器 - CSDN
精华内容
参与话题
  • Asp.net Web Api开发(第三篇)自定义异常过滤

    如果不自定义异常过滤器,客户端调用API出现错误时,将只能得到一个500之类的错误状态,以及一句:出现错误。而服务端却无法拦截到任何异常代码,当然你也可以在所有Action里面写try-catch来捕获处理。但这不是我想要的,我们可以自定义一个异常过滤器来捕获单个Action或整个Controller里面的所有Action的异常。

    上代码:

    using System.Net;
    using System.Net.Http;
    using System.Web.Http.Filters;
    using RRP.Models.Response;
    
    namespace RRPService.WebApi.Comm
    {
        /// <summary>
        /// 异常处理过滤器
        /// </summary>
        public class DExceptionFilterAttribute : ExceptionFilterAttribute
        {
            public override void OnException(HttpActionExecutedContext context)
            {
                //可以记录一些日志
                string fLog = context.Exception.ToString();
                //篡改Response
                context.Response = new HttpResponseMessage(HttpStatusCode.OK);
                context.Response.Content = new StringContent(Dimoo.Lib.DataPack.JSerialize(new BaseResult() { success = 0, msg = "处理异常" }));
            }
        }
    }

    然后,我们再把这个特性标记到所有Controller上或单个Action上面:

    
    

    using System.Linq;
    using System.Web.Http;
    
    namespace RRPService.WebApi.App.Controllers
    {
        [DExceptionFilter]
        public class CompanyController : ApiController
        {
            [HttpPost]
            [Route("api/1110")]
            public RRP.Company.Models.Response.C3000O Login(RRP.Company.Models.Request.C3000I aIn)
            {
                return RRP.Company.BLL.C3000(aIn);
            }
    
            [DExceptionFilter]
            [HttpPost]
            [Route("api/1110")]
            public RRP.Company.Models.Response.C3001O Login2(RRP.Company.Models.Request.C3001I aIn)
            {
                return RRP.Company.BLL.C3001(aIn);
            }
        }
    }
    
    最后,在Global.asax中注册我们得自定义异常过滤器:

    using RRPService.WebApi.Comm;
    using System.Web.Http;
    using System.Web.Mvc;
    
    namespace RRPService.WebApi.App
    {
        /// <summary>
        /// web api 服务
        /// </summary>
        public class WebApiApplication : System.Web.HttpApplication
        {
            /// <summary>
            /// 服务启动
            /// </summary>
            protected void Application_Start()
            {
                GlobalConfiguration.Configure(WebApiConfig.Register);
                GlobalConfiguration.Configuration.Filters.Add(new DExceptionFilterAttribute());//<<<<------------------重点
                //Json序列化库替换
                HttpConfiguration fConfig = GlobalConfiguration.Configuration;
                fConfig.Formatters.Remove(fConfig.Formatters.JsonFormatter);
                fConfig.Formatters.Remove(fConfig.Formatters.XmlFormatter);
                fConfig.Formatters.Insert(0, new JilFormatter());
            }
        }
    }

    展开全文
  • 在使用MVC WebApi的授权发放GrantResourceOwnerCredentials时候 如何获得自定义返回错误 而不是 context.SetError的默认格式 context.SetError 显示的是 {"error":""}这种 我想要自定义的 比如 {"errorCode":0,...
  • Spring Boot 拦截器

    万次阅读 多人点赞 2016-01-12 09:21:48
    Web开发中,我们除了使用 Filter 来过滤请web求外,还可以使用Spring提供的HandlerInterceptor(拦截器)。HandlerInterceptor 的功能跟过滤器类似,但是提供更精细的的控制能力:在request被响应之前、request被...

    上一篇对过滤器的定义做了说明,也比较简单。过滤器属于Servlet范畴的API,与Spring 没什么关系。
    Web开发中,我们除了使用 Filter 来过滤请web求外,还可以使用Spring提供的HandlerInterceptor(拦截器)。

    HandlerInterceptor 的功能跟过滤器类似,但是提供更精细的的控制能力:在request被响应之前、request被响应之后、视图渲染之前以及request全部结束之后。我们不能通过拦截器修改request内容,但是可以通过抛出异常(或者返回false)来暂停request的执行。

    实现 UserRoleAuthorizationInterceptor 的拦截器有:
    ConversionServiceExposingInterceptor
    CorsInterceptor
    LocaleChangeInterceptor
    PathExposingHandlerInterceptor
    ResourceUrlProviderExposingInterceptor
    ThemeChangeInterceptor
    UriTemplateVariablesHandlerInterceptor
    UserRoleAuthorizationInterceptor

    其中 LocaleChangeInterceptor 和 ThemeChangeInterceptor 比较常用。

    配置拦截器也很简单,Spring 为什么提供了基础类WebMvcConfigurerAdapter ,我们只需要重写 addInterceptors 方法添加注册拦截器。

    实现自定义拦截器只需要3步:
    1、创建我们自己的拦截器类并实现 HandlerInterceptor 接口。
    2、创建一个Java类继承WebMvcConfigurerAdapter,并重写 addInterceptors 方法。
    2、实例化我们自定义的拦截器,然后将对像手动添加到拦截器链中(在addInterceptors方法中添加)。
    PS:本文重点在如何在Spring-Boot中使用拦截器,关于拦截器的原理请大家查阅资料了解。

    代码示例:

    MyInterceptor1.java

    package org.springboot.sample.interceptor;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import org.springframework.web.servlet.HandlerInterceptor;
    import org.springframework.web.servlet.ModelAndView;
    
    /**
     * 自定义拦截器1
     *
     * @author   单红宇(365384722)
     * @myblog  http://blog.csdn.net/catoop/
     * @create    2016年1月7日
     */
    public class MyInterceptor1 implements HandlerInterceptor {
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
                throws Exception {
            System.out.println(">>>MyInterceptor1>>>>>>>在请求处理之前进行调用(Controller方法调用之前)");
    
            return true;// 只有返回true才会继续向下执行,返回false取消当前请求
        }
    
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
                ModelAndView modelAndView) throws Exception {
            System.out.println(">>>MyInterceptor1>>>>>>>请求处理之后进行调用,但是在视图被渲染之前(Controller方法调用之后)");
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
                throws Exception {
            System.out.println(">>>MyInterceptor1>>>>>>>在整个请求结束之后被调用,也就是在DispatcherServlet 渲染了对应的视图之后执行(主要是用于进行资源清理工作)");
        }
    
    }
    

    MyInterceptor2.java

    package org.springboot.sample.interceptor;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import org.springframework.web.servlet.HandlerInterceptor;
    import org.springframework.web.servlet.ModelAndView;
    
    /**
     * 自定义拦截器2
     *
     * @author   单红宇(365384722)
     * @myblog  http://blog.csdn.net/catoop/
     * @create    2016年1月7日
     */
    public class MyInterceptor2 implements HandlerInterceptor {
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
                throws Exception {
            System.out.println(">>>MyInterceptor2>>>>>>>在请求处理之前进行调用(Controller方法调用之前)");
    
            return true;// 只有返回true才会继续向下执行,返回false取消当前请求
        }
    
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
                ModelAndView modelAndView) throws Exception {
            System.out.println(">>>MyInterceptor2>>>>>>>请求处理之后进行调用,但是在视图被渲染之前(Controller方法调用之后)");
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
                throws Exception {
            System.out.println(">>>MyInterceptor2>>>>>>>在整个请求结束之后被调用,也就是在DispatcherServlet 渲染了对应的视图之后执行(主要是用于进行资源清理工作)");
        }
    
    }
    

    MyWebAppConfigurer.java

    package org.springboot.sample.config;
    
    import org.springboot.sample.interceptor.MyInterceptor1;
    import org.springboot.sample.interceptor.MyInterceptor2;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
    
    @Configuration
    public class MyWebAppConfigurer 
            extends WebMvcConfigurerAdapter {
    
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
            // 多个拦截器组成一个拦截器链
            // addPathPatterns 用于添加拦截规则
            // excludePathPatterns 用户排除拦截
            registry.addInterceptor(new MyInterceptor1()).addPathPatterns("/**");
            registry.addInterceptor(new MyInterceptor2()).addPathPatterns("/**");
            super.addInterceptors(registry);
        }
    
    }
    

    然后在浏览器输入地址: http://localhost:8080/index 后,控制台的输出为:

    >>>MyInterceptor1>>>>>>>在请求处理之前进行调用(Controller方法调用之前)
    >>>MyInterceptor2>>>>>>>在请求处理之前进行调用(Controller方法调用之前)
    >>>MyInterceptor2>>>>>>>请求处理之后进行调用,但是在视图被渲染之前(Controller方法调用之后)
    >>>MyInterceptor1>>>>>>>请求处理之后进行调用,但是在视图被渲染之前(Controller方法调用之后)
    >>>MyInterceptor2>>>>>>>在整个请求结束之后被调用,也就是在DispatcherServlet 渲染了对应的视图之后执行(主要是用于进行资源清理工作)
    >>>MyInterceptor1>>>>>>>在整个请求结束之后被调用,也就是在DispatcherServlet 渲染了对应的视图之后执行(主要是用于进行资源清理工作)

    根据输出可以了解拦截器链的执行顺序(具体原理介绍,大家找度娘一问便知)

    最后强调一点:只有经过DispatcherServlet 的请求,才会走拦截器链,我们自定义的Servlet 请求是不会被拦截的,比如我们自定义的Servlet地址 http://localhost:8080/xs/myservlet 是不会被拦截器拦截的。并且不管是属于哪个Servlet 只要复合过滤器的过滤规则,过滤器都会拦截。

    最后说明下,我们上面用到的 WebMvcConfigurerAdapter 并非只是注册添加拦截器使用,其顾名思义是做Web配置用的,它还可以有很多其他作用,通过下面截图便可以大概了解,具体每个方法都是干什么用的,留给大家自己研究(其实都大同小异也很简单)。
    这里写图片描述

    展开全文
  • 创建一个类,继承自UserFilter,实现OnAccessDenied函数即可。 ...import org.apache.shiro.web.filter.authc.UserFilter; import org.apache.shiro.web.servlet.ShiroHttpServletRequest; ...

     

    创建一个类,继承自UserFilter,实现OnAccessDenied函数即可。

    package io.tenglu.modules.sys.shiro;
    
    
    import org.apache.shiro.web.filter.authc.UserFilter;
    import org.apache.shiro.web.servlet.ShiroHttpServletRequest;
    
    import org.springframework.stereotype.Component;
    
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;
    import javax.servlet.http.Cookie;
    
    import javax.servlet.http.HttpSession;
    
    
    @Component
    public class SessionCheckFilter extends UserFilter {
    
    
        @Override
        protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
            ShiroHttpServletRequest rrr = (ShiroHttpServletRequest)request;
            String s = rrr.getRequestURI();
            HttpSession session = rrr.getSession();
            Long t1 = session.getCreationTime();
    
            String userAgent = rrr.getHeader("User-Agent");
            String sid = session.getId();
            String a = rrr.getRequestedSessionId();
            String b = rrr.getQueryString();
            String c = rrr.getPathInfo();
            Cookie d[] = rrr.getCookies();
    
            //是APP访问
            if (userAgent.indexOf("Android-APP") >= 0 || userAgent.indexOf("IOS-APP") >= 0) {
    
                response.getWriter().write("{\"code\":\"101\",\"message\":\"token已失效,请重新登录\"}");
                response.getWriter().flush();
                response.getWriter().close();
            }
            else {//是Web访问
                super.redirectToLogin (request, response);
                //super.isLoginRequest(request,response)
            }
    
            return false;
        }
    
    }
    

    添加过滤器到 setFilterChainDefinitionMap 中,系统访问时,如果session失效,访问被拒绝,则会被自定义的过滤器进行拦截。

    
        @Bean("shiroFilter")
        public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
            ShiroFilterFactoryBean shiroFilter = new ShiroFilterFactoryBean();
            shiroFilter.setSecurityManager(securityManager);
    
            SessionCheckFilter sessionCheckFilter = new SessionCheckFilter();
    
            Map<String, Filter> cumstomfilterMap = new HashMap<>();
            //map里面key值要为authc才能使用自定义的过滤器
            cumstomfilterMap.put("user", sessionCheckFilter);
    
            shiroFilter.setLoginUrl("/login.html");
            shiroFilter.setUnauthorizedUrl("/login.html");
    
            Map<String, String> filterMap = new LinkedHashMap<>();
            filterMap.put("/swagger/**", "anon");
            filterMap.put("/v2/api-docs", "anon");
            filterMap.put("/swagger-ui.html", "anon");
            filterMap.put("/webjars/**", "anon");
            filterMap.put("/swagger-resources/**", "anon");
    
            filterMap.put("/statics/**", "anon");
            filterMap.put("/login.html", "anon");
            filterMap.put("/sys/login", "anon");
            filterMap.put("/sys/logoinfo","anon");
    
            filterMap.put("/app/login", "anon");
            filterMap.put("/app/logout", "anon");
            filterMap.put("/app/getCaptcha", "anon");
            filterMap.put("/favicon.ico", "anon");
            filterMap.put("/captcha.jpg", "anon");
    
            filterMap.put("/**", "user");
    
            shiroFilter.setFilterChainDefinitionMap(filterMap);
    
            shiroFilter.setFilters(cumstomfilterMap);
            return shiroFilter;
        }
    

     

    展开全文
  • 一般情况,在访问RESTful风格的API之前,可以对访问行为进行拦截,并做一些逻辑处理,本文主要介绍三种拦截方式,分别是:过滤器Filter、拦截器Interceptor以及面向切面的拦截方式AOP。 一、使用过滤器Filter...

    一般情况,在访问RESTful风格的API之前,可以对访问行为进行拦截,并做一些逻辑处理,本文主要介绍三种拦截方式,分别是:过滤器Filter、拦截器Interceptor以及面向切面的拦截方式AOP

    一、使用过滤器Filter进行拦截

    使用过滤器进行拦截主要有两种方式,第一种是将自定义的拦截器标注为SpringBean,在Spring Boot应用就可以对RESTful风格的API进行拦截。第二种方式往往应用在继承第三方过滤器,这时候就需要将第三方拦截器使用FilterRegistrationBean对象进行注册即可。接下来详细介绍两种方式。

    • 将拦截器标注为SpringBean
    package com.lemon.security.web.filter;
    
    import org.springframework.stereotype.Component;
    
    import javax.servlet.*;
    import java.io.IOException;
    
    /**
     * @author lemon
     * @date 2018/4/1 下午10:19
     */
    @Component
    public class TimeFilter implements Filter {
    
        @Override
        public void init(FilterConfig filterConfig) throws ServletException {
            System.out.println("time filter init.");
        }
    
        @Override
        public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
                throws IOException, ServletException {
            System.out.println("time filter start.");
            long startTime = System.currentTimeMillis();
            chain.doFilter(request, response);
            System.out.println("time filter 耗时: " + (System.currentTimeMillis() - startTime));
            System.out.println("time filter finish.");
        }
    
        @Override
        public void destroy() {
            System.out.println("time filter destroy.");
        }
    }
    

    启动Spring Boot应用的时候,上面的拦截器就会起作用,当访问每一个服务的时候,都会进入这个拦截器中。初始化方法init和销毁方法destroy只会调用一次,分别是应用启动时候调用init方法,应用关闭时候调用destroy方法。而doFilter方法则在每次都会调用。

    • 将拦截器作为第三方拦截器进行注册

    使用的类还是上面的同一个类,只不过这次不需要@Component注解,这时候我们需要自己写一个配置类,将过滤器注册到Spring容器中。推荐使用这种方式,因为这种方式我们可以自己设置需要拦截的API,否则第一种方式是拦截所有的API

    
    package com.lemon.security.web.config;
    
    import com.lemon.security.web.filter.TimeFilter;
    import org.springframework.boot.web.servlet.FilterRegistrationBean;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @author lemon
     * @date 2018/4/1 下午10:34
     */
    @Configuration
    public class WebConfig {
    
        @Bean
        public FilterRegistrationBean timeFilter() {
            FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
            TimeFilter timeFilter = new TimeFilter();
            filterRegistrationBean.setFilter(timeFilter);
            List<String> urls = new ArrayList<>();
            urls.add("/*");
            filterRegistrationBean.setUrlPatterns(urls);
            return filterRegistrationBean;
        }
    }
    

    这里我设置的仍然是拦截所有的API,可以设置为自定义的方式对API进行拦截。

    二、使用拦截器Interceptor进行拦截

    这里需要定义一个拦截器类,并实现HandlerInterceptor接口,这个接口有三个方法需要实现,分别是:

    boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
    			throws Exception;
    void postHandle(
    			HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
    			throws Exception;
    void afterCompletion(
    			HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
    			throws Exception;
    

    下面对三个方法进行一一解释:

    • preHandle方法的第三个参数是具体的API处理方法的Method对象,我们可以将其强转为HandlerMethod,然后就可以获取该Method的一些属性,比如方法名,方法所在类的类名等信息。preHandle是当访问API之前,都要进入这个方法,由这个方法进行一些逻辑处理,如果处理完结果返回true,那么将继续进入到具体的API中,否则将就地结束访问,逻辑不会进入API方法中。

    • postHandle方法是在API方法访问完成之后立即进入的方法,可以处理一些逻辑,比如将API中的数据封装到ModelAndView中,如果前面的preHandle方法返回false,将不会执行该方法,如果API方法发生了异常,也将不会调用此方法。

    • afterCompletion方法的调用只要preHandle方法通过之后就会调用它,不论API方法是否出现了异常。如果出现了异常,将被封装到Exception对象中。

    下面,写一个自定义的类来实现上述接口:

    package com.lemon.security.web.interceptor;
    
    import org.springframework.stereotype.Component;
    import org.springframework.web.method.HandlerMethod;
    import org.springframework.web.servlet.HandlerInterceptor;
    import org.springframework.web.servlet.ModelAndView;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    /**
     * @author lemon
     * @date 2018/4/1 下午10:39
     */
    @Component
    public class TimeInterceptor implements HandlerInterceptor {
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            System.out.println("preHandler");
            System.out.println(((HandlerMethod) handler).getBean().getClass().getName());
            System.out.println(((HandlerMethod) handler).getMethod().getName());
            request.setAttribute("startTime", System.currentTimeMillis());
            return true;
        }
    
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
            System.out.println("postHandler");
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
            System.out.println("afterCompletion");
            System.out.println("TimeInterceptor耗时:" + (System.currentTimeMillis() - (Long) request.getAttribute("startTime")));
        }
    }
    

    这里需要将其标注为SpringBean,但是仅仅标注为Bean还是不够的,需要在配置类中进行配置。代码如下:

    package com.lemon.security.web.config;
    
    import com.lemon.security.web.interceptor.TimeInterceptor;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
    
    /**
     * @author lemon
     * @date 2018/4/1 下午10:34
     */
    @Configuration
    public class WebConfig extends WebMvcConfigurerAdapter {
    
        @Autowired
        private TimeInterceptor timeInterceptor;
    
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
            registry.addInterceptor(timeInterceptor);
        }
    }
    

    这个配置类需要继承WebMvcConfigurerAdapter,并重写添加拦截器的方法addInterceptors,将自定义拦截器添加到应用中。这时候拦截器就生效了。

    三、使用AOP进行拦截

    其实是有拦截器InterceptorAPI进行拦截的时候是有缺陷的,因为无法获取前端访问API的时候所携带的参数的,为什么会这么说?从Spring MVCDispatcherServlet的源代码中可以发现,找到doDispatch方法,也就是请求分发的方法,有一段代码如下:
    这里写图片描述
    如果我们自定的InterceptorpreHandler方法返回的是false,分发任务就会截止,不再继续执行下面的代码,而下面的一行代码正是将前端携带的参数进行映射的逻辑,也就是说,preHandler方法不会接触到前端携带来的参数,也就是说拦截器无法处理参数。所以这里引进AOP进行拦截。
    AOP的核心概念解释:
    描述AOP常用的一些术语有通知(Adivce)、切点(Pointcut)、连接点(Join point)、切面(Aspect)、引入(Introduction)、织入(Weaving

    • 通知(Advice

    通知分为五中类型:
    Before:在方法被调用之前调用
    After:在方法完成后调用通知,无论方法是否执行成功
    After-returning:在方法成功执行之后调用通知
    After-throwing:在方法抛出异常后调用通知
    Around:通知了好、包含了被通知的方法,在被通知的方法调用之前后调用之后执行自定义的行为

    • 连接点(Join point

    连接点是一个应用执行过程中能够插入一个切面的点。比如:方法调用、方法执行、字段设置/获取、异常处理执行、类初始化、甚至是for循环中的某个点。理论上, 程序执行过程中的任何时点都可以作为作为织入点, 而所有这些执行时点都是Joint point,但 Spring AOP 目前仅支持方法执行 (method execution)。

    • 切点(Pointcut

    通知(advice)定义了切面何时,那么切点就是定义切面“何处” 描述某一类 Joint points, 比如定义了很多 Joint point, 对于 Spring AOP 来说就是匹配哪些方法的执行。

    • 切面(Aspect

    切面是切点和通知的结合。通知和切点共同定义了关于切面的全部内容,它是什么时候,在何时和何处完成功能。

    • 引入(Introduction

    引用允许我们向现有的类添加新的方法或者属性

    • 织入(Weaving

    组装方面来创建一个被通知对象。这可以在编译时完成(例如使用AspectJ编译器),也可以在运行时完成。Spring和其他纯Java AOP框架一样,在运行时完成织入。

    上面的概念有点生涩难懂,总结一个核心内容:切面 = 切点 + 通知
    现在通过代码来编写一个切面:

    package com.lemon.security.web.aspect;
    
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.springframework.stereotype.Component;
    
    /**
     * @author lemon
     * @date 2018/4/2 上午10:40
     */
    @Aspect
    @Component
    public class TimeAspect {
    
        @Around("execution(* com.lemon.security.web.controller.UserController.*(..))")
        public Object handleTime(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
            System.out.println("time aspect is start.");
            for (Object object : proceedingJoinPoint.getArgs()) {
                System.out.println(object);
            }
            long startTime = System.currentTimeMillis();
            Object obj = proceedingJoinPoint.proceed();
            System.out.println("time aspect 耗时:" + (System.currentTimeMillis() - startTime));
            System.out.println("time aspect finish.");
            return obj;
        }
    }
    

    @Around定义了环绕通知,也就是定义了何时使用切面,表达式"execution(* com.lemon.security.web.controller.UserController.*(..))"定义了再哪里使用。ProceedingJoinPoint对象的proceed()方法表示执行被拦截的方法,它有一个Object类型的返回值,是原有方法的返回值,后期使用的时候往往需要强转。关于切点的表达式,可以访问Spring官方文档
    对于上面三种拦截方式,他们的执行有一个基本的顺序,进入的顺序是Filter-->Interceptor-->Aspect-->Controller-->Aspect-->Interceptor-->Filter(不考虑异常的发生)。如下图所示:
    这里写图片描述

    Spring Security技术栈开发企业级认证与授权系列文章列表:

    Spring Security技术栈学习笔记(一)环境搭建
    Spring Security技术栈学习笔记(二)RESTful API详解
    Spring Security技术栈学习笔记(三)表单校验以及自定义校验注解开发
    Spring Security技术栈学习笔记(四)RESTful API服务异常处理
    Spring Security技术栈学习笔记(五)使用Filter、Interceptor和AOP拦截REST服务
    Spring Security技术栈学习笔记(六)使用REST方式处理文件服务
    Spring Security技术栈学习笔记(七)使用Swagger自动生成API文档
    Spring Security技术栈学习笔记(八)Spring Security的基本运行原理与个性化登录实现
    Spring Security技术栈学习笔记(九)开发图形验证码接口
    Spring Security技术栈学习笔记(十)开发记住我功能
    Spring Security技术栈学习笔记(十一)开发短信验证码登录
    Spring Security技术栈学习笔记(十二)将短信验证码验证方式集成到Spring Security
    Spring Security技术栈学习笔记(十三)Spring Social集成第三方登录验证开发流程介绍
    Spring Security技术栈学习笔记(十四)使用Spring Social集成QQ登录验证方式
    Spring Security技术栈学习笔记(十五)解决Spring Social集成QQ登录后的注册问题
    Spring Security技术栈学习笔记(十六)使用Spring Social集成微信登录验证方式

    示例代码下载地址:

    项目已经上传到码云,欢迎下载,内容所在文件夹为chapter005

    更多干货分享,欢迎关注我的微信公众号:爪哇论剑(微信号:itlemon)
    在这里插入图片描述

    展开全文
  • Web API系列(三)统一异常处理

    千次阅读 2018-08-17 17:00:03
    前面讲了webapi的安全验证和参数安全,不清楚的朋友,可以看看前面的文章,《Web API系列(二)接口安全和参数校验》,本文主要介绍Web API异常结果的处理。作为内部或者是对外提供的统一webapi 接口,统一的异常处理...
  • web系统开发过程中经常遇见400/404/500类型的错误页面,对于开发人员而言见到这种页面多了可能觉得问题不大,但是实际是很重要的,需要配置一个合理的自定义错误页面。 本文只提通过springmvc controller配置自定义...
  • HandlerMethodArgumentResolver用于统一获取当前登录用户

    千次阅读 多人点赞 2019-08-19 00:13:56
    3.1 自定义权限拦截器 3.2 自定义参数注解 3.3 自定义方法参数解析器 3.4 配置MVC 环境:SpringBoot 2.0.4.RELEASE 需求:很多Controller方法,刚进来要先获取当前登录用户的信息,以便做后续的用户相关操作。 ...
  • 前言 这里了解一下restful api的拦截,文本主要介绍三种方式来对...当然,下面介绍的拦截器、过滤器、切片功能不全一样,侧重点不同。希望可以给大家带来帮助。 应用 过滤器方式实现拦截 1、自定义过滤器:...
  • 十二、springboot 详解RestControllerAdvice(ControllerAdvice)

    万次阅读 多人点赞 2020-01-20 11:07:12
    springboot 详解RestControllerAdvice(ControllerAdvice)拦截异常并统一处理 简介 @Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented @Component public @interface ControllerAdvice {...
  • Web开发中,我们除了使用 Filter 来过滤请web求外,还可以使用Spring提供的HandlerInterceptor(拦截器)。HandlerInterceptor 的功能跟过滤器类似,但是提供更精细的的控制能力:在request被响应之前、request被...
  • resteasy 统一的异常处理handler

    千次阅读 2014-05-19 09:27:08
    一般的,我们在使用resteasy api的时候,都会碰到一个问题就是,若使用spring管理resteasy api
  •  Web开发中,我们除了使用 Filter 来过滤请web求外,还可以使用Spring提供的HandlerInterceptor(拦截器)。 HandlerInterceptor 的功能跟过滤器类似,但是提供更精细的的控制能力:在request被响应之前、...
  • 这篇文章是我们企业开发实战篇应用spring拦截器的第二篇文章,第一篇《解决跨域问题》,该篇文章我们主要讲解下如何使用拦截器+自定义注解来实现登录鉴权校验的功能,关于拦截器自定义注解的基础语法下面也会稍带...
  • 全局异常拦截器: 解决写每个接口都需要去做容错而添加try{}catch{},有了该异常拦截器后,所有接口都不需要去添加异常处理。 实现方式: 第一步:新建一个类继承 IExceptionFilter,添加 using Microsoft....
  • 最近用springboot项目开发了一个后端的接口应用层。但是业务上要有最基本的登陆状态的校验,...自定义拦截器实现比较简单。分为两步: 1.通过implements HandlerInterceptor来实现自定义拦截器。 2.通过 implement...
  • Spring Boot API 版本权限控制

    万次阅读 热门讨论 2019-04-13 16:56:35
    Spring Boot API 版本权限控制 之前有文章讲述在Spring MVC 中扩展 RequestMappingHandlerMapping 实现对版本的控制。 但是在真正使用过程中不是很理想化,因为其需要替换掉WebMvcConfigurationSupport,替换后后...
  • springboot WebMvcConfigurer与HandlerInterceptorAdapter使用 简介 WebMvcConfigurer:... 拦截组件HandlerInterceptorAdapter可以有多个,需要注册到WebMvcConfigurer里面,在WebMvcConfigurer里面拦截器是按顺...
  •  Web开发中,我们除了使用 Filter 来过滤请web求外,还可以使用Spring提供的HandlerInterceptor(拦截器)。 HandlerInterceptor 的功能跟过滤器类似,但是提供更精细的的控制能力:在request被响应之前、...
  • 过滤 概念 Filter(过滤)是 Java 组件,允许运行过程中改变进入资源的请求和资源返回的响应中的有效负载和头信息。 Java Servlet API 类和方法提供了一种轻量级的框架用于过滤动态和静态内容。 还描述了如何在 ...
1 2 3 4 5 ... 20
收藏数 15,703
精华内容 6,281
关键字:

webapi自定义异常拦截器没作用