用户登录认证和权限授权(SpringSecurity、JWT、session)


前言

登录认证和权限授权是所有项目中必不可少的功能,本篇文章首先将通过最简单的方式(Session和JWT)实现登录认证和权限授权,然后再整合Springsecurity框架实现。


一、登录认证

登录认证简言之就是对用户的身份进行确认,判断用户的账号和密码是否正确。

1. 问题引入

HTTP请求是一个无状态的协议,每一次发送的请求都是独立的,需要一种机制来记住用户登录过? 需要凭证
怎么保存凭证?
Session/JWT ,原理都是token机制

  1. 前端发起登录认证请求
  2. 后端登录验证通过,返回给前端一个凭证
  3. 前端发起新的请求时携带凭证

2. Session

有状态的管理机制
如果用户第一次访问某个服务器时,服务器响应数据时会在响应头的Set-Cookie标识里将Session Id返回给浏览器,浏览器就将标识中的数据存在Cookie中,浏览器后续访问服务器就会携带Cookie。
在这里插入图片描述

2.1 实现原理

在这里插入图片描述

2.2 过滤器Filter

问题引入:除了登录接口外,我们其他接口都要在Controller层里做登录判断,这太麻烦了。
解决:使用过滤器拦截,判断有没有登录,登录就放行,没登录结束请求

2.3 上下文对象

问题引入:要在service层获取操作用户对象,需要从Controller层传参过来太麻烦了。
解决:通过SpringMVC提供的RequestContextHolder对象在程序任何地方获取到当前请求对象,从而获取我们保存在HttpSession中的用户对象,写一个上下文对象来实现这一功能。
然后在Service层直接调用我们写的方法就可以获取到用户对象

3. JWT

Json web token。无状态管理机制

  1. 可以将一段数据加密成一段字符串,也可以从这字符串解密回数据
  2. 可以对这个字符串进行校验,比如有没有过期,有没有被篡改
    在这里插入图片描述

3.2 实现步骤

1、写一个JWT的工具类,工具类就提供两个方法一个生成一个解析
2、工具类做好之后我们可以开始写登录接口,登录的时候生成token
3、后续会话中,用户访问其他接口时就可以校验token来判断其是否已经登录。
一般来说,前端将token一般会放在请求头的Authorization项传递过来,其格式一般为类型 + token
调用其他接口的时候,从请求头中获取token,然后再通过JWT工具类解析token判断。

3.3 拦截器 HandlerInterceptorAdapter

如果每个接口都要手动判断一下用户有没有登录太麻烦了,所以我们做一个统一处理。
拦截器类写好之后,别忘了要使其生效,这里我们直接让SpringBoot启动类实现WebMvcConfigurer接
口,重写addInterceptors方法

3.4 上下文对象

在一个线程中横跨若干方法调用,需要传递的对象,我们通常称之为上下文(Context)
JWT不像Session把用户信息直接存储起来,所以JWT的上下文对象要靠我们自己来实现。
这个类专门存储JWT解析出来的用户信息。我们要用到ThreadLocal存储用户信息,以防止线程冲突
通过上下文对象类(如UserContext),可以在程序的其他地方直接获取到数据。上下文对象.方法()

public final class UserContext {
    private static final ThreadLocal<String> user = new ThreadLocal<String>();

    public static void add(String userName) {
        user.set(userName);
    }
    public static void remove() {
        user.remove();
    }
    /**
     * @return 当前登录用户的用户名
     */
    public static String getCurrentUserName() {
        return user.get();
    }
}

4. Session VS JWT

  • Session是有状态的,JWT是无状态的
  • Session在服务端保存了用户信息,而JWT在服务端没有保存任何信息。
  • 当前端携带Session Id到服务端时,服务端要检查其对应的HttpSession中有没有保存用户信息,保存了就代表登录了
  • 当使用JWT时,服务端只需要对这个字符串进行校验,校验通过就代表登录了

二、权限授权

对用户能否问某个资源进行确认。认证成功之后,再确认能访问什么。
权限系统的设计,第一步就是考虑要保护什么资源,再接着思考如何保护这个资源。

1. 权限类型

1.1 页面权限(菜单项权限)

有权限的用户就会显示所有菜单,无权限的用户就只会显示部分菜单
在这里插入图片描述
一个页面(菜单)对应一个URI地址,当用户登录的时候判断这个用户拥有哪些页面权限,自然
而然就知道要渲染出什么导航菜单。

1.2 ACL模型 (Access Control List访问控制列表)不推荐

数据库设计三张表格,一张表用来存储用户信息,一张表存储资源路径,中间表用来映射用户和资源表的关系。
在这里插入图片描述具体实现
前端给后端发请求后,后端回返回数据给前端,这些数据中就包含了用户能够访问的资源信息,前端本地也存有一个映射字典,字典里有资源的信息,比如id对应哪个路径、名称等等,前端拿到了用户的id后根据字典进行判断就可以做到相应的功能。

1.3 RBAC模型(Role-Based Access Controller基于角色访问控制模型)

很多用户的权限都是相同的,通过封装一层角色信息,实现角色和权限绑定,用户和角色绑定。
在这里插入图片描述

1.2 接口权限(操作权限或按钮权限)

前后端分离的模式下,后端在登录的时候将权限数据甩给前端后就再也不管了,如果此时用户的权限发生变化是无法通知前端的,并且数据存储在前端也容易被用户直接篡改,所以很不安全。
例如:没有这个删除权限的人就不会显示该按钮,或者该按钮被禁用.
页面渲染不走后端,但接口可必须得走后端,只需要对每个接口进行一个权限判断。
实现方式

  1. 接口扫描
    RequestMappingInfoHandlerMapping,这个类可以拿到所有你声明的web接口信息
    通过代码将接口信息批量添加到数据库,标记一下哪些接口是否需要被权限管理(注解形式)
  2. 接口扫描具体实现
    使用SpringBoot提供的ApplicationRunner接口来进行处理,重写该接口的方法会在程序启动时被
    执行。
  3. 拦截器
    每一个权限安全判断都是写在方法内,且这个逻辑判断代码都是一样的,会有重复代码
    获取请求的最佳匹配路径,例如:/API/user/test/{id}路径参数
    拦截器中获取权限数据现在是直接查的数据库,实际开发中一定要将权限数据存在缓存里(如Redis)

1.3 数据权限

不同用户所能访问到的数据不同。
1、硬编码,通过编写sql语句(不推荐)
2、Mybatis拦截插件
提供了一个Interceptor接口,实现该接口定义一个拦截器对sql语句进行拦截达到数据过滤效果

三、SpringSecurity

1. 概述

Web系统中登录认证(Authentication)的核心就是凭证机制,无论是Session还是JWT,都是在用户成功登录时返回给用户一个凭证,后续用户访问接口需携带凭证来标明自己的身份。权限授权(Authorization)是对用户能否访问某个资源进行确认,这种通用逻辑都是放在过滤器里进行的统一操作。
Spring Security对Web系统的支持就是基于这一个个过滤器组成的过滤器链
在这里插入图片描述
Spring Security的核心逻辑全在这一套过滤器中,过滤器里会调用各种组件完成功能,掌握了这些过滤器和组件就掌握了Spring Security。
在这里插入图片描述
使用Spring Security肯定是要先引入依赖包

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

2. 登录认证

2.1 了解各个组件

了解各个组件实现简单的登入认证,基于Session机制。
确认当前是哪个用户正在使用我们系统就是登录认证的最终目的
这一概念在Spring Security中的体现就是 Authentication,它存储了认证信息,代表当前登录用户。
通过 SecurityContext(上下文对象) 来获取Authentication
上下文对象则是交由 **SecurityContextHolder **进行管理,用来在程序任何地方获取SecurityContext

Authentication   authentication =  SecurityContextHolder.getContext().getAuthentication()

在这里插入图片描述
认证信息
Principal:用户信息,没有认证时一般是用户名,认证后一般是用户对象
Credentials:用户凭证,一般是密码
Authorities:用户权限
认证流程
登录接口代码

@RestController
@RequestMapping("/API")
public class LoginController {
    @Autowired
    private AuthenticationManager authenticationManager;
    @PostMapping("/login")
    public String login(@RequestBody LoginParam param) {
        // 生成一个包含账号密码的认证信息
        Authentication token = new UsernamePasswordAuthenticationToken(param.getUsername(), param.getPassword());
        // AuthenticationManager校验这个认证信息,返回一个已认证的Authentication
        Authentication authentication = authenticationManager.authenticate(token);
        // 将返回的Authentication存到上下文中
        SecurityContextHolder.getContext().setAuthentication(authentication);
        return "登录成功";
    }
}

AuthenticationManager认证方式
Spring Security用于执行身份验证的组件,只需要调用它的authenticate方法即可完成认证
默认的认证方式就是在UsernamePasswordAuthenticationFilter这个过滤器中调用这个组件,该过滤器
负责认证逻辑。
加密器PasswordEncoder(重写)
实现此接口定义自己的加密规则和校验规则,或者采用Spring Security提供的加密器实现

public interface PasswordEncoder {
    //加密
    String encode(CharSequence rawPassword);
    //将未加密的字符串(前端传递过来的密码)和已加密的字符串(数据库中存储的密码)进行校验
    boolean matches(CharSequence rawPassword, String encodedPassword);
}

配置类里配置

@Bean
public PasswordEncoder passwordEncoder() {
    // bcrypt加密算法,安全性比较高
    return new BCryptPasswordEncoder();
}

往数据库中添加用户数据时就要将密码进行加密,否则后续进行密码校验时从数据库拿出来的还是明文密码。
实现用户注册接口

@Autowired
private PasswordEncoder passwordEncoder;
@PostMapping("/register")
public String register(@RequestBody UserParam param) {
    UserEntity user = new UserEntity();
    // 调用加密器将前端传递过来的密码进行加密
    user.setUsername(param.getUsername()).setPassword(passwordEncoder.encode(param.getPassword()));
    // 将用户实体对象添加到数据库
    userService.save(user);
    return "注册成功";
}

用户对象UserDetails (重写)
提供了用户的一些通用属性

public interface UserDetails extends Serializable {
   // 用户权限集合
   Collection<? extends GrantedAuthority> getAuthorities();
   // 用户密码
   String getPassword();
   // 用户名
   String getUsername();
   // 用户没过期返回true,反之则false
   boolean isAccountNonExpired();
   //......
}

以上默认属性满足不了实际开发需求,可以继承Spring Security提供org.springframework.security.core.userdetails.User类,该类实现了
UserDetails接口帮我们省去了重写方法的工作

public class UserDetail extends User {
    //我们自己的用户实体对象,要调取用户信息时直接获取这个实体对象。
    private UserEntity userEntity;
    public UserDetail(UserEntity userEntity, Collection<? extends GrantedAuthority> authorities) {
        // 必须调用父类的构造方法,以初始化用户名、密码、权限
        super(userEntity.getUsername(), userEntity.getPassword(), authorities);
        this.userEntity = userEntity;
    }
}

业务对象UserDetailsService(重写)

public interface UserDetailsService {
    //根据用户名获取用户对象(获取不到直接抛异常)
    UserDetails loadUserByUsername(String username) throws UsernameNotFoundException;
}

可以自己定义逻辑

@Service
public class UserServiceImpl implements UserService, UserDetailsService {
    @Autowired
    private UserMapper userMapper;
    @Override
    public UserDetails loadUserByUsername(String username) {
        // 从数据库中查询出用户实体对象
        UserEntity user = userMapper.selectByUsername(username);
        // 若没查询到一定要抛出该异常,这样才能被Spring Security的错误处理器处理
        if (user == null) {
            throw new UsernameNotFoundException("没有找到该用户");
        }
        // 走到这代表查询到了实体对象,那就返回我们自定义的UserDetail对象(这里权限暂时放个空集合,后面我会讲解)
        return new UserDetail(user, Collections.emptyList());
    }
}

认证异常处理器AuthenticationEntryPoint接口
当我们查询用户失败时或者校验密码失败时都会抛出Spring Security的自定义异常。这些异常不可能放任不管,Spring Security对于这些异常都是在ExceptionTranslationFilter过滤器中进行处理,AuthenticationEntryPoint则专门处理认证异常。
也可以自定义一个类实现AuthenticationEntryPoint接口从而实现我们自己的错误处理逻辑

public class MyEntryPoint implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException e) throws IOException {
        response.setContentType("application/json;charset=utf-8");
        PrintWriter out = response.getWriter();
        // 直接提示前端认证错误
        out.write("认证错误");
        out.flush();
        out.close();
    }
}

配置
Spring Security对哪些接口进行保护、什么组件生效、某些功能是否启用等等都需要在配置类中进行配置

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    ....
    @Bean
    @Override
    protected AuthenticationManager authenticationManager() throws Exception {
        return super.authenticationManager();
    }
     @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

** 实现流程**

  1. 用户进行登录操作,传递账号密码过来 登录接口调用AuthenticationManager
  2. 根据用户名查询出用户数据 UserDetailService查询出UserDetails
  3. 将传递过来的密码和数据库中的密码进行对比校验 PasswordEncoder
  4. 校验通过则将认证信息存入到上下文中 将UserDetails存入到Authentication,将Authentication存入到SecurityContext
  5. 如果认证失败则抛出异常 由AuthenticationEntryPoint处理
    基于session认证:认证后Spring Security会将Authentication存入到session中(不推荐)

2.2 JWT+SpringSecurity

1、当用户登录成功的同时,我们需要生成token并返回给前端,这样前端才能访问其他接口时携带token。

@Autowired
private UserService userService;
@PostMapping("/login")
public UserVO login(@RequestBody @Validated LoginParam user) {
    // 调用业务层执行登录操作
    return userService.login(user);
}

service层实现login方法

public UserVO login(LoginParam param) {
    // 根据用户名查询出用户实体对象
    UserEntity user = userMapper.selectByUsername(param.getUsername());
    // 若没有查到用户 或者 密码校验失败则抛出自定义异常
    if (user == null || !passwordEncoder.matches(param.getPassword(), user.getPassword())) {
        throw new ApiException("账号密码错误");
    }
    // 需要返回给前端的VO对象
    UserVO userVO = new UserVO();
    userVO.setId(user.getId())
        .setUsername(user.getUsername())
        // 生成JWT,将用户名数据存入其中
        .setToken(jwtManager.generate(user.getUsername()));
    return userVO;
}

2、登录成功返回token,后续我们再访问其它接口时需要将token放到请求头中。这里我们需要自定义一个认证过滤器,来对token进行校验。每当一个请求来时我们都会校验JWT进行认证,上下文对象中有了Authentication后续过滤器就会知道该请求已经认证过了。

@Component
public class LoginFilter extends OncePerRequestFilter {
    @Autowired
    private JwtManager jwtManager;
    @Autowired
    private UserServiceImpl userService;
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException {
        // 从请求头中获取token字符串并解析
        Claims claims = jwtManager.parse(request.getHeader("Authorization"));
        if (claims != null) {
            // 从`JWT`中提取出之前存储好的用户名
            String username = claims.getSubject();
            // 查询出用户对象
            UserDetails user = userService.loadUserByUsername(username);
            // 手动组装一个认证对象
            Authentication authentication = new UsernamePasswordAuthenticationToken(user, user.getPassword(), user.getAuthorities());
            // 将认证对象放到上下文中
            SecurityContextHolder.getContext().setAuthentication(authentication);
        }
        chain.doFilter(request, response);
    }
}

3、自定义的认证过滤器需要插入到默认的认证过滤器之前,这样我们的过滤器才能生效。

http.addFilterBefore(loginFilter, UsernamePasswordAuthenticationFilter.class);

3. 权限授权

接口权限授权流程

  1. 当一个请求过来,我们先得知道这个请求的规则,即需要怎样的权限才能访问
  2. 然后获取当前登录用户所拥有的权限
  3. 再校验当前用户是否拥有该请求的权限
  4. 用户拥有这个权限则正常返回数据,没有权限则拒绝请求

Spring Security的授权发生在FilterSecurityInterceptor过滤器中,步骤如下:

  1. 首先调用的是 SecurityMetadataSource,来获取当前请求的鉴权规则
  2. 然后通过Authentication获取当前登录用户所有权限数据: GrantedAuthority认证对象里存放这权限数据
  3. 再调用 AccessDecisionManager 来校验当前用户是否拥有该权限
  4. 如果有就放行接口,没有则抛出异常,该异常会被 授权错误处理器AccessDeniedHandler 处理
  5. 定义好以上组件,就是写一个过滤器,进行属性配置,让组件生效
  6. 回到Spring Security配置类让这个过滤器替换掉原有的过滤器

总结

文章中内容均来源于https://zhuanlan.zhihu.com/p/342755411,原文作者讲解得十分透彻,不仅让我理解了技术框架的使用方法,还对框架中的源码,为什么要这样去做有了更深入的认识,这篇文章是对原文作者写的三篇文章的整合,简化了很多,方便本人之后复习巩固。
在这里插入图片描述

  • 25
    点赞
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
很抱歉,作为AI语言模型,我无法提供实际的编程代码。但我可以为你提供一个基本的Spring Security整合JWT权限管理认证的思路: 1. 添加依赖:在pom.xml文件中添加Spring SecurityJWT的依赖。 2. 配置Spring Security:创建一个配置类,实现WebSecurityConfigurerAdapter,并覆盖configure()方法。在该方法中,配置Spring Security的行为和规则,如认证方式授权规则、登录、登出等。 3. 创建JWT工具类:实现JWT的生成、解析、验证等功能。在生成JWT时,可以将用户信息、角色、权限信息加入到JWT中。 4. 在登录成功后,生成JWT并返回给客户端:在Spring Security登录认证成功后,使用JWT工具类生成JWT,并将JWT返回给客户端。 5. 在客户端请求时,携带JWT:客户端在每次请求时,需要将JWT携带在请求头中。可以在前端通过localStorage或cookie保存JWT。 6. 配置JWT过滤器:在Spring Security的配置类中,添加一个JWT过滤器,用于验证请求中的JWT,并将用户信息、角色、权限信息加入到Spring Security的上下文中。 7. 配置权限控制:在Spring Security的配置类中,配置URL的访问规则和权限控制。可以使用注解或XML配置。 8. 在业务逻辑中使用权限注解:在业务逻辑代码中,可以使用Spring Security提供的注解进行权限控制,如@PreAuthorize、@PostAuthorize等。 9. 配置登出:在Spring Security的配置类中,配置登出行为,包括清除Session、清除Cookie、重定向等操作。 以上是一个基本的Spring Security整合JWT权限管理认证的思路,具体实现可以根据项目需求进行调整。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值