Spring Security + JWT 实现认证和授权

最新推荐文章于 2024-05-31 09:30:00 发布

xujingyiss

最新推荐文章于 2024-05-31 09:30:00 发布

阅读量1.8k

点赞数

分类专栏： java相关 spring系列文章标签： spring java 后端

本文链接：https://blog.csdn.net/xujingyiss/article/details/121146550

版权

java相关同时被 2 个专栏收录

13 篇文章 1 订阅

订阅专栏

spring系列

10 篇文章 8 订阅

订阅专栏

整体流程

用户登录成功后，服务端返回 jwt token 给客户端。token 中包含用户名，失效时间等信息。客户端保存 token，服务端不进行存储。客户端每次发送请求的时候，带上 token，服务端解析并校验 token，并从中获取到帐号信息进行认证。

Maven依赖

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.security</groupId>
	<artifactId>spring-security-jwt</artifactId>
	<version>1.1.1.RELEASE</version>
</dependency>
<dependency>
	<groupId>io.jsonwebtoken</groupId>
	<artifactId>jjwt</artifactId>
	<version>0.9.1</version>
</dependency>

JWT

涉及 JWT Token 的几个步骤：

登录成功后创建token并返回给客户端
客户端保存token，服务端不进行存储
客户端发送请求时，携带token
服务端接收到用户请求，从RequestHeader中获取token
服务端校验token
服务端解析token，并从中获取username
服务端根据username查询用户信息并封装成Authentication
服务端将Authentication设置到security上下文中
服务端spring security根据Authentication进行最终认证

JwtToken

@Data
public class JwtToken {
    private String token;
    private String username;
    private Long expireTime;
}

JwtTokenProvider

工具类，提供创建token、校验token是否合法的方法。

@Slf4j
@Component
public class JwtTokenProvider {
    public JwtToken createJwtToken(Authentication authentication) {
        JwtToken jwtToken = new JwtToken();
        String username = ((MyUserDetails)authentication.getPrincipal()).getUsername();
        Long timestamp = System.currentTimeMillis() + 86400000L; // 一天
        Date expireTime = new Date(timestamp);

        String token = Jwts.builder()
                .setSubject(username)
                .setExpiration(expireTime)
                .setIssuedAt(new Date())
                .signWith(SignatureAlgorithm.HS512, "MY_SALT")
                .compact();

        jwtToken.setToken(token);
        jwtToken.setUsername(username);
        jwtToken.setExpireTime(timestamp);
        return jwtToken;
    }

    public boolean validateToken(String token) {
        try {
            Jwts.parser().setSigningKey("MY_SALT").parseClaimsJws(token);
            return true;
        } catch (Exception ex) {
            log.error("validate failed : " + ex.getMessage());
            return false;
        }
    }
}

JwtAuthenticationFilter(重要)

最为关键，用于校验请求中是否包含 JWT Token，并且从 token 中提取 username，最终封装成 UsernamePasswordAuthenticationToken，并将它保存到 security 上下文中，供后续 spring security 认证使用。

SecurityContextHolder.getContext().setAuthentication(authentication);

@Slf4j
@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {
    @Autowired
    private JwtTokenProvider jwtTokenProvider;
    @Autowired
    private MyUserDetailsService userDetailsService;

    /**
     * 1.从每个请求header获取token
     * 2.调用前面写的validateToken方法对token进行合法性验证
     * 3.解析得到username，并从database取出用户相关信息权限
     * 4.把用户信息(role等)以UserDetail形式放进SecurityContext以备整个请求过程使用。
     * （例如哪里需要判断用户权限是否足够时可以直接从SecurityContext取出去check）
     */
    @Override
    protected void doFilterInternal(HttpServletRequest request
            , HttpServletResponse response
            , FilterChain filterChain) throws ServletException, IOException {
        // 从请求头中获取Jwt-Token
        String token = request.getHeader("Jwt-Token");
        if (token != null && jwtTokenProvider.validateToken(token)) {
            // 从token中获取用户名
            String username = getUsernameFromJwt(token, "MY_SALT");
            UserDetails userDetails = userDetailsService.loadUserByUsername(username);
            Authentication authentication = new UsernamePasswordAuthenticationToken(
                    userDetails, null, userDetails.getAuthorities());
            // 设置到Security上下文中，后续spring security 认证就是通过这个 Authentication
            // 所以如果不传token或者token无效的话，Authentication为空，认证就不会通过
            SecurityContextHolder.getContext().setAuthentication(authentication);
        }
        super.doFilter(request, response, filterChain);
    }

    // 从token中获取用户名
    private String getUsernameFromJwt(String token, String signKey) {
        return Jwts.parser().setSigningKey(signKey)
                .parseClaimsJws(token)
                .getBody()
                .getSubject();
    }
}

Spring Security

UserInfo

登录成功后返回的用户信息

@Data
public class UserInfo {
    // Authentication中的用户信息
    private Object principal;

    // jwt token
    private JwtToken jwtToken;
}

ServletUtils

工具类，封装HttpServletResponse

public class ServletUtils {
    public static void render(HttpServletResponse response, Object object) 
          throws IOException {
        // 允许跨域
        response.setHeader("Access-Control-Allow-Origin", "*");
        // 允许自定义请求头token(允许head跨域)
        response.setHeader("Access-Control-Allow-Headers", "Jwt-Token, token, Accept, Origin, X-Requested-With, Content-Type, Last-Modified");
        response.setHeader("Content-type", "application/json;charset=UTF-8");
        response.getWriter().print(JSON.toJSONString(object));
    }
}

LoginSuccessHandler

登录成功后的处理器

@Slf4j
@Component
public class LoginSuccessHandler implements AuthenticationSuccessHandler {
    @Autowired
    private JwtTokenProvider tokenProvider;

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request
            , HttpServletResponse response, Authentication authentication) throws IOException {
        log.info("User: " + authentication.getName() + " Login in successfully.");
        UserInfo userInfo = new UserInfo();
        userInfo.setPrincipal(authentication.getPrincipal());
        userInfo.setJwtToken(tokenProvider.createJwtToken(authentication));
        ServletUtils.render(response, userInfo);
    }
}

LoginFailureHandler

登录失败后的处理器

@Slf4j
@Component
public class LoginFailureHandler implements AuthenticationFailureHandler {
    @Override
    public void onAuthenticationFailure(
            HttpServletRequest request, HttpServletResponse response
            , AuthenticationException e) throws IOException {
        if (e instanceof BadCredentialsException) {
            ServletUtils.render(response, "密码错误");
        } else if (e instanceof InternalAuthenticationServiceException) {
            ServletUtils.render(response, e.getMessage());
        } else {
            ServletUtils.render(response, "登录失败");
        }
    }
}

LogoutSuccessHandler

登出成功后的处理器

@Component
public class MyLogoutSuccessHandler implements LogoutSuccessHandler {
    @Override
    public void onLogoutSuccess(HttpServletRequest request
     , HttpServletResponse response, Authentication authentication) throws IOException {
        ServletUtils.render(response, "登出成功");
    }
}

AuthenticationEntryPoint

认证失败后的处理器

@Slf4j
@Component
public class MyAuthenticationEntryPoint implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request
      , HttpServletResponse response, AuthenticationException e) throws IOException {
        log.warn("用户需要登录，访问[{}]失败，AuthenticationException={}", request.getRequestURI(), e);
        ServletUtils.render(response, "用户未登录或登录状态已失效，请刷新页面重新登录！");
    }
}

UserDetails(重要)

Spring Security进行用户认证时，需要根据用户名、密码、权限等信息进行认证。而spring security所认可的用户信息，必须是实现了UserDetails接口的类。只要将UserDetails提供给spring security，它会自行进行身份认证。所以我们需要写一个实现UserDetails接口的类，里面包含用户名、密码、权限(权限不是必须)等信息。

spring security 在用户登录 ( "/login" 请求) 时，检验用户名密码就是通过用户传进来的 username 和 password 与 UserDetails 中的比较。这个比较的步骤是 spring security 自动进行的。而 UserDetails 是在 UserDetailsService 的 loadUserByUsername 中返回的。

username 和 password 是必须的，其他可以自定义。

getAuthorities 方法中可以设置一些权限，用于需要对某些接口进行权限校验的场景。

@Data
@NoArgsConstructor
@AllArgsConstructor
public class MyUserDetails implements UserDetails {

    private String username;

    private String password;

    private String roleSign;

    private List<String> privilegeSigns;

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        // authorities 用于接口权限校验（PreAuthorize）
        List<GrantedAuthority> authorities = new ArrayList<>();
        privilegeSigns.forEach(sign -> authorities.add(new SimpleGrantedAuthority(sign)));
        return authorities;
    }

    @Override
    public String getUsername() {
        return username;
    }

    @Override
    public String getPassword() {
        return password;
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }

}

UserDetailsService(重要)

必须实现 UserDetailsService 接口，并重写 loadUserByUsername 方法。

通过用户名加载用户，返回 UserDetails 类型对象给 spring security，具体查询逻辑需要自定义。

@Service
@Slf4j
public class MyUserDetailsService implements UserDetailsService {

    @Autowired
    private UserService userService;

    // 查询用户信息
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 从数据库查询用户记录
        UserDetailVO detail = userService.getDetail(username);
        // 将从数据库查询出来的用户封装成 Spring Security 的 UserDetails
        MyUserDetails userDetails = new MyUserDetails(
                detail.getUser().getUsername(),
                detail.getUser().getPassword(),
                detail.getRoleSign(),
                detail.getPrivilegeSigns());
        return userDetails;
    }

}

WebSecurityConfigurer(重要)

spring security 整体配置类，继承 WebSecurityConfigurerAdapter 类，并重写 configure(HttpSecurity http) 和 configure(AuthenticationManagerBuilder auth) 方法。

在 configure(HttpSecurity http) 方法中，可以配置放行的接口(无需认证)、登录成功/登录失败/登出成功/认证失败的处理器、登录/登出请求、jwt认证过滤器等内容。

configure(AuthenticationManagerBuilder auth) 方法中配置认证管理器和密码加密器。

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class MyWebSecurityConfiguration extends WebSecurityConfigurerAdapter {
    @Autowired
    private LoginSuccessHandler loginSuccessHandler;

    @Autowired
    private LoginFailureHandler loginFailureHandler;

    @Autowired
    private MyLogoutSuccessHandler logoutSuccessHandler;

    @Autowired
    private MyUserDetailsService userDetailsService;

    @Autowired
    private JwtAuthenticationFilter jwtAuthenticationFilter;

    @Autowired
    private MyAuthenticationEntryPoint authenticationEntryPoint;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 所有请求都需要认证才能访问
        http.authorizeRequests()
                // 需要放行的接口
                .antMatchers("/login").permitAll()
                // 除上面外的所有请求全部需要鉴权认证
                .and().authorizeRequests().anyRequest().authenticated()
                // 登录接口
                .and().formLogin().loginProcessingUrl("/login")
                .successHandler(loginSuccessHandler)
                .failureHandler(loginFailureHandler)
                .and().csrf().disable()
                // 登出接口
                .logout().logoutSuccessUrl("/logout")
                .logoutSuccessHandler(logoutSuccessHandler)
                // 接口的前置过滤器 jwtAuthenticationFilter，校验 JWT token 合法性
                .and().addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class)
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                // 认证异常时的处理器
                .and().exceptionHandling().authenticationEntryPoint(authenticationEntryPoint);
    }

    // 认证管理器配置
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService).passwordEncoder(new BCryptPasswordEncoder());;
    }
}

.antMatchers("xxx").permitAll()：配置放行的接口，无需进行认证。可以配置多个，多个之间用逗号分隔

.addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class)：在认证之前，加上 JwtAuthenticationFilter 过滤器，会先对 jwt token 进行验证

BCryptPasswordEncoder：spring security 自带的加密器，spring security 在接收到用户输入的密码后，会使用此加密器对密码进行加密，再与数据库中保存的密码进行比较（从数据库中获取实际密码的逻辑要自己写，获取后设置到UserDetails中就行了，剩下的事情 spring security 会自动完成）

密码加密

为了验证登录，首先在数据库中初始化账号的密码，为了安全起见，这个密码需要是经过 BCryptPasswordEncoder 加密过的，加密方法也很简单，直接调用 BCryptPasswordEncoder 的 encode 方法就行了。

这个 encode 方法每次执行出来的结果是不一样的，比如密码 123456，我分别执行两次得到的结果是：

$2a$10$Ood4tEwP1GAbNzz7y1QzGunSXOLfs1efEMU/UXjDZSXU8WFBIwcpW
$2a$10$pOjvGe4ozKr.hUTy8wNZoekd6Hqxb/cGkNVc9Xx0CHYWus8IKwp9W

虽然得到的结果不一样，但是 spring security 可以保证它俩是相同的。而且这个密码是不可逆的，无法解密。所以，取一个结果保存到数据库中就行了。

比较用户输入的密码是否正确，可以通过 BCryptPasswordEncoder 的 matches 方法。登录的时候 spring security 会自动比较。如果要修改密码，可以调用这个方法来比较用户输入的原密码是否正确。

/**
 * 通过BCryptPasswordEncoder进行加密
 * @param password 后端接收到的密码
 * @return 
 */
public static String encrypt(String password) {
	return new BCryptPasswordEncoder().encode(password);
}

/**
 * 判断密码和加密后的密码是否相同
 * @param password  后端接收到的密码
 * @param encryptedPass  数据库中保存的密码（经过BCryptPasswordEncoder加密过的）
 * @return 是否匹配
 */
public static boolean matches(String password, String encryptedPass) {
	return new BCryptPasswordEncoder().matches(password, encryptedPass);
}

发送请求

编写测试类

DemoController，包含两个方法，get 和 post。其中 post 方法增加权限控制：@PreAuthorize("hasAnyAuthority('PUBLISH')")

只有权限包含 "PUBLISH" 的账号，才能够访问！

@RestController
@RequestMapping("/demo")
public class DemoController {
    @GetMapping
    public String get() {
        return "test get";
    }

    @PostMapping
    @PreAuthorize("hasAnyAuthority('PUBLISH')")
    public String post() {
        return "test post";
    }
}

发送请求

发送请求时，在 Headers 中带上 "Jwt-Token"，请求就能成功被处理。如果不携带此 token，则后端会认为用户未登录，无法进行处理。

request header 的 key，对应 JwtAuthenticationFilter 中的 request.getHeader("Jwt-Token")，名字可以自己起，两边保持一致就行。

发送权限不足的请求

上面访问的post接口，只有权限包含 "PUBLISH" 的账号，才能够访问。用 user1 账号调用它（Jwt-Token 换成 user1 登录成功后返回的 token 就行），会提示"权限不足"。