Spring Boot 2 + Spring Security 5 + JWT 的 Restful简易教程!

沙海 2021年4月25日11:49:04Java评论52字数 21548阅读71分49秒阅读模式
摘要

速读摘要

速读摘要文章源自JAVA秀-https://www.javaxiu.com/20430.html

本项目中JWT密钥是使用用户自己的登入密码,这样每一个token的密钥都不同,相对比较安全。实际项目中我们肯定要自己进行处理,将其转换为Security的role类。后序我们还需要对其进行缓存改造,不然每次请求都要从数据库拿一次数据鉴权,对数据库压力太大了。此处我们实现缓存的时候,我们使用了官方现成的CachingUserDetailsService,但是这个类的构造方法不是public的,我们不能够正常实例化,所以在这里进行曲线救国。文章源自JAVA秀-https://www.javaxiu.com/20430.html

原文约 4553 | 图片 3 | 建议阅读 10 分钟 | 评价反馈文章源自JAVA秀-https://www.javaxiu.com/20430.html

Spring Boot 2 + Spring Security 5 + JWT 的 Restful简易教程!

程序员闪充宝 文章源自JAVA秀-https://www.javaxiu.com/20430.html

收录于话题文章源自JAVA秀-https://www.javaxiu.com/20430.html

#Spring Security2文章源自JAVA秀-https://www.javaxiu.com/20430.html

#实战3文章源自JAVA秀-https://www.javaxiu.com/20430.html

#jwt2文章源自JAVA秀-https://www.javaxiu.com/20430.html

#SpringBoot1文章源自JAVA秀-https://www.javaxiu.com/20430.html

Spring Boot 2 + Spring Security 5 + JWT 的 Restful简易教程!文章源自JAVA秀-https://www.javaxiu.com/20430.html

准备

开始本教程的时候希望对下面知识点进行粗略的了解。文章源自JAVA秀-https://www.javaxiu.com/20430.html

  • 知道 JWT 的基本概念文章源自JAVA秀-https://www.javaxiu.com/20430.html

  • 了解过 Spring Security文章源自JAVA秀-https://www.javaxiu.com/20430.html

本项目中 JWT 密钥是使用用户自己的登入密码,这样每一个 token 的密钥都不同,相对比较安全。文章源自JAVA秀-https://www.javaxiu.com/20430.html

大体思路:

登入:文章源自JAVA秀-https://www.javaxiu.com/20430.html

  1. POST 用户名密码到 \login文章源自JAVA秀-https://www.javaxiu.com/20430.html

  2. 请求到达 JwtAuthenticationFilter 中的 attemptAuthentication() 方法,获取 request 中的 POST 参数,包装成一个 UsernamePasswordAuthenticationToken 交付给 AuthenticationManagerauthenticate() 方法进行鉴权。文章源自JAVA秀-https://www.javaxiu.com/20430.html

  3. AuthenticationManager 会从 CachingUserDetailsService 中查找用户信息,并且判断账号密码是否正确。文章源自JAVA秀-https://www.javaxiu.com/20430.html

  4. 如果账号密码正确跳转到 JwtAuthenticationFilter 中的 successfulAuthentication() 方法,我们进行签名,生成 token 返回给用户。文章源自JAVA秀-https://www.javaxiu.com/20430.html

  5. 账号密码错误则跳转到 JwtAuthenticationFilter 中的 unsuccessfulAuthentication() 方法,我们返回错误信息让用户重新登入。文章源自JAVA秀-https://www.javaxiu.com/20430.html

请求鉴权:文章源自JAVA秀-https://www.javaxiu.com/20430.html

请求鉴权的主要思路是我们会从请求中的 Authorization 字段拿取 token,如果不存在此字段的用户,Spring Security 会默认会用 AnonymousAuthenticationToken() 包装它,即代表匿名用户。文章源自JAVA秀-https://www.javaxiu.com/20430.html

  1. 任意请求发起文章源自JAVA秀-https://www.javaxiu.com/20430.html

  2. 到达 JwtAuthorizationFilter 中的 doFilterInternal() 方法,进行鉴权。文章源自JAVA秀-https://www.javaxiu.com/20430.html

  3. 如果鉴权成功我们把生成的 AuthenticationSecurityContextHolder.getContext().setAuthentication() 放入 Security,即代表鉴权完成。此处如何鉴权由我们自己代码编写,后序会详细说明。文章源自JAVA秀-https://www.javaxiu.com/20430.html

准备 pom.xml

<?xml version="1.0" encoding="UTF-8"?><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">    <modelVersion>4.0.0</modelVersion>    <parent>        <groupId>org.springframework.boot</groupId>        <artifactId>spring-boot-starter-parent</artifactId>        <version>2.1.7.RELEASE</version>        <relativePath/> <!-- lookup parent from repository -->    </parent>    <groupId>org.inlighting</groupId>    <artifactId>spring-boot-security-jwt</artifactId>    <version>0.0.1-SNAPSHOT</version>    <name>spring-boot-security-jwt</name>    <description>Demo project for Spring Boot</description>    <properties>        <java.version>1.8</java.version>    </properties>    <dependencies>        <dependency>            <groupId>org.springframework.boot</groupId>            <artifactId>spring-boot-starter-security</artifactId>        </dependency>        <dependency>            <groupId>org.springframework.boot</groupId>            <artifactId>spring-boot-starter-web</artifactId>        </dependency>        <!-- JWT 支持 -->        <dependency>            <groupId>com.auth0</groupId>            <artifactId>java-jwt</artifactId>            <version>3.8.2</version>        </dependency>        <!-- cache 支持 -->        <dependency>            <groupId>org.springframework.boot</groupId>            <artifactId>spring-boot-starter-cache</artifactId>        </dependency>        <!-- cache 支持 -->        <dependency>            <groupId>org.ehcache</groupId>            <artifactId>ehcache</artifactId>        </dependency>        <!-- cache 支持 -->        <dependency>            <groupId>javax.cache</groupId>            <artifactId>cache-api</artifactId>        </dependency>        <dependency>            <groupId>org.springframework.boot</groupId>            <artifactId>spring-boot-starter-test</artifactId>            <scope>test</scope>        </dependency>        <dependency>            <groupId>org.springframework.security</groupId>            <artifactId>spring-security-test</artifactId>            <scope>test</scope>        </dependency>        <!-- ehcache 读取 xml 配置文件使用 -->        <dependency>            <groupId>javax.xml.bind</groupId>            <artifactId>jaxb-api</artifactId>            <version>2.3.0</version>        </dependency>        <!-- ehcache 读取 xml 配置文件使用 -->        <dependency>            <groupId>com.sun.xml.bind</groupId>            <artifactId>jaxb-impl</artifactId>            <version>2.3.0</version>        </dependency>        <!-- ehcache 读取 xml 配置文件使用 -->        <dependency>            <groupId>com.sun.xml.bind</groupId>            <artifactId>jaxb-core</artifactId>            <version>2.3.0</version>        </dependency>        <!-- ehcache 读取 xml 配置文件使用 -->        <dependency>            <groupId>javax.activation</groupId>            <artifactId>activation</artifactId>            <version>1.1.1</version>        </dependency>    </dependencies>    <build>        <plugins>            <plugin>                <groupId>org.springframework.boot</groupId>                <artifactId>spring-boot-maven-plugin</artifactId>            </plugin>        </plugins>    </build></project>

pom.xml 配置文件这块没有什么好说的,主要说明下面的几个依赖:文章源自JAVA秀-https://www.javaxiu.com/20430.html

<!-- ehcache 读取 xml 配置文件使用 --><dependency>  <groupId>javax.xml.bind</groupId>  <artifactId>jaxb-api</artifactId>  <version>2.3.0</version></dependency><!-- ehcache 读取 xml 配置文件使用 --><dependency>  <groupId>com.sun.xml.bind</groupId>  <artifactId>jaxb-impl</artifactId>  <version>2.3.0</version></dependency><!-- ehcache 读取 xml 配置文件使用 --><dependency>  <groupId>com.sun.xml.bind</groupId>  <artifactId>jaxb-core</artifactId>  <version>2.3.0</version></dependency><!-- ehcache 读取 xml 配置文件使用 --><dependency>  <groupId>javax.activation</groupId>  <artifactId>activation</artifactId>  <version>1.1.1</version></dependency>

因为 ehcache 读取 xml 配置文件时使用了这几个依赖,而这几个依赖从 JDK 9 开始时是选配模块,所以高版本的用户需要添加这几个依赖才能正常使用。文章源自JAVA秀-https://www.javaxiu.com/20430.html

基础工作准备

接下来准备下几个基础工作,就是新建个实体、模拟个数据库,写个 JWT 工具类这种基础操作。文章源自JAVA秀-https://www.javaxiu.com/20430.html

UserEntity.java

关于 role 为什么使用 GrantedAuthority 说明下:其实是为了简化代码,直接用了 Security 现成的 role 类,实际项目中我们肯定要自己进行处理,将其转换为 Security 的 role 类。文章源自JAVA秀-https://www.javaxiu.com/20430.html

public class UserEntity {    public UserEntity(String username, String password, Collection<? extends GrantedAuthority> role) {        this.username = username;        this.password = password;        this.role = role;    }    private String username;    private String password;    private Collection<? extends GrantedAuthority> role;    public String getUsername() {        return username;    }    public void setUsername(String username) {        this.username = username;    }    public String getPassword() {        return password;    }    public void setPassword(String password) {        this.password = password;    }    public Collection<? extends GrantedAuthority> getRole() {        return role;    }    public void setRole(Collection<? extends GrantedAuthority> role) {        this.role = role;    }}

ResponseEntity.java

前后端分离为了方便前端我们要统一 json 的返回格式,所以自定义一个 ResponseEntity.java。文章源自JAVA秀-https://www.javaxiu.com/20430.html

public class ResponseEntity {    public ResponseEntity() {    }    public ResponseEntity(int status, String msg, Object data) {        this.status = status;        this.msg = msg;        this.data = data;    }    private int status;    private String msg;    private Object data;    public int getStatus() {        return status;    }    public void setStatus(int status) {        this.status = status;    }    public String getMsg() {        return msg;    }    public void setMsg(String msg) {        this.msg = msg;    }    public Object getData() {        return data;    }    public void setData(Object data) {        this.data = data;    }}

Database.java

这里我们使用一个 HashMap 模拟了一个数据库,密码我已经预先用 Bcrypt 加密过了,这也是 Spring Security 官方推荐的加密算法(MD5 加密已经在 Spring Security 5 中被移除了,不安全)。文章源自JAVA秀-https://www.javaxiu.com/20430.html

用户名密码权限
jackjack123 存 Bcrypt 加密后ROLE_USER
dannydanny123 存 Bcrypt 加密后ROLE_EDITOR
smithsmith123 存 Bcrypt 加密后ROLE_ADMIN
@Componentpublic class Database {    private Map<String, UserEntity> data = null;        public Map<String, UserEntity> getDatabase() {        if (data == null) {            data = new HashMap<>();            UserEntity jack = new UserEntity(                    "jack",                    "$2a$10$AQol1A.LkxoJ5dEzS5o5E.QG9jD.hncoeCGdVaMQZaiYZ98V/JyRq",                    getGrants("ROLE_USER"));            UserEntity danny = new UserEntity(                    "danny",                    "$2a$10$8nMJR6r7lvh9H2INtM2vtuA156dHTcQUyU.2Q2OK/7LwMd/I.HM12",                    getGrants("ROLE_EDITOR"));            UserEntity smith = new UserEntity(                    "smith",                    "$2a$10$E86mKigOx1NeIr7D6CJM3OQnWdaPXOjWe4OoRqDqFgNgowvJW9nAi",                    getGrants("ROLE_ADMIN"));            data.put("jack", jack);            data.put("danny", danny);            data.put("smith", smith);        }        return data;    }        private Collection<GrantedAuthority> getGrants(String role) {        return AuthorityUtils.commaSeparatedStringToAuthorityList(role);    }}

UserService.java

这里再模拟一个 service,主要就是模仿数据库的操作。文章源自JAVA秀-https://www.javaxiu.com/20430.html

@Servicepublic class UserService {    @Autowired    private Database database;    public UserEntity getUserByUsername(String username) {        return database.getDatabase().get(username);    }}

JwtUtil.java

自己编写的一个工具类,主要负责 JWT 的签名和鉴权。文章源自JAVA秀-https://www.javaxiu.com/20430.html

public class JwtUtil {    // 过期时间5分钟    private final static long EXPIRE_TIME = 5 * 60 * 1000;    /**     * 生成签名,5min后过期     * @param username 用户名     * @param secret 用户的密码     * @return 加密的token     */    public static String sign(String username, String secret) {        Date expireDate = new Date(System.currentTimeMillis() + EXPIRE_TIME);        try {            Algorithm algorithm = Algorithm.HMAC256(secret);            return JWT.create()                    .withClaim("username", username)                    .withExpiresAt(expireDate)                    .sign(algorithm);        } catch (Exception e) {            return null;        }    }    /**     * 校验token是否正确     * @param token 密钥     * @param secret 用户的密码     * @return 是否正确     */    public static boolean verify(String token, String username, String secret) {        try {            Algorithm algorithm = Algorithm.HMAC256(secret);            JWTVerifier verifier = JWT.require(algorithm)                    .withClaim("username", username)                    .build();            DecodedJWT jwt = verifier.verify(token);            return true;        } catch (Exception e) {            return false;        }    }    /**     * 获得token中的信息无需secret解密也能获得     * @return token中包含的用户名     */    public static String getUsername(String token) {        try {            DecodedJWT jwt = JWT.decode(token);            return jwt.getClaim("username").asString();        } catch (JWTDecodeException e) {            return null;        }    }}

Spring Security 改造

登入这块,我们使用自定义的 JwtAuthenticationFilter 来进行登入。文章源自JAVA秀-https://www.javaxiu.com/20430.html

请求鉴权,我们使用自定义的 JwtAuthorizationFilter 来处理。文章源自JAVA秀-https://www.javaxiu.com/20430.html

也许大家觉得两个单词长的有点像,?。文章源自JAVA秀-https://www.javaxiu.com/20430.html

UserDetailsServiceImpl.java

我们首先实现官方的 UserDetailsService 接口,这里主要负责一个从数据库拿数据的操作。文章源自JAVA秀-https://www.javaxiu.com/20430.html

@Servicepublic class UserDetailsServiceImpl implements UserDetailsService {    @Autowired    private UserService userService;    @Override    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {        UserEntity userEntity = userService.getUserByUsername(username);        if (userEntity == null) {            throw new UsernameNotFoundException("This username didn't exist.");        }        return new User(userEntity.getUsername(), userEntity.getPassword(), userEntity.getRole());    }}

后序我们还需要对其进行缓存改造,不然每次请求都要从数据库拿一次数据鉴权,对数据库压力太大了。文章源自JAVA秀-https://www.javaxiu.com/20430.html

JwtAuthenticationFilter.java

这个过滤器主要处理登入操作,我们继承了 UsernamePasswordAuthenticationFilter,这样能大大简化我们的工作量。文章源自JAVA秀-https://www.javaxiu.com/20430.html

public class JwtAuthenticationFilter extends UsernamePasswordAuthenticationFilter {    /*    过滤器一定要设置 AuthenticationManager,所以此处我们这么编写,这里的 AuthenticationManager    我会从 Security 配置的时候传入    */    public JwtAuthenticationFilter(AuthenticationManager authenticationManager) {        /*        运行父类 UsernamePasswordAuthenticationFilter 的构造方法,能够设置此滤器指定        方法为 POST [\login]        */        super();        setAuthenticationManager(authenticationManager);    }    @Override    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {        // 从请求的 POST 中拿取 username 和 password 两个字段进行登入        String username = request.getParameter("username");        String password = request.getParameter("password");        UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(username, password);        // 设置一些客户 IP 啥信息,后面想用的话可以用,虽然没啥用        setDetails(request, token);        // 交给 AuthenticationManager 进行鉴权        return getAuthenticationManager().authenticate(token);    }    /*    鉴权成功进行的操作,我们这里设置返回加密后的 token    */    @Override    protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException {        handleResponse(request, response, authResult, null);    }    /*    鉴权失败进行的操作,我们这里就返回 用户名或密码错误 的信息    */    @Override    protected void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response, AuthenticationException failed) throws IOException, ServletException {        handleResponse(request, response, null, failed);    }    private void handleResponse(HttpServletRequest request, HttpServletResponse response, Authentication authResult, AuthenticationException failed) throws IOException, ServletException {        ObjectMapper mapper = new ObjectMapper();        ResponseEntity responseEntity = new ResponseEntity();        response.setHeader("Content-Type", "application/json;charset=UTF-8");        if (authResult != null) {            // 处理登入成功请求            User user = (User) authResult.getPrincipal();            String token = JwtUtil.sign(user.getUsername(), user.getPassword());            responseEntity.setStatus(HttpStatus.OK.value());            responseEntity.setMsg("登入成功");            responseEntity.setData("Bearer " + token);            response.setStatus(HttpStatus.OK.value());            response.getWriter().write(mapper.writeValueAsString(responseEntity));        } else {            // 处理登入失败请求            responseEntity.setStatus(HttpStatus.BAD_REQUEST.value());            responseEntity.setMsg("用户名或密码错误");            responseEntity.setData(null);            response.setStatus(HttpStatus.BAD_REQUEST.value());            response.getWriter().write(mapper.writeValueAsString(responseEntity));        }    }}

private void handleResponse() 此处处理的方法不是很好,我的想法是跳转到控制器中进行处理,但是这样鉴权成功的 token 带不过去,所以先这么写了,有点复杂。文章源自JAVA秀-https://www.javaxiu.com/20430.html

JwtAuthorizationFilter.java

这个过滤器处理每个请求鉴权,我们选择继承 BasicAuthenticationFilter ,考虑到 Basic 认证和 JWT 比较像,就选择了它。文章源自JAVA秀-https://www.javaxiu.com/20430.html

public class JwtAuthorizationFilter extends BasicAuthenticationFilter {    private UserDetailsService userDetailsService;    // 会从 Spring Security 配置文件那里传过来    public JwtAuthorizationFilter(AuthenticationManager authenticationManager, UserDetailsService userDetailsService) {        super(authenticationManager);        this.userDetailsService = userDetailsService;    }    @Override    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {        // 判断是否有 token,并且进行认证        Authentication token = getAuthentication(request);        if (token == null) {            chain.doFilter(request, response);            return;        }        // 认证成功        SecurityContextHolder.getContext().setAuthentication(token);        chain.doFilter(request, response);    }    private UsernamePasswordAuthenticationToken getAuthentication(HttpServletRequest request) {        String header = request.getHeader("Authorization");        if (header == null || ! header.startsWith("Bearer ")) {            return null;        }        String token = header.split(" ")[1];        String username = JwtUtil.getUsername(token);        UserDetails userDetails = null;        try {            userDetails = userDetailsService.loadUserByUsername(username);        } catch (UsernameNotFoundException e) {            return null;        }        if (! JwtUtil.verify(token, username, userDetails.getPassword())) {            return null;        }        return new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());    }}

SecurityConfiguration.java

此处我们进行 Security 的配置,并且实现缓存功能。缓存这块我们使用官方现成的 CachingUserDetailsService ,唯独的缺点就是它没有 public 方法,我们不能正常实例化,需要曲线救国,下面代码也有详细说明。文章源自JAVA秀-https://www.javaxiu.com/20430.html

// 开启 Security@EnableWebSecurity// 开启注解配置支持@EnableGlobalMethodSecurity(securedEnabled = true, prePostEnabled = true)public class SecurityConfiguration extends WebSecurityConfigurerAdapter {    @Autowired    private UserDetailsServiceImpl userDetailsServiceImpl;    // Spring Boot 的 CacheManager,这里我们使用 JCache    @Autowired    private CacheManager cacheManager;    @Override    protected void configure(HttpSecurity http) throws Exception {        // 开启跨域        http.cors()                .and()                // security 默认 csrf 是开启的,我们使用了 token ,这个也没有什么必要了                .csrf().disable()                .authorizeRequests()                // 默认所有请求通过,但是我们要在需要权限的方法加上安全注解,这样比写死配置灵活很多                .anyRequest().permitAll()                .and()                // 添加自己编写的两个过滤器                .addFilter(new JwtAuthenticationFilter(authenticationManager()))                .addFilter(new JwtAuthorizationFilter(authenticationManager(), cachingUserDetailsService(userDetailsServiceImpl)))                // 前后端分离是 STATELESS,故 session 使用该策略                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);    }    // 此处配置 AuthenticationManager,并且实现缓存    @Override    protected void configure(AuthenticationManagerBuilder auth) throws Exception {        // 对自己编写的 UserDetailsServiceImpl 进一步包装,实现缓存        CachingUserDetailsService cachingUserDetailsService = cachingUserDetailsService(userDetailsServiceImpl);        // jwt-cache 我们在 ehcache.xml 配置文件中有声明        UserCache userCache = new SpringCacheBasedUserCache(cacheManager.getCache("jwt-cache"));        cachingUserDetailsService.setUserCache(userCache);        /*        security 默认鉴权完成后会把密码抹除,但是这里我们使用用户的密码来作为 JWT 的生成密钥,        如果被抹除了,在对 JWT 进行签名的时候就拿不到用户密码了,故此处关闭了自动抹除密码。         */        auth.eraseCredentials(false);        auth.userDetailsService(cachingUserDetailsService);    }    @Bean    public PasswordEncoder passwordEncoder() {        return new BCryptPasswordEncoder();    }    /*    此处我们实现缓存的时候,我们使用了官方现成的 CachingUserDetailsService ,但是这个类的构造方法不是 public 的,    我们不能够正常实例化,所以在这里进行曲线救国。     */    private CachingUserDetailsService cachingUserDetailsService(UserDetailsServiceImpl delegate) {        Constructor<CachingUserDetailsService> ctor = null;        try {            ctor = CachingUserDetailsService.class.getDeclaredConstructor(UserDetailsService.class);        } catch (NoSuchMethodException e) {            e.printStackTrace();        }        Assert.notNull(ctor, "CachingUserDetailsService constructor is null");        ctor.setAccessible(true);        return BeanUtils.instantiateClass(ctor, delegate);    }}

Ehcache 配置

Ehcache 3 开始,统一使用了 JCache,就是 JSR107 标准,网上很多教程都是基于 Ehcache 2 的,所以大家可能在参照网上的教程会遇到很多坑。文章源自JAVA秀-https://www.javaxiu.com/20430.html

JSR107:emm,其实 JSR107 是一种缓存标准,各个框架只要遵守这个标准,就是现实大一统。差不多就是我不需要更改系统代码,也能随意更换底层的缓存系统。文章源自JAVA秀-https://www.javaxiu.com/20430.html

在 resources 目录下创建 ehcache.xml 文件:文章源自JAVA秀-https://www.javaxiu.com/20430.html

<ehcache:config        xmlns:ehcache="http://www.ehcache.org/v3"        xmlns:jcache="http://www.ehcache.org/v3/jsr107">    <ehcache:cache alias="jwt-cache">        <!-- 我们使用用户名作为缓存的 key,故使用 String -->        <ehcache:key-type>java.lang.String</ehcache:key-type>        <ehcache:value-type>org.springframework.security.core.userdetails.User</ehcache:value-type>        <ehcache:expiry>            <ehcache:ttl unit="days">1</ehcache:ttl>        </ehcache:expiry>        <!-- 缓存实体的数量 -->        <ehcache:heap unit="entries">2000</ehcache:heap>    </ehcache:cache></ehcache:config>

application.properties 中开启缓存支持:文章源自JAVA秀-https://www.javaxiu.com/20430.html

spring.cache.type=jcachespring.cache.jcache.config=classpath:ehcache.xml

统一全局异常

我们要把异常的返回形式也统一了,这样才能方便前端的调用。文章源自JAVA秀-https://www.javaxiu.com/20430.html

我们平常会使用 @RestControllerAdvice 来统一异常,但是它只能管理 Controller 层面抛出的异常。Security 中抛出的异常不会抵达 Controller,无法被 @RestControllerAdvice 捕获,故我们还要改造 ErrorController文章源自JAVA秀-https://www.javaxiu.com/20430.html

@RestControllerpublic class CustomErrorController implements ErrorController {    @Override    public String getErrorPath() {        return "/error";    }    @RequestMapping("/error")    public ResponseEntity handleError(HttpServletRequest request, HttpServletResponse response) {        return new ResponseEntity(response.getStatus(), (String) request.getAttribute("javax.servlet.error.message"), null);    }}

测试

写个控制器试试,大家也可以参考我控制器里面获取用户信息的方式,推荐使用 @AuthenticationPrincipal 这个注解!!!文章源自JAVA秀-https://www.javaxiu.com/20430.html

@RestControllerpublic class MainController {    // 任何人都可以访问,在方法中判断用户是否合法    @GetMapping("everyone")    public ResponseEntity everyone() {        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();        if (! (authentication instanceof AnonymousAuthenticationToken)) {            // 登入用户            return new ResponseEntity(HttpStatus.OK.value(), "You are already login", authentication.getPrincipal());        } else {            return new ResponseEntity(HttpStatus.OK.value(), "You are anonymous", null);        }    }    @GetMapping("user")    @PreAuthorize("hasAuthority('ROLE_USER')")    public ResponseEntity user(@AuthenticationPrincipal UsernamePasswordAuthenticationToken token) {        return new ResponseEntity(HttpStatus.OK.value(), "You are user", token);    }    @GetMapping("admin")    @IsAdmin    public ResponseEntity admin(@AuthenticationPrincipal UsernamePasswordAuthenticationToken token) {        return new ResponseEntity(HttpStatus.OK.value(), "You are admin", token);    }}

我这里还使用了 @IsAdmin 注解,@IsAdmin 注解如下:文章源自JAVA秀-https://www.javaxiu.com/20430.html

@Target({ElementType.METHOD, ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@PreAuthorize("hasAnyRole('ROLE_ADMIN')")public @interface IsAdmin {}

这样能省去每次编写一长串的 @PreAuthorize() ,而且更加直观。文章源自JAVA秀-https://www.javaxiu.com/20430.html

FAQ

如何解决JWT过期问题?

我们可以在 JwtAuthorizationFilter 中加点料,如果用户快过期了,返回个特别的状态码,前端收到此状态码去访问 GET /re_authentication 携带老的 token 重新拿一个新的 token 即可。文章源自JAVA秀-https://www.javaxiu.com/20430.html

如何作废已颁发未过期的 token?

我个人的想法是把每次生成的 token 放入缓存中,每次请求都从缓存里拿,如果没有则代表此缓存报废。文章源自JAVA秀-https://www.javaxiu.com/20430.html

项目地址及来源:https://github.com/Smith-Cruise/Spring-Boot-Security-JWT-SPA文章源自JAVA秀-https://www.javaxiu.com/20430.html

Mybatis-Plus学习总结(超详细整理)Shiro + JWT + Spring Boot Restful 简易教程吊炸天的 Docker 图形化工具:Portainer,必须推荐给你!请谨慎使用Arrays.asList、ArrayList的subList19张图带你梳理SpringCloud体系中的重要技术点!Spring Boot 整合 Spring Security 实战!Java + Vue 实现的在线考试系统日志采集系统都用到哪些技术?点击阅读全文前往微服务电商教程
文章源自JAVA秀-https://www.javaxiu.com/20430.html

阅读原文文章源自JAVA秀-https://www.javaxiu.com/20430.html

继续阅读
速蛙云 - 极致体验,强烈推荐!!!购买套餐就免费送各大视频网站会员!快速稳定、独家福利社、流媒体稳定解锁!速度快,全球上网、视频、游戏加速、独立IP均支持!基础套餐性价比很高!这里不多说,我一直正在使用,推荐购买:https://www.javaxiu.com/59919.html
weinxin
资源分享QQ群
本站是JAVA秀团队的技术分享社区, 会经常分享资源和教程; 分享的时代, 请别再沉默!
沙海
匿名

发表评论

匿名网友 填写信息

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定