SpringSecurity

最新推荐文章于 2024-09-25 10:59:43 发布
最新推荐文章于 2024-09-25 10:59:43 发布
阅读量829 收藏 10
点赞数 16
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80098154/article/details/140814952
版权

一、简介

Spring Security 是 Spring 家族中的一个安全管理框架。相比与另外一个安全框架Shiro，它提供了更丰富的功能，社区资源也比Shiro丰富。

一般来说中大型的项目都是使用 SpringSecurity 来做安全框架。小项目有 Shiro 的比较多，因为相比与SpringSecurity， Shiro 的上手更加的简单。
一般 Web 应用的需要进行 认证 和 授权 。
认证：验证当前访问系统的是不是本系统的用户，并且要确认具体是哪个用户
授权：经过认证后判断当前用户是否有权限进行某个操作
而认证和授权也是 SpringSecurity 作为安全框架的核心功能。

二、快速入门

我们先要搭建一个简单的 SpringBoot工程，引入SpringSecurity的依赖，引入依赖后去访问 之前的接口就会自动跳转到一个 SpringSecurity 的默认登陆页面，默认用 户名是 user, 密码会输出在控制台。（/logout是退出登录）

三、认证

（1）登录检验流程

（2）SprignSecurity完整流程

SpringSecurity 的原理其实就是一个过滤器链，内部包含了提供各种功能的过滤器。这里我们可以看看入门案例中的过滤器。
图中只展示了核心过滤器，其它的非核心过滤器并没有在图中展示。
UsernamePasswordAuthenticationFilter：负责处理我们在登录页面填写了用户名密码后的登录请求。
ExceptionTranslationFilter：处理过滤器链中抛出的任何AccessDeniedException和AuthenticationException。
FilterSecurityInterceptor：负责权限校验的过滤器。
我们可以通过 Debug 查看当前系统中 SpringSecurity 过滤器链中有哪些过滤器及它们的顺序。

认证流程详情：

概念速查 :
Authentication 接口 : 它的实现类，表示当前访问系统的用户，封装了用户相关信息。
AuthenticationManager 接口：定义了认证 Authentication 的方法
UserDetailsService 接口：加载用户特定数据的核心接口。里面定义了一个根据用户名查询用户信息的方法。
UserDetails 接口：提供核心用户信息。通过 UserDetailsService 根据用户名获取处理的用户信息要封装成UserDetails 对象返回。然后将这些信息封装到 Authentication 对象中。

（3）解决问题

思路分析：
登录
①自定义登录接口
调用 ProviderManager 的方法进行认证 如果认证通过生成 jwt
把用户信息存入 redis 中
②自定义 UserDetailsService
在这个实现类中去查询数据库
校验：
①定义 Jwt 认证过滤器
获取 token
解析 token 获取其中的 userid
从 redis 中获取用户信息
存入 SecurityContextHolder
注意：如果要测试，需要往用户表中写入用户数据，并且如果你想让用户的密码是明文存储，需要在密码前加{noop}。
（4）登录接口 
@Service
public class LoginServiceImpl implements LoginService {
    @Autowired
    private AuthenticationManager authenticationManager;
    @Autowired
    private RedisCache redisCache;
    @Override
    public ResponseResult login(User user) {
//      AuthenticationManager authenticate进行用户认证
        UsernamePasswordAuthenticationToken authenticationToken=new UsernamePasswordAuthenticationToken(user.getUserName(),user.getPassword());
        Authentication authenticate = authenticationManager.authenticate(authenticationToken);
//        如果认证没通过，给出对应的提示
        if (Objects.isNull(authenticate)){
            throw new RuntimeException("登录失败");
        }
//        如果认证通过了，使用userId生成一个jwt，jwt存入responseResult返回
        LoginUser loginUser = (LoginUser) authenticate.getPrincipal();
        String userId = loginUser.getUser().getId().toString();
        String jwt = JwtUtil.createJWT(userId);
        Map<String,String>map=new HashMap<>();
        map.put("token",jwt);
    //        把完整的用户信息存入redis userId作为key
redisCache.setCacheObject("login"+userId,loginUser);
        return new ResponseResult(200,"登录成功",map);
    }
}

（4）认证过滤器

我们需要自定义一个过滤器，这个过滤器会去获取请求头中的 token ，对 token 进行解析取出其中的 userid。使用userid 去 redis 中获取对应的 LoginUser 对象。然后封装Authentication 对象存入 SecurityContextHolder。 
@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
    @Autowired
    private RedisCache redisCache;
    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response, FilterChain filterChain) throws ServletException,
            IOException {
//获取token
        String token = request.getHeader("token");
        if (!StringUtils.hasText(token)) {
//放行
            filterChain.doFilter(request, response);
            return;
        }
//解析token
        String userid;
        try {
            Claims claims = JwtUtil.parseJWT(token);
            userid = claims.getSubject();
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("token非法");
        }
//从redis中获取用户信息
        String redisKey = "login:" + userid;
        LoginUser loginUser = redisCache.getCacheObject(redisKey);
        if(Objects.isNull(loginUser)){
            throw new RuntimeException("用户未登录");
        }
//存入SecurityContextHolder
//TODO 获取权限信息封装到Authentication中
        UsernamePasswordAuthenticationToken authenticationToken =
                new UsernamePasswordAuthenticationToken(loginUser,null,null);
        SecurityContextHolder.getContext().setAuthentication(authenticationToken);
//放行
        filterChain.doFilter(request, response);
    }
}

把token校验过滤器添加到过滤器链中（5）

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Bean
public PasswordEncoder passwordEncoder(){
return new BCryptPasswordEncoder();
}
@Autowired
private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
    return super.authenticationManagerBean();
    }
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
//关闭csrf
                .csrf().disable()
//不通过Session获取SecurityContext
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
// 对于登录接口 允许匿名访问
                .antMatchers("/user/login").anonymous()
// 除上面外的所有请求全部需要鉴权认证
                .anyRequest().authenticated();
        //把token校验过滤器添加到过滤器链中
        http.addFilterBefore(jwtAuthenticationTokenFilter,
                UsernamePasswordAuthenticationFilter.class);
    }
}

 （5)退出登录

我们只需要定义一个登陆接口，然后获取 SecurityContextHolder 中的认证信息，删除 redis 中对应的数据即可。 
    @Override
    public ResponseResult logout() {
//        获取SecurityContextHolder中的用户id
        UsernamePasswordAuthenticationToken authentication = (UsernamePasswordAuthenticationToken) SecurityContextHolder.getContext().getAuthentication();
        LoginUser loginUser = (LoginUser) authentication.getPrincipal();
        Long userid = loginUser.getUser().getId();
//        删除redis中的值
        redisCache.deleteObject("logout:"+userid);
        return new ResponseResult(200,"注销成功");
    }

四、授权

（1）权限系统的作用

例如一个学校图书馆的管理系统，如果是普通学生登录就能看到借书还书相关的功能，不可能让看到并且去使用添加书籍信息，删除书籍信息等功能。但是如果是一个图书馆管理员的账号登录了应该就能看到并使用添加书籍信息，删除书籍信息等功能。
总结起来就是 不同的用户可以使用不同的功能 。这就是权限系统要去实现的效果。
我们不能只依赖前端去判断用户的权限来选择显示哪些菜单哪些按钮。因为如果只是这样，如果人知道了对应功能的接口地址就可以不通过前端，直接去发送请求来实现相关功能操作。
所以我们还需要在后台进行用户权限的判断，判断当前用户是否有相应的权限，必须具有所需权才能进行相应的操作。

（2）授权基本流程

在 SpringSecurity 中，会使用默认的 FilterSecurityInterceptor 来进行权限校验。在 FilterSecurityInterceptor中会从 SecurityContextHolder 获取其中的 Authentication ，然后获取其中的
权限信息。当前用户是否拥有访问当前资源所需的权限。所以我们在项目中只需要把当前登录用户的权限信息也存入Authentication 。然后设置我们的资源所需要的权限即可。

（3）授权实现

1.限制访问资源所需权限

首先我们需要开启相关的配置

@EnableGlobalMethodSecurity(prePostEnabled = true)

然后就可以使用对应的注解

@RestController
public class HelloController {
    @RequestMapping("hello")
    @PreAuthorize("hasAuthority('test')")
    public String hello(){
        return "hello";
    }
}

2.封装权限信息

ctrl+alt+左键，可以查看实现类。

我们前面在写 UserDetailsServiceImpl 的时候说过，在查询出用户后还要获取对应的权限信息，装到 UserDetails中返回。
我们之前定义了 UserDetails 的实现类 LoginUser，想要让其能封装权限信息就要对其进行修改。 
@Data
@NoArgsConstructor
public class LoginUser implements UserDetails {
    private User user;
    private List<String> permissions;
    public LoginUser(User user,List<String> permissions){
        this.user=user;
        this.permissions=permissions;
    }
    @JSONField(serialize = false)
    private List<SimpleGrantedAuthority> authorities;
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        if (authorities!=null){
            return authorities;
        }
//        把permissions中String类型的权限信息封装成SimpleGrantedAuthority对象
//    1.   List<GrantedAuthority> authorities=new ArrayList<>();
//        for (String permission : permissions) {
//            SimpleGrantedAuthority authority = new SimpleGrantedAuthority(permission);
//            newList.add(authority);
//        }
        List<SimpleGrantedAuthority> authorities = permissions.stream().map(SimpleGrantedAuthority::new).collect(Collectors.toList());


        return authorities;
    }
LoginUser 修改完后我们就可以在 UserDetailsServiceImpl 中去把权限信息封装到 LoginUser 中了。我们写死权限进行测试，后面我们再从数据库中查询权限信息。 
@Service
public class UserDetailsServiceImpl implements UserDetailsService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
//        查询用户信息
        LambdaQueryWrapper<User> queryWrapper=new LambdaQueryWrapper<>();
        queryWrapper.eq(User::getUserName,username);
        User user = userMapper.selectOne(queryWrapper);
//        如果没有查询到用户就抛出异常
        if (Objects.isNull(user)){
            throw new RuntimeException("用户名或密码错误");
        }
//        将数据封装成UserDetails
//        根据用户查询权限信息，添加到LoginUser中
        List<String>list=new ArrayList<>(Arrays.asList("test"));
        return new LoginUser(user,list);
    }
}

3.从数据库查询权限信息

RBAC 权限模型（ Role-Based Access Control ）即：基于角色的权限控制。这是目前最常被开发者使用也是相对易用、通用权限模型。
我们只需要根据用户 id 去查询到其所对应的权限信息即可。
所以我们可以先定义个 mapper ，其中提供一个方法可以根据 userid 查询权限信息 
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.sangeng.domain.Menu;
import java.util.List;
/**
* @Author 三更 B站： https://space.bilibili.com/663528522
*/
public interface MenuMapper extends BaseMapper<Menu> {
List<String> selectPermsByUserId(Long id);
}
尤其是自定义方法，所以需要创建对应的 mapper 文件，定义对应的 sql 语句 
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.sangeng.mapper.MenuMapper">
<select id="selectPermsByUserId" resultType="java.lang.String">
SELECT
DISTINCT m.`perms`
FROM
sys_user_role ur
LEFT JOIN `sys_role` r ON ur.`role_id` = r.`id`
LEFT JOIN `sys_role_menu` rm ON ur.`role_id` = rm.`role_id`
LEFT JOIN `sys_menu` m ON m.`id` = rm.`menu_id`
WHERE
user_id = #{userid}
AND r.`status` = 0
AND m.`status` = 0
</select>
</mapper>
在 application.yml 中配置 mapperXML 文件的位置 
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/sc?characterEncoding=utf-8&serverTimezone=UTC
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
mybatis-plus:
  mapper-locations: classpath*:/mapper/**/*.xml
然后我们可以在 UserDetailsServiceImpl 中去调用该 mapper 的方法查询权限信息封装到 LoginUser 对象中即可。 
@Service
public class UserDetailsServiceImpl implements UserDetailsService {
@Autowired
private UserMapper userMapper;
@Autowired
private MenuMapper menuMapper;
@Override
public UserDetails loadUserByUsername(String username) throws
UsernameNotFoundException {
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(User::getUserName,username);
User user = userMapper.selectOne(wrapper);
if(Objects.isNull(user)){
throw new RuntimeException("用户名或密码错误");
}
List<String> permissionKeyList =
menuMapper.selectPermsByUserId(user.getId());
// //测试写法
// List<String> list = new ArrayList<>(Arrays.asList("test"));
return new LoginUser(user,permissionKeyList);
}
}

五、自定义失败处理

我们还希望在认证失败或者是授权失败的情况下也能和我们的接口一样返回相同结构的 json ，这样可以让前端能对响应进行统一的处理。要实现这个功能我们需要知道SpringSecurity 的异常处理机制。
在 SpringSecurity 中，如果我们在认证或者授权的过程中出现了异常会被 ExceptionTranslationFilter 捕获到。在ExceptionTranslationFilter 中会去判断是认证失败还是授权失败出现的异常。
如果是认证过程中出现的异常会被封装成 AuthenticationException 然后调用
AuthenticationEntryPoint 对象的方法去进行异常处理。
如果是授权过程中出现的异常会被封装成 AccessDeniedException 然后调用 AccessDeniedHandler 对象的方法去进行异常处理。
所以如果我们需要自定义异常处理，我们只需要自定义 AuthenticationEntryPoint 和
AccessDeniedHandler 然后配置给 SpringSecurity 即可。 
@Component
public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authentication) throws IOException, ServletException {
        ResponseResult result=new ResponseResult(HttpStatus.UNAUTHORIZED.value(),"用户认证失败，请重新登录");
        String json = JSON.toJSONString(result);
        WebUtils.renderString(response,json);
    }
}
@Component
public class AccessDeniedHandlerImpl implements AccessDeniedHandler {
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
        ResponseResult result=new ResponseResult(HttpStatus.FORBIDDEN.value(),"您的权限不足");
        String json = JSON.toJSONString(result);
        WebUtils.renderString(response,json);
    }
}
配置给 SpringSecurity
先注入对应的处理器 
   @Autowired
    private AccessDeniedHandlerImpl accessDeniedHandler;
    @Autowired
    private AuthenticationEntryPointImpl authenticationEntryPoint;
然后我们可以使用 HttpSecurity 对象的方法去配置 
  配置异常处理器
        http.exceptionHandling()
                .authenticationEntryPoint(authenticationEntryPoint)
                .accessDeniedHandler(accessDeniedHandler);

六、跨域

PostMan不存在跨域问题。

浏览器出于安全的的考虑，使用XMLHttpRequest对象发起HTTP请求时必须遵守同源策略，否则就是跨域的HTTP请求，默认情况下是被禁止的。同源策略要求相同才能正常进行通信，即协议、域名、端口号都完全一致。

前后端分离项目，前端项目和后端项目一般都不是同源的，所以肯定会存在跨域请求问题。

所以我们就要处理一下，让前端能进行跨域请求。
①先对 SpringBoot 配置，运行跨域请求 
@Configuration
public class CorsConfig implements WebMvcConfigurer {
@Override
public void addCorsMappings(CorsRegistry registry) {
// 设置允许跨域的路径
    registry.addMapping("/**")
// 设置允许跨域请求的域名
            .allowedOriginPatterns("*")
// 是否允许cookie
            .allowCredentials(true)
// 设置允许的请求方式
            .allowedMethods("GET", "POST", "DELETE", "PUT")
// 设置允许的header属性
            .allowedHeaders("*")
// 跨域允许时间
            .maxAge(3600);
}
}
②开启 SpringSecurity 的跨域访问
由于我们的资源都会收到 SpringSecurity 的保护，所以想要跨域访问还要让 SpringSecurity 运行跨域访问。 
//        允许跨域
//        http.cors();
    }

七、遗留小问题

（1）其他权限校验方法

我们前面都是使用 @PreAuthorize 注解，然后在在其中使用的是 hasAuthority 方法进行校验。
SpringSecurity 还为我们提供了其它方法例如： hasAnyAuthority ， hasRole ， hasAnyRole 等。
hasAuthority 方法实际是执行到了 SecurityExpressionRoot 的 hasAuthority，
它内部其实是调用 authentication 的 getAuthorities 方法获取用户的权限列表。然后判断我们存入的方法参数数据在权限列表中。
hasAnyAuthority 方法可以传入多个权限，只有用户有其中任意一个权限都可以访问对应资源。 
@PreAuthorize("hasAnyAuthority('admin','test','system:dept:list')")
public String hello(){
return "hello";
}
hasRole 要求有对应的角色才可以访问，但是它内部会把我们传入的参数拼接上 ROLE_ 后再去比较。所以这种情况下要用用户对应的权限也要有 ROLE_ 这个前缀才可以。 
@PreAuthorize("hasRole('system:dept:list')")
public String hello(){
return "hello";
}
hasAnyRole 有任意的角色就可以访问。它内部也会把我们传入的参数拼接上 ROLE_ 后再去比较。所以这种情况下要用用户对应的权限也要有 ROLE_ 这个前缀才可以。 
@PreAuthorize("hasAnyRole('admin','system:dept:list')")
public String hello(){
return "hello";
}

（2）自定义权限校验方法

我们也可以定义自己的权限校验方法，在 @PreAuthorize 注解中使用我们的方法。 
@Component("ex")
public class SGExpressionRoot {
    public boolean hasAuthority(String authority){
//        获取当前用户的权限
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        LoginUser loginUser = (LoginUser) authentication.getPrincipal();
        List<String> permissions = loginUser.getPermissions();
//        判断用户权限集合中是否存在authority
        return permissions.contains(authority);


    }
}
在 SPEL 表达式中使用 @ex 相当于获取容器中 bean 的名字为 ex 的对象。然后再调用这个对象的
hasAuthority 方法 
@RestController
public class HelloController {
    @RequestMapping("hello")
    @PreAuthorize("@ex.hasAuthority('system:dept:list')")
    public String hello(){
        return "hello";
    }
}

（3）基于配置的权限控制

我们也可以在配置类中使用配置的方式对资源进行权限控制。

  @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
//关闭csrf
                .csrf().disable()
//不通过Session获取SecurityContext
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
// 对于登录接口 允许匿名访问
                .antMatchers("/user/login").anonymous()
                .antMatchers("/testCors").hasAuthority("system:dept:list222")

（4）CSRF

CSRF是指跨站请求伪造，是web常见的攻击之一。

SpringSecurity 去防止 CSRF 攻击的方式就是通过 csrf_token 。后端会生成一个 csrf_token ，前端发起请求的时候需要携带这个csrf_token, 后端会有过滤器进行校验，如果没有携带或者是伪造的就不允许访问。
我们可以发现 CSRF 攻击依靠的是 cookie 中所携带的认证信息。但是在前后端分离的项目中我们的认证信息其实是token ，而 token 并不是存储中 cookie 中，并且需要前端代码去把 token 设置到请求头中才可以，所以CSRF 攻击也就不用担心了。

（5）认证成功处理器

实际上在 UsernamePasswordAuthenticationFilter 进行登录认证的时候，如果登录成功了是会调用
AuthenticationSuccessHandler 的方法进行认证成功后的处理的。 AuthenticationSuccessHandler 就是登录成功处理器。
我们也可以自己去自定义成功处理器进行成功后的相应处理。 
@Component
public class SGSuccessHandler implements AuthenticationSuccessHandler {
    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        System.out.println("认证成功了");
    }
}

再在SecurityConfig中配置

@Configuration
public class SecurityConfig  extends WebSecurityConfigurerAdapter {
    @Autowired
    private AuthenticationSuccessHandler successHandler;


    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.formLogin().successHandler(successHandler);
        http.authorizeRequests().anyRequest().authenticated();
    }
}

（6）认证失败处理器

实际上在 UsernamePasswordAuthenticationFilter 进行登录认证的时候，如果登录失败了是会调用
AuthenticationFailureHandler 的方法进行认证成功后的处理的。 AuthenticationFailureHandler 就是登录失败处理器。
我们也可以自己去自定义失败处理器进行成功后的相应处理。 
@Component
public class SGFailureHandler implements AuthenticationFailureHandler {
    @Override
    public void onAuthenticationFailure(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException {
        System.out.println("认证失败了");
    }
}

再在SecurityConfig中配置

@Configuration
public class SecurityConfig  extends WebSecurityConfigurerAdapter {
    @Autowired
    private AuthenticationSuccessHandler successHandler;
    @Autowired
    private AuthenticationFailureHandler failureHandler;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
//        配置认证成功处理器
        http.formLogin().successHandler(successHandler);
//        配置认证失败处理器
        http.formLogin().failureHandler(failureHandler);
        http.authorizeRequests().anyRequest().authenticated();
    }
}

（7）登出成功处理器

@Component
public class SGLogoutSuccessHandler implements LogoutSuccessHandler {
    @Override
    public void onLogoutSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException {
        System.out.println("注销成功");
    }
}
@Configuration
public class SecurityConfig  extends WebSecurityConfigurerAdapter {
    @Autowired
    private AuthenticationSuccessHandler successHandler;
    @Autowired
    private AuthenticationFailureHandler failureHandler;
    @Autowired
    private LogoutSuccessHandler logoutSuccessHandler;
    protected void configure(HttpSecurity http) throws Exception {
//        配置认证成功处理器
        http.formLogin().successHandler(successHandler);
//        配置认证失败处理器
        http.formLogin().failureHandler(failureHandler);
//        配置注销成功处理器
        http.logout().logoutSuccessHandler(logoutSuccessHandler);
        http.authorizeRequests().anyRequest().authenticated();
    }
}

*haha*,
关注
spring security原理和机制 | Spring Boot 35
学Java，找哪吒
06-25 5万+
一、SpringSecurity 框架简介 Spring 是非常流行和成功的 Java 应用开发框架，Spring Security 正是 Spring 家族中的 成员。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方 案。 正如你可能知道的关于安全方面的两个主要区域是“认证”和“授权”（或者访问控 制），一般来说，Web 应用的安全性包括用户认证（Authentication）和用户授权 （Authorization）两个部分，这两点也是 Spring
SpringSecurity从入门到精通
KYGALYX的博客
11-27 885
我们前面在写UserDetailsServiceImpl的时候说过，在查询出用户后还要获取对应的权限信息，封装到。SpringSecurity为我们提供了基于注解的权限控制方案，这也是我们项目中主要采用的方式。我们之前定义了UserDetails的实现类LoginUser，想要让其能封装权限信息就要对其进行修改。我们可以通过Debug查看当前系统中SpringSecurity过滤器链中有哪些过滤器及它们的顺序。Authentication接口: 它的实现类，表示当前访问系统的用户，封装了用户相关信息。
WEB 认证授权
u011085781的博客
07-12 1046
认证授权 什么是认证（Authentication） 通俗地讲就是验证当前用户的身份。 互联网中的认证： 用户名密码登录 邮箱发送登录链接 手机号接收验证码 只要你能收到邮箱/验证码，就默认你是账号的主人 什么是授权（Authorization） 用户授予第三方应用访问该用户某些资源的权限。 实现授权的方式有：cookie、session、JWT、SSO、OAuth2。 什么是凭证（Credentials） 实现认证和授权的前提是需要一种媒介（证书）来标记访问者的身份。 Cookie&Session
SpringSecurity 你值得学习！！！
DrewWong的博客
11-11 428
JAVA安全框架简介 文章目录SpringSecurity功能介绍和原理分析一、基本原理二、认证流程详解三、个性化用户认证流程1、修改登录成功后返回json数据2、修改处理登录失败后返回json数据3、配置提示信息为中文四、实现图形验证码或短信验证码功能1、编写生成验证码图片的接口2、编写自定义的过滤器，完成验证码校验3、在spring Security中配置过滤器五、实现记住我功能六、SESSION管理Spring Security的Session控制七、授权7.1、Spring Security授权流程
Spring Security
qq_45429856的博客
11-22 3826
Spring Security简介 Spring Security是一个高度自定义的安全框架。利用Spring IOC/DI和AOP功能，为系统提供了声明式安全访问控制功能，减少了为系统安全而编写大量重复代码的工作 spring security 的核心功能主要包括： 认证 （系统认证用户是否登录） 授权 （系统判断用户是否有权限去做某些事情） 攻击防护 （防止伪造身份） Spring Security项目搭建 一：导入依赖 <!--导入spring security依赖-->
springcloud集成Spring Security
youxmm的博客
07-21 2515
1.自定义配置类继承WebSecurityConfigurerAdapter配置类2.通过重写方法来定义安全规则和访问控制。通常用于测试或者开发环境中，因为它并不会对密码进行任何加密，而是将密码以明文的形式存储和验证。存在严重的安全风险，因为密码可以很容易地被窃取和滥用。建议不要在生产环境中使用类似的明文密码存储方式。@Bean//这里配置用户信息,这里暂时使用这种方式将用户存储在内存中//获取一个密码编码器对象@Bean//密码为明文方式//配置安全拦截机制@Override。
SpringSecurity认证
小钟不想敲代码
05-28 5287
SpringSecurity认证
SpringSecurity自定义登录界面
weixin_43472934的博客
04-18 6767
为什么需要自定义登录界面？ 答：因为SpringBoot整合SpringSecurity时，只需要一个依赖，无需其他配置，就可以实现认证功能。但是它的认证登录界面是固定那样的，如下图所示，但是我们希望自己搞个好看的登录界面，所以需要自定义登录界面。 第一步：创建springboot项目 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="ht
Spring Security 6.x 系列（4）—— 基于过滤器链的源码分析（一）
热门推荐
gmHappy
11-01 2万+
`Spring Security`默认的配置是由 `SecurityAutoConfiguration` 、 `UserDetailsServiceAutoConfiguration`、`SecurityFilterAutoConfiguration`这三个自动配置类实现的。
Spring Security in Action
11-22
Spring Security 实践指南 Spring Security 是一个基于 Java 的安全框架，旨在提供身份验证、授权和访问控制等功能。下面是 Spring Security 的主要知识点： 一、身份验证（Authentication） 身份验证是指对用户...
springsecurity学习笔记
12-13
在"springsecurity学习笔记"中，你可能会涉及以下主题： - Spring Security的基本配置，包括web安全配置和全局安全配置。 - 如何自定义认证和授权流程，比如实现自定义的AuthenticationProvider和...
最详细Spring Security学习资料（源码）
11-16
Spring Security是一个功能强大且高度可定制的身份验证和授权框架，专门用于保护Java应用程序的安全性。它构建在Spring Framework基础之上，提供了全面的安全解决方案，包括身份验证、授权、攻击防护等功能。 Spring...
Spring Cloud Gateway 整合 Spring Security 统一登录认证鉴权
02-24
在压缩包文件`spring_gateway_security_webflux`中，可能包含了示例代码或配置文件，用于演示如何在Spring Cloud Gateway中集成Spring Security，实现统一登录认证鉴权。这些资源可以帮助开发者更快地理解和实践上述...
SpringSecurity笔记，编程不良人笔记
10-28
SpringSecurity是Java领域中一款强大的安全框架，主要用于Web应用程序的安全管理。它提供了全面的身份验证、授权、会话管理以及安全相关的功能，可以帮助开发者构建安全的Web应用。在本笔记中，我们将深入探讨Spring...
Spring Boot 学习和使用
cesske的博客
09-24 1209
Spring Boot是一款开源的Java Web应用框架，旨在简化Spring应用的初始搭建以及开发过程。Spring Boot通过整合Spring技术栈中的诸多关键组件，为开发者提供了一种快速、简便的Spring应用开发方式。它遵循“约定优于配置”的原则，通过自动配置、起步依赖和内置的Servlet容器，极大地简化了传统Spring应用的配置和部署过程。Spring Boot通过其自动化配置、起步依赖、内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。
工厂模式的介绍及实现
最新发布
户伟伟的博客
09-25 142
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
央顺科技官方博客
09-24 1012
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值