BlogJava-无极，无际，无迹-文章分类-设计模式

SpringSecurity使用记录（六）-- 本地配置二

taochen — Mon, 25 Jan 2010 08:29:00 GMT

接着来。
2.过滤器的配置：
我们已经配置了那些过滤器了，但是要跟spring context中的对象对应，于是乎，做了如下配置：
          class="org.springframework.security.web.context.SecurityContextPersistenceFilter">

          class="org.springframework.security.web.authentication.logout.LogoutFilter" >

          class="org.springframework.security.web.authentication.www.BasicAuthenticationFilter">



          class="org.springframework.security.web.savedrequest.RequestCacheAwareFilter">

          class="org.springframework.security.web.servletapi.SecurityContextHolderAwareRequestFilter">

          class="org.springframework.security.web.authentication.AnonymousAuthenticationFilter">



          class="org.springframework.security.web.session.SessionManagementFilter">

          class="org.springframework.security.web.access.ExceptionTranslationFilter">


          class="org.springframework.security.web.access.intercept.FilterSecurityInterceptor">




          class="org.springframework.security.web.authentication.logout.SecurityContextLogoutHandler">

          class="org.springframework.security.core.userdetails.memory.UserAttribute">







          class="org.springframework.security.core.authority.GrantedAuthorityImpl">

          class="org.springframework.security.web.context.HttpSessionSecurityContextRepository">

          class="org.springframework.security.access.vote.AffirmativeBased">






          class="com.saveworld.authentication.web.access.expression.MyWebExpressionVoter">

          class="com.saveworld.authentication.web.access.intercept.MyFilterInvocationSecurityMetadataSource">

ref="expressionHandler" />

class="org.springframework.security.web.util.AntUrlPathMatcher" >

          class="org.springframework.security.web.access.expression.DefaultWebSecurityExpressionHandler">

这里做几点说明：
   (1) 数据库中的权限相关的表：
            ROLES
      AUTHORITIES
            USER_AUTHS
            ROLE_AUTHS
            USERS
       这里的表结构还不是最终的，所以就不发上来误导兄弟姐妹们了。
       关键是看我们如何加载这些持久化的东西。
       这个就要看看filterSecurityInterceptor了，它里面使用了一个securityMetadataSource，本地的securityMetadataSource实现代码：
      public class MyFilterInvocationSecurityMetadataSource extends DefaultFilterInvocationSecurityMetadataSource{
    private final static Log logger = LogFactory.getLog(ExpressionBasedFilterInvocationSecurityMetadataSource.class);
    private DataSource datasource;

    public MyFilterInvocationSecurityMetadataSource(UrlMatcher urlMatcher,
                                                    DataSource datasource,
                                                    WebSecurityExpressionHandler expressionHandler) {
        super(urlMatcher, processMap(initializeFromDb(datasource,null),expressionHandler.getExpressionParser()));
    }

    //This method is usefulless for now!
    //Because this method is used for parsing the expression kind
    private static LinkedHashMap> processMap(
            LinkedHashMap> requestMap, ExpressionParser parser) {
        Assert.notNull(parser, "SecurityExpressionHandler returned a null parser object");

        LinkedHashMap> requestToExpressionAttributesMap =
            new LinkedHashMap>(requestMap);

        for (Map.Entry> entry : requestMap.entrySet()) {
            RequestKey request = entry.getKey();
            Assert.isTrue(entry.getValue().size() == 1, "Expected a single expression attribute for " + request);
            ArrayList attributes = new ArrayList(1);
            String expression = entry.getValue().toArray(new ConfigAttribute[1])[0].getAttribute();
            logger.debug("Adding web access control expression '" + expression + "', for " + request);
            try {
                //Replacing WebExpressionConfigAttribute with MyWebExpressionConfigAttribute
                //which is defined locally!
                attributes.add(new MyWebExpressionConfigAttribute(parser.parseExpression(expression)));
            } catch (ParseException e) {
                throw new IllegalArgumentException("Failed to parse expression '" + expression + "'");
            }

            requestToExpressionAttributesMap.put(request, attributes);
        }

        return requestToExpressionAttributesMap;
    }

    private static LinkedHashMap> initializeFromDb(DataSource datasource,LinkedHashMap> configMap){
        LinkedHashMap> result =
            new LinkedHashMap>();
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs   = null;
        try {
            conn = datasource.getConnection();
            stmt = conn.createStatement();
            StringBuilder sql = new StringBuilder("SELECT b.AUTHORITYPATTERN ,'hasRole('||chr(39)||a.ROLENAME||chr(39)||')' rolename ")
                                             .append(" FROM ROLES a,AUTHORITIES b,ROLE_AUTHS c ")
                                             .append(" WHERE a.rolename = c.rolename AND b.authorityname = c.authorityname");

            rs = stmt.executeQuery(sql.toString());
            String roles = "";
            RequestKey key = null;
            List value = null;
            while(rs != null && rs.next()){
                key = new RequestKey(rs.getString(1));
                roles = rs.getString(2);
                String[] roleArray = roles.split(",|\\s+|;");
                value = new ArrayList();
                for(String role : roleArray){
                    ConfigAttribute config = new SecurityConfig(role);
                    value.add(config);
                }
                result.put(key, value);
            }
            //just for test
        } catch (SQLException e) {
            e.printStackTrace();
        } finally{
            try{
                rs.close();
                stmt.close();
                conn.close();
            }catch(SQLException e){
                e.printStackTrace();
            }
        }
        return result;
    }



    public boolean supports(Class clazz) {
        return FilterInvocation.class.isAssignableFrom(clazz);
    }

    public DataSource getDatasource() {
        return datasource;
    }

    public void setDatasource(DataSource datasource) {
        this.datasource = datasource;
    }
}
(2) expressionHandler:
     这个东西要单独说说，我这里用的是表达式来检测用户角色的，所以，我用org.springframework.security.web.access.expression.DefaultWebSecurityExpressionHandler来处理了，还有其他的方式，就是直接用角色进行判断，那样会更好，这里就不描述了！

taochen 2010-01-25 16:29 发表评论

SpringSecurity使用记录（六）-- 本地配置一

taochen — Mon, 25 Jan 2010 07:56:00 GMT

按照SpringSecurity的文档，我们可以使用namespace的配置方式（前篇中已经说明）。
但是，我们这里的需求有点蹊跷，就是通过spring context进行权限配置太不方便，你想想能让人家客户通过spring xml来配置权限吗？不能，坚决不能！所以，我就单步跟踪获取里面的东西（这种方法比直接看代码快点，而且可以知道里面的逻辑结构！）
那就开始吧：
1.配置FilterChainProxy：
SpringSecurity的验证过程是通过一系列的filter来实现的。
这种chain的设计模式比较经典，可以说相当经典！
看看代码实现：
上篇中说过，默认的配置要求springSecurityFilterChain，那这个springSecurityFilterChain是怎么来用的呢？
public class DelegatingFilterProxy extends GenericFilterBean {
... ... ...
protected void initFilterBean() throws ServletException {
        // If no target bean name specified, use filter name.
        if (this.targetBeanName == null) {
            this.targetBeanName = getFilterName();
        }

        // Fetch Spring root application context and initialize the delegate early,
        // if possible. If the root application context will be started after this
        // filter proxy, we'll have to resort to lazy initialization.
        synchronized (this.delegateMonitor) {
            WebApplicationContext wac = findWebApplicationContext();
            if (wac != null) {
                this.delegate = initDelegate(wac);
            }
        }
    }
.....
}
不用说，你会猜到我们没有配置过targetBeanName这个属性，所以，就有了this.targetBeanName = getFilterName();这样的话就会配置FilterChainProxy了，因为FilterChainProxy在springContext中id是springSecurityFilterChain，所以我们要通过自己的数据库方式配置的话，就要琢磨这个FilterChainProxy了！
所以，首先做点这样的配置吧：

这个里面配置的id为myFilterChain，所以要在web.xml里面做相应配置：

myFilterChain

org.springframework.web.filter.DelegatingFilterProxy

myFilterChain

而且，尤为重要的是要配置上这些过滤器：
filter-chain pattern="/**" filters="securityContextPersistenceFilter,logoutFilter,
                                             myUsernamePasswordAuthenticationFilter,
                                             basicAuthenticationFilter,
                                             requestCacheAwareFilter,
                                             securityContextHolderAwareRequestFilter,
                                             anonymousAuthenticationFilter,
                                             sessionManagementFilter,
                                             exceptionTranslationFilter,
                                             filterSecurityInterceptor"
针对这些过滤器的用途，在spring security的文档中有详细描述，这里不多说了，在文档中的具体位置是7.2 FilterChainProxy，看看这一章就会有感觉了，不过绝知此事要躬行啊！
完成这些配置之后，我们就算是把入口给搭建好了！
鉴于文档篇幅，换到下篇接着说。

taochen 2010-01-25 15:56 发表评论

SpringSecurity使用记录（一）

taochen — Thu, 24 Dec 2009 12:05:00 GMT

第一次配置和使用SpringSecurity，总是要碰很多次墙！
先说说个人理解的它里面比较有意义的架构。
里面有好多设计模式的影子：策略模式，代理模式，工厂模式，链条模式=====，看到这些模式（除了工厂或单例）心里总是会有些兴奋，总算是看到了模式的真正练兵场！跟兄弟们好好分享一下!(才看了一天！有不对之处，还望各位斧正！)
策略模式（Strategy Pattern）:
主要说一下session相关的这个策略模式，以SessionAuthenticationStrategy接口的策略划分，根据我们的session安全策略，指定不同的策略，现在看是这种布局：

顶层接口	SessionAuthenticationStrategy
具体实现	SessionFixationProtectionStrategy （直接默认实现）	NullAuthenticatedSessionStrategy （空实现）
二级实现	ConcurrentSessionControlStrategy

画图比较麻烦，各位还是凑合着看吧！说明一下：顶层接口被下面“具体实现”两个类实现，而“二级实现”实现SessionFixationProtectionStrategy。具体采用哪种策略要看我们的配置了！
代理模式（Proxy）：
很明显的代理类，DelegatingFilterProxy和FilterChainProxy，这两个类看着心里都痒痒的，呵呵，平常总是看代理模式呀什么的，即时看着例子也不踏实，现在看到这两个东西，心里突然有种平静的激动！
这两个代理类以FilterChainProxy为例说明一下吧，FilterChainProxy代理了权限验证Filters的工作，通过它来访问整个过滤器串里面的过滤器。
Chain模式：这个也应该以FilterChainProxy这个类入口来分析，呵呵，有兴趣的各位就通过这个来看看吧！

taochen 2009-12-24 20:05 发表评论