SpringBoot 3.2.1 + SpringSecurity 3.2.1 + JWT 实现登录鉴权

已于 2024-01-17 17:56:18 修改
阅读量734 收藏 7
点赞数 7
文章标签： spring boot java mybatis
于 2024-01-17 17:34:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ICanForYou/article/details/135653919
版权

前言

文档已验证, 有问题请留言. 欢迎各位大佬斧正.

Maven依赖

	    <!-- spring web -->
        <dependency>
        	<groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>3.2.1</version>
        </dependency>
        
        <!-- Spring Security -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
            <version>3.2.1</version>
        </dependency>
        
        <!-- JWT -->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>
        <dependency>
            <groupId>javax.xml.bind</groupId>
            <artifactId>jaxb-api</artifactId>
            <version>2.3.0</version>
        </dependency>

        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.30</version>
            <optional>true</optional>
        </dependency>

        <!-- commons-lang3 工具包 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.13.0</version>
        </dependency>
        
        <!-- hutool 工具包 -->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.25</version>
        </dependency>

TokenUtil

package com.trade.util;

import cn.hutool.core.util.IdUtil;
import com.trade.security.UserDetail;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;

/**
 * Jwt Util
 *
 * @author Hollis
 * @since 2024-01-08 15:55
 */
@Component
public class JwtTokenUtil {

	/**
     * Token 盐值\密钥, 请注意修改
     */
    private final static String SECRET_KEY = "NoteSecret";

    public String extractUsername(String token) {
        return extractClaim(token, Claims::getSubject);
    }

    public Date extractExpiration(String token) {
        return extractClaim(token, Claims::getExpiration);
    }

    public <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {
        final Claims claims = extractAllClaims(token);
        return claimsResolver.apply(claims);
    }

    private Claims extractAllClaims(String token) {
        return Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token).getBody();
    }

    private Boolean isTokenExpired(String token) {
        return extractExpiration(token).before(new Date());
    }

    public String generateToken(UserDetail userDetail) {
        Map<String, Object> claims = new HashMap<>();
        claims.put("jwtId", IdUtil.getSnowflakeNextId());
        claims.put("memberId", userDetail.getMemberId());
        claims.put("memberName", userDetail.getMemberName());
        claims.put("tenantId", userDetail.getTenantId());
        claims.put("tenantName", userDetail.getTenantName());
        claims.put("enterpriseId", userDetail.getEnterpriseId());
        claims.put("enterpriseName", userDetail.getEnterpriseName());
        claims.put("grantedAuthorities", userDetail.getAuthorities());
        return createToken(claims, userDetail.getUsername());
    }

    /**
     * 生成 Token
     * 注: 自测使用, Token过期时间写死 '1' 天, 业务中可根据实际情况调整
     *
     * @param claims  Token中的业务数据
     * @param subject Token中的用户名
     * @return {@link String} Token
     * @see #generateToken(UserDetail) 方法使用示例
     */
    private String createToken(Map<String, Object> claims, String subject) {
        return Jwts.builder()
                .setClaims(claims)
                .setSubject(subject)
                .setIssuedAt(new Date(System.currentTimeMillis()))
                .setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 24))
                .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
                .compact();
    }

    public Boolean validateToken(String token, UserDetails userDetails) {
        final String username = extractUsername(token);
        return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
    }
}

自定义 Security Exception 实现

JwtAccessDeniedHandler - 访问被拒

package com.trade.security.exception;

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.stereotype.Component;

import java.io.IOException;

/**
 * 访问被拒
 *
 * @author Hollis
 * @since 2024-01-08 16:11
 */
@Component
public class JwtAccessDeniedHandler implements AccessDeniedHandler {

    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException {
        //当用户在没有授权的情况下访问受保护的REST资源时，将调用此方法发送403 Forbidden响应
        response.sendError(HttpServletResponse.SC_FORBIDDEN, accessDeniedException.getMessage());
    }
}

JwtAuthenticationEntryPoint - 登录失败

package com.trade.security.exception;

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;

import java.io.IOException;

/**
 * 登录失败
 *
 * @author Hollis
 * @since 2024-01-08 16:11
 */
@Component
public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint {

    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response,
                         AuthenticationException authException) throws IOException {
        response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized");
    }
}

[重点] SpringSecurityConfig

SrpingSecurity 策略配置类

package com.trade.security.config;

import cn.hutool.core.util.StrUtil;
import com.trade.security.JwtUserDetailsService;
import com.trade.security.exception.JwtAccessDeniedHandler;
import com.trade.security.exception.JwtAuthenticationEntryPoint;
import com.trade.security.filter.JwtRequestFilter;
import lombok.RequiredArgsConstructor;
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.configuration.AuthenticationConfiguration;
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.configurers.AbstractHttpConfigurer;
import org.springframework.security.config.annotation.web.configurers.HeadersConfigurer;
import org.springframework.security.config.core.GrantedAuthorityDefaults;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.CorsConfigurationSource;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;

import java.util.List;

/**
 * Spring Security Configuration
 *
 * @author Hollis
 * @since 2024-01-08 16:11
 */
@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class SecurityConfig {

    private static final Long CORS_MAX_AGE = 3600L;
    private static final List<String> CORS_ALLOWED_HEADERS = List.of("*");

    private final JwtRequestFilter jwtRequestFilter;
    private final JwtUserDetailsService userDetailsServiceImpl;
    private final JwtAccessDeniedHandler jwtAccessDeniedHandler;
    private final JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;
    private final AuthenticationConfiguration authenticationConfiguration;


    /**
     * Spring Security Filter Chain
     *
     * @param http http
     * @return {@link SecurityFilterChain}
     * @throws Exception 异常
     */
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        return http
        		// 解决跨域
                .csrf(AbstractHttpConfigurer::disable)
                .cors(corsCustomizer -> corsCustomizer.configurationSource(corsConfigurationSource()))
                .headers(headers -> headers.frameOptions(HeadersConfigurer.FrameOptionsConfig::disable))
                .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
                // 指定 登录鉴权 处理类
                .addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class)
                // 鉴权白名单, 配置绕过鉴权的接口
                .authorizeHttpRequests(authorized -> authorized
                        .requestMatchers("/member/login").permitAll()
                        .requestMatchers("/member/register").permitAll()
                        .requestMatchers(HttpMethod.OPTIONS).permitAll()
                        .anyRequest().authenticated()
                )
                // 指定 登录鉴权时 查询用户信息的实现类
                .userDetailsService(userDetailsServiceImpl)
                // 自定义异常处理
                .exceptionHandling(exceptionHandling -> exceptionHandling
                        .accessDeniedHandler(jwtAccessDeniedHandler)
                        .authenticationEntryPoint(jwtAuthenticationEntryPoint)
                )
                .build();
    }

    /**
     * 移除用户角色的 ROLE_ 前缀
     * 
     * @return {@link GrantedAuthorityDefaults}
     */
    @Bean
    GrantedAuthorityDefaults grantedAuthorityDefaults() {
        return new GrantedAuthorityDefaults(StrUtil.EMPTY);
    }

    /**
     * 指定用户密码加密方式
     *
     * @return {@link PasswordEncoder}
     */
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    public AuthenticationManager authenticationManager() throws Exception {
        return authenticationConfiguration.getAuthenticationManager();
    }

    /**
     * CORS配置源, 解决跨域
     *
     * @return {@link CorsConfigurationSource}
     */
    @Bean
    public CorsConfigurationSource corsConfigurationSource() {
        CorsConfiguration corsConfiguration = new CorsConfiguration();
        corsConfiguration.setAllowedHeaders(CORS_ALLOWED_HEADERS);
        corsConfiguration.setAllowedMethods(CORS_ALLOWED_HEADERS);
        corsConfiguration.setAllowedOrigins(CORS_ALLOWED_HEADERS);
        corsConfiguration.setMaxAge(CORS_MAX_AGE);
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", corsConfiguration);
        return source;
    }
}

[重点] JwtRequestFilter

登录鉴权处理类

package com.trade.security.filter;

import com.trade.util.JwtTokenUtil;
import com.trade.security.JwtUserDetailsService;
import io.jsonwebtoken.ExpiredJwtException;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.log4j.Log4j2;
import org.apache.commons.lang3.StringUtils;
import org.jetbrains.annotations.NotNull;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import java.io.IOException;

/**
 * 登录过滤器
 *
 * @author Hollis
 * @since 2024-01-08 16:12
 */
@Log4j2
@Component
public class JwtRequestFilter extends OncePerRequestFilter {

    public static final String TOKEN_HEAD = "Bearer ";
    private static final String AUTHORIZATION = "Authorization";

    @Autowired
    private JwtUserDetailsService jwtUserDetailsService;

    @Autowired
    private JwtTokenUtil jwtTokenUtil;


    @Override
    protected void doFilterInternal(@NotNull HttpServletRequest request,
                                    @NotNull HttpServletResponse response,
                                    @NotNull FilterChain filterChain)
            throws ServletException, IOException {

        // 从请求头中获取 Token 信息
        final String token = request.getHeader(AUTHORIZATION);

        // 校验 Token 有效性
        if (StringUtils.isBlank(token) || !token.startsWith(TOKEN_HEAD)) {
            filterChain.doFilter(request, response);
            return;
        }

        String username = null;
        // JWT Token is in the form "Bearer token". Remove Bearer word and get only the Token
        String jwtToken = token.replace(TOKEN_HEAD, StringUtils.EMPTY);

        try {
            username = jwtTokenUtil.extractUsername(jwtToken);
        } catch (IllegalArgumentException e) {
            log.warn("JwtRequestFilter#doFilterInternal Unable to get JWT Token, jwtToken : {}", jwtToken, e);
        } catch (ExpiredJwtException e) {
            log.warn("JwtRequestFilter#doFilterInternal JWT Token has expired, jwtToken : {}", jwtToken, e);
        }

        if (StringUtils.isBlank(username)) {
            filterChain.doFilter(request, response);
            return;
        }

        // Once we get the token validate it.
        UserDetails userDetails = this.jwtUserDetailsService.loadUserByUsername(username);

        // if token is valid configure Spring Security to manually set authentication
        if (jwtTokenUtil.validateToken(jwtToken, userDetails)) {
            UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(
                    userDetails,
                    null,
                    userDetails.getAuthorities()
            );
            usernamePasswordAuthenticationToken
                    .setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
            // After setting the Authentication in the context, we specify
            // that the current user is authenticated. So it passes the Spring Security Configurations successfully.
            SecurityContextHolder
                    .getContext()
                    .setAuthentication(usernamePasswordAuthenticationToken);
        }
        filterChain.doFilter(request, response);
    }
}

JwtUserDetailsService

package com.trade.security;

import com.trade.domain.dto.member.MemberDetailDTO;
import com.trade.enums.DataStatusEnum;
import com.trade.service.MemberService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.DisabledException;
import org.springframework.security.core.AuthenticationException;
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.Component;

import java.util.List;
import java.util.Objects;

/**
 * Spring Security UserDetailsService impl
 *
 * @author Hollis
 * @since 2023-09-06 11:21
 */
@Component
public class JwtUserDetailsService implements UserDetailsService {

    // 测试项目, 直接写死用户角色.实际业务请动态查询替换
    private static final List<String> DEF_MEMBER_ROLE = List.of("ROLE_MEMBER");

    @Autowired
    private MemberService memberService;

    @Override
    public UserDetails loadUserByUsername(String username) throws AuthenticationException {
        // 查询用户信息
        MemberDetailDTO member = memberService.queryMemberDetailByMemberCode(username);
        if (Objects.isNull(member)) {
            throw new UsernameNotFoundException("未查询到会员信息!");
        }

        // 校验用户状态
        DataStatusEnum memberStatus = member.getDataStatus();
        if (DataStatusEnum.INVALID.equals(memberStatus)) {
            throw new DisabledException("该账号已被禁用, 请联系管理员处理!");
        }
        return new UserDetail(member, DEF_MEMBER_ROLE);
    }
}

UserDetail

Security中的用户信息, 会随业务变更, 仅供参考

package com.trade.security;

import com.trade.domain.dto.member.MemberDetailDTO;
import com.trade.enums.DataStatusEnum;
import lombok.Data;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import java.util.Collection;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * Spring Security User
 *
 * @author Hollis
 * @since 2023-09-06 11:33
 */
@Data
public class UserDetail implements UserDetails {

    /**
     * 会员id
     */
    private Long memberId;

    /**
     * 代码
     */
    private String memberCode;

    /**
     * 名称
     */
    private String memberName;

    /**
     * 密码
     */
    private String memberPassword;

    /**
     * 手机号
     */
    private String memberMobilePhone;

    /**
     * 数据状态（0：有效，1：无效）
     */
    private DataStatusEnum dataStatus;

    /**
     * 租户id
     */
    private Long tenantId;

    /**
     * 租户名称
     */
    private String tenantName;

    /**
     * 企业id
     */
    private Long enterpriseId;

    /**
     * 企业名称
     */
    private String enterpriseName;

    /**
     * 用户角色
     */
    private Set<GrantedAuthority> grantedAuthorities;


    public UserDetail(MemberDetailDTO member, List<String> permissions) {
        this.memberId = member.getMemberId();
        this.memberCode = member.getMemberCode();
        this.memberName = member.getMemberName();
        this.memberPassword = member.getMemberPassword();
        this.memberMobilePhone = member.getMemberMobilePhone();
        this.dataStatus = member.getDataStatus();
        this.tenantId = member.getTenantId();
        this.tenantName = member.getTenantName();
        this.enterpriseId = member.getEnterpriseId();
        this.enterpriseName = member.getEnterpriseName();
        if (CollectionUtils.isNotEmpty(permissions)) {
            this.grantedAuthorities = permissions
                    .stream()
                    .map(SimpleGrantedAuthority::new)
                    .collect(Collectors.toSet());
        }
    }

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

    @Override
    public String getPassword() {
        return this.memberPassword;
    }

    @Override
    public String getUsername() {
        return this.memberCode;
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }
}

备注

  • 缺失的 MemberDetailDTO 为系统中的用户信息字段.
忙里偷闲的日和月
关注
SpringBoot+SpringSecurity+Jwt权限认证---认证
python6_quanzhan的博客
12-10 544
1. 整体逻辑 1. SpringSecurity认证的逻辑规则 启动项目时，SpringBoot自动检索所有带@Configuration的注解，所以就将我们的WebSecurityConfig给加载了，这个config中，我们需要在configure(AuthenticationManagerBuilder auth)方法中注册一个继承自UserDetailsService的接口，这个接口中只有一个方法，那就是使用username获取到数据库中用户信息并返回成UserDetail实体。这个方法需要.
Spring Boot 整合 JWT token 实现登录鉴权
include_hcj的博客
08-11 1256
JWT token 是一种经过加密的字符串，其中包含了加密的载体信息（例如登录用户的信息），经过解密后可以得到加密的载体信息。我们可以使用 JWT token 实现用户登录鉴权，例如：前后端分离并且不使用 session 保存用户登录状态的项目中，前端登录后，服务器将 token 字符串返回给浏览器保存，此后浏览器的请求都携带 token 字符串发送。服务端解密请求的 token 字符串，确定是有效 token 后，再进行后续业务处理。...
springboot3整合SpringSecurity实现登录校验与权限认证（万字超详细讲解）
热门推荐
2301_78646673的博客
12-11 1万+
用户提交登录请求Spring Security 将请求交给 UsernamePasswordAuthenticationFilter 过滤器处理。UsernamePasswordAuthenticationFilter 获取请求中的用户名和密码，并生成一个 AuthenticationToken 对象，将其交给 AuthenticationManager 进行认证。
订单防重复提交：token 发放以及校验
Blue_Pepsi_Cola的博客
09-16 939
在很多秒杀场景中，用户为了能下单成功，会频繁的点击下单按钮，这时候如果没有做好控制的话，就可能会给一个用户创建重复订单。
springboot3+Spring Security+JWT+redis+MySQL实现登陆验证
admin_cx的博客
05-15 2333
使用springboot3+Spring Security+JWT+redis+mysql实现登陆验证功能
详细！SpringBoot整合SpringSecurity实现JWT认证
MarkerHub的博客
01-02 1181
小Hub领读：最近做了个security项目，参考了一下这个例子，还可以作者：智慧zhuhuixhttps://blog.csdn.net/jpgzhu/article/details/...
SpringSecurity(一): Springboot 3.2.1 整合 SpringSecurity 完成认证
zhw74101的博客
01-19 1623
目的：将springsecurity默认的登录逻辑迁移到自定义的逻辑上（访问数据库）/*实现 UserDetailsService 接口，自定义校验逻辑@Component让spring知晓自定义的内容*/@Component@Autowired@Override//1.根据用户名查询用户信息//2.TODO 查询该用户的权限列表并整合对象/*
SpringBoot+Spring Security+JWT（三更草堂）
Roc的博客
09-12 7969
Springsecurity是Spring家族中的一个安全管理框架。相比与另外一个安全框架shiro，它提供了更丰富的功能，社区资源也比Shiro丰富。一般来说中大型的项目都是使用来做安全框架。小项目有Shiro的比较多，因为相比与SpringSecurity，Shiro的上手更加的简单。—般Web应用的需要进行认证和授权。认证：验证当前访问系统的是不是本系统的用户，并且要确认具体是哪个用户授权：经过认证后判断当前用户是否有权限进行某个操作而认证和授权也是SpringSecurity作为安全框架的核心功能。
SpringBoot+MyBatisPlus+Redis+Jwt+Shiro+Vue 完整博客文章管理前后端实战
小青蛙的博客
07-04 2307
从零开始搭建一个项目骨架，最好选择合适，熟悉的技术，并且在未来易拓展，适合微服务化体系等。所以一般以Springboot作为我们的框架基础，这是离不开的了。 然后数据层，我们常用的是Mybatis，易上手，方便维护。但是单表操作比较困难，特别是添加字段或减少字段的时候，比较繁琐，所以这里我推荐使用Mybatis Plus，为简化开发而生，只需简单配置，即可快速进行 CRUD`操作，从而节省大量时间。...
开发知识点-JAVA-springboot+Spring Security/Shiro
aming小老弟
02-18 644
Spring 还提供了一个名为 Spring Security 的子项目，用于处理应用程序的安全需求。Spring Security 可以与 Shiro 集成，以提供更强大的安全功能。Shiro 提供了一套灵活的安全管理功能，可以处理用户身份验证、访问控制、会话管理等任务。因此，可以说 Shiro 是一个独立的安全框架，而 Spring 平台可以与 Shiro 一起使用来增强应用程序的安全性。Shiro 和 Spring 平台是两个不同的项目，它们可以在一起使用来提供安全认证和授权功能。
SpringBoot 3 SpringBoot+VUE案例
u012474395的博客
02-20 1677
3 SpringBoot+VUE案例开发 经过对SpringBoot及VUE的学习，我们已经对他们的开发流程有了一定的了解，我们将这两个框架进行整合，并实现一个简单的前后的开发案例“HelloWorld”。这个案例我们主要实现：（1）系统的登陆、退出；（2）用户的查询、新增、修改、删除。系统架构如下图所示： 从架构图中可以看到前端UI采用VUE框架开发， vue框架整合了mock、validat...
SpringBoot搭建的shiro鉴权的最简单的登录demo（绝对可用）
09-04
直接把项目导入idea就能打开使用，该项目在简单实现shiro登录鉴权的基础上，还实现了接收数据的统一加工处理模块，在接收post或者get请求后，能返回固定模板格式的json数据给前端，对于初期的学习与应用很有帮助。对了数据库需要自己布置一下，有问题的话可以给我留言
SpringBoot + shiro Demo 简单登录验证权限验证
02-08
SpringBoot ，Shiro 密码加密，登录验证，权限控制demo
Springboot整合shiro+jwt上手教程
一条会编程的鱼
04-23 713
目录前言开源依赖maven依赖Shiro配置类配置Realm自定义Filter用到的工具类测试小结 前言 为啥要写这一篇文章呢？无他，网上水文太多了。摸了一周的鱼，终于配置出来了自己理想的效果。 在工作中，权限是一个后台系统的重中之重。在Java中，我们可以选择Shiro和SpringSecurity这两款权限框架。我个人来说是比较喜欢Shiro这款。 网上搜了很多教程，要么就是版本比较老，要么就是配置不生效。所以，求人不如求己，万事开头难，男上加男，迎男而上，满身大汉。。。。扯远了 进入正题… 开源依赖
这才是 SpringBoot 统一登录鉴权、异常处理、数据格式 的正确姿势！！！
群群的博客
08-06 353
本篇将要学习 Spring Boot 统一功能处理模块，这也是 AOP 的实战环节。
Spring用户登陆鉴权功能
RuiHao-He的博客
01-26 985
1.创建一个方法注解，用于定义需要登录 package com.example.demo1.config; import java.lang.annotation.*; @Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented public...
springboot整合Sa-Token实现登录认证和权限校验（万字长文）
2301_78646673的博客
02-03 6857
我本来是想写一篇介绍spring boot项目中整合Sa-Token来实现最常用的登录校验和权限认证的，但是写着写着就变成官网的复制机了。我在本篇文章中大量复制了官网上的内容，原本只是想复制一些官方介绍就行了。但是这也从侧面说明了Sa-Token官网制作的确实是比较好的，基本上不需要额外的学习，只要你有做过登录和权限方面的项目经验，再看一遍官网的介绍就能直接上手了。我之前写过一个B2C模式的购物商台，分为用户端和管理端。管理端的登录和权限校验是用spring security写的。
keycloak-鉴权springboot
YSTXDONG的专栏
03-04 1437
keycloak鉴权springboot的方式，此处简单介绍，springboot官方也提供了demo以及文档说明本文环境springboot版本：2.7.1，(此版本无所谓，都是一样的)keycloak版本：23.0.7(截止目前最新版本)
Springboot+Spring-Security+JWT 实现用户登录和权限认证
最新发布
yuwinter的博客
10-10 1819
Spring Boot 项目初始化：利用 Spring Initializr 创建项目，并添加必要依赖（Spring Web、Spring Security、JWT、JPA 等）。 用户登录和注册接口：实现 AuthController，处理用户登录请求，并返回 JWT。 Spring Security 配置：通过扩展 WebSecurityConfigurerAdapter 来配置 Spring Security，设置无状态的会话管理、JWT 过滤器、受保护的资源路径等。 JWT 生成和解析：实现。
winxp+pyinstaller3.2.1+pywin32-220.zip
01-08
WinXP是指Windows XP操作系统，而pyinstaller3.2.1和pywin32-220.zip是python程序开发工具。 pyinstaller是一个用于将Python程序打包成可执行文件的工具。它可以将Python程序及其所有依赖的库文件打包为一个独立的可执行文件，这样就可以在没有安装Python解释器的系统上直接运行Python程序。 pywin32是一个用于在Windows系统上访问和操作Windows API的Python扩展模块。它提供了一系列的函数和类，可以用于实现Windows系统的各种功能，比如创建、操作和管理Windows进程、文件和注册表等。 对于Windows XP操作系统来说，它已经过时并不再得到微软官方的官方支持。而pyinstaller3.2.1和pywin32-220.zip则是较旧的版本。需要注意的是，这两个工具可能不再支持或兼容Windows XP操作系统，因为它们可能依赖于Windows XP不再支持的一些功能或接口。 如果您计划在Windows XP上使用pyinstaller3.2.1和pywin32-220.zip，建议您先查看官方文档或相关的支持资源，确认它们是否兼容及可以在Windows XP上正常使用。另外，由于Windows XP存在安全风险，建议您考虑升级到更新的操作系统，以确保系统的安全性和稳定性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值