SpringSecurity 基本使用方法（JWT以及基本表单验证）

最新推荐文章于 2023-10-15 16:05:17 发布
最新推荐文章于 2023-10-15 16:05:17 发布
阅读量1.2k 收藏 2
点赞数 1
分类专栏： SpringSecurity 文章标签： spring spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44907046/article/details/124202327
版权

SpringSecurity 使用方法

一、本地视图方式校验（Thymeleaf）

1、基本用户名校验

  1. 配置Pom依赖

    //父工程
 	<parent>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-starter-parent</artifactId>
    	<version>2.6.4</version>
	</parent>
//依赖
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
    </dependencies>

  2. 配置application.yaml

    spring:
  application:
    name: springboot-security-test
server:
  port: 8899

  3. 配置SpringBootApplication主启动

    @SpringBootApplication
public class SpingBootApplicationMain {
    public static void main(String[] args) {
        SpringApplication.run(SpingBootApplicationMain.class, args);
    }
}

  4. 编写Controller

    @RestController
@RequestMapping("/sec")
public class TestController {
    @GetMapping("hello")
    public String hello(){
        return "认证成功";
    }
}

1.1、从配置文件中进行校验

修改配置文件中的application.yaml添加Security配置

security:
 user:
   name: byz
   password: 123

启动工程进行验证，访问配置的映射器路径：

image-20220414095444309

进入登陆页面，输入在配置文件中的用户名密码进入

image-20220414095725437

1.2、从配置类中进行校验

1、修改配置文件，注释掉：

#  security:
#    user:
#      name: byz
#      password: 123

2、新建一个配置类

/**
 * @Author BaiYZ
 * @Program SpringSecurityDemo
 * @Description TODO
 * @Date 2022-04-14 09:43:31
 */
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    //注入密码加密编码器
    @Bean
    PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
	
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        BCryptPasswordEncoder passwordEncoder = (BCryptPasswordEncoder) passwordEncoder();
        String password = passwordEncoder.encode("123");
        auth.inMemoryAuthentication().withUser("byz").password(password).roles("admin");
    }
}

1.3、从数据库或者其他方式自定义校验UserDetailService

  1. 自定义USerDeatilService实现UserdetailService接口

    @Service("userDetailsService") //名称必须叫这个
public class MyUserDetailsServiceImpl implements UserDetailsService {
    //这里注入数据库查询逻辑,实际校验用户是否存在
    //注入mapper进行校验

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        /*
         * 1、使用Mapper查询数据库
         * 2、判断是否查询到用户
         * (这里假定查询结果)
         * */
        MyUser user = new MyUser();
        List<GrantedAuthority> grantedAuthorities = AuthorityUtils.commaSeparatedStringToAuthorityList("admin,user,ROLE_admin");
        if (user != null) {
            /**
             * 从数据库查询到的用户
             * 实质上需要返回一个数据库查询到的用户
             * 并将其封装成为一个UserDetail对象进行返回，系统会自动校验其中的密码以及用户名信息
             */
            return new User("byz", new BCryptPasswordEncoder().encode("123"), grantedAuthorities); //这里USer为UserDetail的子类
        } else {
            //查询不到就报错
            throw new UsernameNotFoundException("用户名不存在！");
        }
    }
}

  2. 设置配置类并且重写配置权限方法configure(AuthenticationManagerBuilder auth)

    /**
 * @Author BaiYZ
 * @Program SpringSecurityDemo
 * @Description TODO
 * @Date 2022-04-14 09:43:31
 */
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    //注入密码编码器
    @Bean
    PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        //设置自定义的USerDetailService逻辑，以及配置密码编码器
        auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder());
    }
}

  3. 配置类中配置Httpl拦截方法

    /**
     * 重写http加密校验规则
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                //配置登陆也米娜
                .formLogin() //自定义登陆页面 ，这里会调用UserNamePasswordFilter
                .loginPage("/user/login")
                //登陆访问url地址  由控制器处理
                .loginProcessingUrl("/login")
                //登陆成功url地址 由控制器处理
                .defaultSuccessUrl("/user/success")

                //配置路径权限
                .and()
                .authorizeRequests() //表示配置地址权限访问
                //配置以路径匹配来怕配置权限
                .antMatchers("/", "/index", "/user/login").permitAll()

                //配置指定页面使用角色管理
                .antMatchers("/role/admin").hasRole("admin")
                .antMatchers("/role/service").hasAnyRole("user,test")
                //指定权限管理
                .antMatchers("/role/auth").hasAuthority("admin")
                .antMatchers("/role/test").hasAnyAuthority("test")

                //对请求进行配置 POST Get ....
                .anyRequest().authenticated() //所有请求都需要授权

                //csrf跨站请求配置
                .and()
                .csrf().disable()

                //配置403 自定义逻辑
                //403自定义错误url
                .exceptionHandling().accessDeniedPage("/unauth");

    }

2、记住我rememberMe

2.1、记住我（基于数据库）

  1. 注入数据源

  2. 安全配置类中配置（注入）PersistentTokenRepository

     	@Bean
    public PersistentTokenRepository persistentTokenRepository(){
        JdbcTokenRepositoryImpl jdbcTokenRepository = new JdbcTokenRepositoryImpl();
        //启动时创建表,创建一次，也可以手动创建（进入这个PersistentTokenRepository获取建表的sql）
        jdbcTokenRepository.setCreateTableOnStartup(true);
        return jdbcTokenRepository;
    }

  3. 配置类中

     protected void configure(HttpSecurity http) throws Exception {
     http
         .and()
         .rememberMe().tokenRepository(persistentTokenRepository()) //开启RememberMe设置操作数据库对象
         .tokenValiditySeconds(60) //设置过期时间 
         .userDetailsService(userDetailsService); //设置查询数据库的逻辑板 返回UserDetails
         //其他配置....
 }

  4. 页面配置复选框

    名称必须叫做remember-me 框架底层设置

    <input type="checkbox" name="remember-me"/>

3、退出登陆（默认行为）

默认的退出登录URL为/logout

需要自定义就实现LogoutHandler接口

二、分布式Token校验

2.1、编写UserDetail对象(UserDetailService查询会使用到)

  1. 编写基础用户对象（存储数据库中）

    /**
 * @Author BaiYZ
 * @Program SpringSecurityDemo
 * @Description 实际的实体类
 * @Date 2022-04-15 17:01:52
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
    @Serial
    private static final long serialVersionUID = 2211L;
    private String userName;
    private String password;
    private String age;
    private String birthday;
}

  2. 编写SecurityUser用于SpringSecurity中权限用户封装

    /**
 * @Author BaiYZ
 * @Program SpringSecurityDemo
 * @Description 用于鉴权的实体类
 * @Date 2022-04-15 17:02:31
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class SecurityUser implements UserDetails {
    /**
     * 当前用户
     */
    private transient User currentUserInfo;
    /**
     * 权限列表
     */
    private List<String> permissionValueList;

    public SecurityUser(User currentUserInfo) {
        if(currentUserInfo != null){
            this.currentUserInfo = currentUserInfo;
        }
    }

    /**
     * 获取授权列表 GrantedAuthority
     * @return  Collection<? extends GrantedAuthority>
     */
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        Assert.notNull(this.permissionValueList, "Cannot pass a null GrantedAuthority collection");
        //遍历设置权限
        Set<GrantedAuthority> setAuthorities = new HashSet<>();
        for (String grantedAuthority : this.permissionValueList) {
            //权限不为空
            if(StringUtils.hasText(grantedAuthority)){
                SimpleGrantedAuthority simpleGrantedAuthority = new SimpleGrantedAuthority(grantedAuthority);
                setAuthorities.add(simpleGrantedAuthority);
            }
        }
        return setAuthorities;
    }

    @Override
    public String getPassword() {
        return null;
    }

    @Override
    public String getUsername() {
        return null;
    }

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

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

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

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

2.2、编写Security

image-20220415163947241

2.1.1、编写自定义密码加密规则PassWordEncoder

/**
 * @Author BaiYZ
 * @Program SpringSecurityDemo
 * @Description TODO
 * @Date 2022-04-15 14:56:21
 */
@Component
public class DefaultPasswordEncoder implements PasswordEncoder {
    @Autowired
    BCryptPasswordEncoder bCryptPasswordEncoder;

    public DefaultPasswordEncoder() {
    }

    public DefaultPasswordEncoder(int strength) {

    }

    /**
     * 自定义加密方式  --->> 也可以使用md5加密，返回加密字符串即可
     * @param rawPassword 原始密码由Securuty框架传入
     * @return
     */
    @Override
    public String encode(CharSequence rawPassword) {
        return bCryptPasswordEncoder.encode(rawPassword);
    }

    /**
     * 比对密码比较的是输入后加密与存储的加密密码比对
     * @param rawPassword 框架获取的用户提交的密码
     * @param encodedPassword 存储的加密后的密码
     * @return bool 真为通过
     */
    @Override
    public boolean matches(CharSequence rawPassword, String encodedPassword) {
        //输入密码加密
        String encodeInput = bCryptPasswordEncoder.encode(rawPassword);
        return encodedPassword.equals(encodeInput);
    }
}

2.1.2 Token工具类

  • 生成Token（jwt生成—JsonWebToken）
  • 根据用户名获取Token
  • Token中获取用户名
  • 删除Token

Jwt介绍：

  1. JWT头

    1. alg：表示签名算法
    2. typ：令牌类型
    {
    "alg":"HS256",
    "typ":"JWT"
}

  2. 有效载荷 PayLoad(Claims)

    1. iss：发行人
    2. exp：到期时间
    3. sub：主题
    4. aud：用户
    5. nbf：在此之前不可用
    6. iat：发布时间
    7. jti：jwt id 标识一个JWt
    8. 私有字段
    {
    "iss":"xxx",
    "exp":"222",
    "sub":"loginedUSer",
    "nbf":"xxx",
    "aud":"user",
    "iat":"xxx",
    "jti":"xxx",
    "自定义字段":"value"
}

  3. 签名哈希

    对上面两部分进行签名，使用指定算法生成前面哈希

    例子：

    HMACSHA256(base64UrlEncode(header)+"."+base64UrlEncode(payload),secret)

完整JWt字符串：

image-20220415151923617

拼装结构：

JWTString=Base64(Header).Base64(Payload).签名哈希
2.1.2.1、导入JWt依赖
<!--父工程-->
<parent>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-parent</artifactId>
   <version>2.6.4</version>
</parent>       

<!--JWT依赖-->
<dependency>
   <groupId>io.jsonwebtoken</groupId>
   <artifactId>jjwt</artifactId>
   <version>0.9.1</version>
</dependency>
2.1.2.2、编写TokenManager工具类
/**
 * @Author BaiYZ
 * @Program SpringSecurityDemo
 * @Description token 管理工具类
 * @Date 2022-04-15 15:25:04
 */
@Component("tokenManager")
public class TokenManager {
    /**
     * token有效期 这里设置60min
     */
    private long tokenExpiredTime = 60 * 60 * 1000;

    /**
     * token密钥
     * <b>一般实际项目中需要实际生成</b>
     */
    private String tokenSecrect = "111111";

    /**
     * 根据Token获取用户名信息
     * setSubject(String sub); 设置jwt加密对象
     * setExpiration(Date exp); 设置过期时间
     * signWith(SignatureAlgorithm alg, String base64EncodedSecretKey); 设置签名算法，签名密钥
     * CompressionCodecs.GZIP 进行压缩
     */
    public String createToken(String userName){
        String token = Jwts.builder()
                .setSubject(userName)
                .setExpiration(new Date(System.currentTimeMillis() + tokenExpiredTime))
                .signWith(SignatureAlgorithm.ES512,tokenSecrect)
                .compressWith(CompressionCodecs.GZIP).compact();
        return token;
    }
    //根据用户名获取Token

    /**
     * Jwts.parser()：获取jwt转化器
     * setSigningKey(String key)：设置签名密钥
     * parseClaimsJws(String claimsJws)：转化jwt
     * getBody()：获取body
     * @param token 传入token串
     * @return 返回信息
     */
    public String getUserInfoFromToken(String token){
        String userInfo = Jwts.parser()
                .setSigningKey(tokenSecrect)
                .parseClaimsJws(token)
                .getBody()
                .getSubject();
        return userInfo;
    }
    public void removeToken(String token){

    }
}

2.1.3 退出登陆处理器（Token）

2.1.3.1、使用Redis存储Token
  1. 引入Pom依赖
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
  1. application.yaml中配置Redis
spring:
  redis:
    port: 6379
    host: localhost
2.1.3.2、编写退出处理器
/**
 * @Author BaiYZ
 * @Program SpringSecurityDemo
 * @Description Token退出登陆逻辑
 * @Date 2022-04-15 16:11:20
 */
@Component("tokenLogOutHandler")
public class TokenLogOutHandler implements LogoutHandler {

    /**
     * 注入Token工具类
     */
    private TokenManager tokenManager;
    /**
     * redis模板类
     */
    private RedisTemplate redisTemplate;

    public TokenLogOutHandler(TokenManager tokenManager, RedisTemplate redisTemplate) {
        this.tokenManager = tokenManager;
        this.redisTemplate = redisTemplate;
    }

    /**
     * 退出登陆逻辑
     * @param request 请求
     * @param response 响应
     * @param authentication 授权信息封装
     */
    @Override
    public void logout(HttpServletRequest request, HttpServletResponse response, Authentication authentication) {
        //1、从header拿到Token
        String token = request.getHeader("token");
        //2、存在Token
        //2.1、移出Token(从Redis删除)
        if(token!=null){
            tokenManager.removeToken(token);
            String userInfoFromToken = tokenManager.getUserInfoFromToken(token);
            redisTemplate.delete(userInfoFromToken);
        }
        //写响应相关操作，返回一个状态xxx
    }
}

退出逻辑配置

@Override 
protected void configure(HttpSecurity http) throws Exception {
     http
         .and()
         .logout()
         .logoutUrl("/logout") //默认为logout
         .logoutSuccessHandler(tokenLogOutHandler) //自定义退出成功处理器
         .deleteCookies("JSESSIONID") //要删除的Cookies
}

2.1.4 未授权统一处理AuthenticationEntryPoint

/**
 * @Author BaiYZ
 * @Program SpringSecurityDemo
 * @Description 未授权统一处理
 * @Date 2022-04-15 16:32:12
 */
@Component("unAuthenticationEntryPoint")
public class UnAuthenticationEntryPoint implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        //处理未授权逻辑
    }
}

未授权统一权限配置：

@Override
protected void configure(HttpSecurity http) throws Exception {
  http
  //没有权限处理器
  .exceptionHandling().authenticationEntryPoint(unAuthenticationEntryPoint)
}

2.3、编写过滤器

image-20220415191708836

2.3.1、认证过滤器

/**
 * @Author BaiYZ
 * @Program SpringSecurityDemo
 * @Description 认证过滤器
 * @Date 2022-04-15 16:47:42
 */
@Component("tokenLoginFilter")
public class TokenLoginFilter extends UsernamePasswordAuthenticationFilter {
    /**
     * redis模板类
     */
    private RedisTemplate redisTemplate;
    /**
     * token工具类
     */
    private TokenManager tokenManager;
    /**
     * 权限管理工具类
     */
    private AuthenticationManager authenticationManager;

    public TokenLoginFilter(RedisTemplate redisTemplate, TokenManager tokenManager, AuthenticationManager authenticationManager) {
        this.redisTemplate = redisTemplate;
        this.tokenManager = tokenManager;
        this.authenticationManager = authenticationManager;
        //设置不止用post提交
        this.setPostOnly(false);
    }

    /**
     * 重写尝试认证的方法
     * 父类会进行调用
     *
     * @param request  请求
     * @param response 响应
     * @return Authentication 返回认证封装
     * @throws AuthenticationException 认证异常
     */
    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
        //获取表单提交数据
        try {
            //从请求中获取用户信息
            User user = new ObjectMapper().readValue(request.getInputStream(), User.class);
            //交给SpringSecurity管理
            return authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(user.getUserName(), user.getPassword(), new ArrayList<>()));
        } catch (IOException e) {
            e.printStackTrace();
            throw new RuntimeException();
        }
    }

    /**
     * AbstractAuthenticationProcessingFilter调用子类attemptAuthentication认证之后
     * <b>成功调用</b>
     *
     * @param request    请求
     * @param response   响应
     * @param chain      过滤器链
     * @param authResult 认证结果Authentication
     * @throws IOException      id异常
     * @throws ServletException servlet异常
     */
    @Override
    protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException {
        //获取认证之后用户信息UserDetail
        SecurityUser securityUser = (SecurityUser) authResult.getPrincipal();
        //封装token（这里使用用户名生成）
        String token = tokenManager.createToken(securityUser.getCurrentUserInfo().getUserName());
        //将用户名以及权限列表放入Redis
        redisTemplate.opsForValue().set(token, securityUser.getPermissionValueList());
		
        //将Token 返回前端！！！！前端会进行封装放到请求头中
        
        
        //返回相关页面信息

    }

    /**
     * AbstractAuthenticationProcessingFilter调用子类attemptAuthentication认证之后
     * <b>成功调用</b>
     *
     * @param request  请求
     * @param response 响应
     * @param failed   失败的认证异常
     * @throws IOException      id异常
     * @throws ServletException servlet异常
     */
    @Override
    protected void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response, AuthenticationException failed) throws IOException, ServletException {
        //认证失败的逻辑 比如返回页面error json
    }
}

配置认证过滤器：

@Override
protected void configure(HttpSecurity http) throws Exception {
  //增加自定义认证过滤器
  http.addFilter(tokenLoginFilter)
}

2.3.2、编写授权过滤器

/**
 * @Author BaiYZ
 * @Program SpringSecurityDemo
 * @Description 授权过滤器
 * @Date 2022-04-15 16:47:15
 */
@Component("tokenAuthenticationFilter")
public class TokenAuthenticationFilter extends BasicAuthenticationFilter {
    private TokenManager tokenManager;
    private RedisTemplate redisTemplate;

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

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
        //获取当前认证成功用户权限信息
        UsernamePasswordAuthenticationToken authResult = getAuthentication(request);
        //判断存在权限信息，放到权限上下文
        if (authResult != null) {
            SecurityContextHolder.getContext().setAuthentication(authResult);
        }
        //放行过滤器
        chain.doFilter(request, response);
    }

    /**
     * 从请求中获取解析Token生成UsernamePasswordAuthenticationToken
     *
     * @param request 请求
     * @return UsernamePasswordAuthenticationToken
     */
    private UsernamePasswordAuthenticationToken getAuthentication(HttpServletRequest request) {
        //拿到token 
        String token = request.getHeader("token");
        if (token != null) {
            //从token 解析用户名
            String username = tokenManager.getUserInfoFromToken(token);
            //从redis中获取权限列表
            List<String> permissionList = (List<String>) redisTemplate.opsForValue().get("username");
            List<GrantedAuthority> collect = null;
            if (permissionList != null) {
                collect = permissionList.stream().map(SimpleGrantedAuthority::new).collect(Collectors.toList());
            }
            return new UsernamePasswordAuthenticationToken(username, token, collect);
        }
        return null;
    }

}

配置授权过滤器：

@Override
protected void configure(HttpSecurity http) throws Exception {
  //增加自定义授权过滤器
  http.addFilter(tokenAuthenticationFilter)
}

2.4、编写UserDetailService

/**
 * @Author BaiYZ
 * @Program SpringSecurityDemo
 * @Description 实际查询数据库获取UserDetail
 * @Date 2022-04-15 18:54:03
 */
@Service("userDetailService") //名称必须叫这个，否则无法注入
public class UserDetailServiceImpl implements UserDetailsService {
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //根据用户名查询数据库，获取Security需要的对象

        //返回UserDetail对象
        return new SecurityUser();
    }
}

配置自定义UserDetailService：

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
  //增加自定义授权过滤器
  auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder());
}

2.5、编写核心配置类

/**
 * @Author BaiYZ
 * @Program SpringSecurityDemo
 * @Description token 核心配置类
 * @Date 2022-04-15 18:22:00
 */
@Configuration
public class TokenWebSecurityConfig extends WebSecurityConfigurerAdapter {
    /**
     * 授权失败（为授权）统一处理器
     */
    private final UnAuthenticationEntryPoint unAuthenticationEntryPoint;
    /**
     * 退出处理器
     */
    private final TokenLogOutHandler tokenLogOutHandler;
    /**
     * 认证过滤器
     */
    private final TokenLoginFilter tokenLoginFilter;
    /**
     * 授权过滤器
     */
    private final TokenAuthenticationFilter tokenAuthenticationFilter;
  	/**
     * 实际查询数据库获取UserDetail的逻辑
     */
    private final UserDetailsService userDetailsService;

    @Autowired
    public TokenWebSecurityConfig(UnAuthenticationEntryPoint unAuthenticationEntryPoint, TokenLogOutHandler tokenLogOutHandler, TokenLoginFilter tokenLoginFilter,
                                  TokenAuthenticationFilter tokenAuthenticationFilter,UserDetailsService userDetailsService) {
        this.unAuthenticationEntryPoint = unAuthenticationEntryPoint;
        this.tokenLogOutHandler = tokenLogOutHandler;
        this.tokenLoginFilter = tokenLoginFilter;
        this.tokenAuthenticationFilter = tokenAuthenticationFilter;
        this.userDetailsService = userDetailsService;
    }

    /**
     * 整体配置
     * @param http
     * @throws Exception
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                //没有权限处理器
                .exceptionHandling().authenticationEntryPoint(unAuthenticationEntryPoint)

                //自定义退出成功处理器
                .and()
                .logout()
                .logoutUrl("/logout") //默认为logout
                .addLogoutHandler(tokenLogOutHandler)
                .deleteCookies("JSESSIONID") //要删除的Cookies


                //配置所有的需要授
                .and()
                .authorizeRequests()
                //这里增加需要hasAuth权限或者需要角色的地址认证
                //配置以路径匹配来怕配置权限
//                .antMatchers("/", "/index", "/user/login").permitAll()
//
//                //配置指定页面使用角色管理
//                .antMatchers("/role/admin").hasRole("admin")
//                .antMatchers("/role/service").hasAnyRole("user,test")

                .anyRequest().authenticated()

                //关闭csrf跨域攻击
                .and().csrf().disable()

                //增加自定义认证过滤器
                .addFilter(tokenLoginFilter)

                //增加权限过滤器
                .addFilter(tokenAuthenticationFilter);
    }
    /**
     * 配置权限验证相关
     * @param auth
     * @throws Exception
     */
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailService).passwordEncoder(passwordEncoder());
    }

    /**
     * 设置访问路径相关的
     * @param web
     * @throws Exception
     */
    @Override
    public void configure(WebSecurity web) throws Exception {
        //设置不进行权限校验的路径
        web.ignoring().antMatchers("/");
    }
    
}

三、Handler配置

3.1、授权成功处理器

1、编写处理器

/**
 * @Author BaiYZ
 * @Program SpringSecurityDemo
 * @Description 登陆成功处理逻辑
 * @Date 2022-04-15 15:52:27
 */
@Component("authenticationSuccessHandlerImpl")
public class AuthenticationSuccessHandlerImpl implements AuthenticationSuccessHandler {
    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        //登陆成功的逻辑
    }
}

2、配置到Security配置文件中

@Override 
protected void configure(HttpSecurity http) throws Exception {
        http.successHandler(authenticationSuccessHandlerImpl);
 }

3.2、授权失败处理器

1、编写处理器

/**
 * @Author BaiYZ
 * @Program SpringSecurityDemo
 * @Description 授权失败处理器
 * @Date 2022-04-15 15:57:03
 */
@Component("authenticationFailureHandlerImpl")
public class AuthenticationFailureHandlerImpl implements AuthenticationFailureHandler {

    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
        //授权失败的逻辑
    }
}

2、配置到Security配置文件中

@Override 
protected void configure(HttpSecurity http) throws Exception {
        http.failureHandler(authenticationFailureHandlerImpl);
 }

3.3、退出登陆处理器

1、编写处理器

/**
 * @Author BaiYZ
 * @Program SpringSecurityDemo
 * @Description 退出登陆处理器
 * @Date 2022-04-15 16:02:26
 */
@Component("logoutSuccessHandlerImpl")
public class LogoutSuccessHandlerImpl implements LogoutHandler {

    @Override
    public void logout(HttpServletRequest request, HttpServletResponse response, Authentication authentication) {
        //退出登陆的逻辑
    }
}

2、配置到Sevurity配置文件中

@Override 
protected void configure(HttpSecurity http) throws Exception {
        http
            .and()
            .logout()
            .logoutUrl("/logout") //默认为logout
            .logoutSuccessHandler(logoutSuccessHandlerImpl) //自定义退出成功处理器
            .deleteCookies("JSESSIONID") //要删除的Cookies
}

四、权限注解

4.1、开启权限注解

@Configuration
/**
 * 开启全局方法权限注解  
 * securedEnabled：开启安全注解
 * prePostEnabled：前置后置过滤注解
 */
@EnableGlobalMethodSecurity(securedEnabled = true,prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
}

4.2、常用注解使用

4.2.1、@Secured

适用于方法上，标识当前这个方法是什么样的角色可以访问

    /**
     * securedEnable测试 开启角色权限
     *
     * @return
     */
    @ResponseBody
    @GetMapping("/securedEnabled")
    @Secured({"ROLE_test"}) //允许test角色访问
    public String securedEnabledTest() {
        return "允许访问，这里是 @EnableGlobalMethodSecurity(securedEnabled = true) 注解配置使用@Secure";
    }

4.2.2、@PreAuthorize

适用于方法上,可以用权限或者角色，先校验权限，后执行方法 不通过403

    /**
     * prePostEnabled测试 可以只用权限或者角色，先校验权限，后执行方法 不通过403
     *
     * @return
     */
    @ResponseBody
    @GetMapping("/prePostEnabled")
    @PreAuthorize("hasAnyAuthority('admin')")
    public String prePostEnabled() {
        return "允许访问，这里是 @EnableGlobalMethodSecurity(prePostEnabled = true) 注解配置使用 提前校验@PreAuthorize";
    }

4.2.3、@PostAuthorize

适用于方法上,有任何权限，先执行方法 后校验权限,不通过403

   /**
     * prePostEnabled测试 有任何权限，先执行方法 后校验权限
     *
     * @return
     */
    @ResponseBody
    @GetMapping("/postEnabled")
    @PostAuthorize("hasAnyAuthority('test')")
    public String postAuthorize() {
        return "允许访问，这里是 @EnableGlobalMethodSecurity(prePostEnabled = true) 注解配置使用 后置校验@PostAuthorize";
    }

4.2.4、@PostFilter

适用于方法上,输出匹配的指定值（留下这个其他过滤）

    /**
     * 权限校验之后，输出匹配的指定值（留下这个其他过滤）
     *
     * @return
     */
    @ResponseBody
    @RequestMapping("/postFilter")
    @PostFilter("filterObject == 'admin'")
    public List<String> getAllListPostFilter() {
        ArrayList<String> list = new ArrayList<>();
        list.add("admin");
        list.add("test");
        return list;
    }

会输出 admin , test被过滤掉

4.2.4、@PreFilter

适用于方法上,权限校验之后，输出匹配的指定值

    /**
     * 权限校验之后，输出匹配的指定值
     *
     * @return
     */
    @ResponseBody
    @RequestMapping("/preFilter")
    @PreFilter("filterObject == 'test'")
    public List<String> getAllListPreFilter(@RequestBody List<String> input) {
        return input;
    }

输入：

[
	"test","admin","user","abcd"
]

输出：

[
    "test"
]

五、坑

  1. 角色配置中不需要增加“ROLE_”前缀,但是注解中需要增加，数据库中不用增加

    		public ExpressionInterceptUrlRegistry hasRole(String role) {
			return access(ExpressionUrlAuthorizationConfigurer
                          //这里会传入前缀
					.hasRole(ExpressionUrlAuthorizationConfigurer.this.rolePrefix, role));
		}

    this.rolePrefix在构造方法中进行设置，如果没有覆盖默认的设置GrantedAuthorityDefaults.class会使用前缀

    image-20220415192937614

不会拯救世界的SuperMan
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring-Boot结合Security+JWT 简单实现前后端分离用户登录、授权案例
07-12
Spring-Security结合JWT 实现前后端分离完成权限验证功能案例，案例中，主要完成用户登录获取Token，通过Token访问Rest接口，没有权限或授权失败时返回JSON，前端根据状态码进行重新登录；案例中的用户名称： jake_j，密码：123。用户、角色、及菜单权限都是代码中指定的，未实现查询数据库相关数据。正常开发需要和现有系统数据库结合，这里只是简单说明整体用户认证、授权流程逻辑说明。 仓库地址：https://gitee.com/JakeRhino/spring-security-jwt-demo
spring-security-jwt, 演示如何在 Spring Security 中使用 JWT.zip
09-18
spring-security-jwt, 演示如何在 Spring Security 中使用 JWT Spring Security 和JWT教程这里代码主要用于使用 Spring Security 和 JWT 教程补充无状态身份验证。如果你选择了代码，还可以使用这个库发现添加XSRF保护的策略，以及在Java项目中注册/登录功能的策
spring-security中jwt的使用
qq_36872322的博客
01-13 399
** 1 什么是jwt? 这个规范允许我们使用JWT在用户和服务器之间传递安全可靠的信息。 一个JWT实际上就是一个字符串，它由三部分组成，头部、载荷与签名。 1 header 头部用于描述关于该JWT的最基本的信息，例如其类型以及签名所用的算法等。这也可以被表示成一个JSON对象。 {“typ”:“JWT”,“alg”:“HS256”} 2 载荷（playload） 载荷就是存放有效信息的地方。...
spring security jwt 简单使用
weixin_43727520的博客
11-10 612
spring security jwt 简单使用 首先要定义一个实体类UserDetail.java；并集成org.springframework.security.core.userdetails.UserDetails类； import lombok.Data; import org.springframework.security.core.GrantedAuthority; import org.springframework.security.core.authority.SimpleGrant
Spring Security实现多种方式认证
最新发布
luoxuhuan_的博客
10-15 398
Spring Security的多种认证方式
spring security 校验详解
u013911102的博客
09-10 926
项目场景： 延续上篇文章，在我们APP的应用场景仅依赖于是spring security是不够的，我们还需要扩展相关功能才能够满足我们的需求. 技术详解： 这里就插播一段技术讲解吧，主要是对于spring security的相关实现源码，这里借鉴了https://blog.csdn.net/qq_22172133/article/details/86503223的一些图片. 校验流程图： spring security的拦截器，用户名和密码校验的流程简化如下AbstractAuthentic
springsecurity+oauth2+jwt实现单点登录demo
06-06
该资源是springsecurity+oauth2+jwt实现的单点登录demo，模式为授权码模式，实现自定义登录页面和自定义授权页面。应用数据存在内存中或者存在数据库中（附带数据库表结构），token存储分为数据库或者Redis。demo...
解析SpringSecurity+JWT认证流程实现
08-18
首先，我们需要配置SpringSecurity来使用JWT认证方式，然后在认证流程中，我们使用JWT token来验证用户的身份。在认证完成后，我们将生成一个JWT token，并将其传递给客户端，以便客户端在每次请求时都可以带上这个...
SpringBoot+SpringSecurity+JWT+MybatisPlus实现基于注解的权限验证
08-26
SpringBoot+SpringSecurity+JWT+MybatisPlus实现基于注解的权限验证，可根据注解的格式不同，做到角色权限控制，角色加资源权限控制等，粒度比较细化。 @PreAuthorize("hasAnyRole('ADMIN','USER')")：具有admin或...
Spring Security OAuth2实现使用JWT的示例代码
08-27
Spring Security OAuth2 实现使用 JWT 的示例代码 在本文中，我们将讨论如何使用 Spring Security OAuth2 实现使用 JSON Web Tokens（JWT），并提供了一个完整的示例代码。 Spring Security OAuth2 介绍 Spring ...
Spring Security结合JWT的方法教程
08-28
Spring Security 结合 JWT 的方法教程 Spring Security 是一个基于 Java 的安全框架，提供了强大的身份验证和...通过本教程，读者可以了解 Spring Security 结合 JWT 的实现细节，并掌握如何使用 JWT 实现身份验证。
Spring 之 jwt，过滤器，拦截器，aop，监听器，参数校验
初心魏的博客
05-25 1659
OverrideSystem.out.println("过滤器2初始化");System.out.println("过滤器2前执行");System.out.println("过滤器2后执行");System.out.println("过滤器2毁灭");} }/*** 重写addCorsMappings() 解决跨域问题* 配置：允许http请求进行跨域访问* @Author 有梦想的肥宅*/
SpringSecurity学习之路2-处理创建请求，数据校验
kevin
05-01 216
SpringSecurity学习之路1 在本篇中将会介绍到的内容有：@RequestBody注解、日期类型参数的处理、@Valid注解和BindingResult。先看@RequestBody注解的使用。 场景：前后端分离，后端使用Restful风格进行开发。例子，创建用户请求，并期望返回用户ID信息。下面是Controller代码： 测试代码如下： PS：如果这段测试代码你看不...
Springboot +spring security，认证方式---实现HTTP摘要认证
weixin_40991408的博客
05-30 785
Springboot +spring security，认证方式---实现HTTP摘要认证
spring-security登录流程和集成JWT功能
码上有源
05-03 1139
一、基本登录流程 编写一个配置文件 SecurityConfig.java package com.wesdata.com.config; import com.wesdata.com.filter.JwtAuthenticationTokenFilter; import com.wesdata.com.handler.MyAccessDeniedHandler; import com.wesdata.com.handler.MyAuthenticationEntryPoint; import org.s
SpringSecurity+JWT快速构建登录验证，授权
m0_37979950的博客
06-06 454
SpringSecurity+JWT快速构建登录验证，授权
SpringSecurity认证用户状态的判断
Leon_Jinhai_Sun的博客
11-16 1593
设置用户状态 用户认证业务里，我们封装User对象时，选择了三个构造参数的构造方法，其实还有另一个构造方法： public User(String username, String password, boolean enabled, boolean accountNonExpired, boolean credentialsNonExpired, boolean accountNonLocked, Collection<? extends GrantedAuthority> author
Spring Security6 全新写法，大变样！
江南一点雨的专栏
06-14 4609
自定义 JSON 登录也和之前旧版不太一样了。小伙伴们知道，Spring Security 中默认的登录接口数据格式是 key-value 的形式，如果我们想使用 JSON 格式来登录，那么就必须自定义过滤器或者自定义登录接口，下面松哥先来和小伙伴们展示一下这两种不同的登录形式。Spring Security 默认处理登录数据的过滤器是 UsernamePasswordAuthenticationFilter，在这个过滤器中，系统会通过。
Security 登录认证流程详细分析 源码与图相结合
北
09-25 928
最近在写毕业设计的时候用这个框架，小伙伴给我提了个多种登录方式的需求，说仅仅只有账号、密码登录不太行，说让我增加几种方式，如：手机短信验证登录、邮箱验证登录、第三方登录等等(前两个已经实现，第三方登录还没搞定)一开始也挺让人懵逼，无从下手的。 看了好几篇博客，都弄的不完整，或者就是太高级了，我不太能行。之后就是看博客，说弄懂原理、流程后，写多种方式其实也蛮简单。然后我就老老实实的去Debug了。 这样子的效果是十分好的，多Debug几回，无论是对使用，还是对于编写代码，以及对这个技术的理解都会加深一些，以.
springsecurity 和jwt
09-29
在Spring Security中集成JWT可以实现无状态的身份验证和授权。具体步骤包括： 1. 在认证配置中，通过配置AuthenticationManagerBuilder来指定认证方式，可以是基于用户名和密码的表单认证，也可以是基于token的认证...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不会拯救世界的SuperMan

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值