SpringSecurity 的登录流程

​

用过SpringSecurity的小伙伴，都知道 Authentication 这个接口，我们在任何地方通过这个接口来获取到用户登录的信息，而我们用的频繁的一个它的一个实现类就是 UsernamePasswordAuthenticationToken。那么我们的登录信息是如何保存在这个类中的？那我们就需要知道SpringSecurity 的登录流程了。这两个类很重要！

在 SpringSecurity 中 认证和授权的校验是通过一系列的过滤器链。

首先到 AbstractAuthenticationProcessingFilter中，doFilter 方法：

public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
		throws IOException, ServletException {

	HttpServletRequest request = (HttpServletRequest) req;
	HttpServletResponse response = (HttpServletResponse) res;

	if (!requiresAuthentication(request, response)) {
		chain.doFilter(request, response);

		return;
	}

	Authentication authResult;

	try {
		authResult = attemptAuthentication(request, response);
		if (authResult == null) {
			// return immediately as subclass has indicated that it hasn't completed
			// authentication
			return;
		}
		sessionStrategy.onAuthentication(authResult, request, response);
	}
	catch (InternalAuthenticationServiceException failed) {
		logger.error(
				"An internal error occurred while trying to authenticate the user.",
				failed);
		unsuccessfulAuthentication(request, response, failed);

		return;
	}
	catch (AuthenticationException failed) {
		// Authentication failed
		unsuccessfulAuthentication(request, response, failed);

		return;
	}

	// Authentication success
	if (continueChainBeforeSuccessfulAuthentication) {
		chain.doFilter(request, response);
	}

	successfulAuthentication(request, response, chain, authResult);
}

分析：

1，authResult = attemptAuthentication(request, response); 调用登录相关的过滤器中的方法

也就是 UsernamePasswordAuthenticationFilter这个过滤器

2，unsuccessfulAuthentication(request, response, failed); 登录失败的处理

此方法中会调用我们在 SecurityConfig 中重写的方法 failureHandler

3，successfulAuthentication(request, response, chain, authResult); 登录成功的处理

此方法中会调用我们在 SecurityConfig 中重写的方法 successHandler

UsernamePasswordAuthenticationFilter(用户名密码身份验证过滤器)。其中比较重要的几个方法：

public class UsernamePasswordAuthenticationFilter extends

AbstractAuthenticationProcessingFilter {

public Authentication attemptAuthentication(HttpServletRequest request,
		HttpServletResponse response) throws AuthenticationException {
	if (postOnly && !request.getMethod().equals("POST")) {
		throw new AuthenticationServiceException(
				"Authentication method not supported: " + request.getMethod());
	}

	String username = obtainUsername(request);
	String password = obtainPassword(request);

	if (username == null) {
		username = "";
	}

	if (password == null) {
		password = "";
	}

	username = username.trim();

	UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(
			username, password);

	// Allow subclasses to set the "details" property
	setDetails(request, authRequest);

	return this.getAuthenticationManager().authenticate(authRequest);
}
@Nullable
protected String obtainPassword(HttpServletRequest request) {
	return request.getParameter(passwordParameter);
}

@Nullable
protected String obtainUsername(HttpServletRequest request) {
	return request.getParameter(usernameParameter);
}

protected void setDetails(HttpServletRequest request,
		UsernamePasswordAuthenticationToken authRequest) {
	authRequest.setDetails(authenticationDetailsSource.buildDetails(request));
}

}

通过上面的代码逻辑我们可以看出：

1，获取用户名和密码通过两个方法 obtainUsername(request);obtainPassword(request); 这两个方法都是通过 request.getParameter() 来获取的。

2，new 了一个 UsernamePasswordAuthenticationToken 来保存获取到的用户名和密码。

用户名保存到了 principal 属性中，密码保存到了 credentials 属性中。请注意：此时的               principal(主要的) 的类型是字符串类型，到后面会变为一个对象类型。

3，通过 setDetails() 方法来设置 details 属性。而 UsernamePassworAuthenticationToken 是没有这个属性的，而他的父类 AbstractAuthenticationTocken 中有，所以就保存在了它的父类中。这个details 属性是一个对象类型，这个对象里放的是 WebAuthenticationDetails 的实例，这个类中有两个属性 remoteAddress(远程地址) 和 sessionId。

4，最后调用 authenticate(authRequest) 方法进行验证，里面传了一个刚才new的 UsernamePassworAuthenticationToken 类的实例

接下来就是具体的校验操作了。

在上面 attemptAuthentication 方法的最后一步是开始做校验的操作，该行代码的首先拿到一个 AuthenticationManager ，然后调用它的 authenticate() 方法进行身份验证，而 AuthenticationManager 是一个接口，需要由它的实现类去执行 authenticate() 方法，而这时候获取到的实现类是 ProviderManger ，这时我们进入到它的 authenticate() 方法中，这里仅提供比较重要的部分：

public Authentication authenticate(Authentication authentication)
		throws AuthenticationException {
	Class<? extends Authentication> toTest = authentication.getClass();
	AuthenticationException lastException = null;
	AuthenticationException parentException = null;
	Authentication result = null;
	Authentication parentResult = null;
	boolean debug = logger.isDebugEnabled();

	for (AuthenticationProvider provider : getProviders()) {
		if (!provider.supports(toTest)) {
			continue;
		}

		if (debug) {
			logger.debug("Authentication attempt using "
					+ provider.getClass().getName());
		}

		try {
			result = provider.authenticate(authentication);

			if (result != null) {
				copyDetails(authentication, result);
				break;
			}
		}
		...
	}

	if (result == null && parent != null) {
		// Allow the parent to try.
		try {
			result = parentResult = parent.authenticate(authentication);
		}
		...
	}

	if (result != null) {
		if (eraseCredentialsAfterAuthentication
				&& (result instanceof CredentialsContainer)) {
			// Authentication is complete. Remove credentials and other secret data
			// from authentication
			((CredentialsContainer) result).eraseCredentials();
		}

		// If the parent AuthenticationManager was attempted and successful than it will publish an AuthenticationSuccessEvent
		// This check prevents a duplicate AuthenticationSuccessEvent if the parent AuthenticationManager already published it
		if (parentResult == null) {
			eventPublisher.publishAuthenticationSuccess(result);
		}
		return result;
	}

	...
}

认证逻辑在这个方法完成

1，我们首先拿到 Authentication 类的 Class对象

2，进入到 for 循环，通过 getProviders() 方法获取到 AuthenticationProvider(身份验证提供者)，然后调用 provider.supports(toTest) 来判断 当前拿到的 provider 是否支持对应的 Authentication(这里的Authentication 是 UsernamePasswordAuthenticationToken。如果不支持就 continue 。而第一次只拿到了一个 AuthenticationProvider  ，所以会结束for循环。如果支持调用 result = provider.authenticate(authentication); 来进行身份校验。

3，调用 copyDetails() 方法，这个方法会把旧的 Token 的details信息复制到新的 Token 中

5，调用 eraseCredentials() 方法，来擦除凭证信息，也就是你登录时的密码信息。

for循环分析：第一次循环 拿到的 provider 是 AnonymousAuthenticationProvider(匿名身份验证提供者)，它根本就不支持验证 UsernamePasswordAuthenticationToken，然后判断成立 执行 continue。结束了此次循环。然后调用 parent.authenticate(authentication); 来继续验证，而 parent 就是 AuthenticationProvider ，所以又回到了此方法。而第二次拿到的是一个 DaoAuthenticationProvider，这个 provider 是支持验证 UsernamePasswordAuthenticationToken的，但是 DaoAuthenticationProvider 中并没有重写此方法，但是它的父类 AbstractUserDetailsAuthenticationProvider 类中定义了此方法，所以会来到它的父类的这个方法中，依旧是比较重要的部分：

public Authentication authenticate(Authentication authentication)
		throws AuthenticationException {

        ...
    // Determine username
	String username = (authentication.getPrincipal() == null) ? "NONE_PROVIDED"
			: authentication.getName();

		try {
			user = retrieveUser(username,
					(UsernamePasswordAuthenticationToken) authentication);
		}
        ...

	try {
		preAuthenticationChecks.check(user);
		additionalAuthenticationChecks(user,
				(UsernamePasswordAuthenticationToken) authentication);
	}
	catch (AuthenticationException exception) {
		if (cacheWasUsed) {
			// There was a problem, so try again after checking
			// we're using latest data (i.e. not from the cache)
			cacheWasUsed = false;
			user = retrieveUser(username,
					(UsernamePasswordAuthenticationToken) authentication);
			preAuthenticationChecks.check(user);
			additionalAuthenticationChecks(user,
					(UsernamePasswordAuthenticationToken) authentication);
		}
		else {
			throw exception;
		}
	}

	postAuthenticationChecks.check(user);

	if (!cacheWasUsed) {
		this.userCache.putUserInCache(user);
	}

	Object principalToReturn = user;

	if (forcePrincipalAsString) {
		principalToReturn = user.getUsername();
	}

	return createSuccessAuthentication(principalToReturn, authentication, user);
}

分析：

1，首先拿到用户名，然后调用 retrieveUser() 方法来检索用户，这个方法会调用自己重写后的 loadUserByUsername() 方法 返回一个 User 对象，也就是从数据库中根据用户名查询出来的

protected final UserDetails retrieveUser(String username,
		UsernamePasswordAuthenticationToken authentication)
		throws AuthenticationException {
	prepareTimingAttackProtection();
	try {
		UserDetails loadedUser = this.getUserDetailsService().loadUserByUsername(username);
		if (loadedUser == null) {
			throw new InternalAuthenticationServiceException(
					"UserDetailsService returned null, which is an interface contract violation");
		}
		return loadedUser;
	}
    ...
}

2，接下来调用 preAuthenticationChecks.check(user); 来校验用户的状态。比如：账户是否锁定，是否禁用，是否过期

3，接下来调用 additionalAuthenticationChecks(user, (UsernamePasswordAuthenticationToken) authentication); 来校验密码是否正确

4，然后再调用 postAuthenticationChecks.check(user); 来校验密码是否过期

5，接下来有一个 forcePrincipalAsString 属性，这个是 是否强制将 Authentication 中的 principal 属性设置为字符串。这个默认值是 false ，不用改，这样获取信息会很方便。

6，最后通过 createSuccessAuthentication(principalToReturn, authentication, user); 创建一个新的 UsernamePasswordAuthenticationToken 对象返回。

​