Spring Sercuity实现认证授权

最新推荐文章于 2024-04-21 16:56:00 发布
最新推荐文章于 2024-04-21 16:56:00 发布
阅读量863 收藏 2
点赞数 2
文章标签： java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gtxy_2015/article/details/127171499
版权

用户\角色\权限

提到登录流程就不得不提到用户角色权限, 因为登录实际上就是判断用户属于什么角色,拥有什么权限,因此谈到登录,就不得不提用户\角色\权限

用户是一个基本的单位, 我们登录时都是在登录用户的,我们再登录后需要明确这个用户具有哪些角色

用户和角色的关系是多对多

用户是一张表,角色也是一张表,因为它们是多对多的关系所以要有一张保存用户和角色关系的中间表

角色也不能直接决定这个用户能做什么操作, 有哪些权限, 需要再关联权限表决定

角色和权限也是多对多的关系, 也要有中间表

如果项目开发的权限比较全面, 可能会出现临时用户权限关系表

Spring Security

Spring Security框架用于实现登录,内置加密,验证,放行等各种功能,可靠性强, 同时还可以将当前登录用户的信息保存, 特别的,对于用户具备的权限,有特殊的管理

在控制器运行前,可以使用注解来判断当前登录用户是否具备某个权限

@PreAuthorize("[权限名称]")

SpringSecurity在运行该方法之前进行核查

如果不具备这个权限会返回403状态码

如果不使用此框架,想要实现它所提供的功能的登录, 肯定非常麻烦!

关于单点登录

普通登录带来的问题:

单体项目登录之后的操作流程主要依靠服务器的session保存用户信息, 客户端发请求时, 将sessionid同时发往服务器,根据sessionid就能确认用户身份

分布式或微服务项目中,服务器不再只有一个

那么就会出现下面的问题

我们在用户模块中登录,只是将用户信息保存在用户模块的session中

而这个session不会和其他模块共享

所以在我们访问购物车模块或其他模块时,通过sessionid并不能获得在用户模块中登录成功的信息

这样就丢失的用户信息,不能完成业务

市面上现在大多使用JWT来实现微服务架构下的会话保持

也就是在一个服务器上登录成功后,微服务的其他模块也能识别用户的登录信息

这个技术就是单点登录(Single Sign On)

单点登录解决方案

Session共享

Session共享是能够实现单点登录效果的

这种方式的核心思想是将用户的登录信息共享给其他模块

适用于小型的,用户量不大的微服务项目

将登录成功的用户信息共享给Redis

其他模块根据sessionId获得Redis中保存的用户信息即可

  • 这样做最大的缺点就是内存严重冗余,不适合大量用户的微服务项目

JWT单点登录  

Json Web Token, 这种登录方式,最大的优点就是不占用内存, 关于这个详见关于Token与JWT

 

生成的JWT由客户端自己保存,不占用服务器内存

在需要表明自己用户身份\信息时,将JWT信息保存到请求头中发送请求即可

Jwt登录流程图

 

SpringBoot整合Spring Sercurity 

 在Spring Boot项目，当需要使用Spring Security时，需要添加spring-boot-starter-security依赖：

<!-- Spring Boot Security，用于处理认证与授权 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

Spring Security的基本特点

 当添加以上依赖项后，再次启动项目，Spring Security会执行自动配置，使得：

  • 此主机上所有的请求都必须先登录才可以访问，并提供了登录页面，包括根本不存在的URL

    • 此特点是由WebSecurityConfigurerAdapter类中的protected void configure(HttpSecurity http)方法决定的

      • 此配置方法中的http.formLogin()将决定是否开启登录表单

  • 默认的用户名是user，默认是密码在启动日志中，每次启动都会变化

    • Using generated security password: 92062850-fb3d-4b86-be10-209ac26c143e

  • 当登录成功后，会自动跳转到此前尝试访问的URL

  • Spring Security默认使用Session保存用户的登录信息

    • 例如，当关闭浏览器后，再次访问，需要重新登录

  • 通过 http://localhost:9081/logout 退出登录

  • 自带BCryptPasswordEncoder，可以用于使用BCrypt算法对密码进行加密处理

  • 如果项目运行时Spring容器中有密码编码器（PasswordEncoder），Spring Security框架会自动使用它

  • Spring Security默认开启了“禁止跨域的异步提交”，避免“伪造的跨域攻击”

关于BCrypt算法

BCrypt算法是一种基于哈希算法的算法，所以，这种算法也是不可逆的！

通过BCrypt算法进行编码后的结果，长度固定为60字符。

使用同一个原文进行反复编码，每次得到的结果都是不同的，因为在编码过程中，BCrypt使用了随机的盐，并且，使用的盐也作为编码结果的一部分保存了下来。

在开发实现中，通常，可以使用配置类中的@Bean方法来创建BCryptPasswordEncoder对象，此对象将是由Spring进行管理的，当需要使用时，自动装配即可，例如：

@Slf4j
@Configuration
public class SecurityConfiguration {

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

}
@Slf4j
@Service
public class AdminServiceImpl implements IAdminService {

    @Autowired
    private PasswordEncoder passwordEncoder;
    
}

关于401和403这2个HTTP响应码

在HTTP协议中，401表示未认证的，通常是没有成功登录的，403表示未授权的，通常是已经登录，但是不具备相关的操作权限。

在Spring Security中，在许多“禁止”的场景中都会使用403，并不完全符全HTTP协议的规范。

关于伪造跨域攻击

在多选项卡的浏览器中，如果在第1个选项卡中登录了某个平台，在同一个窗口中打开其它选项卡，访问同一平台，都会被平台识别，视为“已通过认证”。

所谓的伪造跨域攻击，就是利用以上特性，在网页源代码中隐藏一些恶意访问的、会自动提交的请求URL（例如使用隐藏的<img>标签的src属性），例如，当用户在第1个选项卡登录了某银行系统，打开的第2个选项卡是有恶意代码的平台，第2个选项卡的网页发出“转账”的请求，会被银行系统视为“已通过认证的”。

提示：以上只是举例，事实上，现在防止这种做法的技术已经非常成熟，不会出现此问题，并且，银行转账通常都需要再次输出密码，而不会收到请求就直接转账  

Spring Security在防止伪造跨域攻击时，会自动生成值为UUID的Token（票据 / 令牌），并且，将此值响应给客户端，针对客户端后续提交的 POST / DELETE / PUT / PATCH 类型的请求，都要求携带名为 _csrf 的参数，且值就是此UUID，如果客户端提交请求时没有携带此值，则视为“伪造的跨域攻击”，将响应 403 错误。  

在继承了WebSecurityConfigurerAdapter的配置类中，重写configurer(HttpSecurity http)方法，调用http.csrf().disable()即可禁用它，即不再检查各请求是否为“伪造跨域”的访问。  

后续学到JWT会知道, 这个通过JWT也实现了防止跨域攻击的问题!!

使用数据库中的账号实现登录认证

要能够使用数据库中的账号实现登录认证，必须至少实现”根据用户名查询用户登录信息“的查询功能！在项目的根包下创建pojo.vo.AdminLoginInfoVO.java类，在此类中添加登录时所需的数据属性：

@Data
public class AdminLoginInfoVO implements Serializable {
    // 必须包括：id, username, password, enable
}

在AdminMapper.java接口中添加查询方法：  

AdminLoginInfoVO getLoginInfoByUsername(String usernanme);

在AdminMapper.xml中配置以上抽象方法映射的SQL语句, 此处简单, 略 

Spring Security在执行认证时，会根据用户提交的用户名，自动调用UserDetailsService接口类型的对象中的UserDetails loadUserByUsername(String username);方法，当得到返回的UserDetails后，会自动处理后续的细节，例如验证密码是否正确、将认证信息（登录成功后的用户信息）保存下来，便于后续识别用户身份等  

所以，在根包下创建security.UserDetailsServiceImpl类，实现UserDetailsService接口

public class UserDetailsServiceImpl implements UserDetailsService {

    @Autowired
    private AdminMapper adminMapper;

    @Override
    public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
        log.debug("Spring Security自动调用loadUserByUsername()方法获取用户名为【{}】的用户详情……", s);

        AdminLoginInfoVO loginInfoByUsername = adminMapper.getLoginInfoByUsername(s);
        log.debug("从数据库中查询到的用户信息：{}", loginInfoByUsername);
        if (loginInfoByUsername == null) {
            String message = "登录失败，用户名不存在！";
            log.warn(message);
            throw new BadCredentialsException(message);
        }

        UserDetails userDetails = User.builder()
                .username(loginInfoByUsername.getUsername())
                .password(loginInfoByUsername.getPassword())
                .accountExpired(false) // 账号是否已过期
                .accountLocked(false) // 账号是否已锁定
                .credentialsExpired(false) // 凭证是否已过期
                .disabled(loginInfoByUsername.getEnable() == 0) // 账号是否已禁用
                .authorities("临时设置的权限，避免报错，暂无意义") // 权限，【注意】必须调用此方法表示此用户具有哪些权限
                .build();
        log.debug("即将向Spring Security框架返回UserDetails对象：{}", userDetails);
        return userDetails;
    }

}

提示：一旦Spring窗口存在UserDetailsService接口类型的对象，在启动项目时（包括执行测试时），将不再生成随机的临时密码，此前使用的user账号也将不再允许使用！  

完成以上代码后，可以在Security的配置类中，通过http.formLogin();方法启用登录页面，并启动项目，通过 http://localhost:9081/login 打开登录页面，此时，可以使用数据库的账号尝试登录。  

注意：此前完成的查询功能中，必须查询password和enable这2个字段的值！

注意：因为Spring Security会自动应用密码编码器（在Security配置类中使用@Bean方法配置的PasswordEncoder），数据库中的密码值必须是BCrypt编码结果！

注意：必须确保尝试登录的账号的enable值是有效的，如果为null，则会导致NPE！

现有的问题

  • 当前做法并不是前后端分离的

  • Spring Security默认使用Session保存认证信息

关于Session

HTTP协议本身是无状态协议！

  • 无状态：同一个客户端的多次请求，服务器并不能识别此客户端的身份，例如：第2次收到此客户端的请求时，并不知道此客户端此前已经提交过一次请求，更不知道第1次处理此客户端请求时产生的数据

在开发实践中，是需要明确客户端身份的，所以，从技术层面，使用了Session来解决HTTP协议无状态的问题。

Session的本质是一个MAP结构的数据，当客户端首次向服务器端提交请求时，服务器端会响应一个Session ID到客户端，客户端在后续的访问中，都会在请求中自动携带此Session ID，同时，服务器端的内存中会存在每个Session ID对应的Session数据，从而，每个客户端都可以访问到自己的此前存入的数据。

由于Session是在服务器端的内存中的数据，因此，默认情况下，并不适合于集群系统，更不适用于分布式系统。

使用前后端分离的方式处理认证

在自定义的`SecurityConfiguration`配置类中添加：

@Bean
@Override
protected AuthenticationManager authenticationManager() throws Exception {
    // 调用父类的方法得到AuthenticationManager
    return super.authenticationManager();
}
```

因为自定义的配置类继承自WebSecurityConfigurerAdapter类，此父类中存在authenticationManager()方法，可以返回AuthenticationManager对象，可用于后续自行调用authenticate()，使得Spring Security执行认证！所以，为了保证后续代码可以调用AuthenticationManager的authenticate()方法，应该在当前配置类中重写authenticationManager()方法  

在AdminController中添加处理登录认证的请求的方法：  

@PostMapping("/login")
public JsonResult<Void> login(AdminLoginInfoDTO adminLoginInfoDTO) {
    adminService.login(adminLoginInfoDTO);
    return JsonResult.ok();
}

最后，还需要在Security的配置类中，将/admins/login添加到”白名单“中。

此时，可以通过Knife4j的在线API文档的调试功能尝试登录。

为了更好的显示错误信息，还应该对相关异常进行处理！首先，在ServiceCode中添加新的业务状态码：

public enum ServiceCode {

    OK(20000),
    ERR_BAD_REQUEST(40000),
    ERR_UNAUTHORIZED(40100), // 新增
    ERR_UNAUTHORIZED_DISABLED(40110), // 新增
    ERR_FORBIDDEN(40300), // 新增
    
    // ... ...（原有其它代码）

并且，在全局异常处理器（GlobalExceptionHandler）中处理新的异常：  

@ExceptionHandler({
        InternalAuthenticationServiceException.class,
        BadCredentialsException.class
})
public JsonResult<Void> handleAuthenticationException(AuthenticationException e) {
    log.debug("处理AuthenticationException");
    log.debug("异常类型：{}", e.getClass().getName());
    log.debug("异常信息：{}", e.getMessage());
    Integer serviceCode = ServiceCode.ERR_UNAUTHORIZED.getValue();
    String message = "登录失败，用户名或密码错误！";
    return JsonResult.fail(serviceCode, message);
}

@ExceptionHandler
public JsonResult<Void> handleDisabledException(DisabledException e) {
    log.debug("处理DisabledException");
    Integer serviceCode = ServiceCode.ERR_UNAUTHORIZED_DISABLED.getValue();
    String message = "登录失败，此账号已经禁用！";
    return JsonResult.fail(serviceCode, message);
}

认证过程: 使用JWT实现认证

Spring Security会自动调用UserDetailsService对象的loadUserByUsername()获取用户详情
并根据loadUserByUsername()返回的用户详情自动验证是否启用、判断密码是否正确等!!通过认证后会将此authentication作为认证管理器的参数

在使用Spring Security框架处理认证时，如果认证通过，必须把通过认证的用户的信息存入到SecurityContext（Spring Security框架的上下文）对象中，后续，Spring Security框架会自动的尝试从SecurityContext中获取认证信息，如果获取到有效的认证信息，则视为“已登录”，否则，将视为“未登录”！

使用JWT实现认证需要完成的开发任务：

  • 当认证通过时生成JWT，并将JWT响应到客户端

  • 当客户端后续提交请求时，应该自觉携带JWT，而服务器端将对JWT进行解析，如果解析成功，将得此客户端的用户信息，并将认证信息存入到SecurityContext中

 首先，需要修改IAdminService中处理认证的方法（login()方法）的声明，将返回值类型修改为String：

String login(AdminLoginInfoDTO adminLoginInfoDTO);

并且，AdminServiceImpl中方法的声明也同步修改，在实现过程中，当通过认证后，应该生成JWT并返回：  

@Override
public String login(AdminLoginInfoDTO adminLoginInfoDTO) {
    log.debug("开始处理【登录认证】的业务，参数：{}", adminLoginInfoDTO);

    // 调用AuthenticationManager的authenticate()方法执行认证
    // 在authenticate()方法的执行过程中
    // Spring Security会自动调用UserDetailsService对象的loadUserByUsername()获取用户详情
    // 并根据loadUserByUsername()返回的用户详情自动验证是否启用、判断密码是否正确等
    Authentication authentication
            = new UsernamePasswordAuthenticationToken(
                    adminLoginInfoDTO.getUsername(),
                    adminLoginInfoDTO.getPassword());
    Authentication authenticateResult
            = authenticationManager.authenticate(authentication);
    log.debug("Spring Security已经完成认证，且认证通过，返回的结果：{}", authenticateResult);
    log.debug("返回认证信息中的当事人（Principal）类型：{}", authenticateResult.getPrincipal().getClass().getName());
    log.debug("返回认证信息中的当事人（Principal）数据：{}", authenticateResult.getPrincipal());

    // 从认证返回结果中取出当事人信息
    User principal = (User) authenticateResult.getPrincipal();
    String username = principal.getUsername();
    log.debug("认证信息中的用户名：{}", username);

    // 生成JWT，并返回
    // 准备Claims值
    Map<String, Object> claims = new HashMap<>();
    claims.put("username", username);

    // JWT的过期时间
    Date expiration = new Date(System.currentTimeMillis() + 15 * 24 * 60 * 60 * 1000);
    log.debug("即将生成JWT数据，过期时间：{}", expiration);

    // JWT的组成：Header（头：算法和Token类型）、Payload（载荷）、Signature（签名）
    String secretKey = "97iuFDVDfv97iuk534Tht3KJR89kBGFSBgfds";
    String jwt = Jwts.builder()
            // Header
            .setHeaderParam("alg", "HS256")
            .setHeaderParam("typ", "JWT")
            // Payload
            .setClaims(claims)
            .setExpiration(expiration)
            // Signature
            .signWith(SignatureAlgorithm.HS256, secretKey)
            .compact();
    log.debug("已经生成JWT数据：{}", jwt);
    return jwt;
}

最后，在AdminController中，将处理认证的方法（login()方法）的返回值类型由JsonResult<Void>修改为JsonResult<String>，并且，在方法体中，调用IAdminService的认证方法时，必须获取返回值，最终将此返回值封装到JsonResult对象中，响应到客户端：  

@ApiOperation("管理员管理")
@ApiOperationSupport(order = 88)
@PostMapping("/login")
public JsonResult<String> login(AdminLoginInfoDTO adminLoginInfoDTO) {
    String jwt = adminService.login(adminLoginInfoDTO);
    return JsonResult.ok(jwt);
}

授权过程: 解析JWT并处理SecurityContext

当客户端成功的通过认证后，将可以得到JWT，后续，客户端可以携带JWT提交请求，但是，作为服务器端，并不知道客户端将会向哪个URL提交请求，或者说，不管客户端向哪个URL提交请求，服务器端都应该尝试解析JWT，以识别客户端的身份，则解析JWT的代码可以使用“过滤器”组件来实现  

 关于客户端携带JWT，业内通用的做法是：将JWT携带在请求头（Request Header）中名为Authorization的属性中！

所以，此过滤器将固定的通过请求头（Request Header）中的Authorization属性获取JWT数据，并尝试解析。

由于Spring Security框架判断是否登录的标准是：在SecurityContext中是否存在认证信息！所以，当成功解析JWT数据后，应该将认证信息保存到SecurityContext中。

另外，还有几个细节：

  • 一旦SecurityContext中存在认证信息，在后续的访问中，即使不携带JWT数据，只要在SecurityContext还存在此前存入的认证信息，就会被视为“已经通过认证”，所以，为了避免此问题，应该在接收到请求的那一刻就直接清除SecurityContext

  • 认证的过程应该是“先将认证信息存入到SecurityContext（由我们的过滤器执行），再判断是否是通过认证的状态（由Spring Security的过滤器等组件执行）”，所以，当前过滤器必须在Spring Security的相关过滤器之前执行。

@Slf4j
@Component
public class JwtAuthorizationFilter extends OncePerRequestFilter {

    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain filterChain) throws ServletException, IOException {
        log.debug("处理JWT的过滤器开始执行……");

        // 清除SecurityContext中原有的认证信息
        // 避免曾经成功访问过，后续不携带JWT也能被视为“已认证”
        SecurityContextHolder.clearContext();

        // 尝试从请求头中获取JWT数据
        String jwt = request.getHeader("Authorization");
        log.debug("尝试从请求头中获取JWT数据：{}", jwt);

        // 判断客户端是否携带了有效的JWT数据，如果没有，直接放行
        if (!StringUtils.hasText(jwt) || jwt.length() < 113) {
            log.debug("获取到的JWT被视为【无效】，过滤器执行【放行】");
            filterChain.doFilter(request, response);
            return;
        }

        // 程序执行到此处，表示客户端携带了有效的JWT，则尝试解析
        log.debug("获取到的JWT被视为【有效】，则尝试解析……");
        String secretKey = "97iuFDVDfv97iuk534Tht3KJR89kBGFSBgfds";
        Claims claims = Jwts.parser()
                .setSigningKey(secretKey)
                .parseClaimsJws(jwt)
                .getBody();
        String username = claims.get("username", String.class);
        log.debug("从JWT中解析得到【username】的值：{}", username);

        // 准备权限，将封装到认证信息中
        List<GrantedAuthority> authorityList = new ArrayList<>();
        GrantedAuthority authority = new SimpleGrantedAuthority("这是一个山寨的权限");
        authorityList.add(authority);

        // 准备存入到SecurityContext的认证信息
        Authentication authentication
                = new UsernamePasswordAuthenticationToken(
                username, null, authorityList);

        // 将认证信息存入到SecurityContext中
        SecurityContext securityContext = SecurityContextHolder.getContext();
        securityContext.setAuthentication(authentication);

        log.debug("过滤器执行【放行】");
        filterChain.doFilter(request, response);
    }

}

然后，在SecurityConfiguration中自动装配此过滤器：  

@Autowired
private JwtAuthorizationFilter jwtAuthorizationFilter;

并在configurer()方法中补充：  

// 将JWT过滤器添加在Spring Security的UsernamePasswordAuthenticationFilter之前
http.addFilterBefore(jwtAuthorizationFilter,
			UsernamePasswordAuthenticationFilter.class);

完成后，重启项目，在Knife4j的在线API文档中，先不携带JWT并使用正确的账号登录，然后，携带登录返回的JWT即可向那些不在白名单中的URL进行访问！  

关于账号的权限

当处理认证时，应该从数据库中查询出此用户的权限，并且，将权限封装到UserDetails对象中，当认证成功后，返回的认证对象中的当事人信息就会包含权限信息，接下来，可以将权限信息也写入到JWT中！

后续，在解析JWT时，也可以从中解析得到权限信息，并将权限信息存入到SecurityContext中，则后续Spring Security的相关组件可以实现对权限的验证！

查询管理员的权限

在处理认证时，会调用AdminMapper接口中的AdminLoginInfoVO getLoginInfoByUsername(String username);方法，此方法的返回值应该包含管理员的权限。

select
    ams_admin.id,
    ams_admin.username,
    ams_admin.password,
    ams_admin.enable,
    ams_permission.value
from ams_admin
left join ams_admin_role on ams_admin.id=ams_admin_role.admin_id
left join ams_role_permission on ams_admin_role.role_id=ams_role_permission.role_id
left join ams_permission on ams_role_permission.permission_id=ams_permission.id
where username='root';

为了保证查询结果可以封装权限信息，需要在返回值类型中添加属性：  

@Data
public class AdminLoginInfoVO implements Serializable {

    private Long id;
    private String username;
    private String password;
    private Integer enable;
    private List<String> permissions; // 新增

}

然后，重新配置getLoginInfoByUsername()方法映射的SQL查询：  

<!-- AdminLoginInfoVO getLoginInfoByUsername(String usernanme); -->
<select id="getLoginInfoByUsername" resultMap="LoginResultMap">
    SELECT
        <include refid="LoginQueryFields"/>
    FROM
        ams_admin
    LEFT JOIN ams_admin_role ON ams_admin.id=ams_admin_role.admin_id
    LEFT JOIN ams_role_permission ON ams_admin_role.role_id=ams_role_permission.role_id
    LEFT JOIN ams_permission ON ams_role_permission.permission_id=ams_permission.id
    WHERE
        username=#{username}
</select>

<sql id="LoginQueryFields">
    <if test="true">
        ams_admin.id,
        ams_admin.username,
        ams_admin.password,
        ams_admin.enable,
        ams_permission.value
    </if>
</sql>

<!-- collection标签：用于配置返回结果类型中List类型的属性 -->
<!-- collection标签的ofType属性：List中的元素类型 -->
<!-- collection子级：需要配置如何创建出List中的每一个元素 -->
<resultMap id="LoginResultMap" 
           type="csmall.passport.pojo.vo.AdminLoginInfoVO">
    <id column="id" property="id"/>
    <result column="username" property="username"/>
    <result column="password" property="password"/>
    <result column="enable" property="enable"/>
    <collection property="permissions" ofType="java.lang.String">
        <constructor>
            <arg column="value"/>
        </constructor>
    </collection>
</resultMap>

使用JWT保存权限

 在UserDetailsServiceImpl中，调用的adminMapper.getLoginInfoByUsername()中已经包含用户的权限，则，在返回的UserDetails对象中封装权限信息：

UserDetails userDetails = User.builder()
                .username(loginAdmin.getUsername())
                .password(loginAdmin.getPassword())
                .accountExpired(false)
                .accountLocked(false)
                .credentialsExpired(false)
                .disabled(loginAdmin.getEnable() == 0)
                .authorities(loginAdmin.getPermissions().toArray(new String[] {})) // 调整
                .build();

需要注意：如果直接将权限（Collection<? extends GrantedAuthority>）存入到JWT数据中，相当于把Collection<? extends GrantedAuthority>转换成String，此过程会丢失数据的原始类型，且不符合自动反序列化格式，后续解析时，无法直接还原成Collection<? extends GrantedAuthority>类型！为解决此问题，可以先将Collection<? extends GrantedAuthority>转换成JSON格式的字符串再存入到JWT中，后续，解析JWT时得到的也会是JSON格式的字符串，可以反序列化为Collection<? extends GrantedAuthority>格式！  

 则先添加JSON工具类的依赖项：

<!-- fastjson：实现对象与JSON的相互转换 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.75</version>
</dependency>

然后，在AdminServiceImpl中，先从认证成功的返回结果中取出权限，然后存入到JWT中：  

// 从认证返回结果中取出当事人信息
User principal = (User) authenticateResult.getPrincipal();
String username = principal.getUsername();
log.debug("认证信息中的用户名：{}", username);
// ===== 以下是新增 ======
Collection<GrantedAuthority> authorities = principal.getAuthorities();
log.debug("认证信息中的权限：{}", authorities);
String authorityListString = JSON.toJSONString(authorities);
log.debug("认证信息中的权限转换为JSON字符串：{}", authorityListString);

// 生成JWT，并返回
// 准备Claims值
Map<String, Object> claims = new HashMap<>();
claims.put("username", username);
claims.put("authorities", authorityListString); // 新增

最后，在JwtAuthorizationFilter中，解析JWT时，取出权限的JSON字符串，将其反序列化为符合Collection<? extends GrantedAuthority>的格式：List<SimpleGrantedAuthority>，并用于存入到认证信息中：  

String username = claims.get("username", String.class);
log.debug("从JWT中解析得到【username】的值：{}", username);
String authorityListString = claims.get("authorities", String.class); // 新增
log.debug("从JWT中解析得到【authorities】的值：{}", authorityListString); // 新增

// 准备权限，将封装到认证信息中
List<SimpleGrantedAuthority> authorityList
        = JSON.parseArray(authorityListString, SimpleGrantedAuthority.class);

// 准备存入到SecurityContext的认证信息
Authentication authentication
        = new UsernamePasswordAuthenticationToken(
        		username, null, authorityList);

使用Spring Security控制访问权限

首先，需要在Spring Security的配置类上开启方法前的权限检查：  

@Slf4j
@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true) // 新增
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
    // 省略配置类中原有代码
}

然后，在需要对权限进行检查（控制）的控制器类的方法上，使用注解来配置权限，例如：  

// http://localhost:9081/admins
@ApiOperation("查询管理员列表")
@ApiOperationSupport(order = 400)
@PreAuthorize("hasAuthority('/ams/admin/read')") // 新增
@GetMapping("")
public JsonResult<List<AdminListItemVO>> list() {
    log.debug("开始处理【查询管理员列表】的请求……");
    List<AdminListItemVO> list = adminService.list();
    return JsonResult.ok(list);
}

以上新增的@PreAuthorize("hasAuthority('/ams/admin/read')")就表示已经通过认证的用户必须具有 '/ams/admin/read' 权限才可以访问此请求路径（http://localhost:9081/admins），如果没有权限，将抛出org.springframework.security.access.AccessDeniedException: 不允许访问。

由于无操作权限时会出现新的异常，则在GlobalExceptionHandler中补充对此类异常的处理

@ExceptionHandler
public JsonResult<Void> handleAccessDeniedException(AccessDeniedException e) {
    log.debug("处理AccessDeniedException");
    Integer serviceCode = ServiceCode.ERR_FORBIDDEN.getValue();
    String message = "请求失败，当前账号无此操作权限！";
    return JsonResult.fail(serviceCode, message);
}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

loading9527
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Token与Jwt详解
向着高亮的地方
10-30 3914
区别： Token验证方式：由于服务器没有存储token数据，因此需要先从数据库中查询当前token，服务器再是验证否有效； JWT验证方式：直接在服务端进行校验，并且不用查库。因为用户的信息及加密信息，在第二部分payload和第三部分签证中已经生成，只要在服务端进行校验就行，并且校验也是JWT自己实现的。 接下来，详细介绍Token和Jwt相关概念 1.To...
Spring Security介绍
li123128的博客
11-03 2万+
文章主要分三部分 1、Spring Security的架构及核心组件：(1)认证；(2)权限拦截；(3)数据库管理；(4)权限缓存；(5)自定义决策； 2、环境搭建与使用，使用当前热门的Spring Boot来搭建环境，结合项目中实际的例子来做几个Case; 3、Spring Security的优缺点总结，结合第二部分中几个Case的实现来总结Spring Security的优点和缺点。 1、Spring Security介绍 ​ 整体介绍，Spring Security为基于J2EE开发的企业应用软件
springboot和springsercurity整合实现登录验证增删改功能
10-16
springboot和springsercurity整合实现登录验证增删改功能，hibernate
知识点系列~SpringSecurity-认证授权
最新发布
weixin_62868720的博客
04-21 616
在互联网中，我们每天都会使用到各种各样的APP和网站，在使用过程中通常还会遇到需要注册登录的情况，输入你的用户名和密码才能正常使用，也就是说成为这个应用的合法身份才可以访问应用的资源，这个过程就是认证。认证是为了保护系统的隐私数据与资源，用户的身份合法方可访问该系统的资源。当然认证的方式有很多，常见的账号密码登录，手机验证码登录，指纹登录，刷脸登录等等。简单说: 认证就是让系统知道我们是谁。
spring-sercurity实现JWT认证
lizsy的博客
04-18 105
结合上述内容，可以分析出认证的核心是AuthenticationManager，所以，我们需要自定义jwt的AuthenticationManager并将其注入到认证过滤器里面去。Authentication：可以是AuthenticationManager的输入，以提供用户为身份验证或SecurityContext中的当前用户提供的凭据。AuthenticationManager：定义Spring Security的过滤器如何执行身份验证的API。
Spring Security详解
JAVA_KX的博客
05-15 2万+
AuthenticationManager进行认证时，将该认证管理器中的所有认证提供器遍历一遍，遍历过程中，首先检测认证提供器是否支持认证的票据类型，如果支持，则认证提供器开始进行认证。用于处理基于表单的登录请求，从表单中获取用户名和密码，默认情况下处理来自/login的请求，从表单中获取用户名和密码， 默认使用表单name值为username和password，这两个值可以通过这个过滤器的usernaemparamter个passwordParameter连个参数的值进行修改。
Spring Security
q475476257的博客
09-12 550
Spring Security
Jwt和Token
xmp
05-12 243
小白也能看懂的Jwt和Token
JWT 身份认证优缺点分析以及常见问题解决方案
Angus
10-08 1336
JWT 身份认证优缺点分析以及常见问题解决方案 之前分享了一个使用 Spring Security 实现 JWT 身份认证的 Demo，文章地址：适合初学者入门 Spring Security With JWT 的 Demo。Demo 非常简单，没有介绍到 JWT 存在的一些问题。所以，单独抽了一篇文章出来介绍。为了完成这篇文章，我查阅了很多资料和文献，我觉得应该对大家有帮助。 相关阅读： ...
token与JWT详细介绍
热门推荐
lixianhe的博客
06-28 4万+
token与JWT详细介绍
SpringSecutiry实现认证授权功能，整合SpringBoot
07-02
本资源通过SpringBoot整合SpringSecurity框架，实现对用户的认证授权功能，其中写了多个小demo，并且对SpringSecuirty进行了相应的配置，读者通过本资源可以得到关于SpringSecurity的认证授权知识，以及相关的流程。
spring security 认证授权实现
10-14
项目包含认证实现和jwt结合内容 项目使用redis cluster 和mybatis-plus 技术 项目包含建库脚本，一键使用，现成的认证授权框架 本项目不包含oauth2.0开放授权的内容
Java课程实验 Spring Security 实现用户认证和授权管理
07-07
要在Spring Boot中实现用户认证和授权管理，你可以使用Spring Security框架。Spring Security提供了一套强大的功能来处理用户身份验证和授权，以下是一些常见的步骤： 1.添加Spring Security依赖： 在项目的 pom.xml...
Spring security认证授权
11-30
Spring security认证授权例子，自动创建数据库，在SysUser类增加字段，即可动态增加数据库对应表sys_user字段（前提是要删除原表，启动应用时才会重建表）
Spring Security Oauth2.0认证授权专题
06-19
Spring boot+Spring Security Oauth2.0，Sprint cloud+Spring Security Oauth2集成。四种认证方式。附带有代码，和案例，案例，还有视频链接。我保证看完就回，如果视频链接失效，评论回复我，我单独再给你一份。
Token和JWT
学而不思则忘
05-08 243
我们知道 Session 信息需要保存⼀份在服务器端。这种⽅式会带来⼀些麻烦，⽐如 需要我们保证保存 Session 信息服务器的可⽤性、不适合移动端（依赖Cookie）等等。 有没有⼀种不需要⾃⼰存放 Session 信息就能实现身份验证的⽅式呢？使⽤ Token 即可！JWT （JSON Web Token） 就是这种⽅式的实现，通过这种⽅式服务器端就不需要保存 Session 数据 了，只⽤在客户端保存服务端返回给客户的 Token 就可以了，扩展性得到提升。 JWT 本质上就⼀段签名的 JSON 格
Token和Jwt的区别
weixin_45203607的博客
03-25 1万+
token基本原理 Token(就是加密的字符串,使用MD5,等不可逆加密算法,一定要保证唯一性) 客户端使用用户名跟密码请求登录 服务端收到请求，去验证用户名与密码 验证成功，服务端会签发一个Token保存到(Session,redis,mysql…)中，然后再把这个 Token 发送给客户端 客户端收到 Token 以后可以把它存储起来，比如放在 Cookie 里或者 Local Storage 里 客户端每次向服务端请求资源的时候需要带着服务端签发的 Token 服务端收到请求
token、jwt学习
fenghenzr的博客
08-12 888
参考资料 思维导图 一、背景 HTTP协议无状态 HTTP是无状态协议，虽然下层是TCP协议，能保证传输的可靠性，但是HTTP没有记忆功能，对事务处理没有记忆能力，可以这样理解，我们通过浏览器前后两次访问同一网站是完全不同的请求，相互独立的，可能你会发现现在访问并不是这样，那是我们做了一定的处理。 Cookie & Session cookie和session是经常环绕在日常工作或者面试中，cookie和session就是我们希望浏览器能够有“记忆”的访问网址衍生出来的作品。 当我们登录时，如果符
token令牌和jwt
weixin_33801856的博客
10-23 155
用户登录，后端生成token返回给前端 前端拿到token，以后每次登录使用header里的token进行权限验证 后端接收到前端传来的token，如果是通过数据库或redis或session进行比对验证，这种方式为令牌验证 后端接收到前端传来的token，如果是通过一套加密解密算法来确定用户的身份是否合法，这种方式为jwt 前端并不进行加密和解密的处理，只是用一个载体存住token，这个toke...
SpringSecurity实现认证和授权
11-02
在Spring Boot应用中使用Spring Security可以非常方便地实现用户身份认证和授权。Spring Security实现身份认证和授权的步骤如下： 1.添加Spring Security依赖，可以在pom.xml文件中添加以下依赖： ```xml ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值