SpringBoot入门建站全系列（十二）Spring Security使用token做认证

Spring 是一个非常流行和成功的 Java 应用开发框架。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方案。一般来说，Web 应用的安全性包括用户认证（Authentication）和用户授权（Authorization）两个部分。用户认证指的是验证某个用户是否为系统中的合法主体，也就是说用户能否访问该系统。用户认证一般要求用户提供用户名和密码。系统通过校验用户名和密码来完成认证过程。用户授权指的是验证某个用户是否有权限执行某个操作。在一个系统中，不同用户所具有的权限是不同的。比如对一个文件来说，有的用户只能进行读取，而有的用户可以进行修改。一般来说，系统会为不同的用户分配不同的角色，而每个角色则对应一系列的权限。

Spring-security其实就是用filter，多请求的路径进行过滤。

如果是基于Session，那么Spring-security会对cookie里的sessionid进行解析，找到服务器存储的sesion信息，然后判断当前用户是否符合请求的要求。

如果是token，则是解析出token，然后将当前请求加入到Spring-security管理的权限信息中去。

上一篇《SpringBoot入门建站全系列（十一）Spring-security进行权限认证》已经介绍了如何使用Spring-security进行form表单的权限控制。

这一篇介绍如何使用token做访问控制，token的访问控制主要是对token的生成和解析，对token的来源并没有强制要求，我们完全可以自己来管理，也可以用jwt token，本篇就以jwt token来讲解如何使用token做访问控制。

项目地址：
品茗IT-同步发布

品茗IT 提供在线支持：

一键快速构建Spring项目工具

一键快速构建SpringBoot项目工具

一键快速构建SpringCloud项目工具

一站式Springboot项目生成

Mysql一键生成Mybatis注解Mapper

如果大家正在寻找一个java的学习环境，或者在开发中遇到困难，可以加入我们的java学习圈，点击即可加入，共同学习，节约学习时间，减少很多在学习中遇到的难题。

一、配置

本文假设你已经引入spring-boot-starter-web。已经是个SpringBoot项目了,如果不会搭建，可以打开这篇文章看一看《SpringBoot入门建站全系列（一）项目建立》。

1.1 Maven依赖


    org.mybatis.spring.boot
    mybatis-spring-boot-starter


    mysql
    mysql-connector-java


    org.apache.commons
    commons-dbcp2


    org.springframework.boot
    spring-boot-starter-security


    io.jsonwebtoken
    jjwt
    0.9.0

Spring-security一般需要从数据库中查询用户信息的，所以这里还是要把mybatis引入，以查询用户信息使用。

1.2 配置文件

application.properties 中需要添加下面的配置：

spring.datasource.type=org.apache.commons.dbcp2.BasicDataSource
spring.datasource.dbcp2.max-wait-millis=60000
spring.datasource.dbcp2.min-idle=20
spring.datasource.dbcp2.initial-size=2
spring.datasource.dbcp2.validation-query=SELECT 1
spring.datasource.dbcp2.connection-properties=characterEncoding=utf8
spring.datasource.dbcp2.validation-query=SELECT 1
spring.datasource.dbcp2.test-while-idle=true
spring.datasource.dbcp2.test-on-borrow=true
spring.datasource.dbcp2.test-on-return=false

spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/boot?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC
spring.datasource.username=cff
spring.datasource.password=123456

mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

token.expire=3600000
token.key=123456

这里的配置主要就是数据库连接和数据源、mybatis的配置。因为要连接数据库。

另外两个token开发的属性，是对token的配置，一般不怎么变化，写死也可以的。

二、安全控制核心

这个配置的作用和上篇的一致。

Spring Security的核心配置就是继承WebSecurityConfigurerAdapter并注解@EnableWebSecurity的配置。

这个配置指明了用户名密码的处理方式、请求路径的开合、登录登出控制等和安全相关的配置。

TokenWebSecurityConfig ：

package com.cff.springbootwork.token.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetailsService;

import com.cff.springbootwork.token.filter.TokenAuthenticationFilter;
import com.cff.springbootwork.token.filter.TokenLoginFilter;
import com.cff.springbootwork.token.handler.DefaultPasswordEncoder;
import com.cff.springbootwork.token.handler.TokenLogoutHandler;
import com.cff.springbootwork.token.handler.UnauthorizedEntryPoint;
import com.cff.springbootwork.token.manager.TokenManager;

@Configuration
public class TokenWebSecurityConfig extends WebSecurityConfigurerAdapter {
    private UserDetailsService userDetailsService;
    private TokenManager tokenManager;
    private DefaultPasswordEncoder defaultPasswordEncoder;

    @Autowired
    public TokenWebSecurityConfig(UserDetailsService userDetailsService, DefaultPasswordEncoder defaultPasswordEncoder,
            TokenManager tokenManager) {
        this.userDetailsService = userDetailsService;
        this.defaultPasswordEncoder = defaultPasswordEncoder;
        this.tokenManager = tokenManager;
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.exceptionHandling().authenticationEntryPoint(new UnauthorizedEntryPoint()).and().csrf().disable()
                .authorizeRequests().antMatchers("/login").permitAll().antMatchers("/public/**").permitAll()
                .anyRequest().authenticated().and().logout().logoutUrl("/logout")
                .addLogoutHandler(new TokenLogoutHandler(tokenManager)).and()
                .addFilter(new TokenLoginFilter(authenticationManager(), tokenManager))
                .addFilter(new TokenAuthenticationFilter(authenticationManager(), tokenManager)).httpBasic();
    }

    @Override
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService).passwordEncoder(defaultPasswordEncoder);
    }
}

这里：

UserDetailsService ：用户名密码查询的业务逻辑，实现loadUserByUsername方法。
UnauthorizedEntryPoint：未授权的统一处理方式。
TokenManager：token管理。
DefaultPasswordEncoder：密码的处理方法。
TokenLogoutHandler：登出业务逻辑。
TokenLoginFilter：登录过滤器，继承UsernamePasswordAuthenticationFilter，对用户名密码进行登录校验。
TokenAuthenticationFilter：访问过滤器。

这里的配置之所以和上篇的略有差别，是因为，

1.本篇未使用AuthenticationProvider，用户名密码的校验由Spring自己完成，我们提供用户名密码的查询和密码的验证规则。
2.TokenLoginFilter过滤器其实和上篇介绍的类似，如果是form表单提交，这个地方其实和上篇的一样，可以用AuthenticationProvider对用户名密码进行校验，只不过校验成功了之后，需要生成token并返回；但是这里是json数据，我们不能像上篇那样通过配置获取到用户名密码，因此需要用filter来获取。
3.TokenAuthenticationFilter访问过滤器对每个请求进行过滤，拿到请求中的token,解析出用户，然后生成UsernamePasswordAuthenticationToken交给Springsecurity进行控制。

三、安全处理逻辑

3.1 用户名密码校验并生成token

TokenLoginFilter过滤器是对登录信息的验证。

如果是form表单提交，这个地方其实和上篇的一样，可以用AuthenticationProvider对用户名密码进行校验，校验成功了之后，需要生成token并返回。

如果是json数据，我们不能通过配置获取到用户名密码，因此需要用TokenLoginFilter来获取。

TokenLoginFilter：

package com.cff.springbootwork.token.filter;

import com.cff.springbootwork.token.manager.TokenManager;
import com.cff.springbootwork.token.model.LoginUserReq;
import com.cff.springbootwork.token.model.LoginUserRes;
import com.cff.springbootwork.token.model.ResultCode;
import com.cff.springbootwork.token.model.ResultModel;
import com.cff.springbootwork.token.model.TokenUserDetails;
import com.fasterxml.jackson.databind.ObjectMapper;

import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.security.authentication.AuthenticationCredentialsNotFoundException;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.authentication.ProviderNotFoundException;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;

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

public class TokenLoginFilter extends UsernamePasswordAuthenticationFilter {
    private AuthenticationManager authenticationManager;
    private TokenManager tokenManager;

    public TokenLoginFilter(AuthenticationManager authenticationManager, TokenManager tokenManager) {
        this.authenticationManager = authenticationManager;
        this.tokenManager = tokenManager;
        this.setPostOnly(false);
        this.setRequiresAuthenticationRequestMatcher(new AntPathRequestMatcher("/login"));
    }

    @Override
    public Authentication attemptAuthentication(HttpServletRequest req, HttpServletResponse res)
            throws AuthenticationException {
        try {
            LoginUserReq user = new ObjectMapper().readValue(req.getInputStream(), LoginUserReq.class);
            return authenticationManager.authenticate(
                    new UsernamePasswordAuthenticationToken(user.getUserName(), user.getPassword(), new ArrayList<>()));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }

    @Override
    protected void successfulAuthentication(HttpServletRequest req, HttpServletResponse res, FilterChain chain,
            Authentication auth) throws IOException, ServletException {
        TokenUserDetails user = (TokenUserDetails) auth.getPrincipal();

        String token = tokenManager.createToken(user.getUsername());

        LoginUserRes loginUserRes = new LoginUserRes();
        loginUserRes.setUsername(user.getUsername());
        loginUserRes.setToken(token);
        ResultModel rm = new ResultModel(ResultCode.CODE_00000);
        rm.setData(loginUserRes);

        ObjectMapper mapper = new ObjectMapper();
        res.setStatus(HttpStatus.OK.value());
        res.setContentType(MediaType.APPLICATION_JSON_UTF8_VALUE);
        mapper.writeValue(res.getWriter(), rm);
    }

    @Override
    protected void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response,
            AuthenticationException e) throws IOException, ServletException {
        response.setStatus(HttpStatus.OK.value());
        ObjectMapper mapper = new ObjectMapper();
        ResultModel rm = null;
        if (e instanceof BadCredentialsException) {
            rm = new ResultModel(ResultCode.CODE_00001.getCode(), e.getMessage());
        } else if (e instanceof UsernameNotFoundException) {
            rm = new ResultModel(ResultCode.CODE_00011);
        } else if (e instanceof AuthenticationCredentialsNotFoundException) {
            rm = new ResultModel(ResultCode.CODE_00003);
        } else if (e instanceof ProviderNotFoundException) {
            rm = new ResultModel(ResultCode.CODE_10000, e.getMessage());
        } else {
            rm = new ResultModel(ResultCode.CODE_00013);
        }

        response.setContentType(MediaType.APPLICATION_JSON_UTF8_VALUE);
        mapper.writeValue(response.getWriter(), rm);

    }
}

这里面的AuthenticationManager 是Spring管理的。

TokenManager是我们自己的，对token进行管理。

3.2 访问控制过滤器

这里假设token字段存在http头中。

从http头中取出token字段，并通过TokenManager解析出用户信息，生成UsernamePasswordAuthenticationToken交给SpringSecurity进行管理。

TokenAuthenticationFilter :

package com.cff.springbootwork.token.filter;

import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;
import org.springframework.util.StringUtils;

import com.cff.springbootwork.token.manager.TokenManager;

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

public class TokenAuthenticationFilter extends BasicAuthenticationFilter {
    private TokenManager tokenManager;

    public TokenAuthenticationFilter(AuthenticationManager authManager, TokenManager tokenManager) {
        super(authManager);
        this.tokenManager = tokenManager;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest req, HttpServletResponse res, FilterChain chain)
            throws IOException, ServletException {
        String header = req.getHeader("token");

        if (header == null) {
            chain.doFilter(req, res);
            return;
        }

        UsernamePasswordAuthenticationToken authentication = getAuthentication(req);

        if (authentication != null) {
            SecurityContextHolder.getContext().setAuthentication(authentication);
        }
        chain.doFilter(req, res);
    }

    private UsernamePasswordAuthenticationToken getAuthentication(HttpServletRequest request) {
        // token置于header里
        String token = request.getHeader("token");
        if (token != null && !"".equals(token.trim())) {
            // parse the token.
            String userName = tokenManager.getUserFromToken(token);

            if (!StringUtils.isEmpty(userName)) {
                return new UsernamePasswordAuthenticationToken(userName, token, new ArrayList<>());
            }
            return null;
        }
        return null;
    }
}

3.3 token管理

将TokenManager定义为接口，我们使用jwt token来实现它。当然也可以用其他方式实现，比如将token和用户信息作为对应存储在redis中。

TokenManager:

package com.cff.springbootwork.token.manager;

public interface TokenManager {

    public String createToken(String username);

    public String getUserFromToken(String token);

    public void removeToken(String token);

}

JwtTokenManager：

package com.cff.springbootwork.token.manager;

import java.util.Date;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

import io.jsonwebtoken.CompressionCodecs;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

@Component
public class JwtTokenManager implements TokenManager{
    @Value("${token.expire}")
    private long tokenExpiration = 3600;
    @Value("${token.key}")
    private String tokenSignKey;

    @Override
    public String createToken(String username) {
        String token = Jwts.builder().setSubject(username)
                .setExpiration(new Date(System.currentTimeMillis() + tokenExpiration))
                .signWith(SignatureAlgorithm.HS512, tokenSignKey).compressWith(CompressionCodecs.GZIP).compact();
        return token;
    }

    @Override
    public String getUserFromToken(String token) {
        String user = Jwts.parser().setSigningKey(tokenSignKey).parseClaimsJws(token).getBody().getSubject();
        return user;
    }

    @Override
    public void removeToken(String token) {
        //jwttoken无需删除，客户端扔掉即可。
    }

}

四、安全处理的一些handler

UnauthorizedEntryPoint：

package com.cff.springbootwork.token.handler;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.http.MediaType;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;

import com.cff.springbootwork.token.model.ResultCode;
import com.cff.springbootwork.token.model.ResultModel;
import com.fasterxml.jackson.databind.ObjectMapper;

public class UnauthorizedEntryPoint implements AuthenticationEntryPoint {

    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response,
            AuthenticationException authException) throws IOException, ServletException {
        ResultModel rm = new ResultModel(ResultCode.CODE_00005, "401未授权!");

        ObjectMapper mapper = new ObjectMapper();
        response.setContentType(MediaType.APPLICATION_JSON_UTF8_VALUE);
        mapper.writeValue(response.getWriter(), rm);
    }

}

TokenLogoutHandler, jwt token没有删除选项，主要客户端遗弃即可，如果token是自己管理的，这个地方要将token移除。

TokenLogoutHandler ：

package com.cff.springbootwork.token.handler;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.logout.LogoutHandler;

import com.cff.springbootwork.token.manager.TokenManager;
import com.cff.springbootwork.token.model.ResultCode;
import com.cff.springbootwork.token.model.ResultModel;
import com.fasterxml.jackson.databind.ObjectMapper;

public class TokenLogoutHandler implements LogoutHandler {
    private TokenManager tokenManager;

    public TokenLogoutHandler(TokenManager tokenManager) {
        this.tokenManager = tokenManager;
    }

    @Override
    public void logout(HttpServletRequest request, HttpServletResponse response, Authentication authentication) {
        String token = request.getHeader("token");
        if (token != null) {
            tokenManager.removeToken(token);
        }
        ResultModel rm = new ResultModel(ResultCode.CODE_00000);

        ObjectMapper mapper = new ObjectMapper();
        response.setStatus(HttpStatus.OK.value());
        response.setContentType(MediaType.APPLICATION_JSON_UTF8_VALUE);
        try {
            mapper.writeValue(response.getWriter(), rm);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

DefaultPasswordEncoder，密码的处理规则，因为用户名密码的校验过程交给Spring Security来管理了，因为要给它说明密码是经过怎样的处理了，如果传输过来的密码跟数据库里的密码一致，就可以啥也不做，下面的这个就是啥也不做。

DefaultPasswordEncoder：

package com.cff.springbootwork.token.handler;

import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Component;

@Component
public class DefaultPasswordEncoder implements PasswordEncoder {

    public DefaultPasswordEncoder() {
        this(-1);
    }

    /**
     * @param strength
     *            the log rounds to use, between 4 and 31
     */
    public DefaultPasswordEncoder(int strength) {

    }

    public String encode(CharSequence rawPassword) {
        return rawPassword.toString();
    }

    public boolean matches(CharSequence rawPassword, String encodedPassword) {
        return rawPassword.toString().equals(encodedPassword);
    }
}

五、用户信息查询

TokenUserDetailsService调用了UserInfoService进行查询，并将查询后的结果转换为Spring的UserDetails，以供Spring使用。

TokenUserDetailsService:

package com.cff.springbootwork.token.service;

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.cff.springbootwork.mybatis.domain.UserInfo;
import com.cff.springbootwork.mybatis.service.UserInfoService;
import com.cff.springbootwork.token.model.TokenUserDetails;

@Service("formUserDetailsService")
public class TokenUserDetailsService implements UserDetailsService {
    @Autowired
    private UserInfoService userInfoService;

    @Override
    public UserDetails loadUserByUsername(String userName) throws UsernameNotFoundException {
        UserInfo user;
        try {
            user = userInfoService.getUserInfoByUserName(userName);
        } catch (Exception e) {
            throw new UsernameNotFoundException("user select fail");
        }
        if (user == null) {
            throw new UsernameNotFoundException("no user found");
        } else {
            try {
                return new TokenUserDetails(user);
            } catch (Exception e) {
                throw new UsernameNotFoundException("user role select fail");
            }
        }
    }

}

UserInfoService：

package com.cff.springbootwork.mybatis.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.cff.springbootwork.mybatis.dao.UserInfoDao;
import com.cff.springbootwork.mybatis.domain.UserInfo;

@Service
public class UserInfoService {
    @Autowired
    UserInfoDao userInfoDao;
    public UserInfo getUserInfoByUserName(String userName){
        return userInfoDao.findByUserName(userName);
    }
}

UserInfoDao:

package com.cff.springbootwork.mybatis.dao;

import java.util.List;

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import com.cff.springbootwork.mybatis.domain.UserInfo;

@Mapper
public interface UserInfoDao {
    @Select({
        ""})
    UserInfo findByUserName(@Param("userName") String userName);
    
    
}

六、过程中用到的实体

详细完整的实体，可以访问品茗IT-博客《SpringBoot入门建站全系列（十二）Spring Security使用token做认证》进行查看

快速构建项目

Spring组件化构建

SpringBoot组件化构建

SpringCloud服务化构建

喜欢这篇文章么，喜欢就加入我们的Java学习圈(点击加入或下方扫码)一起讨论SpringBoot技术吧!

SpringBoot入门建站全系列（十二）Spring Security使用token做认证_第1张图片

品茗IT交流群

SpringBoot入门建站全系列（十二）Spring Security使用token做认证