首页 > 代码库 > Spring Security：核心组件说明
Spring Security：核心组件说明
理解了Spring Security核心组件说明，Spring Security的后续学习和使用将不再是难题。
1、Spring Security 核心
SecurityContextHolder、SecurityContext、Authentication、GrantedAuthority、UserDetails
Authentication：代表了Spring Security中的当事人。
SecurityContext：拥有了Authentication、请求相关的信息。
SecurityContextHodler：用于获取SecurityContext。
GrantedAuthority：代表在应用程序中给当事人授予的权限。
UserDetails：用户详细信息。其实就是一个JavaBean。
UserDetailsService：UserDetails相关的业务处理。
这几个是Spring Security的核心，其它的API都是围绕这些API展开的，都是为它们服务的。
2、身份认证Authentication
2.1、一般的身份认证
从Spring Security核心部分，对Spring Security有一个笼统概念了，那该怎么理解上面说的呢？
通常情况下，我们的系统都是这样的：
1、用户输入用户名、密码登录
2、系统对用户名、密码进行验证
3、获取用户上下文信息（角色列表等等）
4、获取相关操作权限
对于上面说的前三条，用Spring Security来处理，就是：
1、用户名、密码组合生成一个Authentication对象（也就是UsernamePasswordAuthenticationToken对象）。
2、生成的这个token对象会传递给一个AuthenticationManager对象用于验证。
3、当成功认证后，AuthenticationManager返回一个Authentication对象。
4、接下来，就可以调用
SecurityContextHodler.getContext().setAuthentication(…)。
为了更好的理解，下面就写一个例子：
package com.springsecurity.java.test; import java.io.BufferedReader;import java.io.InputStreamReader;import java.util.ArrayList;import java.util.List; import org.springframework.security.authentication.AuthenticationManager;import org.springframework.security.authentication.BadCredentialsException;import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;import org.springframework.security.core.Authentication;import org.springframework.security.core.AuthenticationException;import org.springframework.security.core.GrantedAuthority;import org.springframework.security.core.authority.SimpleGrantedAuthority;import org.springframework.security.core.context.SecurityContextHolder; public class AuthenticationExample { private static SimpleAuthenticationManager samgr = new SimpleAuthenticationManager(); public static void main(String[] args) { try {// 用户输入用户名、密码： BufferedReader in = new BufferedReader(new InputStreamReader( System.in)); System.out.println("Please enter your username:"); String name = in.readLine(); System.out.println("Please enter your password:"); String password = in.readLine();// 接下来是系统进行身份认证的过程：//1、将用户名、密码封装成一个token Authentication token = new UsernamePasswordAuthenticationToken( name, password);//2、将token传给AuthenticationManager进行身份认证//3、认证完毕，返回一个认证后的身份： Authentication result = samgr.authenticate(token);// 认证后，存储到SecurityContext里 ： SecurityContextHolder.getContext().setAuthentication(result); } catch (Exception ex) { System.out.println("认证失败"); } // 从SecurityContext读取认证的身份：System.out.println(SecurityContextHolder.getContext() .getAuthentication()); }} class SimpleAuthenticationManager implements AuthenticationManager { static final List<GrantedAuthority> AUTHORITIES = new ArrayList<GrantedAuthority>(); static { AUTHORITIES.add(new SimpleGrantedAuthority("ROLE_USER")); } public Authentication authenticate(Authentication auth) throws AuthenticationException { if (auth.getName().equals(auth.getCredentials())) { return new UsernamePasswordAuthenticationToken(auth.getName(), auth.getCredentials(),AUTHORITIES); } throw new BadCredentialsException("Bad Credentials"); } }
2.2、Web Application中如何进行身份认证呢？
1、用户在首页上点击某个链接
2、后台处理时，先判断是否是要访问一个受保护的资源
3、如果是受保护的资源，判断用户是否登录，是否有这个资源的访问权限
4、如果用户没有登录，返回一个登录页面给用户
5、用户输入username、password，然后登录
6、接下来开始上面的身份认证过程
在Web Application环境下，将上述1-4过程由AuthenticationEntryPoint来处理。
如何存储已认证的用户呢？
用户要访问另外的资源时，肯定要判断是否有该资源的访问权限，在判断是否有访问权限前，一般要用户先登录系统（要对用户的身份进行认证）的。如果用户已经成功登录，只需要判断是否有访问权即可。
在一般的Web Application中（不使用Spring Security），我们通常会将用户信息存储到HttpSession中。
如果在Web Application系统中，加上了Spring Security呢？
做法没什么两样，还是将这个信息存储在HttpSession中。但对于无状态的RESTful Web Service不是这样做的。
3、授权Authorization(Access Control)
身份认证Authentication保证了用户可访问系统。权限认证（授权保证了用户可以访问系统中的资源）。
在用户的一次资源访问中，这两个过程是不可少的。Access Control就是决定你这个请求是否被允许，它是在身份认证之后，访问资源之前进行的。
用户请求-->身份认证-->授权-->资源访问-->响应 |
身份认证过程由AuthenticationManager来处理，授权决定则是由AccessDecisionManager来处理的。
void decide(Authentication authentication, Object object, Collection<ConfigAttribute> configAttributes) throws AccessDeniedException, InsufficientAuthenticationException;
Spring在进行授权时，充分利用了Spring的核心之一：AOP。通过前段时间关于AOP的研究，AOP在程序中一般体现为Filter或者是Interceptor，其中更多的是使用Interceptor。
上面的decide方法需要三个参数：
·Authentication就是已经通过认证的Authentication对象。上面的学习已经可以理解。
·Object obj 是代表方法调用（MethodInvocation）或者请求处理（Action的Handler），在接下来的AbstractSecurityInterceptor中说明。
·configAttributes则是相关的特性配置。下面会有说明。
AbstractSecurityInterceptor
Security中关于授权部分使用了AOP,所以就不得不了解一下AbstractSecurityInterceptor。
Interceptor一般都会提供invoke方法。这个类是抽象类，没有提供，使用时用的是它的子类，在子类中提供了invoke方法。而在AccessDecisionManager的decide方法中的第二个参数，就是invoke方法的参数MethodInvocation对象。
ConfigAttribute
其实就是对某个拦截器配置一些访问属性。举个例子：
某个拦截器interceptor,配置访问属性有ROLE_A, ROLE_B，如果一个用户经过认证后他有一个Authentication为ROLE_A，那么他的这个请求就会被拦截器interceptor处理。
再说的通俗点就是：设置某个拦截器能够处理哪些身份的用户的请求。
AbstractSecurityInterceptor的执行流程
1、查找有哪些configAttributes与当前的请求相关联。
2、提交secure object（就是前面说的MethodInvocation对象）、当前的Authentication（就是已经认证好的身份）、以及1中找到的那些configAttributes，提交给AccessDecisionManager用于授权。
3、选择性的改变用户的身份去进行验证。这是因为用户身份的多样性的需要。
4、Secure Object(methodInvocation 对象执行)，也就是执行我们在action中写的Handler。
5、如果配置了AfterInvocationManager，那么AfterInvocationManager也会执行的。
这个流程是官方文档中说明的，已经很清楚了。为了更清新的了解这个过程，还是查看一下源码吧：
在AbstractSecurityInterceptor的子类MethodSecurityInterceptor中：
public Object invoke(MethodInvocation mi) throws Throwable {// 预先处理 InterceptorStatusToken token = super.beforeInvocation(mi); Object result; try {// 真实方法调用，也就是我们写的action调用 result = mi.proceed(); } finally { super.finallyInvocation(token); }// afterInvocationManager处理 return super.afterInvocation(token, result); }
这段代码与上面的流程说明对应起来，那就应该是上面说的流程中的1、2、3对应了这段代码中的 预先处理部分。就来看看beforeInvocation：
// 参数object就是方法调用protected InterceptorStatusToken beforeInvocation(Object object) { Assert.notNull(object, "Object was null"); final boolean debug = logger.isDebugEnabled(); 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()); }// 收集与方法调用相关的特性配置 Collection<ConfigAttribute> attributes = this.obtainSecurityMetadataSource().getAttributes(object); if (attributes == null || attributes.isEmpty()) { if (rejectPublicInvocations) { throw new IllegalArgumentException("Secure object invocation " + object + " was denied as public invocations are not allowed via this interceptor. " + "This indicates a configuration error because the " + "rejectPublicInvocations property is set to ‘true‘"); } if (debug) { logger.debug("Public object - authentication not attempted"); } publishEvent(new PublicInvocationEvent(object)); return null; // no further work post-invocation } if (debug) { logger.debug("Secure object: " + object + "; Attributes: " + attributes); } if (SecurityContextHolder.getContext().getAuthentication() == null) { credentialsNotFound(messages.getMessage("AbstractSecurityInterceptor.authenticationNotFound", "An Authentication object was not found in the SecurityContext"), object, attributes); }// 取得该用户已验证的身份 Authentication authenticated = authenticateIfRequired(); // Attempt authorization try { // 进行用户授权this.accessDecisionManager.decide(authenticated, object, attributes); } catch (AccessDeniedException accessDeniedException) { publishEvent(new AuthorizationFailureEvent(object, attributes, authenticated, accessDeniedException)); throw accessDeniedException; } if (debug) { logger.debug("Authorization successful"); } if (publishAuthorizationSuccess) { publishEvent(new AuthorizedEvent(object, attributes, authenticated)); }// 切换为其他身份 // Attempt to run as a different user Authentication runAs = this.runAsManager.buildRunAs(authenticated, object, attributes); if (runAs == null) { if (debug) { logger.debug("RunAsManager did not change Authentication object"); } // no further work post-invocation return new InterceptorStatusToken(SecurityContextHolder.getContext(), false, attributes, object); } else { if (debug) { logger.debug("Switching to RunAs Authentication: " + runAs); } SecurityContext origCtx = SecurityContextHolder.getContext(); SecurityContextHolder.setContext(SecurityContextHolder.createEmptyContext()); SecurityContextHolder.getContext().setAuthentication(runAs); // need to revert to token.Authenticated post-invocation return new InterceptorStatusToken(origCtx, true, attributes, object); } }
4、Localization异常消息的国际化
Spring Security分为了身份认证和授权两个过程，上面已经讲明 。在这两个过程中，发生异常是在所难免的。Spring为此提供了异常消息的国际化支持。
Spring Security：核心组件说明