devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Spring Boot2 + Spring Security + JWT 实现项目级前后端分离认证授权_spring-boot-starter-security jwt

作者：不正经 | 2024-05-29 01:25:26

赞

踩

spring-boot-starter-security jwt

一 简介

Spring Security 是 Spring 家族中的一个安全管理框架。相比与另外一个安全框架 Shiro，它提供了更丰富的功能，扩展性更好，社区资源也比 Shiro 丰富。在 Spring Boot 出现之前，Spring Security 就已经发展了多年了，但是使用的并不多，安全管理这个领域，一直是 Shiro 的天下。
相对于 Shiro，在 SSM/SSH 中整合 Spring Security 都是比较麻烦的操作，所以 Spring Security 虽然功能比 Shiro 强大，但是使用反而没有 Shiro 多（Shiro 虽然功能没有 Spring Security 多，但是对于大部分项目而言，Shiro 上手简单也够用了）。
自从有了 Spring Boot 之后，Spring Boot 对于 Spring Security 提供了 自动化配置方案，可以零配置使用 Spring Security。

一般 WEB 应用的需要进行认证和授权。

  • 认证：验证当前访问系统的是不是系统用户，并且要确认具体是那个用户。
  • 授权：经过认证后判断当前用户是否有权限进行某个操作。

常见的安全管理技术栈的组合是这样的：

  • SSM + Shiro
  • Spring Boot/Spring Cloud + Spring Security

注意：这只是一个推荐的组合而已，如果单纯从技术上来说，无论怎么组合，都是可以运行的。

二 实际使用

项目技术：Spring Boo2 、Spring Security、MyBatis、MySQL

项目结构：

2.1 pom.xml

  1.         <!-- spring security 安全认证 -->
  2.         <dependency>
  3.             <groupId>org.springframework.boot</groupId>
  4.             <artifactId>spring-boot-starter-security</artifactId>
  5.         </dependency>
  6.  
  7.         <!--Token生成与解析-->
  8.         <dependency>
  9.             <groupId>io.jsonwebtoken</groupId>
  10.             <artifactId>jjwt</artifactId>
  11.             <version>0.9.0</version>
  12.         </dependency>

2.2 application.properties

  1. # jwt token配置
  2. # 令牌自定义标识
  3. jwt.token.header=token
  4. # 令牌秘钥
  5. jwt.token.secret=abcdefghijklmnopqrstuvwxyz
  6. # 令牌有效期（默认30分钟）
  7. jwt.token.expireTime=30

2.3 JwtToken工具类

  1. package com.modules.security;
  2.  
  3. import io.jsonwebtoken.Claims;
  4. import io.jsonwebtoken.Jwts;
  5. import io.jsonwebtoken.SignatureAlgorithm;
  6. import lombok.extern.slf4j.Slf4j;
  7. import org.springframework.beans.factory.annotation.Value;
  8. import org.springframework.security.core.userdetails.UserDetails;
  9. import org.springframework.stereotype.Component;
  10.  
  11. import javax.servlet.http.HttpServletRequest;
  12. import java.util.Date;
  13. import java.util.HashMap;
  14. import java.util.Map;
  15.  
  16. /**
  17.  * @ClassName JwtTokenUtil
  18.  * @Description JwtToken生成的工具类
  19.  * @Author li'chao
  20.  * @Date 2022-3-8 17:17
  21.  * @Version 1.0
  22.  **/
  23. @Slf4j
  24. @Component
  25. public class JwtTokenUtil {
  26.  
  27.     private static final String CLAIM_KEY_USERNAME = "sub";
  28.     private static final String CLAIM_KEY_CREATED = "created";
  29.  
  30.     // 令牌自定义标识
  31.     @Value("${jwt.token.header}")
  32.     private String header;
  33.  
  34.     // 令牌秘钥
  35.     @Value("${jwt.token.secret}")
  36.     private String secret;
  37.  
  38.     // 令牌有效期（默认30分钟）
  39.     @Value("${jwt.token.expireTime}")
  40.     private Long expiration;
  41.  
  42.  
  43.     /**
  44.      * 根据负责生成JWT的token
  45.      */
  46.     private String generateToken(Map<String, Object> claims) {
  47.         return Jwts.builder()
  48.                 .setClaims(claims)
  49.                 .setExpiration(generateExpirationDate())
  50.                 .signWith(SignatureAlgorithm.HS512, secret)
  51.                 .compact();
  52.     }
  53.  
  54.     /**
  55.      * 从token中获取JWT中的负载
  56.      */
  57.     private Claims getClaimsFromToken(String token) {
  58.         Claims claims = null;
  59.         try {
  60.             claims = Jwts.parser()
  61.                     .setSigningKey(secret)
  62.                     .parseClaimsJws(token)
  63.                     .getBody();
  64.         } catch (Exception e) {
  65.             log.info("JWT格式验证失败:{}",token);
  66.         }
  67.         return claims;
  68.     }
  69.  
  70.     /**
  71.      * 生成token的过期时间
  72.      */
  73.     private Date generateExpirationDate() {
  74.         return new Date(System.currentTimeMillis() + expiration * 1000);
  75.     }
  76.  
  77.     /**
  78.      * 从token中获取登录用户名
  79.      */
  80.     public String getUserNameFromToken(String token) {
  81.         String username;
  82.         try {
  83.             Claims claims = getClaimsFromToken(token);
  84.             username =  claims.getSubject();
  85.         } catch (Exception e) {
  86.             username = null;
  87.         }
  88.         return username;
  89.     }
  90.  
  91.     /**
  92.      * 验证token是否还有效
  93.      *
  94.      * @param token       客户端传入的token
  95.      * @param userDetails 从数据库中查询出来的用户信息
  96.      */
  97.     public boolean validateToken(String token, UserDetails userDetails) {
  98.         String username = getUserNameFromToken(token);
  99.         return username.equals(userDetails.getUsername()) && !isTokenExpired(token);
  100.     }
  101.  
  102.     /**
  103.      * 判断token是否已经失效
  104.      */
  105.     public boolean isTokenExpired(String token) {
  106.         Date expiredDate = getExpiredDateFromToken(token);
  107.         return expiredDate.before(new Date());
  108.     }
  109.  
  110.     /**
  111.      * 从token中获取过期时间
  112.      */
  113.     private Date getExpiredDateFromToken(String token) {
  114.         Claims claims = getClaimsFromToken(token);
  115.         return claims.getExpiration();
  116.     }
  117.  
  118.     /**
  119.      * 根据用户信息生成token
  120.      */
  121.     public String generateToken(UserDetails userDetails) {
  122.         Map<String, Object> claims = new HashMap<>();
  123.         claims.put(CLAIM_KEY_USERNAME, userDetails.getUsername());
  124.         claims.put(CLAIM_KEY_CREATED, new Date());
  125.         return generateToken(claims);
  126.     }
  127.  
  128.     /**
  129.      * 根据用户信息生成token
  130.      */
  131.     public String generateToken(LoginUser loginUser) {
  132.         Map<String, Object> claims = new HashMap<>();
  133.         claims.put(CLAIM_KEY_USERNAME, loginUser.getUsername());
  134.         claims.put(CLAIM_KEY_CREATED, new Date());
  135.         return generateToken(claims);
  136.     }
  137.  
  138.     /**
  139.      * 判断token是否可以被刷新
  140.      */
  141.     public boolean canRefresh(String token) {
  142.         return !isTokenExpired(token);
  143.     }
  144.  
  145.     /**
  146.      * 刷新token
  147.      */
  148.     public String refreshToken(String token) {
  149.         Claims claims = getClaimsFromToken(token);
  150.         claims.put(CLAIM_KEY_CREATED, new Date());
  151.         return generateToken(claims);
  152.     }
  153.  
  154.     /**
  155.      * 获取请求token
  156.      *
  157.      * @param request
  158.      * @return token
  159.      */
  160.     public String getToken(HttpServletRequest request)
  161.     {
  162.         return request.getHeader(header);
  163.     }
  164. }

2.4 自定义权限不足处理类

  1. package com.modules.security.handle;
  2.  
  3. import com.alibaba.fastjson.JSON;
  4. import com.modules.common.utils.ServletUtils;
  5. import com.modules.common.web.Result;
  6. import org.springframework.security.access.AccessDeniedException;
  7. import org.springframework.security.web.access.AccessDeniedHandler;
  8. import org.springframework.stereotype.Component;
  9.  
  10. import javax.servlet.ServletException;
  11. import javax.servlet.http.HttpServletRequest;
  12. import javax.servlet.http.HttpServletResponse;
  13. import java.io.IOException;
  14.  
  15. /**
  16.  * 当访问接口没有权限时，自定义的返回结果
  17.  *
  18.  * @author li'chao
  19.  */
  20. @Component
  21. public class AccessDeniedHandlerImpl implements AccessDeniedHandler {
  22.     @Override
  23.     public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException e) throws IOException, ServletException {
  24.         ServletUtils.renderString(response, JSON.toJSONString(Result.unauth("权限不足")));
  25.     }
  26. }

2.5 自定义认证失败处理类

  1. package com.modules.security.handle;
  2.  
  3. import com.alibaba.fastjson.JSON;
  4. import com.modules.common.utils.ServletUtils;
  5. import com.modules.common.web.Result;
  6. import org.springframework.security.core.AuthenticationException;
  7. import org.springframework.security.web.AuthenticationEntryPoint;
  8. import org.springframework.stereotype.Component;
  9.  
  10. import javax.servlet.ServletException;
  11. import javax.servlet.http.HttpServletRequest;
  12. import javax.servlet.http.HttpServletResponse;
  13. import java.io.IOException;
  14.  
  15. /**
  16.  * 认证失败处理类 自定义返回未授权
  17.  *
  18.  * @author li'chao
  19.  */
  20. @Component
  21. public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint
  22. {
  23.  
  24.     @Override
  25.     public void commence(HttpServletRequest equest, HttpServletResponse response, AuthenticationException e) throws IOException, ServletException {
  26.         ServletUtils.renderString(response, JSON.toJSONString(Result.auth("token认证失败")));
  27.     }
  28. }

2.6 自定义 token 验证类

  1. package com.modules.security.handle;
  2.  
  3. import com.alibaba.fastjson.JSON;
  4. import com.modules.common.utils.ServletUtils;
  5. import com.modules.common.web.Result;
  6. import org.springframework.security.core.AuthenticationException;
  7. import org.springframework.security.web.AuthenticationEntryPoint;
  8. import org.springframework.stereotype.Component;
  9.  
  10. import javax.servlet.ServletException;
  11. import javax.servlet.http.HttpServletRequest;
  12. import javax.servlet.http.HttpServletResponse;
  13. import java.io.IOException;
  14.  
  15. /**
  16.  * 认证失败处理类 自定义返回未授权
  17.  *
  18.  * @author li'chao
  19.  */
  20. @Component
  21. public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint
  22. {
  23.  
  24.     @Override
  25.     public void commence(HttpServletRequest equest, HttpServletResponse response, AuthenticationException e) throws IOException, ServletException {
  26.         ServletUtils.renderString(response, JSON.toJSONString(Result.auth("token认证失败")));
  27.     }
  28. }

2.7 自定义登录处理

  1. package com.modules.security;
  2.  
  3. import com.fasterxml.jackson.annotation.JsonIgnore;
  4. import com.modules.system.entity.SysUser;
  5. import org.springframework.security.core.GrantedAuthority;
  6. import org.springframework.security.core.userdetails.UserDetails;
  7.  
  8. import java.util.Collection;
  9. import java.util.Set;
  10.  
  11. /**
  12.  * 登录用户身份权限
  13.  *
  14.  * @author li'chao
  15.  */
  16. public class LoginUser implements UserDetails
  17. {
  18.     private static final long serialVersionUID = 1L;
  19.  
  20.     /**
  21.      * 用户唯一标识
  22.      */
  23.     private String token;
  24.  
  25.     /**
  26.      * 登陆时间
  27.      */
  28.     private Long loginTime;
  29.  
  30.     /**
  31.      * 过期时间
  32.      */
  33.     private Long expireTime;
  34.  
  35.     /**
  36.      * 登录IP地址
  37.      */
  38.     private String ipaddr;
  39.  
  40.     /**
  41.      * 登录地点
  42.      */
  43.     private String loginLocation;
  44.  
  45.     /**
  46.      * 浏览器类型
  47.      */
  48.     private String browser;
  49.  
  50.     /**
  51.      * 操作系统
  52.      */
  53.     private String os;
  54.  
  55.     /**
  56.      * 权限列表
  57.      */
  58.     private Set<String> permissions;
  59.  
  60.     /**
  61.      * 用户信息
  62.      */
  63.     private SysUser user;
  64.  
  65.     public String getToken()
  66.     {
  67.         return token;
  68.     }
  69.  
  70.     public void setToken(String token)
  71.     {
  72.         this.token = token;
  73.     }
  74.  
  75.     public LoginUser()
  76.     {
  77.     }
  78.  
  79.     public LoginUser(SysUser user, Set<String> permissions)
  80.     {
  81.         this.user = user;
  82.         this.permissions = permissions;
  83.     }
  84.  
  85.     @JsonIgnore
  86.     @Override
  87.     public String getPassword()
  88.     {
  89.         return user.getPassword();
  90.     }
  91.  
  92.     @Override
  93.     public String getUsername()
  94.     {
  95.         return user.getUserName();
  96.     }
  97.  
  98.     /**
  99.      * 账户是否未过期,过期无法验证
  100.      */
  101.     @JsonIgnore
  102.     @Override
  103.     public boolean isAccountNonExpired()
  104.     {
  105.         return true;
  106.     }
  107.  
  108.     /**
  109.      * 指定用户是否解锁,锁定的用户无法进行身份验证
  110.      *
  111.      * @return
  112.      */
  113.     @JsonIgnore
  114.     @Override
  115.     public boolean isAccountNonLocked()
  116.     {
  117.         return true;
  118.     }
  119.  
  120.     /**
  121.      * 指示是否已过期的用户的凭据(密码),过期的凭据防止认证
  122.      *
  123.      * @return
  124.      */
  125.     @JsonIgnore
  126.     @Override
  127.     public boolean isCredentialsNonExpired()
  128.     {
  129.         return true;
  130.     }
  131.  
  132.     /**
  133.      * 是否可用 ,禁用的用户不能身份验证
  134.      *
  135.      * @return
  136.      */
  137.     @JsonIgnore
  138.     @Override
  139.     public boolean isEnabled()
  140.     {
  141.         return true;
  142.     }
  143.  
  144.     public Long getLoginTime()
  145.     {
  146.         return loginTime;
  147.     }
  148.  
  149.     public void setLoginTime(Long loginTime)
  150.     {
  151.         this.loginTime = loginTime;
  152.     }
  153.  
  154.     public String getIpaddr()
  155.     {
  156.         return ipaddr;
  157.     }
  158.  
  159.     public void setIpaddr(String ipaddr)
  160.     {
  161.         this.ipaddr = ipaddr;
  162.     }
  163.  
  164.     public String getLoginLocation()
  165.     {
  166.         return loginLocation;
  167.     }
  168.  
  169.     public void setLoginLocation(String loginLocation)
  170.     {
  171.         this.loginLocation = loginLocation;
  172.     }
  173.  
  174.     public String getBrowser()
  175.     {
  176.         return browser;
  177.     }
  178.  
  179.     public void setBrowser(String browser)
  180.     {
  181.         this.browser = browser;
  182.     }
  183.  
  184.     public String getOs()
  185.     {
  186.         return os;
  187.     }
  188.  
  189.     public void setOs(String os)
  190.     {
  191.         this.os = os;
  192.     }
  193.  
  194.     public Long getExpireTime()
  195.     {
  196.         return expireTime;
  197.     }
  198.  
  199.     public void setExpireTime(Long expireTime)
  200.     {
  201.         this.expireTime = expireTime;
  202.     }
  203.  
  204.     public Set<String> getPermissions()
  205.     {
  206.         return permissions;
  207.     }
  208.  
  209.     public void setPermissions(Set<String> permissions)
  210.     {
  211.         this.permissions = permissions;
  212.     }
  213.  
  214.     public SysUser getUser()
  215.     {
  216.         return user;
  217.     }
  218.  
  219.     public void setUser(SysUser user)
  220.     {
  221.         this.user = user;
  222.     }
  223.  
  224.     @Override
  225.     public Collection<? extends GrantedAuthority> getAuthorities()
  226.     {
  227.         return null;
  228.     }
  229. }
  1. package com.modules.security.service;
  2.  
  3. import com.modules.common.enmus.PublicEnum;
  4. import com.modules.common.exception.CustomException;
  5. import com.modules.common.utils.StringUtils;
  6. import com.modules.security.LoginUser;
  7. import com.modules.system.entity.SysUser;
  8. import com.modules.system.service.SysUserService;
  9. import lombok.extern.slf4j.Slf4j;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.security.core.userdetails.UserDetails;
  12. import org.springframework.security.core.userdetails.UserDetailsService;
  13. import org.springframework.security.core.userdetails.UsernameNotFoundException;
  14. import org.springframework.stereotype.Service;
  15.  
  16. /**
  17.  * @ClassName UserDetailsServiceImpl
  18.  * @Description 用户验证处理
  19.  * @Author li'chao
  20.  * @Date 2022-3-9 22:20
  21.  * @Version 1.0
  22.  **/
  23. @Slf4j
  24. @Service
  25. public class UserDetailsServiceImpl implements UserDetailsService {
  26.  
  27.     @Autowired
  28.     private SysUserService sysUserService;
  29.  
  30.     /**
  31.      * 登录信息验证
  32.      * @param username
  33.      * @return
  34.      * @throws UsernameNotFoundException
  35.      */
  36.     @Override
  37.     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
  38.         SysUser sysUser = sysUserService.selectUserByLoginName(username);
  39.         if (StringUtils.isNull(sysUser))
  40.         {
  41.             log.info("登录用户：{} 不存在.", username);
  42.             throw new UsernameNotFoundException("登录账号不存在");
  43.         }
  44.         else if (PublicEnum.DELETE.getCode().equals(sysUser.getStatus()))
  45.         {
  46.             log.info("登录用户：{} 已被删除.", username);
  47.             throw new CustomException("账号已被删除");
  48.         }
  49.         else if (PublicEnum.DISABLE.getCode().equals(sysUser.getStatus()))
  50.         {
  51.             log.info("登录用户：{} 已被停用.", username);
  52.             throw new CustomException("账号已停用");
  53.         }
  54.         return createLoginUser(sysUser);
  55.     }
  56.  
  57.     public UserDetails createLoginUser(SysUser user)
  58.     {
  59.         return new LoginUser(user, null);
  60.     }
  61. }
  1. package com.modules.security.service;
  2.  
  3. import com.modules.security.JwtTokenUtil;
  4. import com.modules.security.LoginUser;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.security.authentication.AuthenticationManager;
  8. import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
  9. import org.springframework.security.core.Authentication;
  10. import org.springframework.stereotype.Service;
  11.  
  12. /**
  13.  * @ClassName LoginService
  14.  * @Description 登录校验
  15.  * @Author li'chao
  16.  * @Date 2022-3-11 14:21
  17.  * @Version 1.0
  18.  **/
  19. @Slf4j
  20. @Service
  21. public class LoginService {
  22.  
  23.     @Autowired
  24.     private AuthenticationManager authenticationManager;
  25.  
  26.     @Autowired
  27.     private JwtTokenUtil jwtTokenUtil;
  28.  
  29.     /**
  30.      * 登录验证
  31.      *
  32.      * @param username 用户名
  33.      * @param password 密码
  34.      * @return 结果
  35.      */
  36.     public LoginUser login(String username, String password) {
  37.         String token = null;
  38.         LoginUser loginUser = null;
  39.         // 用户验证
  40.         Authentication authentication = null;
  41.         // 该方法会去调用UserDetailsServiceImpl.loadUserByUsername
  42.         authentication = authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(username, password));
  43.         loginUser = (LoginUser) authentication.getPrincipal();
  44.         token = jwtTokenUtil.generateToken(loginUser);
  45.         loginUser.setToken(token);
  46.         return loginUser;
  47.     }
  48. }
  1. package com.modules.common.web;
  2.  
  3.  
  4. import com.modules.common.utils.StringUtils;
  5.  
  6. import java.util.HashMap;
  7.  
  8. /**
  9.  * 操作消息提醒
  10.  *
  11.  * @author lc
  12.  */
  13. public class Result extends HashMap<String, Object> {
  14.     private static final long serialVersionUID = 1L;
  15.  
  16.     public static final String CODE_TAG = "code";
  17.  
  18.     public static final String MSG_TAG = "msg";
  19.  
  20.     public static final String DATA_TAG = "data";
  21.     public static final String success_Count = "successCount";
  22.     public static final String fail_Count = "failCount";
  23.     public static final String messCell_Count = "messCellCount";
  24.  
  25.     /**
  26.      * 状态类型
  27.      */
  28.     public enum Type {
  29.         /**
  30.          * 成功
  31.          */
  32.         SUCCESS(200),
  33.         /**
  34.          * 警告
  35.          */
  36.         WARN(300),
  37.  
  38.         /**
  39.          * 失败
  40.          */
  41.         FAIL(400),
  42.  
  43.         /**
  44.          * 错误
  45.          */
  46.         ERROR(500),
  47.  
  48.         /**
  49.          * 权限不足
  50.          */
  51.         UNAUTH(600),
  52.  
  53.         /**
  54.          * token认证失败
  55.          */
  56.         AUTH(700);
  57.  
  58.         private final int value;
  59.  
  60.  
  61.         Type(int value) {
  62.             this.value = value;
  63.         }
  64.  
  65.         public int value() {
  66.             return this.value;
  67.         }
  68.     }
  69.  
  70.     /**
  71.      * 初始化一个新创建的 Result 对象，使其表示一个空消息。
  72.      *
  73.      * @param type
  74.      * @param msg
  75.      * @param successCount
  76.      * @param failCount
  77.      * @param messCellCount
  78.      * @param data
  79.      */
  80.     public Result(Type type, String msg, int successCount, int failCount, int messCellCount, Object data) {
  81.         super.put(CODE_TAG, type.value);
  82.         super.put(MSG_TAG, msg);
  83.         if (StringUtils.isNotNull(data)) {
  84.             super.put(DATA_TAG, data);
  85.         }
  86.         super.put(success_Count, successCount);
  87.         super.put(fail_Count, failCount);
  88.         super.put(messCell_Count, messCellCount);
  89.  
  90.     }
  91.  
  92.     /**
  93.      * 初始化一个新创建的 Result 对象
  94.      *
  95.      * @param type 状态类型
  96.      * @param msg  返回内容
  97.      */
  98.     public Result(Type type, String msg) {
  99.         super.put(CODE_TAG, type.value);
  100.         super.put(MSG_TAG, msg);
  101.     }
  102.  
  103.     /**
  104.      * 初始化一个新创建的 Result 对象
  105.      *
  106.      * @param type 状态类型
  107.      * @param msg  返回内容
  108.      * @param data 数据对象
  109.      */
  110.     public Result(Type type, Object msg, Object data) {
  111.         super.put(CODE_TAG, type.value);
  112.         super.put(MSG_TAG, msg);
  113.         if (StringUtils.isNotNull(data)) {
  114.             super.put(DATA_TAG, data);
  115.         }
  116.     }
  117.  
  118.     /**
  119.      * 返回成功消息
  120.      *
  121.      * @return 成功消息
  122.      */
  123.     public static Result success() {
  124.         return success("操作成功");
  125.     }
  126.  
  127.     /**
  128.      * 返回成功数据
  129.      *
  130.      * @return 成功消息
  131.      */
  132.     public static Result success(Object data) {
  133.         return success("操作成功", data);
  134.     }
  135.  
  136.     /**
  137.      * 返回成功消息
  138.      *
  139.      * @param msg 返回内容
  140.      * @return 成功消息
  141.      */
  142.     public static Result success(String msg) {
  143.         return success(msg, null);
  144.     }
  145.  
  146.     /**
  147.      * 返回成功消息
  148.      *
  149.      * @param msg  返回内容
  150.      * @param data 数据对象
  151.      * @return 成功消息
  152.      */
  153.     public static Result success(String msg, Object data) {
  154.         return new Result(Type.SUCCESS, msg, data);
  155.     }
  156.  
  157.     /**
  158.      * 返回成功消息
  159.      *
  160.      * @param msg           返回内容
  161.      * @param data          数据对象
  162.      * @param successCount  成功数据集条数
  163.      * @param failCount     失败条数条数
  164.      * @param messCellCount 异常单元格条数
  165.      * @return 成功消息
  166.      */
  167.     public static Result success(String msg, int successCount, int failCount, int messCellCount, Object data) {
  168.         return new Result(Type.SUCCESS, msg, successCount, failCount, messCellCount, data);
  169.     }
  170.  
  171.     /**
  172.      * 返回成功消息
  173.      *
  174.      * @param msg           返回内容
  175.      * @param data          数据对象
  176.      * @param successCount  成功数据集条数
  177.      * @param failCount     失败条数条数
  178.      * @param messCellCount 异常单元格条数
  179.      * @return 失败消息
  180.      */
  181.     public static Result error(String msg, int successCount, int failCount, int messCellCount, Object data) {
  182.         return new Result(Type.ERROR, msg, successCount, failCount, messCellCount, data);
  183.     }
  184.  
  185.  
  186.     /**
  187.      * 返回警告消息
  188.      *
  189.      * @param msg 返回内容
  190.      * @return 警告消息
  191.      */
  192.     public static Result warn(String msg) {
  193.         return warn(msg, null);
  194.     }
  195.  
  196.     /**
  197.      * 返回警告消息
  198.      *
  199.      * @param msg  返回内容
  200.      * @param data 数据对象
  201.      * @return 警告消息
  202.      */
  203.     public static Result warn(String msg, Object data) {
  204.         return new Result(Type.WARN, msg, data);
  205.     }
  206.  
  207.     /**
  208.      * 返回错误消息
  209.      *
  210.      * @return
  211.      */
  212.     public static Result error() {
  213.         return error("操作失败");
  214.     }
  215.  
  216.     /**
  217.      * 返回错误消息
  218.      *
  219.      * @param msg 返回内容
  220.      * @return 警告消息
  221.      */
  222.     public static Result error(Object msg) {
  223.         return error(msg, null);
  224.     }
  225.  
  226.     /**
  227.      * 返回错误消息
  228.      *
  229.      * @param msg  返回内容
  230.      * @param data 数据对象
  231.      * @return 警告消息
  232.      */
  233.     public static Result error(Object msg, Object data) {
  234.         return new Result(Type.ERROR, msg, data);
  235.     }
  236.  
  237.     /**
  238.      * 返回权限不足消息
  239.      *
  240.      * @return
  241.      */
  242.     public static Result unauth() {
  243.         return error("权限不足");
  244.     }
  245.  
  246.     /**
  247.      * 返回权限不足消息
  248.      *
  249.      * @param msg 返回内容
  250.      * @return 警告消息
  251.      */
  252.     public static Result unauth(String msg) {
  253.         return error(msg, null);
  254.     }
  255.  
  256.     /**
  257.      * 返回无权限信息
  258.      *
  259.      * @param msg  返回内容
  260.      * @param data 数据对象
  261.      * @return 警告消息
  262.      */
  263.     public static Result unauth(String msg, Object data) {
  264.         return new Result(Type.UNAUTH, msg, data);
  265.     }
  266.  
  267.     /**
  268.      * 返回token认证失败消息
  269.      *
  270.      * @return
  271.      */
  272.     public static Result auth() {
  273.         return error("token认证失败");
  274.     }
  275.  
  276.     /**
  277.      * 返回token认证失败消息
  278.      *
  279.      * @param msg 返回内容
  280.      * @return 警告消息
  281.      */
  282.     public static Result auth(String msg) {
  283.         return error(msg, null);
  284.     }
  285.  
  286.     /**
  287.      * 返回token认证失败消息
  288.      *
  289.      * @param msg  返回内容
  290.      * @param data 数据对象
  291.      * @return 警告消息
  292.      */
  293.     public static Result auth(String msg, Object data) {
  294.         return new Result(Type.AUTH, msg, data);
  295.     }
  296.  
  297.     /**
  298.      * 返回失败消息
  299.      *
  300.      * @return
  301.      */
  302.     public static Result fail()
  303.     {
  304.         return fail("操作失败");
  305.     }
  306.  
  307.     /**
  308.      * 返返回失败消息
  309.      *
  310.      * @param msg 返回内容
  311.      * @return 警告消息
  312.      */
  313.     public static Result fail(String msg)
  314.     {
  315.         return fail(msg, null);
  316.     }
  317.  
  318.     /**
  319.      * 返回失败消息
  320.      *
  321.      * @param msg 返回内容
  322.      * @param data 数据对象
  323.      * @return 警告消息
  324.      */
  325.     public static Result fail(String msg, Object data)
  326.     {
  327.         return new Result(Type.FAIL, msg, data);
  328.     }
  329.  
  330. }

2.8 SpringSecurity 核心配置

  1. package com.modules.common.config;
  2.  
  3. import com.modules.security.filter.JwtAuthenticationTokenFilter;
  4. import com.modules.security.handle.AccessDeniedHandlerImpl;
  5. import com.modules.security.handle.AuthenticationEntryPointImpl;
  6. import com.modules.security.handle.LogoutSuccessHandlerImpl;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.context.annotation.Configuration;
  10. import org.springframework.http.HttpMethod;
  11. import org.springframework.security.authentication.AuthenticationManager;
  12. import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
  13. import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
  14. import org.springframework.security.config.annotation.web.builders.HttpSecurity;
  15. import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
  16. import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
  17. import org.springframework.security.config.http.SessionCreationPolicy;
  18. import org.springframework.security.core.userdetails.UserDetailsService;
  19. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
  20. import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
  21.  
  22. import javax.annotation.Resource;
  23.  
  24. /**
  25.  * @ClassName SecurityConfig
  26.  * @Description SpringSecurity的配置
  27.  * @Author li'chao
  28.  * @Date 2022-3-8 17:46
  29.  * @Version 1.0
  30.  **/
  31. @Configuration
  32. @EnableWebSecurity
  33. @EnableGlobalMethodSecurity(prePostEnabled=true)
  34. public class SecurityConfig extends WebSecurityConfigurerAdapter {
  35.  
  36.     /**
  37.      * 自定义用户认证逻辑
  38.      */
  39.     @Resource
  40.     private UserDetailsService userDetailsService;
  41.  
  42.     /**
  43.      * 自定义权限不足处理类
  44.      */
  45.     @Autowired
  46.     private AccessDeniedHandlerImpl accessDeniedHandler;
  47.  
  48.     /**
  49.      * 自定义认证失败处理类
  50.      */
  51.     @Autowired
  52.     private AuthenticationEntryPointImpl authenticationEntryPoint;
  53.  
  54.     /**
  55.      * 自定义退出处理类
  56.      */
  57.     @Autowired
  58.     private LogoutSuccessHandlerImpl logoutSuccessHandler;
  59.  
  60.     /**
  61.      * token认证过滤器
  62.      */
  63.     @Autowired
  64.     private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
  65.  
  66.  
  67.     /**
  68.      * 注入 AuthenticationManager
  69.      *
  70.      * @return
  71.      * @throws Exception
  72.      */
  73.     @Bean
  74.     @Override
  75.     public AuthenticationManager authenticationManagerBean() throws Exception
  76.     {
  77.         return super.authenticationManagerBean();
  78.     }
  79.  
  80.  
  81.     /**
  82.      * anyRequest          |   匹配所有请求路径
  83.      * access              |   SpringEl表达式结果为true时可以访问
  84.      * anonymous           |   匿名可以访问
  85.      * denyAll             |   用户不能访问
  86.      * fullyAuthenticated  |   用户完全认证可以访问（非remember-me下自动登录）
  87.      * hasAnyAuthority     |   如果有参数，参数表示权限，则其中任何一个权限可以访问
  88.      * hasAnyRole          |   如果有参数，参数表示角色，则其中任何一个角色可以访问
  89.      * hasAuthority        |   如果有参数，参数表示权限，则其权限可以访问
  90.      * hasIpAddress        |   如果有参数，参数表示IP地址，如果用户IP和参数匹配，则可以访问
  91.      * hasRole             |   如果有参数，参数表示角色，则其角色可以访问
  92.      * permitAll           |   用户可以任意访问
  93.      * rememberMe          |   允许通过remember-me登录的用户访问
  94.      * authenticated       |   用户登录后可访问
  95.      */
  96.     @Override
  97.     protected void configure(HttpSecurity httpSecurity) throws Exception
  98.     {
  99.         httpSecurity
  100.                 // CRSF禁用，因为不使用session
  101.                 .csrf().disable()
  102.                 .exceptionHandling()
  103.                 // 认证失败处理类
  104.                 .authenticationEntryPoint(authenticationEntryPoint)
  105.                 // 权限不足处理类
  106.                 .accessDeniedHandler(accessDeniedHandler)
  107.                 .and()
  108.                 // 基于token，所以不需要session
  109.                 .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and()
  110.                 // 过滤请求
  111.                 .authorizeRequests()
  112.                 // 对于登录login 验证码captchaImage 允许匿名访问
  113.                 .antMatchers("/user/**", "/captchaImage").anonymous()
  114.                 .antMatchers(
  115.                         HttpMethod.GET,
  116.                         "/*.html",
  117.                         "/**/*.html",
  118.                         "/**/*.css",
  119.                         "/**/*.js"
  120.                 ).permitAll()
  121.                 .antMatchers("/profile/**").anonymous()
  122.                 .antMatchers("/common/download**").anonymous()
  123.                 .antMatchers("/common/download/resource**").anonymous()
  124.                 .antMatchers("/swagger-ui.html").anonymous()
  125.                 .antMatchers("/swagger-resources/**").anonymous()
  126.                 .antMatchers("/webjars/**").anonymous()
  127.                 .antMatchers("/*/api-docs").anonymous()
  128.                 .antMatchers("/druid/**").anonymous()
  129.                 // 除上面外的所有请求全部需要鉴权认证
  130.                 .anyRequest().authenticated()
  131.                 .and()
  132.                 .headers().frameOptions().disable();
  133.         httpSecurity.logout().logoutUrl("/logout").logoutSuccessHandler(logoutSuccessHandler);
  134.         // 添加JWT filter
  135.         httpSecurity.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
  136.     }
  137.  
  138.     /**
  139.      * 自定义身份认证
  140.      */
  141.     @Override
  142.     protected void configure(AuthenticationManagerBuilder builder) throws Exception
  143.     {
  144.         builder.userDetailsService(userDetailsService).passwordEncoder(bCryptPasswordEncoder());
  145.     }
  146.  
  147.     /**
  148.      * 强散列哈希加密实现密码加密
  149.      */
  150.     @Bean
  151.     public BCryptPasswordEncoder bCryptPasswordEncoder()
  152.     {
  153.         return new BCryptPasswordEncoder();
  154.     }
  155.  
  156. }

2.9 登录控制类

  1. package com.modules.system.controller;
  2.  
  3. import com.modules.common.aspectj.Log;
  4. import com.modules.common.enmus.BusinessType;
  5. import com.modules.common.web.BaseController;
  6. import com.modules.common.web.Result;
  7. import com.modules.security.service.LoginService;
  8. import io.swagger.annotations.Api;
  9. import io.swagger.annotations.ApiOperation;
  10. import io.swagger.annotations.ApiParam;
  11. import lombok.extern.slf4j.Slf4j;
  12. import org.springframework.beans.factory.annotation.Autowired;
  13. import org.springframework.security.authentication.BadCredentialsException;
  14. import org.springframework.web.bind.annotation.*;
  15.  
  16. import javax.servlet.http.HttpServletRequest;
  17.  
  18. /**
  19.  * 登录管理
  20.  *
  21.  * @author lc
  22.  */
  23. @Api(tags = "登录管理")
  24. @Slf4j
  25. @CrossOrigin
  26. @RestController
  27. @RequestMapping("/user")
  28. public class LoginController extends BaseController {
  29.  
  30.     @Autowired
  31.     private LoginService loginService;
  32.  
  33.     @Log(title = "用户登录", businessType = BusinessType.LOGIN)
  34.     @ApiOperation(value = "用户登录", notes = "用户登录")
  35.     @PostMapping(value = "/login")
  36.     public Result login(HttpServletRequest request,
  37.                         @ApiParam(name = "loginName", value = "登录账号") @RequestParam(value = "loginName", required = true) String loginName,
  38.                         @ApiParam(name = "password", value = "密码") @RequestParam(value = "password", required = true) String password) {
  39.         try {
  40.             return success(loginService.login(loginName, password));
  41.         }catch (Exception e) {
  42.             if(e instanceof BadCredentialsException){
  43.                 log.error("BadCredentialsException=====>账号或者密码错误", e.getMessage());
  44.                 return error("账号或者密码错误");
  45.             }else {
  46.                 log.error("CustomException=====>", e.getMessage());
  47.                 return error(e.getMessage());
  48.             }
  49.         }
  50.     }
  51. }

2.10 Swagger2的接口配置

  1. package com.modules.common.config;
  2.  
  3. import io.swagger.annotations.ApiOperation;
  4. import org.springframework.beans.factory.annotation.Value;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  7. import springfox.documentation.builders.ApiInfoBuilder;
  8. import springfox.documentation.builders.PathSelectors;
  9. import springfox.documentation.builders.RequestHandlerSelectors;
  10. import springfox.documentation.service.*;
  11. import springfox.documentation.spi.DocumentationType;
  12. import springfox.documentation.spi.service.contexts.SecurityContext;
  13. import springfox.documentation.spring.web.plugins.Docket;
  14. import springfox.documentation.swagger2.annotations.EnableSwagger2;
  15.  
  16. import java.util.ArrayList;
  17. import java.util.List;
  18.  
  19. /**
  20.  * Swagger2的接口配置
  21.  *
  22.  * @author lc
  23.  */
  24. @Configuration
  25. @EnableSwagger2
  26. public class SwaggerConfig {
  27.  
  28.     @Value("${swagger.show}")
  29.     private boolean swaggerShow;
  30.  
  31.     /**
  32.      * 创建API
  33.      */
  34.     @Bean
  35.     public Docket createRestApi() {
  36.         return new Docket(DocumentationType.SWAGGER_2)
  37.                 // 是否开启
  38.                 .enable(swaggerShow)
  39.                 // 用来创建该API的基本信息，展示在文档的页面中（自定义展示的信息）
  40.                 .apiInfo(apiInfo())
  41.                 // 全局header配置
  42. //                .globalOperationParameters(parameters)
  43.                 // 设置哪些接口暴露给Swagger展示
  44.                 .select()
  45.                 // 扫描所有有注解的api，用这种方式更灵活
  46.                 .apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class))
  47.                 // 扫描指定包中的swagger注解
  48.                 //.apis(RequestHandlerSelectors.basePackage("com.modules.swagger"))
  49.                 // 扫描所有 .apis(RequestHandlerSelectors.any())
  50.                 .paths(PathSelectors.any())
  51.                 .build()
  52.                 /* 设置安全模式，swagger可以设置访问token */
  53.                 .securitySchemes(securitySchemes())
  54.                 .securityContexts(securityContexts());
  55.     }
  56.  
  57.     /**
  58.      * 安全模式，这里指定token通过Authorization头请求头传递
  59.      */
  60.     private List<ApiKey> securitySchemes()
  61.     {
  62.         List<ApiKey> apiKeyList = new ArrayList<ApiKey>();
  63.         apiKeyList.add(new ApiKey("token", "token", "header"));
  64.         return apiKeyList;
  65.     }
  66.  
  67.     /**
  68.      * 安全上下文
  69.      */
  70.     private List<SecurityContext> securityContexts()
  71.     {
  72.         List<SecurityContext> securityContexts = new ArrayList<>();
  73.         securityContexts.add(
  74.                 SecurityContext.builder()
  75.                         .securityReferences(defaultAuth())
  76.                         .forPaths(PathSelectors.regex("^(?!auth).*$"))
  77.                         .build());
  78.         return securityContexts;
  79.     }
  80.  
  81.     /**
  82.      * 默认的安全上引用
  83.      */
  84.     private List<SecurityReference> defaultAuth()
  85.     {
  86.         AuthorizationScope authorizationScope = new AuthorizationScope("global", "accessEverything");
  87.         AuthorizationScope[] authorizationScopes = new AuthorizationScope[1];
  88.         authorizationScopes[0] = authorizationScope;
  89.         List<SecurityReference> securityReferences = new ArrayList<>();
  90.         securityReferences.add(new SecurityReference("token", authorizationScopes));
  91.         return securityReferences;
  92.     }
  93.  
  94.     /**
  95.      * 添加摘要信息
  96.      */
  97.     private ApiInfo apiInfo() {
  98.         // 用ApiInfoBuilder进行定制
  99.         return new ApiInfoBuilder()
  100.                 // 设置标题
  101.                 .title("标题：系统接口文档")
  102.                 // 描述
  103.                 .description("描述：用于描述系统接口...")
  104.                 // 作者信息
  105.                 .contact(new Contact("lc", null, null))
  106.                 // 版本
  107.                 .version("版本号:" + "v1.0.0")
  108.                 .build();
  109.     }
  110. }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/639982
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号