Apache Shiro学习笔记（六）Shiro Filter介绍

最新推荐文章于 2023-08-08 18:35:05 发布

weixin_33953384

最新推荐文章于 2023-08-08 18:35:05 发布

阅读量135

点赞数

文章标签： java web.xml

原文链接：http://blog.51cto.com/luchunli/1833372

版权

鲁春利的工作笔记，好记性不如烂笔头

ShiroFilter

ShiroFilter，它是在整个 Shiro Web 应用中请求的门户，所有的请求都会被 ShiroFilter 拦截并进行相应的链式处理。ShiroFilter 往上有五层，最上层是 Filter（即 javax.servlet.Filter），它是 Servlet 规范中的 Filter 接口。

1、AbstractFilter

Shiro通过抽象类对Servlet的Filter接口进行了封装，并通过继承ServletContextSupport对ServletContext也进行了封装。

package org.apache.shiro.web.servlet;
// ServletContextSupport对ServletContext进行了封装
public abstract class AbstractFilter extends ServletContextSupport implements Filter {

    protected FilterConfig filterConfig;

    public FilterConfig getFilterConfig() {
        return filterConfig;
    }
    
    // 初始化 FilterConfig 与 ServletContext
    public void setFilterConfig(FilterConfig filterConfig) {
        this.filterConfig = filterConfig;
        // 调用ServletContextSupport的方法来封装ServletContext
        setServletContext(filterConfig.getServletContext());
    }
    
    // 从 FilterConfig 中获取初始参数
    protected String getInitParam(String paramName) {
        FilterConfig config = getFilterConfig();
        if (config != null) {
            return StringUtils.clean(config.getInitParameter(paramName));
        }
        return null;
    }

    public final void init(FilterConfig filterConfig) throws ServletException {
        // 初始化 FilterConfig
        setFilterConfig(filterConfig);
        try {
            // 在子类中实现该模板方法
            onFilterConfigSet();
        } catch (Exception e) {
            // 异常信息
        }
    }
}

Shiro对ServletContext的封装

Shiro 为了封装 ServletContext 的而提供的一个类ServletContextSupport

package org.apache.shiro.web.servlet;
// 
public class ServletContextSupport {
    private ServletContext servletContext = null;

    public ServletContext getServletContext() {
        return servletContext;
    }

    public void setServletContext(ServletContext servletContext) {
        this.servletContext = servletContext;
    }
    
    // 其他代码略
}

2、NameableFilter

提供了Filter Name的获取方式。

package org.apache.shiro.web.servlet;

public abstract class NameableFilter extends AbstractFilter implements Nameable {
    /**
     * The name of this filter, unique within an application.
     */
    private String name;
    
    // 若成员变量 name 为空，则从 FilterConfig 中获取 Filter Name
    protected String getName() {
        if (this.name == null) {
            FilterConfig config = getFilterConfig();
            if (config != null) {
                this.name = config.getFilterName();
            }
        }
        return this.name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
}

每个 Filter 必须有一个名字，可通过 setName 方法设置的，如果不设置就取该 Filter 默认的名字，也就是在 web.xml 中配置的 filter-name 了。

3、OncePerRequestFilter

NameableFilter是为了让每个 Filter 有一个名字，而且这个名字必须是唯一的。此外，在 shiro.ini 的 [urls] 片段的配置要求满足一定规则，例如：

[urls]
/foo = ssl, authc

等号左边的是 URL，右边的是 Filter Chian，一个或多个 Filter，每个 Filter 用逗号进行分隔。

对于 /foo 这个 URL 而言，可先后通过 ssl 与 authc 这两个 Filter。如果我们同时配置了两个 ssl，这个 URL 会被 ssl 拦截两次吗？答案是否定的，因为 Shiro 为我们提供了一个“一次性Filter”的原则，也就是保证了每个请求只能被同一个 Filter 拦截一次，而且仅此一次。

package org.apache.shiro.web.servlet;

public abstract class OncePerRequestFilter extends NameableFilter {

     /**
     * 已执行过的过滤器（"already filtered"）附加的后缀名
     *
     * @see #getAlreadyFilteredAttributeName
     */
    public static final String ALREADY_FILTERED_SUFFIX = ".FILTERED";

    /**
     * 是否开启过滤功能
     *
     * @see #isEnabled()
     */
    private boolean enabled = true; //most filters wish to execute when configured, so default to true

    public final void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
        // 获取 Filter 已过滤的属性名
        String alreadyFilteredAttributeName = getAlreadyFilteredAttributeName();
        // 判断是否已过滤
        if ( request.getAttribute(alreadyFilteredAttributeName) != null ) {
            // 若已过滤，则进入 FilterChain 中下一个 Filter
            filterChain.doFilter(request, response);
            
        // 若未过滤，则判断是否未开启过滤功能（其中 shouldNotFilter 方法将被废弃
        } else if (!isEnabled(request, response) || shouldNotFilter(request) ) {
            // 若未开启，则进入 FilterChain 中下一个 Filter
            filterChain.doFilter(request, response);
        } else {
            // Do invoke this filter...（执行过滤）
            // 将已过滤属性设置为 true（只要保证 Request 中有这个属性即可）
            request.setAttribute(alreadyFilteredAttributeName, Boolean.TRUE);

            try {
                // 在子类中执行具体的过滤操作
                doFilterInternal(request, response, filterChain);
            } finally {
                // 当前 Filter 执行结束需移除 Request 中的已过滤属性
                request.removeAttribute(alreadyFilteredAttributeName);
            }
        }
    }
    
    protected String getAlreadyFilteredAttributeName() {
        String name = getName();
        if (name == null) {
            name = getClass().getName();
        }
        return name + ALREADY_FILTERED_SUFFIX;
    }
    // 抽象方法，由子类实现
    protected abstract void doFilterInternal(ServletRequest request, ServletResponse response, FilterChain chain)
            throws ServletException, IOException;
}

如何确保每个请求只会被同一个 Filter 拦截一次呢？Shiro 提供了一个超简单的解决方案：在 Requet 中放置一个后缀为 .FILTERED 的属性，在执行具体拦截操作（即 doFilterInternal 方法）之前放入该属性，执行完毕后移除该属性。

在 Shiro 的 Filter Chian 配置中，如果我们想禁用某个 Filter，如何实现呢？OncePerRequestFilter 也为我们提供了一个 enabled 的属性，方便我们可以在 shiro.ini 中随时禁用某个 Filter，例如：

[main]
ssl.enabled = false

[urls]
/foo = ssl, authc

这样一来 ssl 这个 Filter 就被我们给禁用了，以后想开启 ssl 的话，完全不需要在 urls配置中一个个手工来添加，只需把 ssl.enabled 设置为 true，或注释掉该行，或直接删除该行即可。

可见，OncePerRequestFilter 给我们提供了一个模板方法doFilterInternal，在其子类中我们需要实现该方法的具体细节，那么谁来实现呢？

3.1、AbstractShiroFilter

package org.apache.shiro.web.servlet;
/**
 * 确保可通过 SecurityUtils 获取 SecurityManager，并执行过滤器操作
 */
public abstract class AbstractShiroFilter extends OncePerRequestFilter {
    // 是否可以通过 SecurityUtils 获取 SecurityManager
    private static final String STATIC_INIT_PARAM_NAME = "staticSecurityManagerEnabled";
    
    // Reference to the security manager used by this filter
    private WebSecurityManager securityManager;

    // Used to determine which chain should handle an incoming request/response
    private FilterChainResolver filterChainResolver;
    
    private boolean staticSecurityManagerEnabled;

    protected AbstractShiroFilter() {
        this.staticSecurityManagerEnabled = false;
    }

    public WebSecurityManager getSecurityManager() {
        return securityManager;
    }

    public void setSecurityManager(WebSecurityManager sm) {
        this.securityManager = sm;
    }

    public FilterChainResolver getFilterChainResolver() {
        return filterChainResolver;
    }

    public void setFilterChainResolver(FilterChainResolver filterChainResolver) {
        this.filterChainResolver = filterChainResolver;
    }
    
    // 在AbstractFilter.ini()中调用子类的实现
    protected final void onFilterConfigSet() throws Exception {
        //added in 1.2 for SHIRO-287:
        // 从 web.xml 中读取 staticSecurityManagerEnabled 参数（默认为 false）
        applyStaticSecurityManagerEnabledConfig();
        // 初始化（在子类中实现）
        init();
        // 确保 SecurityManager 必须存在
        ensureSecurityManager();
        //added in 1.2 for SHIRO-287:
        // 若已开启 static 标志，则将当前的 SecurityManager 放入 SecurityUtils 中，以后可以随时获取
        if (isStaticSecurityManagerEnabled()) {
            SecurityUtils.setSecurityManager(getSecurityManager());
        }
    }
    
    public void init() throws Exception {
        // 空方法体
    }
    
    // OncePerRequestFilter.doFilter 时需要执行的方法
    protected void doFilterInternal(ServletRequest servletRequest, ServletResponse servletResponse, 
                                    final     FilterChain chain)throws ServletException, IOException {

        Throwable t = null;

        try {
            // 通过ShiroHttpServletRequest对ServletRequest进行了封装
            final ServletRequest request = prepareServletRequest(servletRequest, servletResponse, chain);
            // 通过ShiroHttpServletResponse对ServletResponse进行了封装
            final ServletResponse response = prepareServletResponse(request, servletResponse, chain);
            // 创建 Shiro 的 Subject 对象（WebSubject）
            final Subject subject = createSubject(request, response);

            // 使用异步的方式执行相关操作
            //noinspection unchecked
            subject.execute(new Callable() {
                public Object call() throws Exception {
                    // 更新 Session 的最后访问时间
                    updateSessionLastAccessTime(request, response);
                    // 执行 Shiro 的 Filter Chain
                    executeChain(request, response, chain);
                    return null;
                }
            });
        } catch (ExecutionException ex) {
            // 异常处理
        } catch (Throwable throwable) {
            // 异常处理
        }

        if (t != null) {
            // 异常处理
        }
    }
    
    protected void executeChain(ServletRequest request, ServletResponse response, FilterChain origChain)
            throws IOException, ServletException {
        // 获取 Shiro 代理后的 FilterChain 对象，并进行链式处理
        FilterChain chain = getExecutionChain(request, response, origChain);
        chain.doFilter(request, response);
    }
    
    protected FilterChain getExecutionChain(ServletRequest request, ServletResponse response, FilterChain origChain) {
        FilterChain chain = origChain;

        // 在ShiroFilter的init方法中设置FilterChainResolver
        FilterChainResolver resolver = getFilterChainResolver();
        if (resolver == null) {
            log.debug("No FilterChainResolver configured.  Returning original FilterChain.");
            return origChain;
        }
        // 通过 FilterChainResolver(PathMatchingFilterChainResolver) 获取 ProxiedFilterChain
        FilterChain resolved = resolver.getChain(request, response, origChain);
        if (resolved != null) {
            log.trace("Resolved a configured FilterChain for the current request.");
            chain = resolved;
        } else {
            log.trace("No FilterChain configured for the current request.  Using the default.");
        }

        return chain;
    }
}

3.1.1、ShiroFilter

package org.apache.shiro.web.servlet;

public class ShiroFilter extends AbstractShiroFilter {
    @Override
    public void init() throws Exception {
        // 从 ServletContext 中获取 WebEnvironment（该对象已通过 EnvironmentLoader 创建）
        // 实际实现为：通过ServletContext获取到web.xml文件中定义的shiroEnvironmentClass
        WebEnvironment env = WebUtils.getRequiredWebEnvironment(getServletContext());

        // IniWebEnvironment.init会生成SecurityManager，在getWebSecurityManager时直接获取到
        setSecurityManager(env.getWebSecurityManager());
        
        // 通过IniFilterChainResolverFactory.createDefaultInstance获取PathMatchingFilterChainResolver
        FilterChainResolver resolver = env.getFilterChainResolver();
        if (resolver != null) {
            setFilterChainResolver(resolver);
        }
    }
}

在 ShiroFilter 中只用做初始化的行为，就是从 WebEnvironment 中分别获取 WebSecurityManager与FilterChainResolver，其它的事情都由它的父类去实现了。
实际上ShiroFilter 还实现了一些其他的封装，例如：
    通过 ShiroHttpServletRequest 来包装 Request
    通过 ShiroHttpServletResponse 来包装 Response
    通过 Session 来代理 HttpSession
    提供 FilterChain 的代理机制
    使用 ThreadContext 来保证线程安全

转载于:https://blog.51cto.com/luchunli/1833372

weixin_33953384

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Apache Shiro学习笔记（六）Shiro Filter介绍

鲁春利的工作笔记，好记性不如烂笔头ShiroFilterShiroFilter，它是在整个 Shiro Web 应用中请求的门户，所有的请求都会被 ShiroFilter 拦截并进行相应的链式处理。ShiroFilter 往上有五层，最上层是 Filter（即 javax.servlet.Filter），它是 Servlet 规范中的 Filter 接口。1、Abstract...
复制链接

扫一扫