SpringBoot+SpringSecurity和JWT实现认证和授权

学习一个新知识，咱们应该先分析这个东西是干吗的，它的优缺点是啥。

请看博客：基于jwt和session的区别和优点

知道jwt的作用后，再来看看jwt是如何生成的吧。

1：首先maven里面引入相关依赖

<!--SpringSecurity依赖配置-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

<!--JWT(Json Web Token)登录支持-->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.0</version>
</dependency>

2：Jwt生成的工具类(供参考)

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * @author yangfan
 * @description
 *
 * Jwt生成的工具类
 * JWT的格式：header.payload.signature
 * header的格式（算法、token的类型）：
 * {"alg": "HS512","typ": "JWT"}
 * payload的格式（用户名、创建时间、生成时间）：
 * {"sub":"wang","created":1489079981393,"exp":1489684781}
 * signature的生成算法：
 * HMACSHA512(base64UrlEncode(header) + "." +base64UrlEncode(payload),secret)
 *
 * @modified By
 */

@Component
@Slf4j
public class JwtTokenUtil {
    //用户名
    private static final String CLAIM_KEY_USERNAME = "sub";
    //生成时间
    private static final String CLAIM_KEY_CREATED = "created";
    //jwt密钥
    @Value("${jwt.secret}")
    private String secret;
    //jwt过期时间
    @Value("${jwt.expiration}")
    private Long expiration;

    /**
     * 根据负责生成JWT的token
     *  subject    主体,即用户信息的JSON
     *  issuer     签发人
     *  claims     自定义参数
     */
    private String generateToken(Map<String, Object> claims) {
        return Jwts.builder()
                // 自定义属性
                .setClaims(claims)
                // 过期时间
                .setExpiration(generateExpirationDate())
                // 签名算法以及密匙
                .signWith(SignatureAlgorithm.HS512, secret)
                // 主题：代表这个JWT的主体，即它的所有人，这个是一个json格式的字符串，可以存放什么userid，roldid之类的，作为什么用户的唯一标志。
                //.setSubject(subject)
                // 签发人
                //.setIssuer(Optional.ofNullable(issuer).orElse(ISS))
                .compact();
    }

    /**
     * 从token中获取JWT中的负载
     */
    private Claims getClaimsFromToken(String token) {
        Claims claims = null;
        try {
            claims = Jwts.parser()
                    .setSigningKey(secret)
                    .parseClaimsJws(token)
                    .getBody();
        } catch (Exception e) {
           log.info("JWT格式验证失败:{}",token);
        }
        return claims;
    }

    /**
     * 生成token的过期时间
     */
    private Date generateExpirationDate() {
        return new Date(System.currentTimeMillis() + expiration * 1000);
    }

    /**
     * 从token中获取登录用户名
     */
    public String getUserNameFromToken(String token) {
        String username;
        try {
            Claims claims = getClaimsFromToken(token);
            username =  claims.getSubject();
        } catch (Exception e) {
            username = null;
        }
        return username;
    }

    /**
     * 验证token是否还有效
     *
     * @param token       客户端传入的token
     * @param userDetails 从数据库中查询出来的用户信息
     */
    public boolean validateToken(String token, UserDetails userDetails) {
        String username = getUserNameFromToken(token);
        return username.equals(userDetails.getUsername()) && !isTokenExpired(token);
    }

    /**
     * 判断token是否已经失效
     */
    private boolean isTokenExpired(String token) {
        Date expiredDate = getExpiredDateFromToken(token);
        return expiredDate.before(new Date());
    }

    /**
     * 从token中获取过期时间
     */
    private Date getExpiredDateFromToken(String token) {
        Claims claims = getClaimsFromToken(token);
        return claims.getExpiration();
    }

    /**
     * 根据用户信息生成token
     * @param userDetails  自定义参数
     *
     */
    public String generateToken(UserDetails userDetails) {
        Map<String, Object> claims = new HashMap<>();
        claims.put(CLAIM_KEY_USERNAME, userDetails.getUsername());
        claims.put(CLAIM_KEY_CREATED, new Date());
        return generateToken(claims);
    }

    /**
     * 判断token是否可以被刷新
     */
    public boolean canRefresh(String token) {
        return !isTokenExpired(token);
    }

    /**
     * 刷新token
     */
    public String refreshToken(String token) {
        Claims claims = getClaimsFromToken(token);
        claims.put(CLAIM_KEY_CREATED, new Date());
        return generateToken(claims);
    }
}

3：现在我们就通过前端账号密码登陆，这个登陆实现接口通过上面的jwtTokenUtil生成token。

/**
     * 第一次账号密码登陆验证，验证通过则生成token
     * @param username 用户名
     * @param password 密码
     * @return String jwt
     */
    @Override
    public String login(String username, String password) {
        String token = null;
        try {
            //通过用户名到数据库中查找用户信息
            UserDetails userDetails = userDetailsService.loadUserByUsername(username);
            //对密码进行编码及比对，目前使用的是BCryptPasswordEncoder类实现PasswordEncoder接口
            if (!passwordEncoder.matches(password, userDetails.getPassword())) {
                throw new BadCredentialsException("密码不正确");
            }
            /**
             * UsernamePasswordAuthenticationToken继承AbstractAuthenticationToken实现Authentication
             * 所以当在页面中输入用户名和密码之后首先会进入到UsernamePasswordAuthenticationToken验证(Authentication)，
             * 然后生成的Authentication会被交由AuthenticationManager来进行管理
             * 而AuthenticationManager管理一系列的AuthenticationProvider，
             * 而每一个Provider都会通UserDetailsService和UserDetail来返回一个
             * 以UsernamePasswordAuthenticationToken实现的带用户名和密码以及权限的Authentication
             */
            UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
            SecurityContextHolder.getContext().setAuthentication(authentication);
            token = jwtTokenUtil.generateToken(userDetails);
        } catch (AuthenticationException e) {
            log.warn("登录异常:{}", e.getMessage());
        }
        return token;
    }

4：上面login接口生成的token发送至前端，在前端每次访问后端接口，携带这个token，一般放在header头里

而这里的过滤器就是过滤请求，验证token是否有效合法，之后会获取相应的用户权限，在SecurityContextHolder中保存的是当前访问者的信息

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * @author yangfan
 * @description JWT登录授权过滤器
 * @modified By
 */
@Slf4j
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
    @Autowired
    private UserDetailsService userDetailsService;
    @Autowired
    private JwtTokenUtil jwtTokenUtil;
    @Value("${jwt.tokenHeader}")
    private String tokenHeader;
    @Value("${jwt.tokenHead}")
    private String tokenHead;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String authHeader = request.getHeader(this.tokenHeader);
        if (authHeader != null && authHeader.startsWith(this.tokenHead)) {
            String authToken = authHeader.substring(this.tokenHead.length());// The part after "Bearer "
            String username = jwtTokenUtil.getUserNameFromToken(authToken);
            log.info("checking username:{}", username);
            //SecurityContextHolder保留系统当前的安全上下文细节，其中就包括当前使用系统的用户的信息
            if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
                //在SpringSecurityConfig类中，自己实现UserDetailsService接口的loadUserByUsername方法，
                //此方法获取用户信息，并保存在AdminUserDetails对象中
                //而AdminUserDetails这个类实现了UserDetails接口，所以可使用UserDetails接口接收
                UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);
                //验证前端传来的token是否过期、是否被篡改
                if (jwtTokenUtil.validateToken(authToken, userDetails)) {
                    UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());

                    /**
                     *  springsecurity默认只验证用户的username和password信息，
                     *  所以我们如果想实现验证码登录，需要重写WebAuthenticationDetails类，
                     *  使其能通过HttpServletRequest获取到用户输入的验证码的信息
                     *  我们这里登陆暂时还没做验证码的功能
                     */
                    authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                    log.info("authenticated user:{}", username);
                    SecurityContextHolder.getContext().setAuthentication(authentication);
                }
            }
        }
        filterChain.doFilter(request, response);
    }
}

5：重点来了，现在开始编写spring security配置类，需要将上面的jwt过滤器集成到spring security

/**
 * @author yangfan
 * @description SpringSecurity的配置,解决csrf校验开启问题,druid登陆界面无效的解决
 * @modified By
 *
 * |@EnableGlobalMethodSecurity(prePostEnabled=true) 开启注解，使用户对某个controller层的方法具有访问权限
 * |Controller层上加上@PreAuthorize("hasAuthority('pms:brand:read')")注解，用来判断当前用户是否有读的权限
 * |用户账号密码登录之后，从数据库查找当前用户的权限放入Authentication对象中
 * |SecurityExpressionRoot类中的getAuthoritySet()方法可以获取当前用户的权限集合
 *
 */
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled=true)
public class SpringSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UmsAdminService adminService;
    
    //当访问接口没有权限时，自定义的返回结果
    @Autowired
    private RestfulAccessDeniedHandler restfulAccessDeniedHandler;
    
    //当未登录或者token失效访问接口时，自定义的返回结果
    @Autowired
    private RestAuthenticationEntryPoint restAuthenticationEntryPoint;

    /**
     * 用于配置需要拦截的url路径、jwt过滤器及出异常后的处理器.
     * @param httpSecurity
     * @throws Exception
     */
    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception {
        httpSecurity
                .csrf().disable() //关闭CSRF
                .sessionManagement()// 基于token，所以不需要session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
                .antMatchers(HttpMethod.GET, // 允许对于网站静态资源的无授权访问
                        "/",
                        "/*.html",
                        "/favicon.ico",
                        "/**/*.html",
                        "/**/*.css",
                        "/**/*.js",
                        "/swagger-resources/**",
                        "/v2/api-docs/**"
                )
                .permitAll()
                .antMatchers("/admin/login", "/admin/register")// 对登录注册要允许匿名访问
                .permitAll()
                .antMatchers(HttpMethod.OPTIONS)//跨域请求会先进行一次options请求
                .permitAll()
                .antMatchers("/druid/*")//允许访问druid监控页面，由于CSRF跨站点请求伪造(Cross—Site Request Forgery)的原因，会进不去druid监控页面
                .permitAll()
                .anyRequest()// 除上面外的所有请求全部需要鉴权认证
                .authenticated();
        // 禁用缓存
        httpSecurity.headers().cacheControl();
        // 添加JWT filter
        httpSecurity.addFilterBefore(jwtAuthenticationTokenFilter(), UsernamePasswordAuthenticationFilter.class);
        // 添加自定义未授权和未登录结果返回
        httpSecurity.exceptionHandling()
                .accessDeniedHandler(restfulAccessDeniedHandler)
                .authenticationEntryPoint(restAuthenticationEntryPoint);
    }

    /**
     * 用于配置UserDetailsService及PasswordEncoder
     * @param auth
     * @throws Exception
     */
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication().withUser("user").password("password").roles("USER");
    }

    /**
     * SpringSecurity定义的用于对密码进行编码及比对的接口，目前使用的是BCryptPasswordEncoder
     * @return
     */
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    /**
     * 定义的核心接口，用于根据用户名获取用户信息，需要自行实现
     * @return
     */
    @Bean
    public UserDetailsService userDetailsService() {
        //获取登录用户信息
        return username -> {
            UmsAdmin admin = adminService.getAdminByUsername(username);
            if (admin != null) {
                List<UmsPermission> permissionList = adminService.getPermissionList(admin.getId());
                return new AdminUserDetails(admin,permissionList);
            }
            throw new UsernameNotFoundException("用户名或密码错误");
        };
    }

    /**
     * 在用户名和密码校验前添加的过滤器，如果有jwt的token，会自行根据token信息进行登录.
     * @return
     */
    @Bean
    public JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter(){
        return new JwtAuthenticationTokenFilter();
    }


    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
}

好了，思路就是这么个思路