Spring源代码解析（十）：Spring Acegi框架授权的实现

Spring源代码解析（十）：Spring Acegi框架授权的实现2011-03-29 javaeye jiwenke我们从FilterSecurityInterceptor我们从入手看看怎样进行授权的：

Java代码

//这里是拦截器拦截HTTP请求的入口
   public void doFilter（ServletRequest request, ServletResponse response, FilterChain chain）
     throws IOException, ServletException {
     FilterInvocation fi = new FilterInvocation（request, response, chain）;
     invoke（fi）;
   }
//这是具体的拦截调用
   public void invoke（FilterInvocation fi） throws IOException, ServletException {
     if （（fi.getRequest（） ！= null） && （fi.getRequest （）.getAttribute（FILTER_APPLIED） ！= null）
       && observeOncePerRequest） {
      //在第一次进行过安全检查之后就不会再做了
       fi.getChain（）.doFilter（fi.getRequest（）, fi.getResponse（））;
     } else {
       //这是第一次收到相应的请求，需要做安全检测，同时把标志为设置好 - FILTER_APPLIED，下次就再有请求就不会作相同的安全检查了
       if （fi.getRequest（） ！= null） {
         fi.getRequest（）.setAttribute（FILTER_APPLIED, Boolean.TRUE）;
       }
       //这里是做安全检查的地方
       InterceptorStatusToken token = super.beforeInvocation（fi）;
       //接着向拦截器链执行
       try {
         fi.getChain（）.doFilter（fi.getRequest（）, fi.getResponse （））;
       } finally {
         super.afterInvocation（token, null）;
       }
     }
   }

我们看看在AbstractSecurityInterceptor是怎样对HTTP请求作安全检测的：

Java代码

protected InterceptorStatusToken beforeInvocation（Object object） {
     Assert.notNull（object, "Object was null"）;
     if （！getSecureObjectClass（）.isAssignableFrom（object.getClass（））） {
       throw new IllegalArgumentException（"Security invocation attempted for object "
         + object.getClass（）.getName（）
         + " but AbstractSecurityInterceptor only configured to support secure objects of type: "
         + getSecureObjectClass（））;
     }
     //这里读取配置FilterSecurityInterceptor的ObjectDefinitionSource属性 ，这些属性配置了资源的安全设置
     ConfigAttributeDefinition attr = this.obtainObjectDefinitionSource （）.getAttributes（object）;
     if （attr == null） {
       if（rejectPublicInvocations） {
         throw new IllegalArgumentException（
            "No public invocations are allowed via this AbstractSecurityInterceptor. "
           + "This indicates a configuration error because the "
           + "AbstractSecurityInterceptor.rejectPublicInvocations property is set to "true""）;
       }
       if （logger.isDebugEnabled（）） {
         logger.debug（"Public object - authentication not attempted"）;
       }
       publishEvent（new PublicInvocationEvent（object））;
       return null; // no further work post-invocation
     }
     if （logger.isDebugEnabled（）） {
       logger.debug（"Secure object: " + object.toString（） + "; ConfigAttributes: " + attr.toString（））;
     }
     //这里从SecurityContextHolder中去取Authentication对象，一般在登录时 会放到SecurityContextHolder中去
     if （SecurityContextHolder.getContext（）.getAuthentication（） == null） {
       credentialsNotFound（messages.getMessage （"AbstractSecurityInterceptor.authenticationNotFound",
           "An Authentication object was not found in the SecurityContext"）, object, attr）;
     }
     // 如果前面没有处理鉴权，这里需要对鉴权进行处理
     Authentication authenticated;
     if （！SecurityContextHolder.getContext（）.getAuthentication （）.isAuthenticated（） || alwaysReauthenticate） {
       try {//调用配置好的AuthenticationManager处理鉴权，如果鉴权不成 功，抛出异常结束处理
         authenticated = this.authenticationManager.authenticate （SecurityContextHolder.getContext（）
                                                .getAuthentication（））;
       } catch （AuthenticationException authenticationException） {
         throw authenticationException;
       }
       // We don"t authenticated.setAuthentication（true）, because each provider should do that
       if （logger.isDebugEnabled（）） {
         logger.debug（"Successfully Authenticated: " + authenticated.toString（））;
       }
       //这里把鉴权成功后得到的Authentication保存到 SecurityContextHolder中供下次使用
       SecurityContextHolder.getContext（）.setAuthentication （authenticated）;
     } else {//这里处理前面已经通过鉴权的请求，先从SecurityContextHolder 中去取得Authentication
       authenticated = SecurityContextHolder.getContext （）.getAuthentication（）;
       if （logger.isDebugEnabled（）） {
         logger.debug（"Previously Authenticated: " + authenticated.toString（））;
       }
     }
     // 这是处理授权的过程
     try {
       //调用配置好的AccessDecisionManager来进行授权
       this.accessDecisionManager.decide（authenticated, object, attr）;
     } catch （AccessDeniedException accessDeniedException） {
       //授权不成功向外发布事件
       AuthorizationFailureEvent event = new AuthorizationFailureEvent（object, attr, authenticated,
           accessDeniedException）;
       publishEvent（event）;
       throw accessDeniedException;
     }
     if （logger.isDebugEnabled（）） {
       logger.debug（"Authorization successful"）;
     }
     AuthorizedEvent event = new AuthorizedEvent（object, attr, authenticated）;
     publishEvent（event）;
     // 这里构建一个RunAsManager来替代当前的Authentication对象，默认情况 下使用的是NullRunAsManager会把SecurityContextHolder中的Authentication对象清空 
     Authentication runAs = this.runAsManager.buildRunAs（authenticated, object, attr）;
     if （runAs == null） {
       if （logger.isDebugEnabled（）） {
         logger.debug（"RunAsManager did not change Authentication object"）;
       }
       // no further work post-invocation
       return new InterceptorStatusToken（authenticated, false, attr, object）;
     } else {
       if （logger.isDebugEnabled（）） {
         logger.debug（"Switching to RunAs Authentication: " + runAs.toString（））;
       }
       SecurityContextHolder.getContext（）.setAuthentication （runAs）;
       // revert to token.Authenticated post-invocation
       return new InterceptorStatusToken（authenticated, true, attr, object）;
     }
   }