Spring Security(三更)

最新推荐文章于 2024-03-31 13:51:57 发布

Lazy龙

最新推荐文章于 2024-03-31 13:51:57 发布

阅读量210

点赞数

文章标签： spring java 后端

原文链接：https://www.bilibili.com/video/BV1mm4y1X7Hc?p=40&spm_id_from=pageDriver&vd_source=6b664fb3236a2f45f99b9eb3868cdf31

版权

一般大型项目都是使用Spring Security来做安全框架，小项目用Shiro的比较多。相比Spring Security，Shiro上手更加简单。

一般Web应用需要进行认证和授权

认证：验证当前访问系统的是不是本系统的用户，并且要确认具体是哪个用户

授权：经过认证后判断当前用户是否有权限进行某个操作

而认证和授权也是Spring Security作为安全框架的核心功能。

快速入门

准备工作

搭建一个SpringBoot项目

<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>2.5.0</version>
</parent>
<dependencies>
  <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <dependency>
     <groupId>org.projectlombok</groupId>
     <artifactId>lombok</artifactId>
     <optional>true</optional>  
  </dependency>
</<dependencies>

启动类：

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

控制层

@RestController
public class HelloController{
   @RequestMapping("/hello")
   public String hello(){
      return "hello";
   }
}

引入SpringSecurity

在SpringBoot项目中使用SpringSecurity只需要引入依赖即可实现入门案例

<!--SpringSecurity启动器-->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-security</artifactId> 
</dependency>

引入依赖后去访问之前的接口就会自动跳转到一个SpringSecurity的默认登录页面，默认用户名是user，密码会输出在控制台。必须登录之后才能对接口进行访问。

认证

登录校验流程

SpringSecurity完整流程

SpringSecurity的原理其实是一个过滤器链，内部包含了提供各种功能的过滤器，入门案例中的过滤器：

UsernamePasswordAuthenticationFilter:负责处理登录页面填写了用户名密码后的登录请求

ExceptionTranslationFilter：处理过滤链中抛出的任何AccessDeniedException和AuthenticationException。

FilterSecurityInterceptor: 负责权限校验的过滤器

认证流程

根据认证流程自定义验证

校验流程：

自定义登录逻辑（不连数据库版）

首先记录一下Spring Security官方推荐的密码加密方法

PasswordEncoder pw = new BCryptPasswordEncoder();

//加密
String encode = pw.encode("123456");
System.out.println(encode);

//比较密码
boolean matches = pw.matches("123456",encode);
System.out.println(matches);

但是在实际开发中我们不能直接new，要交给Spring容器管理。编写一个配置类SecurityConfig

@Configuration
public class SecurityConfig{
  
    @Bean
    public PasswordEncoder getPwd(){
       return new BCryptPasswordEncoder();
    }
}

UserDetailServiceImpl:

@Service
public class UserDetailServiceImpl implements UserDetailsService{

     @Autowired
     private PasswordEncoder pw;
   
     @Override
     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException{
          //根据用户名去数据库查询，如果不存在抛异常
          //这里就省去连接数据库查询密码了。。。。
          if(!"admin".equals(username)){
              throw new UsernameNotFoundException("用户名不存在");
          }

          //比较密码(注册时已经加密过)，如果匹配成功返回UserDetails
          boolean matches = pw.matches("123456",encode);
          if(matches == false){
              throw new UsernameNotFoundException("密码错误");
          }

          //第三个参数为权限，多个权限用逗号分割
          return new User(username,password,
          AuthorityUtils.commaSeparatedStringToAuthorityList("admin,normal"));
     }
}

自定义登录页面

虽然 Spring Security 给我们提供了登录页面，但是对于实际项目中，大多喜欢使用自己的登录页面。所以 SpringSecurity 中不仅仅提供了登录页面，还支持用户自定义登录页面。需要修改配置类来实现。

继续对配置类SecurityConfig进行编辑

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter{
  
    @Bean
    public PasswordEncoder getPwd(){
       return new BCryptPasswordEncoder();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception{
        //表单提交
        http.formLogin()
            //自定义登录页面,这样就不会走SpringSecurity的默认登录页了
            //但是也没有了登录的限制，现在随便进哪个页面都可以了，所以这里要用到授权
            .loginPage("/login.html")
            //必须和表单提交的接口名字一样login,才会去执行自定义的登录逻辑
            .loginProcessingUrl("/login")
            //登陆成功之后要跳到哪个页面,只接受POST请求
            .successForwardUrl("/toMain")
            //登录失败后跳转的页面，POST请求
            .failureForwardUrl("/toError");

        //授权
        http.authorizeRequests()
             //放行login.html,不需要认证
             .antMatchers("/login.html").permitAll()
             //放行error.html,不需要认证
             .antMatchers("/error.html").permitAll()
             //所有请求都必须认证才能访问，必须登录，有点像拦截器
             .anyRequest().authenticated();
        
        //关闭csrf防护
        http.csrf().disable();
    }
}

自定义登录流程实现：

自定义登录接口

调用ProviderManager的方法进行认证如果认证通过生成jwt
把用户存入Redis中

自定义UserDetailsService

在这个实现列中去查询数据库

校验

定义JWT认证过滤器 —— 获取token，解析token获取其中的userID，从Redis中获取用户信息，存入SecurityContextHolder

搭建环境

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.6</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>top.xbaoziplus</groupId>
    <artifactId>security</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>security</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!--SpringBoot Web服务-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--MyBatis-plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.3</version>
        </dependency>
        <!--MySQL数据库-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!--Lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!--springboot单元测试-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--SpringSecurity启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <!--SpringSecurity测试-->
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--druid数据库连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.11</version>
        </dependency>
        <!--redis依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--fastjson依赖-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.33</version>
        </dependency>
        <!--jwt依赖-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
            <!--解决Maven插件启动报错-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.22.2</version>
                <configuration>
                    <skipTests>true</skipTests>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

# 指定端口号
server:
  port: 8080

# 配置数据源
spring:
  application:
    name: security
  # 数据库连接池配置
  datasource:
    druid:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/db_security?useUnicode=true&characterEncoding=utf-8&useSSL=false
      username: root
      password: 123456
  # Redis配置
  redis:
	host:     
    port: 6379
    password: 123456
    # 操作0号数据库，默认有16个数据库
    database: 0
    jedis:
      pool:
        max-active: 8 # 最大连接数
        max-wait: 1ms # 连接池最大阻塞等待时间
        max-idle: 4   # 连接池中的最大空闲连接
        min-idle: 0   # 连接池中的最小空闲连接
  cache:
    redis:
      time-to-live: 1800000 # 设置数据过期时间为半小时（ms）

Redis配置类。主要是对Redis默认的序列化器进行一个更换。

@Configuration
public class RedisConfig {

    @Bean
    @SuppressWarnings(value = { "unchecked", "rawtypes" })
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory)
    {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        FastJsonRedisSerializer serializer = new FastJsonRedisSerializer(Object.class);

        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(serializer);

        // Hash的key也采用StringRedisSerializer的序列化方式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(serializer);

        template.afterPropertiesSet();
        return template;
    }
}

JWT工具类

public class JwtUtil {
    // 设置有效期为60 * 60 *1000  一个小时
    public static final Long JWT_TTL = 60 * 60 * 1000L;
    //设置秘钥明文
    public static final String JWT_KEY = "xbaozi";

    public static String getUUID() {
        String token = UUID.randomUUID().toString().replaceAll("-", "");
        return token;
    }

    /**
     * 生成jtw
     * @param subject token中要存放的数据（json格式）
     */
    public static String createJWT(String subject) {
        JwtBuilder builder = getJwtBuilder(subject, null, getUUID());// 设置过期时间
        return builder.compact();
    }

    /**
     * 生成jwt
     * @param subject   token中要存放的数据（json格式）
     * @param ttlMillis token超时时间
     */
    public static String createJWT(String subject, Long ttlMillis) {
        JwtBuilder builder = getJwtBuilder(subject, ttlMillis, getUUID());// 设置过期时间
        return builder.compact();
    }

    private static JwtBuilder getJwtBuilder(String subject, Long ttlMillis, String uuid) {
        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
        SecretKey secretKey = generalKey();
        long nowMillis = System.currentTimeMillis();
        Date now = new Date(nowMillis);
        if (ttlMillis == null) {
            ttlMillis = JwtUtil.JWT_TTL;
        }
        long expMillis = nowMillis + ttlMillis;
        Date expDate = new Date(expMillis);
        return Jwts.builder()
                .setId(uuid)            //唯一的ID
                .setSubject(subject)    // 主题  可以是JSON数据
                .setIssuer("sg")        // 签发者
                .setIssuedAt(now)       // 签发时间
                .signWith(signatureAlgorithm, secretKey) //使用HS256对称加密算法签名, 第二个参数为秘钥
                .setExpiration(expDate);
    }

    /**
     * 创建token
     */
    public static String createJWT(String id, String subject, Long ttlMillis) {
        JwtBuilder builder = getJwtBuilder(subject, ttlMillis, id);// 设置过期时间
        return builder.compact();
    }

    /**
     * 生成加密后的秘钥 secretKey
     */
    public static SecretKey generalKey() {
        byte[] encodedKey = Base64.getDecoder().decode(JwtUtil.JWT_KEY);
        SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
        return key;
    }

    /**
     * 解析
     * @throws Exception
     */
    public static Claims parseJWT(String jwt) throws Exception {
        SecretKey secretKey = generalKey();
        return Jwts.parser()
                .setSigningKey(secretKey)
                .parseClaimsJws(jwt)
                .getBody();
    }
}

Redis工具类。这里主要是对Redis操作进行了进一步的封装

@SuppressWarnings(value = { "unchecked", "rawtypes" })
@Component
public class RedisCache
{
    @Autowired
    public RedisTemplate redisTemplate;

    /**
     * 缓存基本的对象，Integer、String、实体类等
     * @param key 缓存的键值
     * @param value 缓存的值
     */
    public <T> void setCacheObject(final String key, final T value)
    {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     * @param key 缓存的键值
     * @param value 缓存的值
     * @param timeout 时间
     * @param timeUnit 时间颗粒度
     */
    public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)
    {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }

    /**
     * 设置有效时间
     * @param key Redis键
     * @param timeout 超时时间
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout)
    {
        return expire(key, timeout, TimeUnit.SECONDS);
    }

    /**
     * 设置有效时间
     * @param key Redis键
     * @param timeout 超时时间
     * @param unit 时间单位
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit)
    {
        return redisTemplate.expire(key, timeout, unit);
    }

    /**
     * 获得缓存的基本对象。
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public <T> T getCacheObject(final String key)
    {
        ValueOperations<String, T> operation = redisTemplate.opsForValue();
        return operation.get(key);
    }

    /**
     * 删除单个对象
     * @param key
     */
    public boolean deleteObject(final String key)
    {
        return redisTemplate.delete(key);
    }

    /**
     * 删除集合对象
     * @param collection 多个对象
     */
    public long deleteObject(final Collection collection)
    {
        return redisTemplate.delete(collection);
    }

    /**
     * 缓存List数据
     * @param key 缓存的键值
     * @param dataList 待缓存的List数据
     * @return 缓存的对象
     */
    public <T> long setCacheList(final String key, final List<T> dataList)
    {
        Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
        return count == null ? 0 : count;
    }

    /**
     * 获得缓存的list对象
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public <T> List<T> getCacheList(final String key)
    {
        return redisTemplate.opsForList().range(key, 0, -1);
    }

    /**
     * 缓存Set
     * @param key 缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet)
    {
        BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
        Iterator<T> it = dataSet.iterator();
        while (it.hasNext())
        {
            setOperation.add(it.next());
        }
        return setOperation;
    }

    /**
     * 获得缓存的set
     * @param key
     * @return
     */
    public <T> Set<T> getCacheSet(final String key)
    {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 缓存Map
     * @param key
     * @param dataMap
     */
    public <T> void setCacheMap(final String key, final Map<String, T> dataMap)
    {
        if (dataMap != null) {
            redisTemplate.opsForHash().putAll(key, dataMap);
        }
    }

    /**
     * 获得缓存的Map
     * @param key
     * @return
     */
    public <T> Map<String, T> getCacheMap(final String key)
    {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 往Hash中存入数据
     * @param key Redis键
     * @param hKey Hash键
     * @param value 值
     */
    public <T> void setCacheMapValue(final String key, final String hKey, final T value)
    {
        redisTemplate.opsForHash().put(key, hKey, value);
    }

    /**
     * 获取Hash中的数据
     * @param key Redis键
     * @param hKey Hash键
     * @return Hash中的对象
     */
    public <T> T getCacheMapValue(final String key, final String hKey)
    {
        HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
        return opsForHash.get(key, hKey);
    }

    /**
     * 删除Hash中的数据
     * @param key
     * @param hkey
     */
    public void delCacheMapValue(final String key, final String hkey)
    {
        HashOperations hashOperations = redisTemplate.opsForHash();
        hashOperations.delete(key, hkey);
    }

    /**
     * 获取多个Hash中的数据
     * @param key Redis键
     * @param hKeys Hash键集合
     * @return Hash对象集合
     */
    public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys)
    {
        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }

    /**
     * 获得缓存的基本对象列表
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection<String> keys(final String pattern)
    {
        return redisTemplate.keys(pattern);
    }
}

fastjson对Redis工具类的配置

public class FastJsonRedisSerializer<T> implements RedisSerializer<T>
{

    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

    private Class<T> clazz;

    static
    {
        ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
    }

    public FastJsonRedisSerializer(Class<T> clazz)
    {
        super();
        this.clazz = clazz;
    }

    @Override
    public byte[] serialize(T t) throws SerializationException
    {
        if (t == null)
        {
            return new byte[0];
        }
        return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
    }

    @Override
    public T deserialize(byte[] bytes) throws SerializationException
    {
        if (bytes == null || bytes.length <= 0)
        {
            return null;
        }
        String str = new String(bytes, DEFAULT_CHARSET);

        return JSON.parseObject(str, clazz);
    }


    protected JavaType getJavaType(Class<?> clazz)
    {
        return TypeFactory.defaultInstance().constructType(clazz);
    }
}

自定义登录逻辑

实现UserDetailsService

@Service
public class UserDetailServiceImpl implements UserDetailsService{

     @Autowired
     private UserMapper userMapper;
   
     @Override
     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException{
         //查询用户信息
         LambdaQueryWrapper<User> querywapper = new LambdaQueryWrapper<>();
         queryWrapper.eq(User::getUserName,username);
         User user = userMapper.selectOne(queryWrapper);
         //如果没有查询到用户就抛出异常
         if(Objects.isNull(user)){
            throw new RuntimeException("用户名或者密码错误");
         }
         //查询对应的权限信息


         //把数据封装成UserDetails返回,LoginUser实现UserDetails
         return new LoginUser(user);
     }
}

修改 Spring Security默认密码加密，创建配置类SecurityConfig

public class SecurityConfig extends WebSecurityConfigurerAdapter{
     @Autowired
     private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;

     //创建BCryptPasswordEncoder注入容器
     @Bean
     public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder(); 
     }

     @Override
     protected void configure(HttpSecurity http) throws Exception{
          //关闭csrf
          http.csrf().disable()
          //不通过Session获取SecurityContext
          .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
          .and()
          .authorizeRequests()
          //对于登录接口  允许匿名访问
          .antMatchers("/user/login").anonymous()
          //除上面外的所有请求全部需要鉴权认证
          .anyRequest().authenticated();
 
        http.addFilterBefore(jwtAuthenticationTokenFilter,UsernamePasswordAuthenticationFilter.class);
     }
}

使用密码加密直接注入

@Autowired
private PasswordEncoder passwordEncoder;

登录接口代码实现

接下我们需要自定义登陆接口，然后让SpringSecurity对这个接口放行,让用户访问这个接口的时候不用登录也能访问。
在接口中我们通过AuthenticationManager的authenticate方法来进行用户认证,所以需要在SecurityConfig中配置把AuthenticationManager注入容器
认证成功的话要生成一个Jwt，放入响应中返回。并且为了让用户下回请求时能通过iwt识别出具体的是哪个用户，我们需要把用户信息存入redis，可以把用户id作为key。

@RestController
public class LoginController{

    @Autowired
    private LoginService loginService;
   
    @PostMapping("/user/login")
    public ResponseResult login(@RequestBody User user){
       //登录
       return loginService.login(user);  
    }

    @RequestMapping("/user/logout")
    public ResponseResult logout(){
       return loginService.logout();
    }
}

public interface LoginService{
    ResponseResult login(User user);
    ResponseResult logout();
}

@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);
    }

    @Override
    public ResponseResult logout(){
        //获取SecurityContextHolder中的用户id
        UsernamePasswordAuthentication authentication = (UsernamePasswordAuthentication )SecurityContextHolder.getContext().getAuthentication();
        LoginUser loginUser = (LoginUser) authentication.getPrincipal();
        Long userid = loginUser.getUser().getId();
        //删除Redis中的值
        redisCache.deleteObject("login:"+userid);
        return new ResponseResult(200,"注销成功");
    }
}

定义Jwt认证过滤器:

获取token
解析token获取其中的userid
从redis中获取用户信息
存入SecurityContextHolder

@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter{

     @Autowired
     private RedisCache redisCache;
     @Override
     protected void doFilterInternal(HttpServletRequest request,HttpServletResponse response,FilterChain filterChain){
        //从前端传过来的请求头获取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().setAuthenication(authenticationToken);
        //放行
        filterChain.doFilter(request,response);
     }
}

SecurityConfig配置类详解

public class SecurityConfig extends WebSecurityConfigurerAdapter{
     @Autowired
     private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;

     //创建BCryptPasswordEncoder注入容器
     @Bean
     public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder(); 
     }

     @Override
     protected void configure(HttpSecurity http) throws Exception{
          //关闭csrf
          http.csrf().disable()
              .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
              .and()
              .authorizeRequests()
              .antMatchers("/user/login").anonymous()
              .antMatchers("/hello").permitAll()
              .anyRequest().authenticated();
     }
}

授权

在SpringSecurity中，会使用默认的FilterSecuritylinterceptor来进行权限校验。在FilterSecuritylnterceptor中会从SecurityContextHolder获取其中的Authentication，然后获取其中的权限信息。当前用户是否拥有访问当前资源所需的权限

所以我们在项目中只需要把当前登录用户的权限信息也存入Authentication。
然后设置我们的资源所需要的权限即可。

限制访问资源所需要的权限

Springsecurity为我们提供了基于注解的权限控制方案，这也是我们项目中主要采用的方式。我们可以使用注解去指定访问对应的资源所需的权限。
但是要使用它我们需要在SpringSecurity配置类先开启相关配置。

@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter{
     @Autowired
     private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;

     //创建BCryptPasswordEncoder注入容器
     @Bean
     public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder(); 
     }

     @Override
     protected void configure(HttpSecurity http) throws Exception{
          //关闭csrf
          http.csrf().disable()
          //不通过Session获取SecurityContext
          .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
          .and()
          .authorizeRequests()
          //对于登录接口  允许匿名访问
          .antMatchers("/user/login").anonymous()
          //除上面外的所有请求全部需要鉴权认证
          .anyRequest().authenticated();
 
        http.addFilterBefore(jwtAuthenticationTokenFilter,UsernamePasswordAuthenticationFilter.class);
     }
}

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

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

封装权限信息

@Service
public class UserDetailServiceImpl implements UserDetailsService{

     @Autowired
     private UserMapper userMapper;
   
     @Override
     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException{
         //查询用户信息
         LambdaQueryWrapper<User> querywapper = new LambdaQueryWrapper<>();
         queryWrapper.eq(User::getUserName,username);
         User user = userMapper.selectOne(queryWrapper);
         //如果没有查询到用户就抛出异常
         if(Objects.isNull(user)){
            throw new RuntimeException("用户名或者密码错误");
         }
         //查询对应的权限信息
         List<String> list = new ArrayList<>(Arrays.asList("test","admin"));
         
         //把数据封装成UserDetails返回,LoginUser实现UserDetails
         return new LoginUser(user,list);
     }
}

实体类新增有参构造方法

重写getAuthorities()方法

@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter{

     @Autowired
     private RedisCache redisCache;
     @Override
     protected void doFilterInternal(HttpServletRequest request,HttpServletResponse response,FilterChain filterChain){
        //从前端传过来的请求头获取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,loginUser.getAuthorities());
        SecurityContextHolder.getContext().setAuthenication(authenticationToken);
        //放行
        filterChain.doFilter(request,response);
     }
}

从数据库查询权限信息

RBAC权限模型

RBAC权限模型（Role-Based Access Control）即：基于角色的权限控制。这是目前最常被开发者使用也是相对易用、通用权限模型

根据userid查询 perms 对应的role和menu都必须是正常状态的

--distinct 去重
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 = 2 and r.'status' = 0 and m.'status' = 0

使用MybatisPlus实现

public interface MenuMapper extends BaseMapper<Menu>{
   List<String> selectPermsByUserId(long userid);
}

@Service
public class UserDetailServiceImpl implements UserDetailsService{

     @Autowired
     private UserMapper userMapper;

     @Autowired
     private MenuMapper menuMapper;
   
     @Override
     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException{
         //查询用户信息
         LambdaQueryWrapper<User> querywapper = new LambdaQueryWrapper<>();
         queryWrapper.eq(User::getUserName,username);
         User user = userMapper.selectOne(queryWrapper);
         //如果没有查询到用户就抛出异常
         if(Objects.isNull(user)){
            throw new RuntimeException("用户名或者密码错误");
         }
         //查询对应的权限信息
         //List<String> list = new ArrayList<>(Arrays.asList("test","admin"));
         List<String> list = menuMapper.selectPermsByUserId(user.getId());
         
         //把数据封装成UserDetails返回,LoginUser实现UserDetails
         return new LoginUser(user,list);
     }
}

自定义失败处理

我们还希望在认证失败或者是授权失败的情况下也能和我们的接口一样返回相同结构的Jiso，这样可以让前端能对响应进行统一的处理。要实现这个功能我们需要知道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 authException){
      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){

      ResponseResult result = new ResponseResult(HttpStatus.FORBIDDEN.value(),"您的权限不足");
      String json = JSON.toJSONString(result);
      //处理异常
      WebUtils.renderString(response,json);
    }
}

配置给SpringSecurity

@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter{
     @Autowired
     private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
     @Autowired
     private AuthenticationEntryPoint authenticationEntryPoint;
     @Autowired
     private AccessDeniedHandler accessDeniedHandler;

     //创建BCryptPasswordEncoder注入容器
     @Bean
     public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder(); 
     }

     @Override
     protected void configure(HttpSecurity http) throws Exception{
          //关闭csrf
          http.csrf().disable()
          //不通过Session获取SecurityContext
          .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
          .and()
          .authorizeRequests()
          //对于登录接口  允许匿名访问
          .antMatchers("/user/login").anonymous()
          //除上面外的所有请求全部需要鉴权认证
          .anyRequest().authenticated();
 
//添加过滤器        http.addFilterBefore(jwtAuthenticationTokenFilter,UsernamePasswordAuthenticationFilter.class);
         
           //配置异常处理器
           http.exceptionHandling()
              //配置认证失败处理器
              .authenticationEntryPoint(authenticationEntryPoint)
              .accessDeniedHandler(accessDeniedHandler);
     }
}

跨域

浏览器出于安全的考虑，使用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();

@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter{
     @Autowired
     private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
     @Autowired
     private AuthenticationEntryPoint authenticationEntryPoint;
     @Autowired
     private AccessDeniedHandler accessDeniedHandler;

     //创建BCryptPasswordEncoder注入容器
     @Bean
     public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder(); 
     }

     @Override
     protected void configure(HttpSecurity http) throws Exception{
          //关闭csrf
          http.csrf().disable()
          //不通过Session获取SecurityContext
          .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
          .and()
          .authorizeRequests()
          //对于登录接口  允许匿名访问
          .antMatchers("/user/login").anonymous()
          //除上面外的所有请求全部需要鉴权认证
          .anyRequest().authenticated();
 
//添加过滤器        http.addFilterBefore(jwtAuthenticationTokenFilter,UsernamePasswordAuthenticationFilter.class);
         
           //配置异常处理器
           http.exceptionHandling()
              //配置认证失败处理器
              .authenticationEntryPoint(authenticationEntryPoint)
              .accessDeniedHandler(accessDeniedHandler);


        //允许跨域
        http.cors();
     }
}

其他权限校验方法

我们前面都是使用@PreAuthorize注解，然后在在其中使用的是hasAuthority方法进行校验。Springsecurity还为我们提供了其它方法例如: hasAnyAuthority，hasRole，hasAnyRole，等。
这里我们先不急着去介绍这些方法，我们先去理解hasAuthority的原理，然后再去学习其他方法你就更容易理解，而不是死记硬背区别。并且我们也可以选择定义校验方法，实现我们自己的校验逻辑。
hasAuthority方法实际是执行到了SecurityExpressionRoot的hasAuthority，大家只要断点调试既可知道它内部的校验原理。
它内部其实是调用authentication的getAuthorities方法获取用户的权限列表。然后判断我们存入的方法参数数据在权限列表中。
hasAnyAuthority方法可以传入多个权限，只有用户有其中任意一个权限都可以访问对应资源
hasRole要求有对应的角色才可以访问，但是它内部会把我们传入的参数拼接上 ROLE后再去比较。所以这种情况下要用用户对应的权限也要有 ROLE这个前缀才可可以。
hasAnyRole 有任意的角色就可以访问。它内部也会把我们传入的参数拼接上 ROLE后再去比较。所以这种情况下要用用户对应的权限也要有 ROLE_这个前缀才可以。

自定义权限校验方法

我们也可以定义自己的权限校验方法，在@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";
    }
}

基于配置的权限控制

@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter{
     @Autowired
     private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
     @Autowired
     private AuthenticationEntryPoint authenticationEntryPoint;
     @Autowired
     private AccessDeniedHandler accessDeniedHandler;

     //创建BCryptPasswordEncoder注入容器
     @Bean
     public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder(); 
     }

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

          //除上面外的所有请求全部需要鉴权认证
          .anyRequest().authenticated();
 
//添加过滤器        http.addFilterBefore(jwtAuthenticationTokenFilter,UsernamePasswordAuthenticationFilter.class);
         
           //配置异常处理器
           http.exceptionHandling()
              //配置认证失败处理器
              .authenticationEntryPoint(authenticationEntryPoint)
              .accessDeniedHandler(accessDeniedHandler);


        //允许跨域
        http.cors();
     }
}

CSRF

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

认证处理器

在UsernamePasswordAuthenticationFilter进行登录认证的时候，如果登录成功了是会调用AuthenticationSuccessHandler的方法进行认证成功后的处理的。AuthenticationSuccessHandler就是登录成功处理器。

在UsernamePasswordAuthenticationFilter进行登录认证的时候，如果登录失败了是会调用AuthenticationFailureHandler的方法进行认证成功后的处理的。AuthenticationFailureHandler就是登录失败处理器。
我们也可以自己去自定义成功、失败处理器进行相应处理。

@Component
public class SGSuccessHandler implements AuthenticationSuccessHandler{

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request,HttpServletResponse response,Authentication authentication) throws IOException,ServletException{
       System.out.println("认证成功了");
    } 
}

@Component
public class SGFailureHandler implements AuthenticationFailureHandler{

    @Override
    public void onAuthenticationFailure(HttpServletRequest request,HttpServletResponse response,Authentication authentication) throws IOException,ServletException{
       System.out.println("认证失败了");
    } 
}

@Component
public class SGLogoutSuccessHandler implements LogoutSuccessHandler{

    @Override
    public void onLogoutSuccess(HttpServletRequest request,HttpServletResponse response,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;
     
     @Override
     protected void configure(HttpSecurity http) throws Exception{
         http.formLogin()
             
             //配置认证成功处理器
             .successHandler(successHandler)

             //配置认证失败处理器
             .failureHandler(failureHandler);
         
         http.logout()
             //配置注销成功处理器
             .logoutSuccessHandler(logoutSuccessHandler);

    
         http.authorizeRequests().anyRequest().authenticated();      
     }
}

Lazy龙

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Spring Security(三更)

首先记录一下Spring Security官方推荐的密码加密方法//加密//比较密码但是在实际开发中我们不能直接new，要交给Spring容器管理。编写一个配置类SecurityConfig@Bean@Service@Autowired@Override//根据用户名去数据库查询，如果不存在抛异常//这里就省去连接数据库查询密码了。。。。if(!throw new UsernameNotFoundException("用户名不存在");
复制链接

扫一扫