springboot3.2.8【security登录认证】

已于 2024-08-23 11:22:14 修改
阅读量131 收藏 4
点赞数 2
分类专栏： springboot3 文章标签： spring boot
于 2024-08-23 11:21:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40570699/article/details/141459863
版权

文章目录

概要

springboot3.2.8,使用security登录认证

整体架构流程

代码思路

1.配置WebSecurityConfig类,配置正给http请求的认证和鉴权
2.自定义拦截器customizeAuthenticationFilter(),+账号密码验证UsernamePasswordAuthenticationFilter对用户认证

代码展示

  • WebSecurityConfig 类,这里隐藏了一些内部使用的包。大家用可替换的包和方法函数解决。
import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.ProviderManager;
import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
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.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

/**
 * 该类定义了SpringSecurity的主要流程配置
 */

@Configuration
@EnableWebSecurity
@EnableMethodSecurity
//从配置文件中的前缀获取配置
@ConfigurationProperties(prefix = "system")
@Data
public class WebSecurityConfig {

    //handler定义了很多 通知
    @Autowired
    private CustomizeAuthenticationSuccessHandler customizeAuthenticationSuccessHandler;

    @Autowired
    private CustomizeAuthenticationFailureHandler customizeAuthenticationFailureHandler;

    @Autowired
    private CustomizeLogoutSuccessHandler customizeLogoutSuccessHandler;

    @Autowired
    //鉴权token过滤器
    private JwtAuthenticationToKenFilter jwtAuthenticationToKenFilter;

    @Autowired
    private CustomizeAccessDeniedHandler customizeAccessDeniedHandler;

    @Autowired
    private CustomizeAuthenticationEntryPoint customizeAuthenticationEntryPoint;

    @Autowired
    private UserDetailsService userDetailsService;

    @Autowired
    private TokenService tokenService;

    //定义了白名单
    private String[] whiteList;

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity httpSecurity) throws  Exception{

        httpSecurity
                //禁用csrf 因为不使用session
                .csrf(csrf->csrf.disable())
                //禁用自带的跨域处理
                .cors(cors->cors.disable())
                //基于token 关掉session
                .sessionManagement(session->session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
                //权限路径控制
                .authorizeHttpRequests(request->{
                    request
                            .requestMatchers(whiteList)
                            .permitAll()
                            /*.requestMatchers(HttpMethod.GET,"/","/*.html","/**.html","/**.css","/**.js","/profile/**","/grpc/**")
                            .permitAll()
                            .requestMatchers("/swagger-ui.html", "/swagger-resources/**", "/webjars/**", "/webjars/**", "/v3/**")
                            .permitAll()
                            .requestMatchers("/auth/**")
                            .permitAll()*/
                            .anyRequest().authenticated();
                })
                //登录,这里将登录注释。依然可以通过POST带参数访问/login
                /*.formLogin(login->{
                    login
                            //登录接口地址
                            .loginProcessingUrl("/login")
                            //允许所有用户登录
                            .permitAll()
                            //登录成功处理
                            .successHandler(customizeAuthenticationSuccessHandler)
                            //登录失败处理
                            .failureHandler(customizeAuthenticationFailureHandler);

                })*/
                //注销
                .logout(logout->{
                    logout
                            .logoutUrl("/logout")
                            //注销成功处理
                            .logoutSuccessHandler(customizeLogoutSuccessHandler);
                })
                //配置自定义filter
                .addFilterAt(customizeAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class)
                //jwt权限过滤
//                .addFilterBefore(jwtAuthenticationToKenFilter, CustomizeAuthenticationFilter.class)
                //异常处理
                .exceptionHandling(exception->{
                    exception
                            //认证失败处理
                            .authenticationEntryPoint(customizeAuthenticationEntryPoint)
                            //权限失败处理
                            .accessDeniedHandler(customizeAccessDeniedHandler);
                });


        return httpSecurity.build();
    }

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

    /**
     * 自定义filter配置
     * 对用户信息验证,并设置成功和失败Handler
     * @return
     */
    @Bean
    public CustomizeAuthenticationFilter customizeAuthenticationFilter(){
        CustomizeAuthenticationFilter filter = new CustomizeAuthenticationFilter();
        //必须设置authenticationManager
        filter.setAuthenticationManager(authenticationManager());
        filter.setAuthenticationSuccessHandler(customizeAuthenticationSuccessHandler);
        filter.setAuthenticationFailureHandler(customizeAuthenticationFailureHandler);
        return filter;
    }

    /**
     * 注入userDetailsService和加解密Encoder,userDetailsService回去调用我们的实现类
     * @return
     */
    @Bean
    public AuthenticationManager authenticationManager(){
        DaoAuthenticationProvider provider = new DaoAuthenticationProvider();
        provider.setUserDetailsService(userDetailsService);
        provider.setPasswordEncoder(bCryptPasswordEncoder());
        ProviderManager pm = new ProviderManager(provider);
        return pm;
    }

}
  • customizeAuthenticationFilter自定义拦截器,验证用户信息
import com.fasterxml.jackson.databind.ObjectMapper;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.http.MediaType;
import org.springframework.security.authentication.AuthenticationServiceException;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

import java.io.IOException;
import java.util.Map;

/**
 * 自定义filter
 * 处理json传参
 * 处理password解码
 */
public class CustomizeAuthenticationFilter extends UsernamePasswordAuthenticationFilter {

    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
        if (!request.getMethod().equals("POST")) {
            throw new AuthenticationServiceException("Authentication method not supported: " + request.getMethod());
        } else {
            if(request.getContentType().equals(MediaType.APPLICATION_JSON_VALUE)){
                Map<String,String> map;
                UsernamePasswordAuthenticationToken authRequest = null;
                try{
                    //转换输入的json为map格式
                    map = new ObjectMapper().readValue(request.getInputStream(),Map.class);
                    String username = map.get(getUsernameParameter());
                    username = username != null ? username.trim() : "";
                    String password = map.get(getPasswordParameter());
                    password = password != null ? password : "";
                    //解密
                    String decryptedPassword = RSAEncrypt.decode(password);
                    authRequest = new UsernamePasswordAuthenticationToken(username,decryptedPassword);

                }catch (IOException e){
                    e.printStackTrace();
                    authRequest = new UsernamePasswordAuthenticationToken("","");
                }finally {
                    setDetails(request,authRequest);
                    //调用authenticate完成认证
                    return this.getAuthenticationManager().authenticate(authRequest);
                }
            }
        }
        //不是json格式按照表单登录逻辑处理
        return super.attemptAuthentication(request, response);
    }

}
  • 自定义实现类UserDetailsServiceImpl,用于查询数据库验证用户
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
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.security.web.server.authorization.AuthorizationContext;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Set;

/**
 */
@Service
public class UserDetailsServiceImpl implements UserDetailsService {

    @Autowired
    private IUserService userService;

    @Autowired
    private IRoleService roleService;

    @Autowired
    private IPermissionService permissionService;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(User::getUserName,username);
        wrapper.eq(User::getDelFlag, UserStatus.OK);
        User user = userService.getOne(wrapper);
        if(StringUtils.isNull(user)){
            //throw new UsernameNotFoundException("账号不存在");
            throw new ServiceException("账号不存在");
        }
        UsernameContextHolder.setContext(username);

        //查询角色
        List<Role> roles = roleService.queryRolesByUser(user.getUserId());

        //查询权限
        Set<String> permissions = permissionService.queryPermissionByRole(roles);

        return new LoginUser().setUserId(user.getUserId()).setUser(user).setRoles(roles).setPermissions(permissions);
    }
}
  • LoginUser,自定义的实例
import cn.hutool.core.collection.CollectionUtil;
import lombok.Data;
import lombok.experimental.Accessors;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import java.util.*;

/**
需要实现UserDetails 
 */
@Data
@Accessors(chain = true)
public class LoginUser implements UserDetails {

    private Long userId;

    private String token;

//    user为普通的用户实体类
    private User user;

    private List<Role> roles;

    private Set<String> permissions;


    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        List<GrantedAuthority> authorities = new ArrayList<>();
        if(CollectionUtil.isNotEmpty(roles)){
            roles.forEach(role->{
                MyGrantedAuthority authority = new MyGrantedAuthority(role);
                //redis对SimpleGrantedAuthority反序列化有问题
                //GrantedAuthority authority = new SimpleGrantedAuthority(role.getRoleKey());
                authorities.add(authority);
            });

        }
        return authorities;
    }


    public static class MyGrantedAuthority implements GrantedAuthority {
        private Role role;

        private String roleKey;

        @Override
        public String getAuthority() {
            return Objects.isNull(this.role) ? this.roleKey : "ROLE_"+this.role.getRoleKey();
        }

        public MyGrantedAuthority(Role role) {
            this.role = role;

        }

        public MyGrantedAuthority(String roleKey) {
            this.roleKey = roleKey;
        }
    }

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

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

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

    @Override
    public boolean isAccountNonLocked() {
        return user.getLockFlag() == FlagStatus.NOT.getCode();
    }

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

    @Override
    public boolean isEnabled() {
        return true;
    }
}
  • jwt token验证
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import java.io.IOException;

/**
 */
@Component
public class JwtAuthenticationToKenFilter extends OncePerRequestFilter {


    @Autowired
    private TokenService tokenService;

    @Autowired
    private RedisService redisService;


    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        //获取token
        String token = tokenService.getRequestToken(request);

        //验证token是否有效
        LoginUser loginUser = tokenService.getUserByToken(token);

        if(StringUtils.isNotNull(loginUser)){
            //判断token是否需要续期
            Long expireTime = redisService.getExpire(CacheConstants.LOGIN_USER_TOKEN_KEY + loginUser.getUserId());
            if(expireTime>0 && expireTime<=600L){
                tokenService.refreshToken(loginUser);
            }
        }

        if(StringUtils.isNotNull(loginUser) && StringUtils.isNull(SecurityUtils.getAuthentication())){
            UsernamePasswordAuthenticationToken authentication =
                    new UsernamePasswordAuthenticationToken(loginUser, null, loginUser.getAuthorities());
            SecurityContextHolder.getContext().setAuthentication(authentication);

        }
        filterChain.doFilter(request,response);
    }
}
  • token的管理
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.security.Keys;
import jakarta.servlet.http.HttpServletRequest;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.TimeUnit;


@Component
@ConfigurationProperties(prefix = "jwt")
@Data
@Slf4j
public class TokenService {

    // 令牌自定义标识
    private String header;

    // 令牌秘钥
    private String secret;

    // 令牌过期时间
    private Long expireTime;

    @Autowired
    private RedisService redisService;

    /**
     * 创建令牌
     *
     * @param loginUser
     * @return
     */
    public String createToken(LoginUser loginUser) {

        String token = UUID.randomUUID().toString();
        loginUser.setToken(token);
        refreshToken(loginUser);

        Map<String, Object> claims = new HashMap<>();
        claims.put(Constants.LOGIN_USER_KEY, token);

        return createToken(claims);
    }

    /**
     * 从数据声明生成令牌
     *
     * @param claims
     * @return
     */
    private String createToken(Map<String, Object> claims) {
        /*return Jwts.builder()
                .setClaims(claims)
                .setHeaderParam("typ", "JWT")
                .setHeaderParam("alg", "HS256")
                .setSubject("jacob-user")
                .setIssuedAt(new Date())
                .signWith(SignatureAlgorithm.HS256, secret)
                .compact();*/
        return Jwts.builder()
                .claims(claims)
                .subject("jacob-user")
                .issuedAt(new Date())
                .signWith(Keys.hmacShaKeyFor(secret.getBytes()), Jwts.SIG.HS256)
                .compact();
    }

    /**
     * 刷新令牌有效期
     *
     * @param loginUser 登录信息
     */
    public void refreshToken(LoginUser loginUser) {
        //缓存（token,user）
        redisService.setCacheObject(getTokenKey(loginUser.getToken()), loginUser, expireTime, TimeUnit.MINUTES);

        //缓存（user,token）
        redisService.setCacheObject(getUserTokenKey(loginUser), loginUser.getToken(), expireTime, TimeUnit.MINUTES);

    }

    /**
     * 删除用户身份信息
     */
    public void deleteToken(LoginUser loginUser) {
        if (StringUtils.isNotEmpty(loginUser.getToken())) {
            redisService.deleteObject(getTokenKey(loginUser.getToken()));
            redisService.deleteObject(getUserTokenKey(loginUser));
        }
    }

    /**
     * 删除用户身份信息
     */
    public void deleteUserToken(LoginUser loginUser) {
        if(redisService.hasKey(getUserTokenKey(loginUser))){
            String token = redisService.getCacheObject(getUserTokenKey(loginUser));
            redisService.deleteObject(getTokenKey(token));
            redisService.deleteObject(getUserTokenKey(loginUser));
        }
    }

    private String getTokenKey(String uuid) {
        return CacheConstants.LOGIN_TOKEN_KEY + uuid;
    }

    private String getUserTokenKey(LoginUser loginUser) {
        return CacheConstants.LOGIN_USER_TOKEN_KEY + loginUser.getUserId();
    }


    /**
     * 获取请求中的token
     *
     * @param request
     * @return
     */
    public String getRequestToken(HttpServletRequest request) {
        String token = request.getHeader(header);
        if (StringUtils.isNotEmpty(token) && token.startsWith(Constants.TOKEN_PREFIX)) {
            token = token.replace(Constants.TOKEN_PREFIX, "");
        }
        return token;
    }


    /**
     * 获取用户信息
     *
     * @param token
     * @return
     */
    public LoginUser getUserByToken(String token) {
        if (StringUtils.isEmpty(token)) {
            return null;
        }
        try {
            Claims claims = parseToken(token);
            // 解析对应的权限以及用户信息
            String uuid = claims.get(Constants.LOGIN_USER_KEY, String.class);
            return redisService.getCacheObject(getTokenKey(uuid));
        } catch (Exception e) {
            log.error("验证token失败！{}", e.getMessage());
        }
        return null;
    }


    /**
     * 从令牌中获取数据声明
     *
     * @param token
     * @return
     */
    private Claims parseToken(String token) {
        /*return Jwts.parser()
                .setSigningKey(secret)
                .parseClaimsJws(token)
                .getBody();*/

        return Jwts.parser()
                .verifyWith(Keys.hmacShaKeyFor(secret.getBytes()))
                .build()
                .parseSignedClaims(token)
                .getPayload();
    }


    /**
     *
     * 清除锁定缓存
     * @param username
     */
    public void clearLoginRecordCache(String username){
        if (redisService.hasKey(getPasswordErrorKey(username))) {
            redisService.deleteObject(getPasswordErrorKey(username));
        }
    }

    private String getPasswordErrorKey(String username){
        return CacheConstants.PWD_ERR_CNT_KEY + username;
    }

}
  • 成功通知类CustomizeAuthenticationSuccessHandler
import cn.hutool.extra.servlet.JakartaServletUtil;
import eu.bitwalker.useragentutils.UserAgent;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import org.springframework.stereotype.Component;

import java.io.IOException;

/**
 * 登录成功处理
 */
@Component
public class CustomizeAuthenticationSuccessHandler implements AuthenticationSuccessHandler {

    @Autowired
    private TokenService tokenService;

    @Autowired
    private IUserService userService;

    @Autowired
    private SystemConfig systemConfig;

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        LoginUser loginUser = (LoginUser) authentication.getPrincipal();
        //登录日志
        Thread.ofVirtual().start(()->{
            AsyncFactory.recordLogininfor(loginUser.getUsername(), Constants.LOGIN_SUCCESS, MessageUtils.message("user.login.success"),
                    UserAgent.parseUserAgentString(request.getHeader("User-Agent")), JakartaServletUtil.getClientIP(request));
        });

        //更新登录信息
        User user = loginUser.getUser();
        user.setLoginTime(System.currentTimeMillis());
        userService.updateById(user);

        //单点登录
        if (systemConfig.getOnlyOneLogin()) {
            tokenService.deleteUserToken(loginUser);
        }

        //删除锁定缓存
        tokenService.clearLoginRecordCache(user.getUserName());

        //生成token
        String token = tokenService.createToken(loginUser);
        ResponseUtil.responseToken(response,token);

    }


}

小结

整体内容比较简单，主要用于给新手理一下思路,更快的学习使用。

万琛
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot整合SpringSecurity和JWT（十二）
BushRo
01-16 1681
文章目录JWTJWT的组成头部（Header）载荷（playload）签证（signature）JWT实现认证和授权的原理SpringSecurity整合数据库表引入pom依赖application.yml配置文件添加JWT token的工具类相关方法说明：添加JwtAuthenticationTokenFilter添加SpringSecurity的配置类相关依赖及方法说明自定义的返回结果添加Ad...
Spring Security：限制登录尝试次数示例
一名可爱的技术搬运工
05-25 1160
在本教程中，我们将向您展示如何在Spring Security中限制登录尝试，这意味着，如果用户尝试使用无效密码登录超过3次，系统将锁定该用户，使其无法再次登录。 使用的技术和工具： 春天3.2.8。发布 Spring Security 3.2.3发布 Spring JDBC 3.2.3.RELEASE Eclipse 4.2 JDK 1.6 Maven 3...
SpringBoot——Spring Security 框架
程序猿进阶
11-30 2206
是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的 Bean，充分利用了Spring IoCDI（控制反转DI依赖注入）和AOP（面向切面编程）功能，为应用系统提供声明式的安全访问控制功能，减少了为企业系统安全控制编写大量重复代码的工作。
Spring Boot 3.3 新特性介绍
欢迎拜读我的作品，喜欢的领域请给我留言
08-06 1134
它可以缩短启动时间并减少 Spring Boot 应用程序的内存消耗。类数据共享 (CDS)是一项 JVM 功能，CDS全称为即类数据共享。其主要作用是在多个 JVM之间实现类文件的共享，从而显著减少应用程序启动时 JVM 进行类加载所耗费的时间，同时有效降低内存的占用。我们可以将类数据共享（CDS）视为 Spring Boot 3.3 中最重要的新功能，与CRaC类似，CDS都是JVM提供的功能，但是其减少启动时间和内存占用的机制不同。
springboot前后端分离项目集成Security框架和JWT完成用户校验
fangl1109的博客
07-31 279
Java流行的安全框架有两种Apache Shiro和Spring Security，其中Shiro对于前后端分离项目不是很友好，最终选用了Spring Security。匿名用户访问无权限资源时的异常处理登录用户是否有权限访问资源集成JWT实现登陆授权访问token过期处理自定义用户登陆逻辑Spring Security是一个功能强大且高度可定制的身份验证和访问控制框架。它实际上是保护基于sprin的应用程序的标准。
Springboot入门到精通（超详细文档）
热门推荐
cuiqwei的博客
06-24 29万+
1. Spring Boot是什么 我们知道，从 2002 年开始，Spring 一直在飞速的发展，如今已经成为了在Java EE（Java Enterprise Edition）开发中真正意义上的标准，但是随着技术的发展，Java EE使用 Spring 逐渐变得笨重起来，大量的 XML 文件存在于项目之中。繁琐的配置，整合第三方框架的配置问题，导致了开发和部署效率的降低。 2012 年 10 月，Mike Youngstrom 在 Spring jira 中创建了一个功能请求，要求在 Spring
在Spring Boot中实现OAuth2.0认证
微赚开发者技术分享博客
07-26 611
配置 OAuth2.0 客户端、设置 Spring Security 的 OAuth2.0 配置、创建控制器和视图都是实现这一认证流程的关键步骤。OAuth2.0 是一种用于授权的协议，它使得用户可以授权第三方应用程序访问他们在某服务提供商上的资源，而无需共享他们的凭据。在这个视图中，我们创建了一个登录链接，当用户点击时会重定向到 Google 的登录页面。大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！现在，可以运行 Spring Boot 应用程序，并在浏览器中访问。
Spring Boot 3 + JWT + Security 联手打造安全帝国：一篇文章让你掌握未来！
Innocence_0的博客
03-06 1509
已经成为java后台权限校验的第一选择.今天就通过读代码的方式带大家深入了解一下Security,本文主要是基于开源项目[spring-security)来讲解Spring Security + JWT(Json Web Token).实现用户鉴权,以及权限校验.所有代码基于jdk17+构建.现在让我们开始吧!
Spring Security
qq_43117059的博客
09-27 477
SpringSecurity 采用的是责任链的设计模式，它有一条很长的过滤器链。现在对这条过滤WebAsyncManagerIntegrationFilter：将 Security 上下文与 Spring Web 中用于处理异步请求映射的 WebAsyncManager 进行集成。
spring3.2.8jar
03-24
9. **安全集成**：Spring Security（以前称为Acegi Security）是Spring生态中的安全模块，它提供了全面的身份验证、授权和访问控制功能，可以轻松地保护你的Spring应用。 10. **事务管理**：Spring的声明式事务管理...
PHPBB v3.2.8
11-05
phpBB不仅是受欢迎的自由软件还是个开放源代码的网络论坛系统,使用PHP作为程序语言,并支持如MySQL、 PostgreSQL、MSSQL、Microsoft Access与Oracle等的资料库.
redis-3.2.8
11-06
这个"redis-3.2.8"版本代表了Redis的一个特定稳定发行版，它在3.x系列中提供了许多关键特性。 首先，Redis的核心是它的键值存储模型。在Redis中，数据以键（key）和值（value）的形式存储，键可以是字符串，而值则...
spring 3.2.8 源码文件
02-21
spring3.2.8的源码文件， eclipse使用方法： lib-jar包-右键buildpoath-configbulidpath-librarits-展开jar-source attachment-添加
redis-3.2.8 for centos.zip
01-22
5. **配置Redis**: 配置文件默认位于`src/redis.conf`，根据需求进行修改，例如设置监听端口、密码认证、持久化策略等。 6. **启动Redis**: 使用`src/redis-server /path/to/redis.conf`启动Redis服务。不指定配置...
【Spring Boot】全局异常处理
2401_83045332的博客
08-16 603
在Spring Boot中捕获全局异常是一种有效的方式，可以将应用程序中的所有异常集中处理，提供统一的错误响应，并且可以避免重复编写异常处理逻辑。实现全局异常处理通常使用@ControllerAdvice注解来定义一个全局的异常处理类。在类中编写异常处理方法，并使用@ExceptionHandler注解指定要处理的异常类型。以下是具体的步骤和示例。
Spring Boot实现简单的Oracle数据库操作
beautiful77moon的博客
08-18 441
使用到的技术：1. Spring Boot：用于简化Spring应用的开发。2. Dynamic DataSource：实现动态多数据源的访问和切换3. Oracle JDBC Driver：与Oracle数据库进行连接和交互。4. Mybatis-Plus：简化SQL映射和数据库访问。其中BaseMapper接口提供了对数据表进行基本操作的功能。5. Lombok：用于简化Java类的开发，自动生成常用的代码，比如getter、setter、构造函数等。
(转)怎么下载spring boot
最新发布
cleble的专栏
08-19 396
https://blog.51cto.com/u_16213321/7735255
Spring Boot实战：使用模板方法模式优化数据处理流程
心猿意码
08-19 607
模板方法模式定义了一个操作中的算法骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变一个算法的结构的情况下，重新定义该算法的某些特定步骤。首先，我们需要定义一个抽象类来描述整个处理流程的骨架。java深色版本23 // 模板方法10 }1112 // 抽象方法，由子类实现1416182022}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值