Apache Shiro --- 9 filter and ana annotation

阅读数:0次 2021-02-03

字数统计: 7.2k字 | 阅读时长≈ 32分

我们都知道shiro是个认证权限框架，除了登录、退出逻辑我们需要侵入项目代码之外，验证用户是否已经登录、是否拥有权限的代码其实都是过滤器来完成的（包含注解），可以这么说，shiro其实就是一个过滤器链集合。当运行web应用程序时，Shiro将创建一些有用的默认过滤器实例，并使它们在[main]部分自动可用。您可以像配置任何其他bean一样在main中配置它们，并在链定义中引用它们。

1、filter

默认筛选器实例由DefaultFilter enum中定义，enum s name字段是可用于配置的名称。

于是我看了一下DefaultFilter的源码：

public enum DefaultFilter {
    // onPreHandle()一定返回true
    anon(AnonymousFilter.class),
    authc(FormAuthenticationFilter.class),
    authcBasic(BasicHttpAuthenticationFilter.class),
    logout(LogoutFilter.class),
    noSessionCreation(NoSessionCreationFilter.class),
    perms(PermissionsAuthorizationFilter.class),
    port(PortFilter.class),
    rest(HttpMethodPermissionFilter.class),
    roles(RolesAuthorizationFilter.class),
    ssl(SslFilter.class),
    user(UserFilter.class);
    ...
}

/admin/**=anon ：无参，表示可匿名访问
/admin/user/**=authc ：无参，表示需要认证才能访问
/admin/user/**=authcBasic ：无参，表示需要httpBasic认证才能访问
/admin/user/**=ssl ：无参，表示需要安全的URL请求，协议为https
/home=user ：表示用户不一定需要通过认证，只要曾被 Shiro 记住过登录状态就可以正常发起 /home 请求
/edit=authc,perms[admin:edit]：表示用户必需已通过认证，并拥有 admin:edit 权限才可以正常发起 /edit 请求
/admin=authc,roles[admin] ：表示用户必需已通过认证，并拥有 admin 角色才可以正常发起 /admin 请求
/admin/user/**=port[8081] ：当请求的URL端口不是8081时，跳转到schemal://serverName:8081?queryString
/admin/user/**=rest[user] ：根据请求方式来识别，相当于 /admins/user/**=perms[user:get]或perms[user:post] 等等
/admin**=roles["admin,guest"] ：允许多个参数（逗号分隔），此时要全部通过才算通过，相当于hasAllRoles()
/admin**=perms["user:add:*,user:del:*"]：允许多个参数（逗号分隔），此时要全部通过才算通过，相当于isPermitedAll()

终于知道我们常用的anon、authc、perms、roles、user过滤器是哪里来的了！这些过滤器我们都是可以直接使用的。但你要弄清楚这些默认过滤器，你还不得不去深入了解一下shiro更底层为我们提供的过滤器，基本我们的这些默认过滤器都是通过继承这几个底层过滤器演变而来的。

1、AbstractFilter

这个过滤器还得说说，shiro最底层的抽象过滤器，虽然我们极少直接继承它，它通过实现Filter获得过滤器的特性。子类初始化逻辑应通过重onFilterConfigSet()模板方法来执行。FilterChain执行逻辑javax.servlet.ServletRequest，javax.servlet.ServletResponse，javax.servlet.FilterChain方法留给子类。保存了Servlet的相关配置。

完成一些过滤器基本初始化操作，FilterConfig：过滤器配置对象，用于servlet容器在初始化期间将信息传递给其他过滤器。

2、NameableFilter

命名过滤器，给过滤器定义名称,保存了该Filter的名称！也是比较基层的过滤器了，未拓展其他功能，我们很少会直接继承这个过滤器。为重写doFilter方法。

3、OncePerRequestFilter

保证了在每次处理 http 请求时，保证该 filter 只会执行一次。重写doFilter方法，保证每个servlet方法只会被过滤一次。可以看到doFilter方法中，第一行代码就是String alreadyFilteredAttributeName = getAlreadyFilteredAttributeName();然后通过request.getAttribute(alreadyFilteredAttributeName) != null来判断过滤器是否已经被调用过，从而保证过滤器不会被重复调用。

进入方法之前，先标记alreadyFilteredAttributeName为True，抽象doFilterInternal方法执行之后再remove掉alreadyFilteredAttributeName。

public final void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
        String alreadyFilteredAttributeName = getAlreadyFilteredAttributeName();
    	// 不为null则已经调用过该filter
        if ( request.getAttribute(alreadyFilteredAttributeName) != null ) {
            log.trace("Filter '{}' already executed.  Proceeding without invoking this filter.", getName());
            filterChain.doFilter(request, response);
            
            //isEnabled(request, response)如果此过滤器应过滤指定的请求，则返回true
            //shouldNotFilter(request) 可以在子类中重写以进行自定义过滤控制，返回true以避免过滤给定的请求。
        } else  if (/* added in 1.2: */ !isEnabled(request, response) ||
                /* retain backwards compatibility: */ shouldNotFilter(request) ) {
            log.debug("Filter '{}' is not enabled for the current request.  Proceeding without invoking this filter.",
                    getName());
            filterChain.doFilter(request, response);
        } else {
            // 调用此过滤器
            log.trace("Filter '{}' not yet executed.  Executing now.", getName());
            // 设置已经调用完该过滤器
            request.setAttribute(alreadyFilteredAttributeName, Boolean.TRUE);

            try {
                //真正执行的的过滤器处理逻辑，子类重写
                doFilterInternal(request, response, filterChain);
            } finally {
                //请求完成后，不再需要将其标记为“已过滤”。
                request.removeAttribute(alreadyFilteredAttributeName);
            }
        }
    }

所以OncePerRequestFilter过滤器保证只会被一次调用的功能，提供了抽象方法doFilterInternal让后面的过滤器可以重写，执行真正的过滤器处理逻辑。

1 2	protected abstract void doFilterInternal(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException;

这个过滤器我们已经可以开始在我们的项目继承使用，比如拦截用户请求，判断用户是否已经登录（携带token或cookie信息），如果未登录则返回Json数据告知未登录！

比如：
开源mblog博客项目中，过滤器就是继承OncePerRequestFilter。

https://gitee.com/mtons/mblog

public class AuthenticatedFilter extends OncePerRequestFilter {

    // 前端弹窗的js代码
    private static final String JS = "<script type='text/javascript'>var wp=window.parent; if(wp!=null){while(wp.parent&&wp.parent!==wp){wp=wp.parent;}wp.location.href='%1$s';}else{window.location.href='%1$s';}</script>";
    private String loginUrl = "/login";

    // 重写doFilterInternal方法
    @Override
    protected void doFilterInternal(ServletRequest request, ServletResponse response, FilterChain chain)
            throws ServletException, IOException {

        Subject subject = SecurityUtils.getSubject();
        // 已经登陆就跳过过滤器
        if (subject.isAuthenticated() || subject.isRemembered()) {
            chain.doFilter(request, response);
        } else {
            // 未登录就返回json或者js代码
            WebUtils.saveRequest(request);
            String path = WebUtils.getContextPath((HttpServletRequest) request);
            String url = loginUrl;
            if (StringUtils.isNotBlank(path) && path.length() > 1) {
                url = path + url;
            }

            if (isAjaxRequest((HttpServletRequest) request)) {
                response.setContentType("application/json;charset=UTF-8");
                response.getWriter().print(JSON.toJSONString(Result.failure("您还没有登录!")));
            } else {
                response.getWriter().write(new Formatter().format(JS, url).toString());
            }
        }
    }
}

未登录情况，ajax请求过滤器返回您还没有登录!提示，web请求则返回一段js代码，前端渲染会跳出一个登陆窗口，这也就是未什么大家常遇到的点击登录，当前跳出一个登陆弹窗的一种实现方式！

效果：

4、AdviceFilter(doFilterInternal分化成了切面编程)

看到Advice，很自然想到切面环绕编程，一般有pre、post、after几个方法。所以这个AdviceFilter过滤器就是提供了和AOP相似的切面功能。

继承OncePerRequestFilter过滤器重写doFilterInternal方法，我们可以先看看：

public void doFilterInternal(ServletRequest request, ServletResponse response, FilterChain chain)
            throws ServletException, IOException {
        Exception exception = null;
        try {
            // preHandle 前置过滤，默认true。false 过滤器则不执行真正处理逻辑，相当于放心
            boolean continueChain = preHandle(request, response);
            if (log.isTraceEnabled()) {
                log.trace("Invoked preHandle method.  Continuing chain?: [" + continueChain + "]");
            }
            if (continueChain) {
                // executeChain 执行真正代码过滤逻辑->chain.doFilter
                executeChain(request, response, chain);
            }
            // postHandle 后置过滤
            postHandle(request, response);
            if (log.isTraceEnabled()) {
                log.trace("Successfully invoked postHandle method");
            }
        } catch (Exception e) {
            exception = e;
        } finally {
            // cleanup 其实主要逻辑是afterCompletion方法
            cleanup(request, response, exception);
        }
    }

于是，我们从OncePerRequestFilter的一个doFilterInternal分化成了切面编程，更容易前后控制执行逻辑。所以如果继承AdviceFilter时候，我们可以重写preHandle方法，判断用户是否满足已登录或者其他业务逻辑，返回false时候表示不通过过滤器。

5、PathMatchingFilter (出现onPreHandle)

请求路径匹配过滤器，通过匹配请求url，判断请求是否需要过滤，如果url未在需要过滤的集合内，则跳过，否则进入isFilterChainContinued的onPreHandle方法。

我们可以看下代码：

// 路径配置过滤器则放行，不匹配则启用过滤器。放行之后不执行过滤逻辑所以不登录啥的都没问题
protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
    	// AppliedPaths属性为null或为空。该过滤器将立即通过，放行
  		// 配置路径条目的集合，其中键是此过滤器应处理的路径，并且值是该过滤器特定于该特定路径的（可能为null）配置元素。 换句话说，键是此筛选器将处理的路径（URL）。protected Map<String, Object> appliedPaths = new LinkedHashMap<String, Object>();
        if (this.appliedPaths == null || this.appliedPaths.isEmpty()) {
            if (log.isTraceEnabled()) {
                log.trace("appliedPaths property is null or empty.  This Filter will passthrough immediately.");
            }
            return true;
        }

        for (String path : this.appliedPaths.keySet()) {
            // 如果路径确实匹配，则继续进行子类实现以进行特定检查
            //(first match 'wins'):
            if (pathsMatch(path, request)) {
                log.trace("当前requestURI匹配模式“ {}”。确定过滤器链执行", path);
                Object config = this.appliedPaths.get(path);
                return isFilterChainContinued(request, response, path, config);
            }
        }

        //no path matched, allow the request to go through:
        return true;
    }

private boolean isFilterChainContinued(ServletRequest request, ServletResponse response,
                                           String path, Object pathConfig) throws Exception {

        if (isEnabled(request, response, path, pathConfig)) { //isEnabled check added in 1.2
            if (log.isTraceEnabled()) {
                log.trace("使用配置[{}]为路径“ {}”下的当前请求启用了过滤器“ {}”。 “ +”委托子类实现“ onPreHandle”检查。",new Object[]{getName(), path, pathConfig});
            }
            //为此特定请求启用了过滤器，因此委托子类实现，以便他们可以确定请求是否应继续通过链：
            return onPreHandle(request, response, pathConfig);
        }

        if (log.isTraceEnabled()) {
            log.trace("使用配置[{}]的路径'{}'下当前请求的过滤器'{}'被禁用。 FilterChain中的下一个元素将立即被调用。",
                    new Object[]{getName(), path, pathConfig});
        }
        //对此特定请求禁用此过滤器，立即返回“ true”以指示该过滤器将不处理请求，并让请求/响应继续通过过滤器链：
        return true;
    }

从上面3个步骤中可以看到，PathMatchingFilter提供的功能是：自定义匹配url，匹配上的请求最终跳转到onPreHandle方法。

这个过滤器为后面的常用过滤器提供的基础，比如我们在config中配置如下

1 2	/login = anon /admin/* = authc

拦截/login请求，经过AnonymousFilter过滤器，我们可以看下

org.apache.shiro.web.filter.authc.AnonymousFilter

public class AnonymousFilter extends PathMatchingFilter {

    @Override
    protected boolean onPreHandle(ServletRequest request, ServletResponse response, Object mappedValue) {
        // Always return true since we allow access to anyone
        return true;
    }
}

AnonymousFilter重写了onPreHandle方法，只不过直接返回了true，说明拦截的链接可以直接通过，不需要其他拦截逻辑。

而authc->FormAuthenticationFilter也是间接继承了PathMatchingFilter。

1	public class FormAuthenticationFilter extends AuthenticatingFilter

所以，需要拦截某个链接进行业务逻辑过滤的可以继承PathMatchingFilter方法拓展哈。

6、AccessControlFilter

访问控制过滤器。继承PathMatchingFilter过滤器，重写onPreHandle方法，又分出了两个抽象方法来控制

public boolean onPreHandle(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {
    // isAccessAllowed 是否允许访问 如果允许请求正常通过过滤器，则返回true,如果请求应由请求方处理，则返回false
    // onAccessDenied 是否拒绝访问 处理由isAccessAllowed方法确定的请求被拒绝访问的请求。
    return isAccessAllowed(request, response, mappedValue) || onAccessDenied(request, response, mappedValue);
}

所以，我们现在可以通过重写这个抽象两个方法来控制过滤逻辑。另外多提供了3个方法，方便后面的过滤器使用。

//子类在需要登录重定向时使用的便捷方法。
protected void saveRequestAndRedirectToLogin(ServletRequest request, ServletResponse response) throws IOException {
    saveRequest(request);
    redirectToLogin(request, response);
}
//来保存请求状态，以备后用。当发出重定向以将用户返回到其最初请求的url /资源时，通常用于保留用户请求状态。
protected void saveRequest(ServletRequest request) {
    WebUtils.saveRequest(request);
}
//请求重定向到该url。果要发出重定向以允许用户随后返回其最初请求的URL，请勿直接使用此方法。使用saveRequestAndRedirectToLogin(ServletRequest request, ServletResponse response) 
protected void redirectToLogin(ServletRequest request, ServletResponse response) throws IOException {
    String loginUrl = getLoginUrl();
    WebUtils.issueRedirect(request, response, loginUrl);
}

其中redirectToLogin提供了调整到登录页面的逻辑与实现，为后面的过滤器发现未登录跳转到登录页面提供了基础。

这个过滤器，我们可以灵活运用。

7、AuthenticationFilter

继承AccessControlFilter，重写了isAccessAllowed方法，通过判断用户是否已经完成登录来判断用户是否允许继续后面的逻辑判断。这里可以看出，从这个过滤器开始，后续的判断会与用户的登录状态相关，直接继承这些过滤器，我们不需要再自己手动去判断用户是否已经登录。并且提供了登录成功之后跳转的方法。

public abstract class AuthenticationFilter extends AccessControlFilter {
    public void setSuccessUrl(String successUrl) {
        this.successUrl = successUrl;
    }

    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        Subject subject = getSubject(request, response);
        return subject.isAuthenticated();
    }
}

8、AuthenticatingFilter

继承AuthenticationFilter，提供了自动登录、是否登录请求等方法。

/**
 * 公众号：MarkerHub
**/
public abstract class AuthenticatingFilter extends AuthenticationFilter {
    public static final String PERMISSIVE = "permissive";

    //TODO - complete JavaDoc

    protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
        AuthenticationToken token = createToken(request, response);
        if (token == null) {
            String msg = "createToken method implementation returned null. A valid non-null AuthenticationToken " +
                    "must be created in order to execute a login attempt.";
            throw new IllegalStateException(msg);
        }
        try {
            Subject subject = getSubject(request, response);
            subject.login(token);
            return onLoginSuccess(token, subject, request, response);
        } catch (AuthenticationException e) {
            return onLoginFailure(token, e, request, response);
        }
    }

    protected abstract AuthenticationToken createToken(ServletRequest request, ServletResponse response) throws Exception;
    
    /**
     *
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        return super.isAccessAllowed(request, response, mappedValue) ||
                (!isLoginRequest(request, response) && isPermissive(mappedValue));
    }
    ...
}

executeLogin 执行登录
onLoginSuccess 登录成功跳转
onLoginFailure 登录失败跳转
createToken 创建登录的身份token
isAccessAllowed 是否允许被访问
isLoginRequest 是否登录请求

这个方法提供了自动登录的课程，比如我们获取到token之后实行自动登录，这场景还是很场景的。

比如在开源项目renren-fast中，就是这样处理的：

https://gitee.com/renrenio/re…

public class OAuth2Filter extends AuthenticatingFilter {

    @Override
    protected AuthenticationToken createToken(ServletRequest request, ServletResponse response) throws Exception {
        //获取请求token
        String token = getRequestToken((HttpServletRequest) request);

        if(StringUtils.isBlank(token)){
            return null;
        }

        return new OAuth2Token(token);
    }

    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        if(((HttpServletRequest) request).getMethod().equals(RequestMethod.OPTIONS.name())){
            return true;
        }

        return false;
    }

    @Override
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
        //获取请求token，如果token不存在，直接返回401
        String token = getRequestToken((HttpServletRequest) request);
        if(StringUtils.isBlank(token)){
            HttpServletResponse httpResponse = (HttpServletResponse) response;
            httpResponse.setHeader("Access-Control-Allow-Credentials", "true");
            httpResponse.setHeader("Access-Control-Allow-Origin", HttpContextUtils.getOrigin());

            String json = new Gson().toJson(R.error(HttpStatus.SC_UNAUTHORIZED, "invalid token"));

            httpResponse.getWriter().print(json);

            return false;
        }

        return executeLogin(request, response);
    }


    @Override
    protected boolean onLoginFailure(AuthenticationToken token, AuthenticationException e, ServletRequest request, ServletResponse response) {
        HttpServletResponse httpResponse = (HttpServletResponse) response;
        httpResponse.setContentType("application/json;charset=utf-8");
        httpResponse.setHeader("Access-Control-Allow-Credentials", "true");
        httpResponse.setHeader("Access-Control-Allow-Origin", HttpContextUtils.getOrigin());
        try {
            //处理登录失败的异常
            Throwable throwable = e.getCause() == null ? e : e.getCause();
            R r = R.error(HttpStatus.SC_UNAUTHORIZED, throwable.getMessage());

            String json = new Gson().toJson(r);
            httpResponse.getWriter().print(json);
        } catch (IOException e1) {

        }

        return false;
    }

    /**
     * 获取请求的token
     */
    private String getRequestToken(HttpServletRequest httpRequest){
        //从header中获取token
        String token = httpRequest.getHeader("token");

        //如果header中不存在token，则从参数中获取token
        if(StringUtils.isBlank(token)){
            token = httpRequest.getParameter("token");
        }

        return token;
    }

}

在onAccessDenied方法校验通过之后执行executeLogin方法完成自动登录！

9、FormAuthenticationFilter

基于form表单的账号密码自动登录的过滤器，我们只需要看这个方法就明白，和renren-fast的实现相似：

public class FormAuthenticationFilter extends AuthenticatingFilter {

    public static final String DEFAULT_USERNAME_PARAM = "username";
    public static final String DEFAULT_PASSWORD_PARAM = "password";
    public static final String DEFAULT_REMEMBER_ME_PARAM = "rememberMe";

    protected AuthenticationToken createToken(ServletRequest request, ServletResponse response) {
        String username = getUsername(request);
        String password = getPassword(request);
        return createToken(username, password, request, response);
    }

    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
        if (isLoginRequest(request, response)) {
            if (isLoginSubmission(request, response)) {
                if (log.isTraceEnabled()) {
                    log.trace("Login submission detected.  Attempting to execute login.");
                }
                return executeLogin(request, response);
            } else {
                if (log.isTraceEnabled()) {
                    log.trace("Login page view.");
                }
                //allow them to see the login page ;)
                return true;
            }
        } else {
            if (log.isTraceEnabled()) {
                log.trace("Attempting to access a path which requires authentication.  Forwarding to the " +
                        "Authentication url [" + getLoginUrl() + "]");
            }

            saveRequestAndRedirectToLogin(request, response);
            return false;
        }
    }
}

onAccessDenied调用executeLogin方法。默认的token是UsernamepasswordToken。

10、AbstractShiroFilter

10.1 主filter

shrio 只会创建一个主 Filter，嵌入到Servlet中。然后其它的独立 Filter 会被添加到主 Filter 里，这种设计可以简化对Servlet的修改，并且可以自定义管理多个独立 Filter。主 Filter 会以 Chain 的方式来组织管理，如下图所示。主 Filter 根据请求的路径不同，选择不同的 FilterChain 来处理。

AbstractShiroFilter作为实现主 Filter 的核心类，需要详细讲解。它在处理请求时，会先创建Subject实例，然后开辟新线程来处理。

public abstract class AbstractShiroFilter extends OncePerRequestFilter {
    
    protected void doFilterInternal(ServletRequest servletRequest, ServletResponse servletResponse, final FilterChain chain) {         
        final ServletRequest request = prepareServletRequest(servletRequest, servletResponse, chain);
        final ServletResponse response = prepareServletResponse(request, servletResponse, chain);
        // 创建Subject，这里会创建WebSubject类型的实例
        final Subject subject = createSubject(request, response);
        subject.execute(new Callable() {
            public Object call() throws Exception {
                updateSessionLastAccessTime(request, response);
                // 执行 filter chain
                executeChain(request, response, chain);
                return null;
            }
        });
    }
}

在创建线程的时候，shiro 做了一些初始化，它会绑定当前的Subject和SecurityManager，存储到线程上下文。结合之前的文章，就可以看到线程安全的使用。

继续看看executeChain的代码，可以看到 shiro 会有一个根据请求选择FilterChain的过程。

public abstract class AbstractShiroFilter extends OncePerRequestFilter {
    
	protected void executeChain(ServletRequest request, ServletResponse response, FilterChain origChain) {
        // 选择对应的FilterChain执行
        FilterChain chain = getExecutionChain(request, response, origChain);
        chain.doFilter(request, response);
    }
}java

FilterChain 匹配原理

shiro 支持根据请求来选择对应的FilterChain，这个功能由FilterChainResolver接口定义。

public interface FilterChainResolver {
    // 根据请求来获取对应的FilterChain
    FilterChain getChain(ServletRequest request, ServletResponse response, FilterChain originalChain);
}

它有两个子类，PathMatchingFilterChainResolver和SimpleFilterChainResolver，都是根据请求路径来判断的。两者的实现没什么本质区别，都是使用Map保存了匹配规则和对应的FilterChain，只不过前者将路径匹配和FilterChain管理分离开了。

SimpleFilterChainResolver 类

首先来讲讲SimpleFilterChainResolver的原理，它非常简单

class SimpleFilterChainResolver implements FilterChainResolver {
    // key 为 匹配路径，value 为 Filter列表。
    private final Map<String, Key<? extends Filter>[]> chains;
    
    public FilterChain getChain(ServletRequest request, ServletResponse response, final FilterChain originalChain) {
        // 提取请求路径
        String path = WebUtils.getPathWithinApplication(WebUtils.toHttp(request));
        // 然后遍历Map，直到找到第一个路径匹配的FilterChain，返回封装后的SimpleFilterChain
        for (final String pathPattern : chains.keySet()) {
            if (patternMatcher.matches(pathPattern, path)) {
                final Iterator<Key<? extends Filter>> chain = Arrays.asList(chains.get(pathPattern)).iterator();
                return new SimpleFilterChain(originalChain, new Iterator<Filter>();
                                             }
                                             }

SimpleFilterChain包含了两部分的Filter，原始的 Serlvet FilterChain，和上述Filter列表。它被调用时，会先执行Filter列表，然后再执行Serlvet FilterChain。

class SimpleFilterChain implements FilterChain {
    // Serlvet 的 FilterChain 
    private final FilterChain originalChain;
    
    // Filter 列表
    private final Iterator<? extends Filter> chain;   
}

PathMatchingFilterChainResolver类

PathMatchingFilterChainResolver是 shiro 默认的实现类，它只负责匹配的功能，管理FilterChain的功能被分离开来了，使得我们可以自由定义FilterChain。

管理FilterChain的功能由FilterChainManager负责，目前只有DefaultFilterChainManager一种实现。它的实现也非常简单，我们通过设置filters和filterChains的值，就可以完成配置。

public class DefaultFilterChainManager implements FilterChainManager {
 
    // 保存所有的Filter，key为filter的名称，value为filter实例
    private Map<String, Filter> filters;
    
    // 保存FilterChain，key为匹配路径，value为NamedFilterList实例，保存了filter列表
    private Map<String, NamedFilterList> filterChains;
    
}

10.2 独立 Filter

我们再来看看独立Filter 的类图，依次从上到下看。

AdviceFilter增加了preHandle方法，子类可以通过实现它，来控制是否继续执行 FilterChain。

PathMatchingFilter增加了请求路径匹配的功能。

AccessControlFilter作为身份和权限认证的父类，提供了执行失败后的回调函数。

下面的类可以分为三块，

AnonymousFilter，表示允许匿名访问
AuthenticationFilter及其子类，表示身份认证方面的
AuthorizationFilter及其子类，表示权限检查方面的

匿名访问 Filter

AnonymousFilter允许匿名访问，它复写了onPreHandle方法，总是放回 true，表示运行通过。

public class AnonymousFilter extends PathMatchingFilter {

    @Override
    protected boolean onPreHandle(ServletRequest request, ServletResponse response, Object mappedValue) {
        return true;
    }

}

AccessControlFilter 类

AccessControlFilter实现了onPreHandle方法，并且还定义了isAccessAllowed和onAccessDenied的方法。子类需要实现isAccessAllowed来负责用户身份认证或者权限检查的逻辑。还需要实现onAccessDenied方法来执行失败后的处理逻辑。

AccessControlFilter会通过两个方法处理的接口，来决定是否要继续执行 filter chain。

身份认证 Filter

身份认证的 Filter 类也比较复杂，从上到下依次介绍：

AuthenticationFilter实现了isAccessAllowed方法，它会判断当前的Subject 是否对已经认证过了。

AuthenticatingFilter提供了登录的方法。

FormAuthenticationFilter提供了表单登录的方法。当用户请求登录地址时（默认为login.jsp），它会自动完成登录操作，并且实现跳转页面操作。我们不用再去定义处理登录的 controller。

BasicHttpAuthenticationFilter提供了 http basic 验证方法。

我们也可以自定义 Filter，只需要继承AuthenticationFilter类，然后实现onAccessDenied方法即可。比如我们在实现 restful 风格的 api 时，当发现用户没登录时，只需要返回 json。

public class RestfulFilter extends AuthenticationFilter {
    
    private final String LOGIN_REQUIRED_RESPONSE = "{\"status\": 1, \"msg\": \"login required\"}";
    
    @Override
    protected boolean onAccessDenied(ServletRequest servletRequest, ServletResponse servletResponse) throws Exception {
        HttpServletResponse httpServletResponse = (HttpServletResponse) servletResponse;
        PrintWriter out = servletResponse.getWriter();
        servletResponse.setContentType("application/json;charset=utf-8");
        servletResponse.setCharacterEncoding("UTF-8");
        out.print(LOGIN_REQUIRED_RESPONSE);
        out.flush();

        return false;
    }
}

权限检查 Filter

权限认证的 Filter 类会相对简单一些，首先看看父类AuthorizationFilter。它实现了onAccessDenied方法，当权限检查没通过时，会被调用。如果用户没有认证通过的话，AuthorizationFilter会返回 302 响应，跳转到登录地址。如果是权限校检没通过，那么会返回 401 响应。

AuthorizationFilter还有很多子类，每个子类都会实现各自的权限校检逻辑。下面表列举了各种子类

类名	检查逻辑
HostFilter	根据用户的ip来判断，是否允许通过
PermissionsAuthorizationFilter	根据用户的权限来判断，是否允许通过
PortFilter	根据用户的端口号来判断，是否允许通过
HttpMethodPermissionFilter	根据用户的请求方法来判断，是否允许通过
RolesAuthorizationFilter	根据用户的角色来判断，是否允许通过
SslFilter	用户只有https请求，才会允许通过

10.3 Filter 创建

ShiroFilterFactoryBean负责创建并且始化主 Filter，我们在使用 spring 配置时，都是修改它的参数来完成。下面是它的createInstance方法，

public class ShiroFilterFactoryBean implements FactoryBean, BeanPostProcessor {

    protected AbstractShiroFilter createInstance() throws Exception {
        SecurityManager securityManager = getSecurityManager();
        // 创建并且初始化FilterChainManager
        FilterChainManager manager = createFilterChainManager();
        // 创建PathMatchingFilterChainResolver，并且设置FilterChainManager
        PathMatchingFilterChainResolver chainResolver = new PathMatchingFilterChainResolver();
        chainResolver.setFilterChainManager(manager);
        // 返回 SpringShiroFilter 实例
        return new SpringShiroFilter((WebSecurityManager) securityManager, chainResolver);
    }
}

上述返回了一个SpringShiroFilter，它非常简单，只是简单的继承了AbstractShiroFilter。创建过程中最为核心的部分是FilterChainManager的创建，通过设置filters和filterChainDefinitionMap哈希表，完成配置化。

public class ShiroFilterFactoryBean implements FactoryBean, BeanPostProcessor {
    
    // 用户可以添加自定义的Filter，key为filter的名称，value为filter实例
    private Map<String, Filter> filters;
    
    // 用户可以配置FilterChain，key为chain的名称，value为filter的名称列表，用逗号相连接
    private Map<String, String> filterChainDefinitionMap;
    
    protected FilterChainManager createFilterChainManager() {
        DefaultFilterChainManager manager = new DefaultFilterChainManager();
        // 将用户添加的Filter，保存到FilterChainManager里
        Map<String, Filter> filters = getFilters();
        if (!CollectionUtils.isEmpty(filters)) {
            for (Map.Entry<String, Filter> entry : filters.entrySet()) {
                String name = entry.getKey();
                Filter filter = entry.getValue();
                manager.addFilter(name, filter, false);
            }
        }

        // 将用户添加的chain，保存到FilterChainManager里
        Map<String, String> chains = getFilterChainDefinitionMap();
        if (!CollectionUtils.isEmpty(chains)) {
            for (Map.Entry<String, String> entry : chains.entrySet()) {
                String url = entry.getKey();
                String chainDefinition = entry.getValue();
                manager.createChain(url, chainDefinition);
            }
        }

        return manager;
    }
}

2、shiro 注解

RequiresAuthentication:使用该注解标注的类，实例，方法在访问或调用时，当前Subject必须在当前session中已经过认证。
RequiresGuest:使用该注解标注的类，实例，方法在访问或调用时，当前Subject可以是“Guest”身份，不能经过认证或者在原先的session中存在记录。
RequiresPermissions:当前Subject需要拥有某些特定的权限时，才能执行被该注解标注的方法。如果当前Subject不具有这样的权限，则方法不会被执行。
RequiresRoles:当前Subject必须拥有所有指定的角色时，才能访问被该注解标注的方法。如果当天Subject不同时拥有所有指定角色，则方法不会执行还会抛出AuthorizationException异常。
RequiresUser:当前Subject必须是应用的用户，才能访问或调用被该注解标注的类，实例，方法。

1、开启shiro注解

@Bean
public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(
        SecurityManager securityManager) {
    AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdjavavisor = new AuthorizationAttributeSourceAdvisor();
    authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
    return authorizationAttributeSourceAdvisor;
}

2、StaticMethodMatcherPointcutAdvisor 静态普通方法名匹配切面

public class AuthorizationAttributeSourceAdvisor extends StaticMethodMatcherPointcutAdvisor {
     public AuthorizationAttributeSourceAdvisor() {
        // 在切面上添加增强（AopAllianceAnnotationsAuthorizingMethodInterceptor 环绕增强）
        setAdvice(new AopAllianceAnnotationsAuthorizingMethodInterceptor());
    }
  
    // 对哪些方法进行拦截（有注解的进行操作）
    public boolean matches(Method method, Class targetClass) {
        Method m = method;
 
        if ( isAuthzAnnotationPresent(m) ) {
            return true;
        }
 
        //The 'method' parameter could be from an interface that doesn't have the annotation.
        //Check to see if the implementation has it.
        if ( targetClass != null) {
            try {
                m = targetClass.getMethod(m.getName(), m.getParameterTypes());
                if ( isAuthzAnnotationPresent(m) ) {
                    return true;
                }
            } catch (NoSuchMethodException ignored) {
                //default return value is false.  If we can't find the method, then obviously
                //there is no annotation, so just use the default return value.
            }
        }
 
        return false;
    }
 
    private boolean isAuthzAnnotationPresent(Method method) {
        for( Class<? extends Annotation> annClass : AUTHZ_ANNOTATION_CLASSES ) {
            Annotation a = AnnotationUtils.findAnnotation(method, annClass);
            if ( a != null ) {
                return true;
            }
        }
        return false;
    }
 
}

3、注解类处理器对相应注解做解析

public AopAllianceAnnotationsAuthorizingMethodInterceptor() {
        List<AuthorizingAnnotationMethodInterceptor> interceptors =
                new ArrayList<AuthorizingAnnotationMethodInterceptor>(5);
        AnnotationResolver resolver = new SpringAnnotationResolver();
        //we can re-use the same resolver instance - it does not retain state:
        interceptors.add(new RoleAnnotationMethodInterceptor(resolver));
        interceptors.add(new PermissionAnnotationMethodInterceptor(resolver));
        interceptors.add(new AuthenticatedAnnotationMethodInterceptor(resolver));
        interceptors.add(new UserAnnotationMethodInterceptor(resolver));
        interceptors.add(new GuestAnnotationMethodInterceptor(resolver));
 
        setMethodInterceptors(interceptors);
    }

以PermissionAnnotationMethodInterceptor为例：

public PermissionAnnotationMethodInterceptor(AnnotationResolver resolver) {
    	// 每个注解有自己的处理类
        super( new PermissionAnnotationHandler(), resolver);
    }

调用父类构造函数并且第一个参数字面意思可以看出是对权限注解的处理类，父类为AuthorizingAnnotationMethodInterceptor，一般我们知道AOP 执行的方法为

invoke（）看到此类中的invoke方法

public Object invoke(MethodInvocation methodInvocation) throws Throwable {
    	// 调用处理器的assertAuthorized(方法)
         ((AuthorizingAnnotationHandler)getHandler()).assertAuthorized(getAnnotation(mi));
        }
        return methodInvocation.proceed();
    }

权限检查

public void assertAuthorized(Annotation a) throws AuthorizationException {
        if (!(a instanceof RequiresPermissions)) return;
 
        RequiresPermissions rpAnnotation = (RequiresPermissions) a;
        String[] perms = getAnnotationValue(a);
        Subject subject = getSubject();
 
        if (perms.length == 1) {
            subject.checkPermission(perms[0]);
            return;
        }
        if (Logical.AND.equals(rpAnnotation.logical())) {
            getSubject().checkPermissions(perms);
            return;
        }
        if (Logical.OR.equals(rpAnnotation.logical())) {
            // Avoid processing exceptions unnecessarily - "delay" throwing the exception by calling hasRole first
            boolean hasAtLeastOnePermission = false;
            for (String permission : perms) if (getSubject().isPermitted(permission)) hasAtLeastOnePermission = true;
            // Cause the exception if none of the role match, note that the exception message will be a bit misleading
            if (!hasAtLeastOnePermission) getSubject().checkPermission(perms[0]);
            
        }
    }

public void checkPermission(String permission) throws AuthorizationException {
        assertAuthzCheckPossible();
        securityManager.checkPermission(getPrincipals(), permission);
    }

继续看securityManager的checkPermission方法，中间类似方法的调用最后在ModularRealmAuthorizer中

public void checkPermission(PrincipalCollection principals, String permission) throws AuthorizationException {
       assertRealmsConfigured();
       if (!isPermitted(principals, permission)) {
           throw new UnauthorizedException("Subject does not have permission [" + permission + "]");
       }
   }

if语句中判断是否满足条件

public boolean isPermitted(PrincipalCollection principals, String permission) {
       assertRealmsConfigured();
       for (Realm realm : getRealms()) {
           if (!(realm instanceof Authorizer)) continue;
           if (((Authorizer) realm).isPermitted(principals, permission)) {
               return true;
           }
       }
       return false;
   }

最后调到AuthorizingRealm的isPermitted方法

public boolean isPermitted(PrincipalCollection principals, Permission permission) {
       AuthorizationInfo info = getAuthorizationInfo(principals);
       return isPermitted(permission, info);
   }

getAuthorizationInfo方法为

protected AuthorizationInfo getAuthorizationInfo(PrincipalCollection principals) {

       if (principals == null) {
           return null;
       }

       AuthorizationInfo info = null;

       if (log.isTraceEnabled()) {
           log.trace("Retrieving AuthorizationInfo for principals [" + principals + "]");
       }

       Cache<Object, AuthorizationInfo> cache = getAvailableAuthorizationCache();
       if (cache != null) {
           if (log.isTraceEnabled()) {
               log.trace("Attempting to retrieve the AuthorizationInfo from cache.");
           }
           Object key = getAuthorizationCacheKey(principals);
           info = cache.get(key);
           if (log.isTraceEnabled()) {
               if (info == null) {
                   log.trace("No AuthorizationInfo found in cache for principals [" + principals + "]");
               } else {
                   log.trace("AuthorizationInfo found in cache for principals [" + principals + "]");
               }
           }
       }


       if (info == null) {
           // Call template method if the info was not found in a cache
           info = doGetAuthorizationInfo(principals);
           // If the info is not null and the cache has been created, then cache the authorization info.
           if (info != null && cache != null) {
               if (log.isTraceEnabled()) {
                   log.trace("Caching authorization info for principals: [" + principals + "].");
               }
               Object key = getAuthorizationCacheKey(principals);
               cache.put(key, info);
           }
       }

       return info;
   }

上面同样是从缓存中取，直接看下面，doGetAuthorizationInfo（）方法有没有很眼熟，没错就是我们自定义realm里面可以拓展的方法，一般就是从数据库获取配置的

权限字符串然后返回过来了

最后就是比较权限字符串是否包含权限注解中的字符串了

protected boolean isPermitted(Permission permission, AuthorizationInfo info) {
       Collection<Permission> perms = getPermissions(info);
       if (perms != null && !perms.isEmpty()) {
           for (Permission perm : perms) {
               if (perm.implies(permission)) {
                   return true;
               }
           }
       }
       return false;
   }

当然没满足就会抛出没有权限的异常了。

3、总结

请求进来之后先进行过滤，之后如果存在注解的方法springAOP将对其进行权限检查。

参考

https://segmentfault.com/a/1190000022631899
https://www.jianshu.com/p/6d85d3408964
https://blog.csdn.net/jin5203344/article/details/53187923
https://blog.csdn.net/w_stronger/article/details/73109248

本文作者： 初心
本文链接： http://funzzz.fun/2021/02/03/Apache Shiro --- 9 filter and annotation/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！