Spring Boot2 + Spring Security + JWT 实现项目级前后端分离认证授权

已于 2023-11-07 14:02:14 修改
阅读量6.2k 收藏 12
点赞数 7
分类专栏： Spring Cloud 文章标签： Spring Security 安全管理框架 认证授权 token JWT
于 2022-03-14 11:48:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lovelichao12/article/details/123319405
版权

一 简介

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

        <!-- spring security 安全认证 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>

        <!--Token生成与解析-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.0</version>
        </dependency>

2.2 application.properties

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

2.3 JwtToken工具类

package com.modules.security;

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 javax.servlet.http.HttpServletRequest;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * @ClassName JwtTokenUtil
 * @Description JwtToken生成的工具类
 * @Author li'chao
 * @Date 2022-3-8 17:17
 * @Version 1.0
 **/
@Slf4j
@Component
public class JwtTokenUtil {

    private static final String CLAIM_KEY_USERNAME = "sub";
    private static final String CLAIM_KEY_CREATED = "created";

    // 令牌自定义标识
    @Value("${jwt.token.header}")
    private String header;

    // 令牌秘钥
    @Value("${jwt.token.secret}")
    private String secret;

    // 令牌有效期（默认30分钟）
    @Value("${jwt.token.expireTime}")
    private Long expiration;


    /**
     * 根据负责生成JWT的token
     */
    private String generateToken(Map<String, Object> claims) {
        return Jwts.builder()
                .setClaims(claims)
                .setExpiration(generateExpirationDate())
                .signWith(SignatureAlgorithm.HS512, secret)
                .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是否已经失效
     */
    public 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
     */
    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 String generateToken(LoginUser loginUser) {
        Map<String, Object> claims = new HashMap<>();
        claims.put(CLAIM_KEY_USERNAME, loginUser.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);
    }

    /**
     * 获取请求token
     *
     * @param request
     * @return token
     */
    public String getToken(HttpServletRequest request)
    {
        return request.getHeader(header);
    }
}

2.4 自定义权限不足处理类

package com.modules.security.handle;

import com.alibaba.fastjson.JSON;
import com.modules.common.utils.ServletUtils;
import com.modules.common.web.Result;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.stereotype.Component;

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

/**
 * 当访问接口没有权限时，自定义的返回结果
 *
 * @author li'chao
 */
@Component
public class AccessDeniedHandlerImpl implements AccessDeniedHandler {
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException e) throws IOException, ServletException {
        ServletUtils.renderString(response, JSON.toJSONString(Result.unauth("权限不足")));
    }
}

2.5 自定义认证失败处理类

package com.modules.security.handle;

import com.alibaba.fastjson.JSON;
import com.modules.common.utils.ServletUtils;
import com.modules.common.web.Result;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;

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

/**
 * 认证失败处理类 自定义返回未授权
 *
 * @author li'chao
 */
@Component
public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint
{

    @Override
    public void commence(HttpServletRequest equest, HttpServletResponse response, AuthenticationException e) throws IOException, ServletException {
        ServletUtils.renderString(response, JSON.toJSONString(Result.auth("token认证失败")));
    }
}

2.6 自定义 token 验证类

package com.modules.security.handle;

import com.alibaba.fastjson.JSON;
import com.modules.common.utils.ServletUtils;
import com.modules.common.web.Result;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;

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

/**
 * 认证失败处理类 自定义返回未授权
 *
 * @author li'chao
 */
@Component
public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint
{

    @Override
    public void commence(HttpServletRequest equest, HttpServletResponse response, AuthenticationException e) throws IOException, ServletException {
        ServletUtils.renderString(response, JSON.toJSONString(Result.auth("token认证失败")));
    }
}

2.7 自定义登录处理

package com.modules.security;

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.modules.system.entity.SysUser;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import java.util.Collection;
import java.util.Set;

/**
 * 登录用户身份权限
 *
 * @author li'chao
 */
public class LoginUser implements UserDetails
{
    private static final long serialVersionUID = 1L;

    /**
     * 用户唯一标识
     */
    private String token;

    /**
     * 登陆时间
     */
    private Long loginTime;

    /**
     * 过期时间
     */
    private Long expireTime;

    /**
     * 登录IP地址
     */
    private String ipaddr;

    /**
     * 登录地点
     */
    private String loginLocation;

    /**
     * 浏览器类型
     */
    private String browser;

    /**
     * 操作系统
     */
    private String os;

    /**
     * 权限列表
     */
    private Set<String> permissions;

    /**
     * 用户信息
     */
    private SysUser user;

    public String getToken()
    {
        return token;
    }

    public void setToken(String token)
    {
        this.token = token;
    }

    public LoginUser()
    {
    }

    public LoginUser(SysUser user, Set<String> permissions)
    {
        this.user = user;
        this.permissions = permissions;
    }

    @JsonIgnore
    @Override
    public String getPassword()
    {
        return user.getPassword();
    }

    @Override
    public String getUsername()
    {
        return user.getUserName();
    }

    /**
     * 账户是否未过期,过期无法验证
     */
    @JsonIgnore
    @Override
    public boolean isAccountNonExpired()
    {
        return true;
    }

    /**
     * 指定用户是否解锁,锁定的用户无法进行身份验证
     *
     * @return
     */
    @JsonIgnore
    @Override
    public boolean isAccountNonLocked()
    {
        return true;
    }

    /**
     * 指示是否已过期的用户的凭据(密码),过期的凭据防止认证
     *
     * @return
     */
    @JsonIgnore
    @Override
    public boolean isCredentialsNonExpired()
    {
        return true;
    }

    /**
     * 是否可用 ,禁用的用户不能身份验证
     *
     * @return
     */
    @JsonIgnore
    @Override
    public boolean isEnabled()
    {
        return true;
    }

    public Long getLoginTime()
    {
        return loginTime;
    }

    public void setLoginTime(Long loginTime)
    {
        this.loginTime = loginTime;
    }

    public String getIpaddr()
    {
        return ipaddr;
    }

    public void setIpaddr(String ipaddr)
    {
        this.ipaddr = ipaddr;
    }

    public String getLoginLocation()
    {
        return loginLocation;
    }

    public void setLoginLocation(String loginLocation)
    {
        this.loginLocation = loginLocation;
    }

    public String getBrowser()
    {
        return browser;
    }

    public void setBrowser(String browser)
    {
        this.browser = browser;
    }

    public String getOs()
    {
        return os;
    }

    public void setOs(String os)
    {
        this.os = os;
    }

    public Long getExpireTime()
    {
        return expireTime;
    }

    public void setExpireTime(Long expireTime)
    {
        this.expireTime = expireTime;
    }

    public Set<String> getPermissions()
    {
        return permissions;
    }

    public void setPermissions(Set<String> permissions)
    {
        this.permissions = permissions;
    }

    public SysUser getUser()
    {
        return user;
    }

    public void setUser(SysUser user)
    {
        this.user = user;
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities()
    {
        return null;
    }
}

package com.modules.security.service;

import com.modules.common.enmus.PublicEnum;
import com.modules.common.exception.CustomException;
import com.modules.common.utils.StringUtils;
import com.modules.security.LoginUser;
import com.modules.system.entity.SysUser;
import com.modules.system.service.SysUserService;
import lombok.extern.slf4j.Slf4j;
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;

/**
 * @ClassName UserDetailsServiceImpl
 * @Description 用户验证处理
 * @Author li'chao
 * @Date 2022-3-9 22:20
 * @Version 1.0
 **/
@Slf4j
@Service
public class UserDetailsServiceImpl implements UserDetailsService {

    @Autowired
    private SysUserService sysUserService;

    /**
     * 登录信息验证
     * @param username
     * @return
     * @throws UsernameNotFoundException
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        SysUser sysUser = sysUserService.selectUserByLoginName(username);
        if (StringUtils.isNull(sysUser))
        {
            log.info("登录用户：{} 不存在.", username);
            throw new UsernameNotFoundException("登录账号不存在");
        }
        else if (PublicEnum.DELETE.getCode().equals(sysUser.getStatus()))
        {
            log.info("登录用户：{} 已被删除.", username);
            throw new CustomException("账号已被删除");
        }
        else if (PublicEnum.DISABLE.getCode().equals(sysUser.getStatus()))
        {
            log.info("登录用户：{} 已被停用.", username);
            throw new CustomException("账号已停用");
        }
        return createLoginUser(sysUser);
    }

    public UserDetails createLoginUser(SysUser user)
    {
        return new LoginUser(user, null);
    }
}

package com.modules.security.service;

import com.modules.security.JwtTokenUtil;
import com.modules.security.LoginUser;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.stereotype.Service;

/**
 * @ClassName LoginService
 * @Description 登录校验
 * @Author li'chao
 * @Date 2022-3-11 14:21
 * @Version 1.0
 **/
@Slf4j
@Service
public class LoginService {

    @Autowired
    private AuthenticationManager authenticationManager;

    @Autowired
    private JwtTokenUtil jwtTokenUtil;

    /**
     * 登录验证
     *
     * @param username 用户名
     * @param password 密码
     * @return 结果
     */
    public LoginUser login(String username, String password) {
        String token = null;
        LoginUser loginUser = null;
        // 用户验证
        Authentication authentication = null;
        // 该方法会去调用UserDetailsServiceImpl.loadUserByUsername
        authentication = authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(username, password));
        loginUser = (LoginUser) authentication.getPrincipal();
        token = jwtTokenUtil.generateToken(loginUser);
        loginUser.setToken(token);
        return loginUser;
    }
}

package com.modules.common.web;


import com.modules.common.utils.StringUtils;

import java.util.HashMap;

/**
 * 操作消息提醒
 *
 * @author lc
 */
public class Result extends HashMap<String, Object> {
    private static final long serialVersionUID = 1L;

    public static final String CODE_TAG = "code";

    public static final String MSG_TAG = "msg";

    public static final String DATA_TAG = "data";
    public static final String success_Count = "successCount";
    public static final String fail_Count = "failCount";
    public static final String messCell_Count = "messCellCount";

    /**
     * 状态类型
     */
    public enum Type {
        /**
         * 成功
         */
        SUCCESS(200),
        /**
         * 警告
         */
        WARN(300),

        /**
         * 失败
         */
        FAIL(400),

        /**
         * 错误
         */
        ERROR(500),

        /**
         * 权限不足
         */
        UNAUTH(600),

        /**
         * token认证失败
         */
        AUTH(700);

        private final int value;


        Type(int value) {
            this.value = value;
        }

        public int value() {
            return this.value;
        }
    }

    /**
     * 初始化一个新创建的 Result 对象，使其表示一个空消息。
     *
     * @param type
     * @param msg
     * @param successCount
     * @param failCount
     * @param messCellCount
     * @param data
     */
    public Result(Type type, String msg, int successCount, int failCount, int messCellCount, Object data) {
        super.put(CODE_TAG, type.value);
        super.put(MSG_TAG, msg);
        if (StringUtils.isNotNull(data)) {
            super.put(DATA_TAG, data);
        }
        super.put(success_Count, successCount);
        super.put(fail_Count, failCount);
        super.put(messCell_Count, messCellCount);

    }

    /**
     * 初始化一个新创建的 Result 对象
     *
     * @param type 状态类型
     * @param msg  返回内容
     */
    public Result(Type type, String msg) {
        super.put(CODE_TAG, type.value);
        super.put(MSG_TAG, msg);
    }

    /**
     * 初始化一个新创建的 Result 对象
     *
     * @param type 状态类型
     * @param msg  返回内容
     * @param data 数据对象
     */
    public Result(Type type, Object msg, Object data) {
        super.put(CODE_TAG, type.value);
        super.put(MSG_TAG, msg);
        if (StringUtils.isNotNull(data)) {
            super.put(DATA_TAG, data);
        }
    }

    /**
     * 返回成功消息
     *
     * @return 成功消息
     */
    public static Result success() {
        return success("操作成功");
    }

    /**
     * 返回成功数据
     *
     * @return 成功消息
     */
    public static Result success(Object data) {
        return success("操作成功", data);
    }

    /**
     * 返回成功消息
     *
     * @param msg 返回内容
     * @return 成功消息
     */
    public static Result success(String msg) {
        return success(msg, null);
    }

    /**
     * 返回成功消息
     *
     * @param msg  返回内容
     * @param data 数据对象
     * @return 成功消息
     */
    public static Result success(String msg, Object data) {
        return new Result(Type.SUCCESS, msg, data);
    }

    /**
     * 返回成功消息
     *
     * @param msg           返回内容
     * @param data          数据对象
     * @param successCount  成功数据集条数
     * @param failCount     失败条数条数
     * @param messCellCount 异常单元格条数
     * @return 成功消息
     */
    public static Result success(String msg, int successCount, int failCount, int messCellCount, Object data) {
        return new Result(Type.SUCCESS, msg, successCount, failCount, messCellCount, data);
    }

    /**
     * 返回成功消息
     *
     * @param msg           返回内容
     * @param data          数据对象
     * @param successCount  成功数据集条数
     * @param failCount     失败条数条数
     * @param messCellCount 异常单元格条数
     * @return 失败消息
     */
    public static Result error(String msg, int successCount, int failCount, int messCellCount, Object data) {
        return new Result(Type.ERROR, msg, successCount, failCount, messCellCount, data);
    }


    /**
     * 返回警告消息
     *
     * @param msg 返回内容
     * @return 警告消息
     */
    public static Result warn(String msg) {
        return warn(msg, null);
    }

    /**
     * 返回警告消息
     *
     * @param msg  返回内容
     * @param data 数据对象
     * @return 警告消息
     */
    public static Result warn(String msg, Object data) {
        return new Result(Type.WARN, msg, data);
    }

    /**
     * 返回错误消息
     *
     * @return
     */
    public static Result error() {
        return error("操作失败");
    }

    /**
     * 返回错误消息
     *
     * @param msg 返回内容
     * @return 警告消息
     */
    public static Result error(Object msg) {
        return error(msg, null);
    }

    /**
     * 返回错误消息
     *
     * @param msg  返回内容
     * @param data 数据对象
     * @return 警告消息
     */
    public static Result error(Object msg, Object data) {
        return new Result(Type.ERROR, msg, data);
    }

    /**
     * 返回权限不足消息
     *
     * @return
     */
    public static Result unauth() {
        return error("权限不足");
    }

    /**
     * 返回权限不足消息
     *
     * @param msg 返回内容
     * @return 警告消息
     */
    public static Result unauth(String msg) {
        return error(msg, null);
    }

    /**
     * 返回无权限信息
     *
     * @param msg  返回内容
     * @param data 数据对象
     * @return 警告消息
     */
    public static Result unauth(String msg, Object data) {
        return new Result(Type.UNAUTH, msg, data);
    }

    /**
     * 返回token认证失败消息
     *
     * @return
     */
    public static Result auth() {
        return error("token认证失败");
    }

    /**
     * 返回token认证失败消息
     *
     * @param msg 返回内容
     * @return 警告消息
     */
    public static Result auth(String msg) {
        return error(msg, null);
    }

    /**
     * 返回token认证失败消息
     *
     * @param msg  返回内容
     * @param data 数据对象
     * @return 警告消息
     */
    public static Result auth(String msg, Object data) {
        return new Result(Type.AUTH, msg, data);
    }

    /**
     * 返回失败消息
     *
     * @return
     */
    public static Result fail()
    {
        return fail("操作失败");
    }

    /**
     * 返返回失败消息
     *
     * @param msg 返回内容
     * @return 警告消息
     */
    public static Result fail(String msg)
    {
        return fail(msg, null);
    }

    /**
     * 返回失败消息
     *
     * @param msg 返回内容
     * @param data 数据对象
     * @return 警告消息
     */
    public static Result fail(String msg, Object data)
    {
        return new Result(Type.FAIL, msg, data);
    }

}

2.8 SpringSecurity 核心配置

package com.modules.common.config;

import com.modules.security.filter.JwtAuthenticationTokenFilter;
import com.modules.security.handle.AccessDeniedHandlerImpl;
import com.modules.security.handle.AuthenticationEntryPointImpl;
import com.modules.security.handle.LogoutSuccessHandlerImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

import javax.annotation.Resource;

/**
 * @ClassName SecurityConfig
 * @Description SpringSecurity的配置
 * @Author li'chao
 * @Date 2022-3-8 17:46
 * @Version 1.0
 **/
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled=true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    /**
     * 自定义用户认证逻辑
     */
    @Resource
    private UserDetailsService userDetailsService;

    /**
     * 自定义权限不足处理类
     */
    @Autowired
    private AccessDeniedHandlerImpl accessDeniedHandler;

    /**
     * 自定义认证失败处理类
     */
    @Autowired
    private AuthenticationEntryPointImpl authenticationEntryPoint;

    /**
     * 自定义退出处理类
     */
    @Autowired
    private LogoutSuccessHandlerImpl logoutSuccessHandler;

    /**
     * token认证过滤器
     */
    @Autowired
    private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;


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


    /**
     * anyRequest          |   匹配所有请求路径
     * access              |   SpringEl表达式结果为true时可以访问
     * anonymous           |   匿名可以访问
     * denyAll             |   用户不能访问
     * fullyAuthenticated  |   用户完全认证可以访问（非remember-me下自动登录）
     * hasAnyAuthority     |   如果有参数，参数表示权限，则其中任何一个权限可以访问
     * hasAnyRole          |   如果有参数，参数表示角色，则其中任何一个角色可以访问
     * hasAuthority        |   如果有参数，参数表示权限，则其权限可以访问
     * hasIpAddress        |   如果有参数，参数表示IP地址，如果用户IP和参数匹配，则可以访问
     * hasRole             |   如果有参数，参数表示角色，则其角色可以访问
     * permitAll           |   用户可以任意访问
     * rememberMe          |   允许通过remember-me登录的用户访问
     * authenticated       |   用户登录后可访问
     */
    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception
    {
        httpSecurity
                // CRSF禁用，因为不使用session
                .csrf().disable()
                .exceptionHandling()
                // 认证失败处理类
                .authenticationEntryPoint(authenticationEntryPoint)
                // 权限不足处理类
                .accessDeniedHandler(accessDeniedHandler)
                .and()
                // 基于token，所以不需要session
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and()
                // 过滤请求
                .authorizeRequests()
                // 对于登录login 验证码captchaImage 允许匿名访问
                .antMatchers("/user/**", "/captchaImage").anonymous()
                .antMatchers(
                        HttpMethod.GET,
                        "/*.html",
                        "/**/*.html",
                        "/**/*.css",
                        "/**/*.js"
                ).permitAll()
                .antMatchers("/profile/**").anonymous()
                .antMatchers("/common/download**").anonymous()
                .antMatchers("/common/download/resource**").anonymous()
                .antMatchers("/swagger-ui.html").anonymous()
                .antMatchers("/swagger-resources/**").anonymous()
                .antMatchers("/webjars/**").anonymous()
                .antMatchers("/*/api-docs").anonymous()
                .antMatchers("/druid/**").anonymous()
                // 除上面外的所有请求全部需要鉴权认证
                .anyRequest().authenticated()
                .and()
                .headers().frameOptions().disable();
        httpSecurity.logout().logoutUrl("/logout").logoutSuccessHandler(logoutSuccessHandler);
        // 添加JWT filter
        httpSecurity.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
    }

    /**
     * 自定义身份认证
     */
    @Override
    protected void configure(AuthenticationManagerBuilder builder) throws Exception
    {
        builder.userDetailsService(userDetailsService).passwordEncoder(bCryptPasswordEncoder());
    }

    /**
     * 强散列哈希加密实现密码加密
     */
    @Bean
    public BCryptPasswordEncoder bCryptPasswordEncoder()
    {
        return new BCryptPasswordEncoder();
    }

}

2.9 登录控制类

package com.modules.system.controller;

import com.modules.common.aspectj.Log;
import com.modules.common.enmus.BusinessType;
import com.modules.common.web.BaseController;
import com.modules.common.web.Result;
import com.modules.security.service.LoginService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;

/**
 * 登录管理
 *
 * @author lc
 */
@Api(tags = "登录管理")
@Slf4j
@CrossOrigin
@RestController
@RequestMapping("/user")
public class LoginController extends BaseController {

    @Autowired
    private LoginService loginService;

    @Log(title = "用户登录", businessType = BusinessType.LOGIN)
    @ApiOperation(value = "用户登录", notes = "用户登录")
    @PostMapping(value = "/login")
    public Result login(HttpServletRequest request,
                        @ApiParam(name = "loginName", value = "登录账号") @RequestParam(value = "loginName", required = true) String loginName,
                        @ApiParam(name = "password", value = "密码") @RequestParam(value = "password", required = true) String password) {
        try {
            return success(loginService.login(loginName, password));
        }catch (Exception e) {
            if(e instanceof BadCredentialsException){
                log.error("BadCredentialsException=====>账号或者密码错误", e.getMessage());
                return error("账号或者密码错误");
            }else {
                log.error("CustomException=====>", e.getMessage());
                return error(e.getMessage());
            }
        }
    }
}

2.10 Swagger2的接口配置

package com.modules.common.config;

import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.*;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spi.service.contexts.SecurityContext;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

import java.util.ArrayList;
import java.util.List;

/**
 * Swagger2的接口配置
 *
 * @author lc
 */
@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Value("${swagger.show}")
    private boolean swaggerShow;

    /**
     * 创建API
     */
    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                // 是否开启
                .enable(swaggerShow)
                // 用来创建该API的基本信息，展示在文档的页面中（自定义展示的信息）
                .apiInfo(apiInfo())
                // 全局header配置
//                .globalOperationParameters(parameters)
                // 设置哪些接口暴露给Swagger展示
                .select()
                // 扫描所有有注解的api，用这种方式更灵活
                .apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class))
                // 扫描指定包中的swagger注解
                //.apis(RequestHandlerSelectors.basePackage("com.modules.swagger"))
                // 扫描所有 .apis(RequestHandlerSelectors.any())
                .paths(PathSelectors.any())
                .build()
                /* 设置安全模式，swagger可以设置访问token */
                .securitySchemes(securitySchemes())
                .securityContexts(securityContexts());
    }

    /**
     * 安全模式，这里指定token通过Authorization头请求头传递
     */
    private List<ApiKey> securitySchemes()
    {
        List<ApiKey> apiKeyList = new ArrayList<ApiKey>();
        apiKeyList.add(new ApiKey("token", "token", "header"));
        return apiKeyList;
    }

    /**
     * 安全上下文
     */
    private List<SecurityContext> securityContexts()
    {
        List<SecurityContext> securityContexts = new ArrayList<>();
        securityContexts.add(
                SecurityContext.builder()
                        .securityReferences(defaultAuth())
                        .forPaths(PathSelectors.regex("^(?!auth).*$"))
                        .build());
        return securityContexts;
    }

    /**
     * 默认的安全上引用
     */
    private List<SecurityReference> defaultAuth()
    {
        AuthorizationScope authorizationScope = new AuthorizationScope("global", "accessEverything");
        AuthorizationScope[] authorizationScopes = new AuthorizationScope[1];
        authorizationScopes[0] = authorizationScope;
        List<SecurityReference> securityReferences = new ArrayList<>();
        securityReferences.add(new SecurityReference("token", authorizationScopes));
        return securityReferences;
    }

    /**
     * 添加摘要信息
     */
    private ApiInfo apiInfo() {
        // 用ApiInfoBuilder进行定制
        return new ApiInfoBuilder()
                // 设置标题
                .title("标题：系统接口文档")
                // 描述
                .description("描述：用于描述系统接口...")
                // 作者信息
                .contact(new Contact("lc", null, null))
                // 版本
                .version("版本号:" + "v1.0.0")
                .build();
    }
}
十点摆码
关注
  • 7
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
Spring boot+Spring security+JWT实现前后端分离登录认证及权限控制
m0_54849806的博客
08-02 5924
基本上没讲什么底层实现，这篇是使用篇，后续会出SpringSecurity的底层源码讲解，并且如果本帖有问题的有疑问的读者可以在评论区留言，本人会积极处理。您的支持是我最大的动力，本人一直在努力的更新各种框架的使用和框架的源码解读~！先自我介绍一下，小编13年上师交大毕业，曾经在小公司待过，去过华为OPPO等大厂，18年进入阿里，直到现在。深知大多数初中级java工程师，想要升技能，往往是需要自己摸索成长或是报班学习，但对于培训机构动则近万元的学费，着实压力不小。httpshttpshttps。...
SpringSecurity框架教程-Spring Security+JWT实现项目级前端分离认证授权
m0_45209551的博客
05-10 964
SpringSecurity框架使用到讲解
将SpringBoot+SpringSecurity改造为前后端分离+Jwt的权限认证系统，Token过期刷新问题
热门推荐
zzzgd_666的博客
07-18 1万+
前言 一般来说，我们用SpringSecurity默认的话是前后端整在一起的，比如thymeleaf或者Freemarker，SpringSecurity还自带login登录页,还让你配置登出页,错误页。 但是现在前后端分离才是正道，前后端分离的话，那就需要将返回的页面换成Json格式交给前端处理了 SpringSecurity默认的是采用Session来判断请求的用户是否登录的，但是不方便分布式...
SpringBoot添加密码安全配置以及Jwt配置
最新发布
qq_64468032的博客
07-25 1039
然后修改之前的SecurityConfig配置类，里面的configure方法里面的.antMatchers里面追加的url是不需要验证就能进行使用的请求，比如登录注册等url请求的放开，需要的话可以一直追加。如果数据库中的密码没有加密，可以通过测试类将密码进行加密，然后用加密之后的字符串与数据库中的数据进行替换即可。通过以下操作可以直接从token中获取用户的信息，然后通过用户的信息进行验证并返回用户需要的信息。在没有配置的情况下，默认用户名为 user ，密码在控制台中查找（如下）。
SpringBoot2.0整合SpringSecurity实现WEB JWT认证
坐看云起时_雨宣
01-22 9468
相信很多做技术的朋友都做过前后端分离项目，项目分离后认证就靠JWT，费话不多说，直接上干活(写的不好还请多多见谅，大牛请绕行) 直接上代码，项目为Maven项目，结构如图： 包分类如下： com.api.config  相关配置类 com.api.ctrl  controller层 com.api.entity  相关实体类 com.api.repo   jpa仓库相关 com....
Springboot使用SpringSecurity+Jwt前后端分离认证
qq_37924768的博客
04-26 1099
Springboot使用SpringSecurity+Jwt前后端分离认证 springsecurity是一个权限管理框架，由多个过滤器链组成，本次主要使用springsecurity结合jwt生成token进行前后端分离的权限校验。 权限这块使用了传统的RBAC权限控制，由五张表组成。 引入依赖: <dependency> <groupId>io.jsonwebtoken</groupId> <artifactI
Spring-Boot结合Security+JWT 简单实现前后端分离用户登录、授权案例
07-12
Spring-Security结合JWT 实现前后端分离完成权限验证功能案例，案例中，主要完成用户登录获取Token，通过Token访问Rest接口，没有权限或授权失败时返回JSON，前端根据状态码进行重新登录；案例中的用户名称： jake_j...
基于SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端商城系统源码
05-13
yshop基于当前流行技术组合的前后端分离商城系统： SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端分离的商城系统， 包含分类、sku、运费模板、素材库、小程序直播、拼团、砍价、商户管理、 秒杀、...
SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端分离的商城系统
04-30
基于当前流行技术组合的前后端分离商城系统：SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端分离的商城系统， 包含商城、sku、运费模板、素材库、小程序直播、拼团、砍价、商户管理、 秒杀、优惠券...
基于springBoot+springSecurity+jwt实现前后端分离用户权限认证
12-09
springSecurity也有很多种权限认证方式，本项目主要实现基于接口授权，也就是说通过注解给controller赋予权限，用户只有拥有某个接口的权限才能成功访问这个接口，从而实现不同用户拥有不同访问权限;
【SpringBoot框架篇】16.security整合jwt实现对前后端分离的项目进行权限认证
皓亮君的博客
08-01 4719
使用Spring Security+JWT实现对前后端分离的项目进行权限认证
Java权限管理｜基于springBoot+springSecurity+jwt实现前后端分离用户权限认证
qq_38200425的博客
12-09 3536
基于springBoot+springSecurity+jwt实现前后端分离用户权限认证 1. 项目说明 主要基于前后端分离情况下用户权限认证, 当用户登录认证成功后，每个用户会获取到自己的token，在请求其他接口时只需携带token即可,后端会通过token来识别用户身份。springSecurity也有很多种权限认证方式，本项目主要实现基于接口授权，也就是说通过注解给controller赋予权限，用户只有拥有某个接口的权限才能成功访问这个接口，从而实现不同用户拥有不同访问权限; 2.
springboot2.x+Spring-Security+JWT
Jiangbohao_的博客
05-19 606
springboot2.x+Spring-Security+JWT的整合 jwt(json web token) jwt官网：https://jwt.io/ 使用的是HS256算法 一个JWT由三个部分组成：header，payload，signature。分别保存了不同的信息 header部分由以下的json结构生成： typ用来标识整个token是一个jwt字符串，alg代表签名和摘要算法，一般签发JWT的时候，只要typ和alg就够了，生成方式是将header部分的json字符串经过Base64Ur
Springboot 整合swagger、springsecurity、jjwt、实现前后端分离架构的权限认证搭建。
weixin_43277309的博客
04-08 1124
Springboot 整合swagger、springsecurity、jjwt、实现前后端分离架构的权限认证搭建。 一、写本文的目的性（） 1.1、网上有很多关于springsecurity、整合jjwt的相关例子，我前段时间因为个人原因，需要整合，但是看了网上的例子，要不太过于复杂，要么前后端耦合度太高，要么没有什么ruan用（但是我还是找到了某位猿猿的分享，得到了启发） 二、需要做的准备 2.1、没学过springboot、springsecurity的去学一下 这里有一份springsecurit
spring-boot + spring-security + jwt 实现前后端分离的权限管理
weixin_53100045的博客
09-16 832
基于 spring-boot + spring-security + jwt 的前后端分离的权限管理
SpringBoot+SpringSecurity +Jwt 实现前后端分离认证 从0到实现
qq_44605317的博客
07-24 546
1.什么是JWT (JSON Web Token) 具体可查看这篇文章，把JWT总结的很到位 什么是jwt? 2.SpringSecurity 整合 Jwt 2.1导入项目所用到的依赖 <!--mybatis-plus依赖--> <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-s
springBoot整合spring security+JWT实现单点登录与权限管理前后端分离--筑基中期
qq_43788185的博客
09-05 1526
写在前面 在前一篇文章当中，我们介绍了springBoot整合spring security单体应用版，在这篇文章当中，我将介绍springBoot整合spring secury+JWT实现单点登录与权限管理。 本文涉及的权限管理模型是基于资源的动态权限管理。数据库设计的表有 user 、role、user_role、permission、role_permission。 单点登录当中，关于访问者信息的存储有多种解决方案。如将其以key-value的形式存储于redis数据库中，访问者令牌中存放key。校验
Spring-Security 与 JWT 前后端分离
竹林幽深
01-13 711
https://mp.weixin.qq.com/s/h6hLe9d2yNXvxG_DpcSPxg
Spring+Boot+Spring+Security+JWT+实现+RESTful+Api+认证+（一）
09-20
Spring Boot和Spring Security可以很好地结合使用来实现RESTful API的认证。而JWT（JSON Web Token）是一种用于认证和授权的安全传输方式。 要在Spring Boot中实现JWT认证，可以遵循以下步骤： 1. 添加依赖：在`...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

十点摆码

有用你就打赏一下

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值