Spring boot Security Jwt

已于 2022-12-26 14:51:20 修改
阅读量1.6k 收藏 3
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 后端框架 文章标签： spring boot java spring
于 2022-05-31 22:50:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/hesqlplus730/article/details/125025354

说明 ： Spring Security 做系统权限的，引入轻松，涵盖各种粒度的权限控制，可以自定义各种处理器，拦截器等.

5.7版本之前，整合Spring Security

引入 security 启动器，默认拦截所有资源，启动项目会生成一个默认密码，账号 user

 <!-- 引入Spring Security -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>

不前后分离，单线开发时 👇

  • 实现 UserDetailsService， 配置 SecurityUser或者返回 security 的User，自定义用户登录逻辑
  • 继承 WebSecurityConfigurerAdapter，定义加密方式，添加自定义拦截器、各种Handler、登录异常、权限不足等…
@Data
@Accessors(chain = true)
public class SecurityUser implements UserDetails {
    private static final long serialVersionUID = -2211380247224432737L;

    private static final String DEFAULT_AUTH="ADMIN";
    private Long userId;
    private String userName;
    private String account;
    private String password;

    /**
     * 用户角色,权限集合
     */
    private List<String> rolesAuthorities;
    /**
     * 是否可用
     */
    private boolean enabled = true;
    /**
     * 是否冻结
     */
    private boolean locked = true;

    /**
     * 设置登录用户信息
     * @param user user 登录用户信息
     * @return SecurityUser
     */
    public SecurityUser setUser(User user,List<String> rolesAuthorities){
        this.userId=user.getId();
        this.userName=user.getUserName();
        this.account=user.getPhone();
        this.password=user.getPassWord();
        this.rolesAuthorities=rolesAuthorities;
        return this;
    }

    /**
     * 登录用户角色
     * @return List<GrantedAuthority>
     */
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        List<GrantedAuthority> authorities = new LinkedList<>();
        if (rolesAuthorities!=null && rolesAuthorities.size()>0){
            for (String role : rolesAuthorities) {
                authorities.add(new SimpleGrantedAuthority(role));
            }
        }else {
            authorities=AuthorityUtils.commaSeparatedStringToAuthorityList(DEFAULT_AUTH);
        }
        return authorities;
    }

    @Override
    public String getPassword() {
        return this.password;
    }
    @Override
    public String getUsername() {
        return this.account;
    }
    @Override
    public boolean isAccountNonExpired() {
        return true;
    }
    @Override
    public boolean isAccountNonLocked() {
        return locked;
    }
    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }
    @Override
    public boolean isEnabled() {
        return enabled;
    }

}

@Service
public class UserDetailServiceImpl implements UserDetailsService {
    @Resource
    UserMapper userMapper;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //username :前面提交登录账号
        User user = userMapper.selectOne(new User().setPhone(username));
        if (user==null){
            throw new UsernameNotFoundException("账号不存在");
        }
        //模拟数据查询用户角色集合,权限集合,角色用ROLE_ 开头
        List<String> rolesAuthorities = Arrays.asList("vip1", "vip2","ROLE_test","ROLE_vip");
        return new SecurityUser().setUser(user,rolesAuthorities);
    }

}

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Resource
    private MyAccessDeniedHandler myAccessDeniedHandler;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        //登录配置 ，如果不前后分离，重新这方法就要配置登录跳转地址了，不然就404
        http.formLogin()
                //自定义：登录接口
                .loginProcessingUrl("/login")
                //定义登录请求参数
                .usernameParameter("username")
                .passwordParameter("password")
                //自定义：登录页面地址
                .loginPage("/toLogin")
                //登录成功跳转地址
                .loginProcessingUrl("/main")
                //登录失败跳转地址
                .failureForwardUrl("/toError");

        //注销配置
        http.logout()
                //注销地址
                .logoutUrl("/logout");
                //退出登录跳转页面
                //.logoutSuccessUrl("/login.html");
                
		//拦截配置
        //http.addFilter();
        
        //授权配置
        http.authorizeRequests()
                //访问 /user 需要权限标识 vip1
                .antMatchers("/user").hasAuthority("vip1")
                //访问 /admin 需要角色 admin
                .antMatchers("/admin").hasAnyRole("admin")
                //添加用户post请求 需要角色 admin
                .regexMatchers(HttpMethod.POST,"/addUser").hasAnyRole("admin")
                //放行静态资源
                .antMatchers("/js/**","/css/**","/images/**").permitAll()
                //放行 option 请求
                .antMatchers(HttpMethod.OPTIONS, "/**").permitAll()
                //放行 /test 所有请求
                .antMatchers("/test/**").permitAll()
                //登录相关请求
                .antMatchers("/login/**").permitAll()
                //之外所有请求需要认证
                .anyRequest().authenticated();

        //自定义异常处理
        http.exceptionHandling()
                //403异常
                .accessDeniedHandler(myAccessDeniedHandler);

        //关闭scrf防护
        // http.csrf().disable();


    }

    /**
     * 配置加密方式
     * @return PasswordEncoder
     */
    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }

}

整合 Jwt，前后分离开发时

  • 配置，登录拦截 LoginFilter extends UsernamePasswordAuthenticationFilter
  • 配置，验证拦截 AuthenticationFilter extends BasicAuthenticationFilter
  • 自定义 异常处理，403 RestAuthenticationAccessDeniedHandler implements AccessDeniedHandler
    ，失效令牌 AuthEntryPoint implements AuthenticationEntryPoint
  • 相当于 token校检、失效丢给 Jwt 处理，接口鉴权，忽略认证等用Security处理

整合代码：

//自定义 403异常
public class RestAuthenticationAccessDeniedHandler implements AccessDeniedHandler {
    public RestAuthenticationAccessDeniedHandler() {}

    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException e) throws IOException, ServletException {
        ResponseUtil.write(response, LoginResult.error("没有权限"));
    }
}

//无效令牌异常
public class AuthEntryPoint implements AuthenticationEntryPoint {

    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException e){
        ResponseUtil.write(response, LoginResult.error("令牌无效"));
    }

}

//配置类
@Data
@Component
@ConfigurationProperties(prefix = "security")
public class SecurityProperties {
    /**
     * 忽略拦截路径
     */
    private List<String> httpIgnore;
    /**
     * 请求头名称
     */
    private String tokenHeader;
    /**
     * 请求头前缀
     */
    private String tokenPrefix;
    /**
     * 令牌加密密匙
     */
    private String secret;
    /**
     * 失效时间 /分钟 - 默认1小时
     */
    private Long expiration;

}

//token生成工具
@Component
public class JwtTokenUtil {

    @Resource
    private SecurityProperties securityProperties;

    public JwtTokenUtil() {}

    /**
     * token生成
     * @param user
     * @return
     */
    public String createToken(SecurityUser user) {
        String secret = this.securityProperties.getSecret();
        if (secret==null){
            secret="secret";
        }
        Long expiration = this.securityProperties.getExpiration();
        if (expiration==null){
            expiration=60L;
        }
        long time = expiration * 60L;
        HashMap<String, Object> map = new HashMap<>(1);
        map.put("user", user);
        return Jwts.builder()
                .setClaims(map)
                .setSubject(user.getUsername())
                .setExpiration(new Date(System.currentTimeMillis() + time * 1000L))
                .signWith(SignatureAlgorithm.HS512, secret).compact();
    }

    public String getUserName(String token) {
        return this.generateToken(token).getSubject();
    }

    private Claims generateToken(String token) {
        String secret = this.securityProperties.getSecret();
        if (secret==null){
            secret="secret";
        }
        return Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
    }

    public SecurityUser getSecurityUser(String token){
        Claims claims = this.generateToken(token);
        Map map = claims.get("user", Map.class);
        return JSON.parseObject(JSON.toJSONString(map), SecurityUser.class);
    }

}

//登录拦截
public class JwtLoginFilter extends UsernamePasswordAuthenticationFilter {

    private static final String REQUEST_METHOD="POST";
    private static final String DATA_FORMAT="json";

    @Resource
    private JwtTokenUtil jwtTokenUtil;
    @Resource
    private SecurityProperties securityProperties;

    public JwtLoginFilter(AuthenticationManager authenticationManager) {
        super.setAuthenticationManager(authenticationManager);
    }


    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
        if (!REQUEST_METHOD.equals(request.getMethod())) {
            throw new AuthenticationServiceException("Authentication method not supported: " + request.getMethod());
        } else {
            String contentType = request.getHeader("Content-Type");
            SecurityUser user = null;
            //json提交
            if (contentType.contains(DATA_FORMAT)) {
                user = this.getSecurityUser(request);
                if (user == null || user.getUsername() == null || user.getPassword() == null) {
                    throw new AuthenticationServiceException("Authentication failure: username or password can't be null.");
                }
                logger.info("账号登录："+user.getUsername());
            } else {
                //表单提交
                String username = this.obtainUsername(request);
                String password = this.obtainPassword(request);
                if (username == null || password == null) {
                    throw new AuthenticationServiceException("Authentication failure: username or password can't be null.");
                }
                logger.info("账号登录："+username);
                user = (new SecurityUser()).setUsername(username.trim()).setPassword(password);
            }
            request.setAttribute("account",user.getUsername());
            return this.getAuthenticationManager().authenticate(new UsernamePasswordAuthenticationToken(user.getUsername(), user.getPassword(), new ArrayList()));
        }
    }

    @Override
    protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException {
        SecurityUser user = (SecurityUser)authResult.getPrincipal();
        user.setPassword("");
        String token = this.jwtTokenUtil.createToken(user);
        String tokenPrefix = this.securityProperties.getTokenPrefix();
        if (!StringUtils.hasLength(tokenPrefix)){
            tokenPrefix="Bearer";
        }
        String tokenHeader = this.securityProperties.getTokenHeader();
        if (!StringUtils.hasLength(tokenHeader)){
            tokenHeader="Authorization";
        }
        response.addHeader(tokenHeader, tokenPrefix + token);
        logger.info("登录成功,用户: "+user.getUsername());
        ResponseUtil.write(response, LoginResult.login(tokenPrefix + token));
    }

    //对应 ->JwtUserDetailsServiceImpl loadUserByUsername()
    @Override
    protected void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response, AuthenticationException failed) throws IOException, ServletException {
        String msg;
        String account = (String)request.getAttribute("account");
        if (failed instanceof UsernameNotFoundException) {
            msg="账号不存在";
        }else if ( failed instanceof BadCredentialsException){
            msg="密码输入错误";
        }else if (failed instanceof DisabledException) {
            msg="用户账号已被禁用";
        } else if (failed instanceof LockedException) {
            msg="抱歉您的账户已被锁定";
        } else if (failed instanceof AccountExpiredException) {
            msg="账户过期";
        }  else {
            msg="登录失败";
        }
        logger.info("登录失败,账号: "+account);
        ResponseUtil.write(response, LoginResult.error(msg));
    }


    private SecurityUser getSecurityUser(HttpServletRequest request) {
        StringBuilder sb = new StringBuilder();
        try {
            InputStream is = request.getInputStream();
            InputStreamReader isr = new InputStreamReader(is);
            BufferedReader br = new BufferedReader(isr);
            String s = "";
            while((s = br.readLine()) != null) {
                sb.append(s);
            }
            return JSON.parseObject(sb.toString(), SecurityUser.class);
        } catch (IOException var7) {
            return null;
        }
    }

}

//鉴权拦截
@Slf4j
public class JwtAuthenticationFilter extends BasicAuthenticationFilter {

    @Resource
    private JwtTokenUtil jwtTokenUtil;

    @Resource
    private SecurityProperties securityProperties;

    public static final List<String> HTTP_IGNORE = new LinkedList<>(Arrays.asList("/doc.html", "/swagger-resources", "/v3/api-docs/**", "/webjars/**","/logout"));

    public JwtAuthenticationFilter(AuthenticationManager authenticationManager) {
        super(authenticationManager);
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        //忽略拦截路径放行
        if (this.ignore(request)) {
            chain.doFilter(request, response);
        } else {
            String tokenHeader = this.securityProperties.getTokenHeader();
            if (!StringUtils.hasLength(tokenHeader)){
                tokenHeader="Authorization";
            }
            //请求头获取
            String header = request.getHeader(tokenHeader);
            //前缀匹配
            String tokenPrefix = this.securityProperties.getTokenPrefix();
            if (!StringUtils.hasLength(tokenPrefix)){
                tokenPrefix="Bearer";
            }
            if (header != null && header.startsWith(tokenPrefix)) {
                UsernamePasswordAuthenticationToken authenticationToken = null;
                try {
                    authenticationToken = this.getAuthentication(header);
                } catch (Exception e) {
                    ResponseUtil.write(response,LoginResult.error("非法token"));
                    return;
                }
                SecurityContextHolder.getContext().setAuthentication(authenticationToken);
                chain.doFilter(request, response);
            } else {
                ResponseUtil.write(response, LoginResult.error("无效令牌"));
            }
        }
    }

    /**
     * 这里从token中获取用户信息并新建一个token
     */
    private UsernamePasswordAuthenticationToken getAuthentication(String header) {
        String tokenPrefix = this.securityProperties.getTokenPrefix();
        if (!StringUtils.hasLength(tokenPrefix)){
            tokenPrefix="Bearer";
        }
        String token = header.replace(tokenPrefix, "");
        String principal = this.jwtTokenUtil.getUserName(token);
        if (principal != null) {
            SecurityUser user = this.jwtTokenUtil.getSecurityUser(token);
            return new UsernamePasswordAuthenticationToken(user, null, user.getAuthorities());
        } else {
            return null;
        }
    }

    /**
     * 校检是否忽略路径,默认放行路径 /logOut
     * @param request request
     * @return boolean
     */
    private boolean ignore(HttpServletRequest request) {
        for (String ignore : HTTP_IGNORE) {
            if (new AntPathRequestMatcher(ignore).matches(request)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 初始化忽略认证
     */
    @PostConstruct
    public void initIgnore(){
        List<String> curIgnore = securityProperties.getHttpIgnore();
        HTTP_IGNORE.addAll(curIgnore);
    }
}

//自定义密码解析
public class MD5PasswordEncoder implements PasswordEncoder {
    //TODO 加盐
    private static String salt="xiaoshu@730!@#$/";
    @Override
    public String encode(CharSequence charSequence) {
        return DigestUtils.md5Hex(charSequence +salt);
    }

    @Override
    public boolean matches(CharSequence charSequence, String s) {
        String s1 = DigestUtils.md5Hex(charSequence +salt);
        return s1.equals(s);
    }
}

//配置类
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Resource
    private UserDetailsService loginUserDetailsService;

    @Resource
    private SecurityProperties properties;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        //拦截配置
        //登录拦截
        http.addFilter(this.jwtLoginFilter())
                //认证拦截
                .addFilter(this.jwtAuthenticationFilter())
                .exceptionHandling()
                //自定义403
                .accessDeniedHandler(new RestAuthenticationAccessDeniedHandler())
                //自定义令牌失效
                .authenticationEntryPoint(new AuthEntryPoint());

        //默认放行配置
        http.authorizeRequests().antMatchers(HttpMethod.GET,"/js/**","/css/**","/images/**").permitAll()
        .antMatchers("/doc.html", "/swagger-resources", "/v3/api-docs/**", "/webjars/**","/logout").permitAll()
        .antMatchers(HttpMethod.OPTIONS,"/**").permitAll()

        //项目放行配置
        .antMatchers(properties.getHttpIgnore().toArray(new String[]{})).permitAll().anyRequest().authenticated();

        //关闭csrf
        http.csrf().disable();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) {
        auth.authenticationProvider(this.authenticationProvider());
    }

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

    @Bean
    public JwtLoginFilter jwtLoginFilter() throws Exception {
        return new JwtLoginFilter(authenticationManager());
    }

    @Bean
    public JwtAuthenticationFilter jwtAuthenticationFilter() throws Exception {
        return new JwtAuthenticationFilter(authenticationManager());
    }

    @Bean
    public DaoAuthenticationProvider authenticationProvider() {
        DaoAuthenticationProvider provider = new DaoAuthenticationProvider();
        provider.setHideUserNotFoundExceptions(false);
        provider.setUserDetailsService(loginUserDetailsService);
        provider.setPasswordEncoder(new MD5PasswordEncoder());
        return provider;
    }

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

}

/**
 * 自定义登录逻辑
 */
@Service
public class UserDetailServiceImpl implements UserDetailsService {
    @Autowired
    private PasswordEncoder passwordEncoder;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        if (!username.equals("admin")){
            throw  new UsernameNotFoundException("用户不存在");
        }
        String password = passwordEncoder.encode("123");
        return new SecurityUser().setUsername(username).setPassword(password).setRoles(Arrays.asList("ROLE_admin,","ROLE_vip","menu_del","auth"));
    }

}

5.7 版本整合，待整理…

springboot整合security与jwt
08-05
springboot2.0整合security与jwt， 还整合了redis,与swagger-ui
SpringBoot2.7.X整合SpringSecurity+JWT（入门级简单易懂）
zyyxiaoxiao的博客
04-12 6206
SpringBoot2.7.9整合SpringSecurity+JWT、入门级简单易懂
Spring Boot 和 Spring Security 实现 JWT 认证
最新发布
weixin_43833540的博客
06-16 1841
在 Spring Security 中，UsernamePasswordAuthenticationToken 的 authorities 参数用于注入当前用户的​​权限集合​​（Collection<?JWT 是一种开放标准（RFC 7519），用于在网络应用间安全传递 JSON 格式的声明信息。JWT 在微服务、跨域单点登录（SSO）场景中优势显著。JWT 由三部分组成，以点号。
Springboot+Security+Jwt
热门推荐
点点的博客
12-13 1万+
工程目录 文章目录 工程目录 前言 一、Security是什么？ 二、使用步骤 1.引入pom.xml文件 2.application.yml文件 。。。。。。 总结:代码足够详细，有耐心的可以看，没耐心的浪费时间！ 前言 随着业务的发展，传统的不分离前后端的Java项目逐渐减少，更多的时候是做到前后端分离，会话管理也就从传统的Session会话管理变为Jwt管理会话，本篇文章就是SpringBoot使用Jwt管理会话同时整合Security，完成权限操作。
SpringBoot 集成 SpringSecurity+JWT
asksl的博客
11-29 4643
SpringBoot 集成 SpringSecurity+JWT
Springboot集成Security和JWT
qq1016499728博客
11-28 1460
Springboot版本2.3.3 pom依赖 <!--security+JWT--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <dependency> <gro
12 spring boot Security Jwt 前后端分离跨域登录
06-02
标题 "12 spring boot Security Jwt 前后端分离跨域登录" 提示我们这个项目是关于使用Spring Boot Security和JWT（JSON Web Tokens）技术来实现一个前后端分离的跨域登录系统。在这个系统中，Spring Boot作为后端...
rest-security-demo：基于Spring BootSpring SecurityJWT的REST服务安全认证
01-29
基于Spring Boot / Spring Security / JWT的REST服务安全认证 项目介绍 预备知识 认证流程 运行演示 获取令牌 测试账号：user/123456 接口地址：http://localhost:8080/auth/ 访问需要认证的接口 接口地址：...
spring-admin-vue:Spring Boot Security Jwt vue.js管理员权限管理模板集成
05-13
spring boot security jwt 整合 vue-admin-template 2.0 项目模板，权限控制到按钮！ 首先感谢 的 vue-admin-template 模板， 我是一名java程序员，所以前端的技术不怎么样。vue.js也只是会用一点，非常感谢 的模板...
SpringBoot2.7整合SpringSecurity+Jwt+Redis+MySQL+MyBatis完整项目代码
10-30
在本项目中，我们主要关注的是SpringBoot 2.7版本与多个技术的深度整合，包括Spring Security、JWT（JSON Web Token）、Redis缓存以及MySQL数据库，并利用MyBatis作为持久层框架。以下是对这些技术及其整合应用的...
spring boot security jwt
09-27
Spring Boot Security与JWT（JSON Web Token）的整合是一种常见的身份验证和授权机制。通过引入Spring Security和Jwt相关依赖，可以轻松地实现基于Token的用户身份验证和授权。 整合Jwt的配置一般包括以下几个方面...
SpringSecurity&JWT(Springboot)
weixin_50601779的博客
03-20 4980
springboot整合安全框架SpringSecurity&JWT
SpringBoot中使用SpringSecurity+JWT
qq_42757083的博客
04-05 766
一、JWT 前提知识 1.1. 对称加密，非对称加密，加盐。 1.2. 报文鉴别，数字签名，身份认证等数据安全。 1.3. jwt介绍 JWT的作用 2.1. 就是把签证解密之后与头部和载荷对应，从而确认身份。 二、SpringSecurity 前提知识 1.1. 了解是什么，知道自定义登陆等 三、实践 添加依赖 <!-- springSecurity依赖：安全框架--> <dependency>
SpringBoot集成SpringSecurity实现Jwt认证
_TMOON_的博客
02-28 327
SpringBoot集成SpringSecurity实现Jwt认证 SpringBoot集成SpringSecurity实现Jwt认证
详细！SpringBoot整合SpringSecurity实现JWT认证
MarkerHub的博客
01-02 1311
小Hub领读：最近做了个security项目，参考了一下这个例子，还可以作者：智慧zhuhuixhttps://blog.youkuaiyun.com/jpgzhu/article/details/...
SpringBoot整合SpringSecurity实现JWT认证
Java笔记虾
01-04 8050
作者：智慧zhuhuixblog.youkuaiyun.com/jpgzhu/article/details/105200598前言微服务架构，前后端分离目前已成为互联网项目开发的业界标准，其核心思...
springboot+security+jwt
yuzheh521的博客
02-04 508
1.创建项目 2.项目创建成功以后，如何查看security已经在项目中生效呢？ 启动项目，并在打开浏览器，输入：http://localhost:8080/login 就会出现security默认的登陆页面 用户名是user，密码在我们的控制台已经输出 ...
SpringBoot 集成SpringSecurity JWT
li123128的博客
08-19 345
Spring Security 是Spring提供的安全框架。提供认证、授权和常见的攻击防护的功能。功能丰富和强大。 Spring Security is a powerful and highly customizable authentication and access-control framework. It is the de-facto standard for securing Spring-based applications. 1.2 OAuth2 OAuth（Open Aut
使用JWT保护你的Spring Boot应用 - Spring Security实战
秋夜无霜
03-03 500
关键词 Spring Boot、OAuth 2.0、JWT、Spring Security、SSO、UAA 写在前面 最近安静下来，重新学习一些东西，最近一年几乎没写过代码。整天疲于奔命的日子终于结束了。坐下来，弄杯咖啡，思考一些问题，挺好。这几天有人问我Spring Boot结合Spring Security实现OAuth认证的问题，写了个Demo，顺便分享下。Spring 2之后就没再用过Ja...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值