本文最后更新于 2024-04-01，欢迎来到我的Blog! https://www.zpeng.site/

RuoYi学习-登录（Spring Security+JWT）

1.1从前端页面获取相关登陆地址

在当前登陆页面，我们进行一个登陆按钮的确认，发现这个请求会被/dev-api/login所处理，那很简单，/dev-api是前端所处理的路由地址，我们直接去后端里找请求路径带/login的方法，

1.2login方法

定位到SysLoginController里面的login方法

src/main/java/com/ruoyi/web/controller/system/SysLoginController.java


    /**
     * 登录方法
     * 
     * @param loginBody 登录信息
     * @return 结果
     */
    @PostMapping("/login")
    public AjaxResult login(@RequestBody LoginBody loginBody)
    {
        AjaxResult ajax = AjaxResult.success();
        // 生成令牌
        String token = loginService.login(loginBody.getUsername(), loginBody.getPassword(), loginBody.getCode(),
                loginBody.getUuid());
        ajax.put(Constants.TOKEN, token);
        return ajax;
    }

1.2.1loginService.login

进入loginService.login这个方法一探究竟。

/**
     * 登录验证
     * 
     * @param username 用户名
     * @param password 密码
     * @param code 验证码
     * @param uuid 唯一标识
     * @return 结果
     */
    public String login(String username, String password, String code, String uuid)
    {
        // wonderc 从数据库中获取验证码是否打开
        boolean captchaEnabled = configService.selectCaptchaEnabled();
        // 验证码开关
        if (captchaEnabled)
        {
            validateCaptcha(username, code, uuid);
        }
        // 用户验证
        // wonderc 熟悉的老朋友- authentication
        Authentication authentication = null;
        try
        {
            //wonderc 可以看到在这里就开始我们之前所说的登录流程
            UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(username, password);
            // 这个是干嘛用的呢，ruoyi自己的上下文对象将这个对象进行存储
            AuthenticationContextHolder.setContext(authenticationToken);
            // 该方法会去调用UserDetailsServiceImpl.loadUserByUsername
            authentication = authenticationManager.authenticate(authenticationToken);
        }
        catch (Exception e)
        {
            if (e instanceof BadCredentialsException)
            {
                //wonderc 新开线程捕获异常 记录日志(后面再说)
                AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_FAIL, MessageUtils.message("user.password.not.match")));
                throw new UserPasswordNotMatchException();
            }
            else
            {
                //wonderc 新开线程捕获异常 记录日志(后面再说)
                AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_FAIL, e.getMessage()));
                throw new ServiceException(e.getMessage());
            }
        }
        finally
        {	
            
            AuthenticationContextHolder.clearContext();
        }
        AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_SUCCESS, MessageUtils.message("user.login.success")));
        LoginUser loginUser = (LoginUser) authentication.getPrincipal();
        recordLoginInfo(loginUser.getUserId());
        // 生成token
        return tokenService.createToken(loginUser);
    }

我们可以看到，ruoyi在 loginService.login里面包含了我们之前所说的登陆流程。UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(username, password);将用户名与密码进行传入AuthenticationContextHolder.setContext(authenticationToken);这里ruoyi实现了自己的上下文对象，我们暂时先不说，只用知道它存储了这个对象进自己的上下文对象。authentication = authenticationManager.authenticate(authenticationToken);调AuthenticationManager 的相关方法，这个方法会去根据用户名查询出用户对象，那这个方法是怎么根据用户名查询出用户对象的呢，这个就要UserDetialsService接口了，这个接口只有一个方法 loadUserByUsername(String username)，通过用户名查询用户对象。

1.2.2UserDetialsService 接口

ruoyi实现了自己UserDetialsService接口，实现自己的业务方法。

package com.ruoyi.framework.web.service;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.enums.UserStatus;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.service.ISysUserService;

/**
 * 用户验证处理
 *
 * @author ruoyi
 */
@Service
public class UserDetailsServiceImpl implements UserDetailsService
{
    private static final Logger log = LoggerFactory.getLogger(UserDetailsServiceImpl.class);

    @Autowired
    private ISysUserService userService;
    
    @Autowired
    private SysPasswordService passwordService;

    @Autowired
    private SysPermissionService permissionService;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException
    {
        //根据用户名校验
        SysUser user = userService.selectUserByUserName(username);
        if (StringUtils.isNull(user))
        {
            log.info("登录用户：{} 不存在.", username);
            throw new ServiceException("登录用户：" + username + " 不存在");
        }
        else if (UserStatus.DELETED.getCode().equals(user.getDelFlag()))
        {
            log.info("登录用户：{} 已被删除.", username);
            throw new ServiceException("对不起，您的账号：" + username + " 已被删除");
        }
        else if (UserStatus.DISABLE.getCode().equals(user.getStatus()))
        {
            log.info("登录用户：{} 已被停用.", username);
            throw new ServiceException("对不起，您的账号：" + username + " 已停用");
        }
    	//密码校验
        passwordService.validate(user);
    	// 创建用户凭证
        return createLoginUser(user);
    }

    public UserDetails createLoginUser(SysUser user)
    {
        return new LoginUser(user.getUserId(), user.getDeptId(), user, permissionService.getMenuPermission(user));
    }
}

SysUser user = userService.selectUserByUserName(username);这串代码找到相关用户，然后进行一系类校验，判断是否当前用户是否正常可使用。
然后是密码校验，我们来关注下 passwordService.validate(user);

public void validate(SysUser user)
    {
        //ruoyi 自己封装的上下文对象
        Authentication usernamePasswordAuthenticationToken = AuthenticationContextHolder.getContext();
        String username = usernamePasswordAuthenticationToken.getName();
        String password = usernamePasswordAuthenticationToken.getCredentials().toString();
    	//重试次数
        Integer retryCount = redisCache.getCacheObject(getCacheKey(username));

        if (retryCount == null)
        {
            retryCount = 0;
        }

        if (retryCount >= Integer.valueOf(maxRetryCount).intValue())
        {
            //异步记录日志 这里是说密码重试次数大于最大次数
            AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_FAIL,
                    MessageUtils.message("user.password.retry.limit.exceed", maxRetryCount, lockTime)));
            throw new UserPasswordRetryLimitExceedException(maxRetryCount, lockTime);
        }

		// 看密码是否匹配
        if (!matches(user, password))
        {
            // 密码不匹配，重试次数＋1
            retryCount = retryCount + 1;
            AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_FAIL,
                    MessageUtils.message("user.password.retry.limit.count", retryCount)));
            //redis进行相关重试次数的存储
            redisCache.setCacheObject(getCacheKey(username), retryCount, lockTime, TimeUnit.MINUTES);
            throw new UserPasswordNotMatchException();
        }
        else
        {
             clearLoginRecordCache(username);
        }
    }

我们再来看看，matches(user, password)方法，最底层是调用matchesPassword这个方法。

/**
 * 判断密码是否相同
 *
 * @param rawPassword 真实密码
 * @param encodedPassword 加密后字符
 * @return 结果
 */
public static boolean matchesPassword(String rawPassword, String encodedPassword)
{
    
    BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
    return passwordEncoder.matches(rawPassword, encodedPassword);
}

这里怎么会调用 BCryptPasswordEncoder进行校验，那这样岂不是跟SpringSecurity自身的密码编码器
不一样，我们看看SpringSecurity的配置类，看看是不是已经配置这个密码编码器。

/**
 * spring security配置
 * 
 * @author ruoyi
 */
@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter
{
    ------------------忽略代码
    /**
     * 强散列哈希加密实现
     */
    @Bean
    public BCryptPasswordEncoder bCryptPasswordEncoder()
    {
        return new BCryptPasswordEncoder();
    }

    /**
     * 身份认证接口
     */
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception
    {
        auth.userDetailsService(userDetailsService).passwordEncoder(bCryptPasswordEncoder());
    }
}

我们看配置文件，果然是配置了BCryptPasswordEncoder这个密码编码器。那这里就是在matches方法做了一次密码的校验，也就是loadUserByUsername方法中进行了一次密码的校验。
我们再回过头来看UserDetailsServiceImpl，还有一个方法 createLoginUser，按照我们在SpringSecurity学到的，这里会返回一个UserDetails对象。

 public UserDetails createLoginUser(SysUser user)
    {
        return new LoginUser(user.getUserId(), user.getDeptId(), user, permissionService.getMenuPermission(user));
    }

当我们拿到这个UserDetails对象，就会返回到login方法,UserDetails封装进authentication对象，返回到方法调用方。

1.2.3createToken

我们再看回一开始的login方法，我们已经返回了认证过的authentication对象

/**
* 登录验证
* 
* @param username 用户名
* @param password 密码
* @param code 验证码
* @param uuid 唯一标识
* @return 结果
*/
public String login(String username, String password, String code, String uuid)
    {
    boolean captchaEnabled = configService.selectCaptchaEnabled();
    // 验证码开关
    if (captchaEnabled)
    {
        validateCaptcha(username, code, uuid);
    }
    // 用户验证
    Authentication authentication = null;
    try
        {
            UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(username, password);
            AuthenticationContextHolder.setContext(authenticationToken);
            // 该方法会去调用UserDetailsServiceImpl.loadUserByUsername
            authentication = authenticationManager.authenticate(authenticationToken);
            //方法调用完  UserDetails 封装到 authentication对象
        }
    catch (Exception e)
        {
            if (e instanceof BadCredentialsException)
            {
                AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_FAIL, MessageUtils.message("user.password.not.match")));
                throw new UserPasswordNotMatchException();
            }
            else
            {
                AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_FAIL, e.getMessage()));
                throw new ServiceException(e.getMessage());
            }
        }
    finally
        {
            AuthenticationContextHolder.clearContext();
        }
    AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_SUCCESS, MessageUtils.message("user.login.success")));
    LoginUser loginUser = (LoginUser) authentication.getPrincipal();
    //刷新用户相关信息
    recordLoginInfo(loginUser.getUserId());
    // 生成token
    return tokenService.createToken(loginUser);
}

我们往下看，
LoginUser loginUser = (LoginUser) authentication.getPrincipal();这里是拿到了已认证用户的信息
我们重点看看这个方法tokenService.createToken(loginUser);

/**
 * 令牌前缀
 */
public static final String LOGIN_USER_KEY = "login_user_key";

/**
 * 创建令牌
 *
 * @param loginUser 用户信息
 * @return 令牌
 */
public String createToken(LoginUser loginUser)
{
    String token = IdUtils.fastUUID();
    loginUser.setToken(token);
    // 设置loginUser的相关代理信息
    setUserAgent(loginUser);
    // 刷新令牌 - 存储令牌
    refreshToken(loginUser);
    Map<String, Object> claims = new HashMap<>();
    claims.put(Constants.LOGIN_USER_KEY, token);
	//利用JWT 生成token
    return createToken(claims);
}
/**
 * 设置用户代理信息
 *
 * @param loginUser 登录信息
 */
public void setUserAgent(LoginUser loginUser)
{
    UserAgent userAgent = UserAgent.parseUserAgentString(ServletUtils.getRequest().getHeader("User-Agent"));
    String ip = IpUtils.getIpAddr(ServletUtils.getRequest());
    loginUser.setIpaddr(ip);
    loginUser.setLoginLocation(AddressUtils.getRealAddressByIP(ip));
    loginUser.setBrowser(userAgent.getBrowser().getName());
    loginUser.setOs(userAgent.getOperatingSystem().getName());
}
// 令牌有效期（默认30分钟）
@Value("${token.expireTime}")
private int expireTime;
/**
 * 刷新令牌有效期
 *
 * @param loginUser 登录信息
 */
public void refreshToken(LoginUser loginUser)
{
    loginUser.setLoginTime(System.currentTimeMillis());
    loginUser.setExpireTime(loginUser.getLoginTime() + expireTime * MILLIS_MINUTE);
    // 根据uuid将loginUser缓存
    String userKey = getTokenKey(loginUser.getToken());
	// 将本次login的用户进行存储至redis中
    redisCache.setCacheObject(userKey, loginUser, expireTime, TimeUnit.MINUTES);
}
 
private String getTokenKey(String uuid)
{
    // public static final String LOGIN_USER_KEY = "login_user_key";
    return CacheConstants.LOGIN_TOKEN_KEY + uuid;
}
/**
     * 从数据声明生成令牌
     *
     * @param claims 数据声明
     * @return 令牌
     */
    private String createToken(Map<String, Object> claims)
    {
        String token = Jwts.builder()
                .setClaims(claims)
                .signWith(SignatureAlgorithm.HS512, secret).compact();
        return token;
    }

我们看这一串代码下来，发现生成了一个UUID，同时用这个UUID在redis中生成对象，并且生成了一个JWT token返回到方法调用处，然后就直接返回给前端了。
前端将这块的token存入到了cookie中，后续发起请求都会携带这个token，我们按照之前学的SpringSecurity结合JWT可以知道，这块应该有个过滤器，专门对token做处理。

1.3JwtAuthenticationTokenFilter

在教学SpringSecurity的时候说过，SpringSecurity的本质是一条过滤器链。ruoyi是在JwtAuthenticationTokenFilter中与JWT结合的。每一次后端被请求时，都会执行 JwtAuthenticationTokenFilter 过滤器，该过滤器是在从请求 request 的请求头（key 为 Authorization 的条目）中获得 token，然后验证 token，验证成功则直接封装一个已经成功认证的信息 authenticationToken，并存在上下文中。相关代码如下：

package com.ruoyi.framework.security.filter;

import java.io.IOException;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.framework.web.service.TokenService;

/**
 * token过滤器 验证token有效性
 * 
 * @author ruoyi
 */
@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter
{
    @Autowired
    private TokenService tokenService;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws ServletException, IOException
    {
        //通过cookie,拿到当前登陆用户
        LoginUser loginUser = tokenService.getLoginUser(request);
        if (StringUtils.isNotNull(loginUser) && StringUtils.isNull(SecurityUtils.getAuthentication()))
        {
            //验证令牌，自动刷新数据库缓存
            tokenService.verifyToken(loginUser);
            //将当前已验证用户放入到上下文对象中
            UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(loginUser, null, loginUser.getAuthorities());
            authenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
            SecurityContextHolder.getContext().setAuthentication(authenticationToken);
        }
        chain.doFilter(request, response);
    }
}

通过token获取到我们登陆时生成的UUID，通过该uuid，拿到已经认证成功存入redis中的当前用户对象。

 /**
     * 获取用户身份信息
     *
     * @return 用户信息
     */
    public LoginUser getLoginUser(HttpServletRequest request)
    {
        // 获取请求携带的令牌
        String token = getToken(request);
        if (StringUtils.isNotEmpty(token))
        {
            try
            {
                Claims claims = parseToken(token);
                // 解析对应的权限以及用户信息
                String uuid = (String) claims.get(Constants.LOGIN_USER_KEY);
                String userKey = getTokenKey(uuid);
                LoginUser user = redisCache.getCacheObject(userKey);
                return user;
            }
            catch (Exception e)
            {
            }
        }
        return null;
    }

tokenService.verifyToken(loginUser);

/**
 * 验证令牌有效期，相差不足20分钟，自动刷新缓存
 *
 * @param loginUser
 * @return 令牌
 */
public void verifyToken(LoginUser loginUser)
{
    long expireTime = loginUser.getExpireTime();
    long currentTime = System.currentTimeMillis();
    if (expireTime - currentTime <= MILLIS_MINUTE_TEN)
    {
        refreshToken(loginUser);
    }
}