Springboot+SpringSecurity 权限管理笔记

最新推荐文章于 2024-05-22 16:49:19 发布
最新推荐文章于 2024-05-22 16:49:19 发布
阅读量3.1k 收藏 12
点赞数 2
分类专栏： Springsecurity 权限管理框架笔记 文章标签： mysql 数据库 database
本文为CSDN博主「王林」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
本文链接：https://blog.csdn.net/qq_45912025/article/details/123232800
版权

Springboot+SpringSecurity 权限管理笔记

一、导入Springsecurity 依赖

   <!--security 权限框架-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>

二、配置白名单路径

（一）在 application.yml 中配置放行的路径

application.yml

secure:
  ignored:
    urls: #安全路径白名单
      - /swagger-ui.html
      - /swagger-ui/**
      - /swagger-resources/**
      - /swagger/**
      - /v3/**
      - /**/*.js
      - /**/*.css
      - /**/*.png
      - /**/*.ico
      - /webjars/**
      - /actuator/**
      - /druid/**
      - /**/common/**
      - /common/**

（二）IgnoreUrlsConfig 类——获取放行路径

IgnoreUrlsConfig

package com.cloud.wl.hp.config.security;

import lombok.Getter;
import lombok.Setter;
import org.springframework.boot.context.properties.ConfigurationProperties;

import java.util.ArrayList;
import java.util.List;

/**
 * SpringSecurity白名单资源路径配置
 *
 * @author wanglin
 * @version 1.0
 * @date 2022-02-28 周一
 */
@Getter
@Setter
@ConfigurationProperties(prefix = "secure.ignored")
public class IgnoreUrlsConfig {
    private List<String> urls = new ArrayList<>();
}

三、编写 SecurityConfig 配置类

（一）SecurityConfig 配置类

package com.cloud.wl.hp.config.security;

import com.cloud.wl.hp.config.component.JwtAccessDeniedHandler;
import com.cloud.wl.hp.config.component.JwtAuthenticationEntryPoint;
import com.cloud.wl.hp.config.component.JwtAuthenticationTokenFilter;
import com.cloud.wl.hp.config.model.LoginUserDetails;
import com.cloud.wl.hp.domain.SysUser;
import com.cloud.wl.hp.service.CommonService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
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.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.annotation.web.configurers.ExpressionUrlAuthorizationConfigurer;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
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.HashSet;
import java.util.Objects;
import java.util.Set;

/**
 * 对SpringSecurity配置类的扩展，支持自定义白名单资源路径和查询用户逻辑
 *
 * @author wanglin
 * @version 1.0
 * @date 2022-01-14 周五
 * @description
 */
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private CommonService commonService;

    @Autowired
    private JwtAccessDeniedHandler jwtAccessDeniedHandler;

    @Autowired
    private JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;

    @Override
    @Bean
    public UserDetailsService userDetailsService() {
        return username -> {
            SysUser user = commonService.getLoginUserInfo(username);
            Set<SimpleGrantedAuthority> authorities = new HashSet<>();
            authorities.add(new SimpleGrantedAuthority("admin"));
            LoginUserDetails userDetails = new LoginUserDetails(user, authorities);

            if (Objects.nonNull(user)) {
                return userDetails;
            }
            return null;
        };
    }

    @Bean
    public BCryptPasswordEncoder bCryptPasswordEncoder() {
        // 密码加密方式
        return new BCryptPasswordEncoder();
    }

    @Bean
    public JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter() {
        return new JwtAuthenticationTokenFilter();
    }

    /**
     * 实现自己的登录逻辑
     *
     * @param auth
     * @throws Exception
     */
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService()).passwordEncoder(bCryptPasswordEncoder());
    }

    //方式二：
//    @Override
//    public void configure(WebSecurity web) {
        放行静态资源
//        web.ignoring()
//                .antMatchers(HttpMethod.GET,
//                        "/swagger-resources/**",
//                        "/common/**",
//                        "/component/**",
//                        "/**/*.html",
//                        "/**/*.css",
//                        "/**/*.js",
//                        "/swagger-ui.html",
//                        "/webjars/**",
//                        "/v3/**",
//                        "/swagger/**");
//    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        ExpressionUrlAuthorizationConfigurer<HttpSecurity>.ExpressionInterceptUrlRegistry registry = http.authorizeRequests();
        // 不需要保护的资源路径允许访问
        for (String url : ignoreUrlsConfig().getUrls()) {
            registry.antMatchers(url).permitAll();
        }

        registry.and()
//        http
                // 禁用 CSRF
                .csrf().disable()
//                .addFilterBefore(corsFilter, UsernamePasswordAuthenticationFilter.class)
                .authorizeRequests()
                // 允许跨域的OPTIONS请求
                .antMatchers(HttpMethod.OPTIONS).permitAll()
                // 放行登录、注册等
//                .antMatchers("/**/common/**").permitAll()
//                .antMatchers("/**/user/page").hasAnyAuthority("admin","user")
                // 自定义匿名访问所有url放行 ： 允许匿名和带权限以及登录用户访问
//                .antMatchers(anonymousUrls.toArray(new String[0])).permitAll()
                // 其他任何请求都需要身份认证
                .anyRequest().authenticated()
                .and()
//                .addFilter(new JwtAuthenticationFilter(authenticationManager()))
//                .addFilter(new JwtAuthorizationFilter(authenticationManager()))
                // 不需要session,不创建会话
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .addFilterBefore(jwtAuthenticationTokenFilter(), UsernamePasswordAuthenticationFilter.class)
                // 添加自定义未授权和未登录返回结果
                .exceptionHandling()
                .accessDeniedHandler(jwtAccessDeniedHandler)
                .authenticationEntryPoint(jwtAuthenticationEntryPoint)
                // 防止iframe 造成跨域
                .and()
                .headers()
                .frameOptions()
                .disable();
    }

    @Bean
    public IgnoreUrlsConfig ignoreUrlsConfig() {
        return new IgnoreUrlsConfig();
    }

    @Bean
    CorsConfigurationSource corsConfigurationSource() {
        final UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", new CorsConfiguration().applyPermitDefaultValues());
        return source;
    }
}

四、自定义JWT登录授权过滤器

（一）JwtAuthenticationTokenFilter 配置类

package com.cloud.wl.hp.config.component;

import com.cloud.wl.hp.base.utils.JwtTokenUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Objects;

/**
 * jwt 登录授权过滤器
 *
 * @author wanglin
 * @version 1.0
 * @date 2022-03-02 周三
 */
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {

    @Value("${jwt.tokenHeader}")
    private String tokenHeader;

    @Value("${jwt.tokenHead}")
    private String tokenHead;

    @Autowired
    private JwtTokenUtil jwtTokenUtil;

    @Autowired
    private UserDetailsService userDetailsService;

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


        String authHeader = request.getHeader(tokenHeader);
        //存在token
        String authToken = authHeader;
        if (StringUtils.isNotBlank(authHeader)) {
            //判断token是否是以 'Bearer ' 开头
            if (authHeader.startsWith(tokenHead)) {
                //截取'Bearer ' 后面的token
                authToken = authHeader.substring(tokenHead.length());
            }
            String username = jwtTokenUtil.getUserNameFromToken(authToken);
            //token 存在用户名，但未登录
            if (StringUtils.isNotBlank(username) && Objects.isNull(SecurityContextHolder.getContext().getAuthentication())) {
                //登录
                UserDetails userDetails = userDetailsService.loadUserByUsername(username);
                //验证token是否有效，重新设置用户对象
                if (jwtTokenUtil.validateToken(authToken, userDetails)) {
                    UsernamePasswordAuthenticationToken authenticationToken =
                            new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                    authenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                    SecurityContextHolder.getContext().setAuthentication(authenticationToken);
                }
            }
        }
        filterChain.doFilter(request, response);
    }
}

LoginUserDetails 类

五、自定义未授权和未登录返回结果

（一）自定义未授权返回类

JwtAccessDeniedHandler 类

package com.cloud.wl.hp.config.component;

import com.cloud.wl.hp.config.utils.SecurityUtils;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * 没有访问权限
 *
 * @author wanglin
 * @version 1.0
 * @date 2022-02-28 周一
 */
@Component
public class JwtAccessDeniedHandler implements AccessDeniedHandler {
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException e) throws IOException {
        SecurityUtils.resultFailMsg(response, HttpServletResponse.SC_FORBIDDEN, "权限不足，请联系管理员！", e.getMessage());
    }
}

（二）未登录返回类

JwtAuthenticationEntryPoint 类

package com.cloud.wl.hp.config.component;

import com.cloud.wl.hp.config.utils.SecurityUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * 当为登录或者token无效时访问接口，自定义返回结果
 *
 * @author wanglin
 * @version 1.0
 * @date 2022-02-28 周一
 */
@Slf4j
@Component
public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request,
                         HttpServletResponse response,
                         AuthenticationException authException) throws IOException {
        SecurityUtils.resultFailMsg(response, HttpServletResponse.SC_UNAUTHORIZED, "未登录，请登录！", authException.getMessage());

    }
}

（三）SecurityUtils 工具类

package com.cloud.wl.hp.config.utils;

import com.cloud.wl.hp.base.common.mapper.JsonMapperUtil;
import com.cloud.wl.hp.base.dto.RestResultDTO;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * @author wanglin
 * @version 1.0
 * @date 2022-01-19 周三
 */
public class SecurityUtils {

    /**
     * security 统一返回信息处理
     *
     * @param response
     * @param code
     * @param msg
     * @throws IOException
     */
    public static void resultSuccessMsg(HttpServletResponse response, Integer code, Object data, String msg) throws IOException {
        response.setHeader("Access-Control-Allow-Origin", "*");
        response.setHeader("Cache-Control", "no-cache");

        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json; charset=utf-8");
        response.setStatus(code);
        RestResultDTO result = new RestResultDTO<>(code, msg, data, null);
        response.getWriter().write(JsonMapperUtil.toJson(result));
        response.getWriter().flush();
    }

    /**
     * security 统一返回信息处理
     *
     * @param response
     * @param code
     * @param msg
     * @param exceptionMsg
     * @throws IOException
     */
    public static void resultFailMsg(HttpServletResponse response, Integer code, String msg, String exceptionMsg) throws IOException {
        response.setHeader("Access-Control-Allow-Origin", "*");
        response.setHeader("Cache-Control", "no-cache");

        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json; charset=utf-8");
        response.setStatus(code);
        RestResultDTO result = new RestResultDTO<>(code, msg, null, exceptionMsg);
        response.getWriter().write(JsonMapperUtil.toJson(result));
        response.getWriter().flush();
    }

    /**
     * security 统一返回信息处理
     *
     * @param response
     * @param code
     * @param msg
     * @throws IOException
     */
    public static void resultFailMsg(HttpServletResponse response, Integer code, String msg) throws IOException {
        response.setHeader("Access-Control-Allow-Origin", "*");
        response.setHeader("Cache-Control", "no-cache");

        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json; charset=utf-8");
        response.setStatus(code);
        RestResultDTO result = new RestResultDTO<>(code, msg, null, null);
        response.getWriter().write(JsonMapperUtil.toJson(result));
        response.getWriter().flush();
    }

    /**
     * security 统一返回信息处理
     *
     * @param response
     * @param msg
     * @throws IOException
     */
    public static void resultFailMsg(HttpServletResponse response, String msg) throws IOException {
        response.setHeader("Access-Control-Allow-Origin", "*");
        response.setHeader("Cache-Control", "no-cache");

        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json; charset=utf-8");
        RestResultDTO result = new RestResultDTO<>(0, msg, null, null);
        response.getWriter().write(JsonMapperUtil.toJson(result));
        response.getWriter().flush();
    }
}

六、自定义登录类 LoginUserDetails

（一）LoginUserDetails类——实现UserDetails类

LoginUserDetails 类

package com.cloud.wl.hp.config.model;

import com.cloud.wl.hp.domain.SysUser;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

import java.util.Collection;
import java.util.Set;

/**
 * @author wanglin
 * @version 1.0
 * @date 2022-02-28 周一
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class LoginUserDetails implements UserDetails {

    @Autowired
    private BCryptPasswordEncoder bCryptPasswordEncoder;

    private String username;
    private String password;
    //实现类 SimpleGrantedAuthority
//    private Collection<? extends GrantedAuthority> authorities;
    private Set<SimpleGrantedAuthority> authorities;
    //只要有一个为false，就不可用用
    private Boolean isAccountNonExpired;
    private Boolean isAccountNonLocked;
    private Boolean isCredentialsNonExpired;
    private Boolean isEnabled;

    public LoginUserDetails(SysUser user, Set<SimpleGrantedAuthority> authorities) {
        this.username = user.getUserId();
        this.password = user.getPassword();
//        this.password = bCryptPasswordEncoder.encode(user.getPassword());
//        this.authorities = Collections.singleton(new SimpleGrantedAuthority(user.getRoleType()));
        this.authorities = authorities;
        this.isEnabled = user.getIsEnabled();
        this.isAccountNonExpired = user.getIsAccountNonExpired();
        this.isAccountNonLocked = user.getIsAccountNonLocked();
        this.isCredentialsNonExpired = user.getIsCredentialsNonExpired();
    }

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

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

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

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

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

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

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

（二）SysUser类

SysUser类

package com.cloud.wl.hp.domain;

import com.baomidou.mybatisplus.annotation.TableName;
import com.cloud.wl.hp.base.model.AbstractBaseDeleteSecurityModel;
import com.cloud.wl.hp.support.utils.Constants;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.hibernate.annotations.Table;

import javax.persistence.Column;
import javax.persistence.Entity;

/**
 * @author wanglin
 * @version 1.0
 * @date 2022-01-04 周二
 */
@Data
@EqualsAndHashCode(callSuper = true)
@Entity(name = SysUser.TABLE_NAME)
@Table(appliesTo = SysUser.TABLE_NAME, comment = "用户表")
@TableName(value = SysUser.TABLE_NAME)
public class SysUser extends AbstractBaseDeleteSecurityModel {
    public static final String TABLE_NAME = Constants.TABLE_PREFIX + "sys_user";

    @Column(columnDefinition = "varchar(32) comment '用户账号'", nullable = false)
    private String userId;
    @Column(columnDefinition = "varchar(50) comment '用户类型，参见RoleType枚举：admin,user'", nullable = false)
    private String roleType;
    @Column(columnDefinition = "varchar(20) comment '姓名'", nullable = false)
    private String name;
    @Column(columnDefinition = "varchar(20) comment '昵称'")
    private String nickname;
    @Column(columnDefinition = "varchar(20) comment '身份证号'")
    private String idNo;
    @Column(columnDefinition = "varchar(5) comment '性别'")
    private String sex;
    @Column(columnDefinition = "varchar(20) comment '手机号'")
    private String mobileNo;
    @Column(columnDefinition = "varchar(64) comment '密码'", nullable = false)
    private String password;
    @Column(columnDefinition = "varchar(30) comment '邮箱'")
    private String email;
    @Column(columnDefinition = "varchar(300) comment '登录凭证'")
    private String loginToken;
    @Column(columnDefinition = "int(1) not null default 0 comment '状态,0:正常 ；1:禁用'")
    private Integer status;
    @Column(columnDefinition = "bit not null default 1 comment '是否首次登录'")
    private Boolean isFirstLogin;
    @Column(columnDefinition = "varchar(200) comment '头像'")
    private String icon;
    @Column(columnDefinition = "bit not null default 0 comment '是否为VIP'")
    private Boolean isVip;

    @Column(columnDefinition = "varchar(200) comment '备注信息'")
    private String note;
}

关注林哥，持续更新哦！！！★,°:.☆(￣▽￣)/$:.°★ 。

王林-wlin
关注
  • 2
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Springboot+SpringSecurity内存账户管理
Rmx的技术小站
09-23 180
内存用户管理 第一种application配置方式 spring.security.user.name=账号 spring.security.user.password=密码 spring.security.user.roles=角色(USER,ADMIN) 此方法只用于修改初始化默认账号，无法进行多账号的添加管理 第二种常见配置管理 import org.springframework.beans.factory.annotation.Autowired; import org.springframe
SpringBoot+SpringSecurity+SpringSession
dsghre的专栏
12-02 780
在一次的web项目开发中，初期用了公司的负载均衡，后台2台服务器，用了会话保持，所以在用户登录后没有问题。后来更换了域名和主体，没法实现会话保持，改成了springsession，记录下来操作。 一、加入依赖 <dependency> <groupId>org.springframework.session</groupId> <artifactId&...
芋道前后端分离项目跳过登录
FanZaiYo的博客
10-27 1258
在此页面中可以看到当在没有获取到token时，如果此页面在白名单中则直接进入，所以我们将刚刚配置在。在此路径下配置需要跳过登录的页面路径，记住path中编辑的名称。根据以上两图可以发现芋道的。将所有需要跳过登录的方法。，否则会提示登录状态过期。至此完成免登录进入页面。
011-若依pro(ruoyi-vue-pro)的功能权限RBAC学习
RichardHLee的博客
09-05 1459
AuthorizeRequestsCustomizer的实现比如各个module里的XxxSecurityConfiguration的配置的bean, return new AuthorizeRequestsCustomizer(), 重写customize方法可以看cn.iocoder.yudao.module.infra.framework.security.config.SecurityConfiguration#authorizeRequestsCustomizer方法@Override。
springboot整合security实现权限控制
最新发布
Amour恋空的博客
05-22 1224
Spring Security 的前身是 Acegi Security ，是。Spring Security 为基于J2EE企业应用软件提供了全面安全服务。特别是使用领先的J2EE解决方案-Spring框架开发的企业软件项目。人们使用Spring Security有很多种原因，不过通常吸引他们的是在J2EE Servlet规范或EJB规范中找不到典型企业应用场景的解决方案。特别要指出的是他们不能再WAR 或 EAR 级别进行移植。
SpringSecurity结合电商项目
渔阳的博客
08-15 229
pom 前台部分 公共配置类 白名单绑定类 没有权限访问时的响应处理类 未登录处理类 JWT类 配置UserDetailsSerrvice 启动注解（具体子类模块中 代码） @EnableWebSecurity 登录方法
如何使用Spring Security控制会话
allway2的博客
11-18 3259
并发会话控制功能用于维护活动会话列表以及关联的经过身份验证的用户的信息。我们在本文前面配置了 Spring 安全性使用此事件发布来发布会话生命周期中的事件，并且相应地更新了 SessionRegistry。每次登录的客户尝试访问应用程序的安全部分时，都会检查用户的活动会话。以下是安全性中可用的选项，可以帮助我们配置和控制会话创建。会话超时后，如果他们提交具有无效会话 ID 的请求，我们可以将使用重定向到特定页面。在本文中，我们讨论了 Spring 安全会话管理以及如何使用 Spring 安全性控制会话。
厉害，我带的实习生仅用四步就整合好SpringSecurity+JWT实现登录认证
热门推荐
沉默王二
04-07 2万+
小二是新来的实习生，作为技术 leader，我还是很负责任的，有什么锅都想甩给他，啊，不，一不小心怎么把心里话全说出来了呢？重来！ 小二是新来的实习生，作为技术 leader，我还是很负责任的，有什么好事都想着他，这不，我就安排了一个整合SpringSecurity+JWT实现登录认证的小任务交，没想到，他仅用四步就搞定了，这让我感觉倍有面。 一、关于 SpringSecurity 在 Spring Boot 出现之前，SpringSecurity 的使用场景是被另外一个安全管理框架 Shiro 牢牢霸占
手把手教你如何使用Spring Security（下）：访问控制
技术分享，读书笔记，面试宝典，算法积累，应有尽有～
05-12 2367
Spring Security是一个功能强大且高度可定制的身份认证和访问控制框架，它是保护基于spring应用程序的事实标准。本篇就来说说使用Spring Security进行请求的访问控制。
springboot+springsecurity入门
12-06
SpringBoot简化了Spring应用的初始搭建以及开发过程，而SpringSecurity则为应用提供了全面的安全管理解决方案。 SpringBoot是Spring框架的扩展，旨在简化Spring应用的初始设置和配置。它通过提供预配置的starter ...
基于Springboot+Vue的学生读书笔记共享源码案例设计.zip
04-20
开发者可能需要掌握Spring Security进行权限控制，Spring Data JPA进行数据库操作，以及Spring Cloud相关组件如Eureka、Ribbon等，以实现服务发现和负载均衡。 Vue.js是前端轻量级的MVVM框架，它简化了单页应用...
SpringSecurity笔记，编程不良人笔记
10-28
在本笔记中，我们将深入探讨SpringSecurity的核心概念、配置以及如何与SpringBoot结合使用。 1. **SpringSecurity核心概念** - **Filter Chain**: SpringSecurity通过一系列过滤器实现其安全功能，这些过滤器构成...
vue+spring boot整合笔记和代码资料
06-21
Spring Security可以用来保护Spring Boot应用，实现登录验证、权限控制等功能。而在Vue中，你可以使用JWT（JSON Web Token）进行身份验证，通过HTTP头部传递令牌。 5. **部署与运行**：前端项目通常打包成静态资源...
springsecurity6.x实战学习笔记，可完美的移植到生产环境
03-28
本实战学习笔记聚焦于如何利用SpringBoot 3.x集成SpringSecurity 6.x，实现灵活的用户认证和授权机制。 首先，SpringBoot 3.x是Spring框架的最新稳定版本，它提供了自动配置、内嵌Web服务器等特性，使得快速开发变...
若依框架中实现配置路径白名单
Xiao_Bai320的博客
06-29 5284
若依框架中实现配置路径白名单——转发方便观看 作者：会飞的皮卡丘EI 个人主页：https://blog.csdn.net/H_Q_Li
Spring全家桶之SpringSecurity
时间静止
09-18 4596
SpringSecurity 知识点的梳理 ，做知识点的存储 ，尤其是RememberMe的实现 ,字数多请有选择观看 ,如果书写有误欢迎及时通知我~~~
springboot实现黑名单和白名单功能
m0_63251896的博客
01-13 2349
springboot实现黑名单和白名单功能
2021-09-03
weixin_45664200的博客
09-03 347
##一，作为架构人员，和其他同学编写gateway网关微服务 packagecom.kkb.kkbgateway.authorization; importcn.hutool.core.convert.Convert; importcn.hutool.core.util.StrUtil; importcn.hutool.json.JSONUtil; importcom.kkb.kkbcommon.constant.AuthConstant; importcom.kkb.kkbcommon.domain.Us
学习杂记
weixin_44677487的博客
12-09 376
记录一些简短的内容。 文章目录@EuqalsAndHashCode@Valid@ResponseEntityResponseStatus参考 @EuqalsAndHashCode lombok插件的注解 此注解会生成equals(Object other) 和 hashCode()方法。 1.它默认使用非静态，非瞬态的属性。且不使用父类的属性，即默认为false 2.指定为true则在1的基础上调用父类的方法 @Valid Controller层通过对标注有@Valid的JavaBean进行校验，并将
Springboot+SpringSecurity+Mybatis
05-27
Spring Boot是一个用于快速构建企业级应用的Java框架，它提供了各种功能强大的特性，例如自动配置、快速启动、监控等。Spring Security是一个基于Spring框架的安全框架，它提供了身份验证、授权、攻击防护等安全功能。MyBatis是一个Java持久化框架，它通过XML或注解方式将Java对象映射到数据库表中。 SpringBoot + SpringSecurity + MyBatis可以用于构建安全可靠的企业级应用程序。其中，SpringBoot提供了快速启动和自动配置的特性，简化了应用程序的开发和部署。SpringSecurity提供了各种安全功能，例如身份验证、授权、攻击防护等。MyBatis提供了Java与数据库之间的映射功能，使得开发者可以很方便地操作数据库。 在使用SpringBoot + SpringSecurity + MyBatis时，一般可以采用前后端分离的方式，前端使用Vue或React等框架，后端使用SpringBoot + SpringSecurity + MyBatis进行开发。前端向后端发送请求时，后端使用SpringSecurity进行身份验证和授权，然后使用MyBatis操作数据库进行数据查询和更新，最终将结果返回给前端。 当然，具体的实现方式还需要根据具体的业务需求和技术栈进行选择。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值