springSecurity(二)：实现登入获取token与解析token

登入生成token

主要思想

springSecurity使用UsernamePasswordAuthenticationToken类来封装用户名和密码的认证信息

代码实现

发起登入请求后，进入到login()方法

  /**
   * 在接口中我们通过AuthenticationManager的authenticate方法来进行用户认证,
   * 所以需要在SecurityConfig中配置把AuthenticationManager注入容器。
   * @param user
   * @return
   */
  @Override
  public ResponseResult login(User user) {
    //通过AuthenticationManager的authenticate方法来进行用户认证
    UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(user.getUserName(),user.getPassword());
    Authentication authenticate = authenticationManager.authenticate(token);

    //如果没通过，给出对应的提示
    if(Objects.isNull(authenticate)){
      throw new RuntimeException("用户名或密码错误");
    }

    //如果通过了，使用userId生成一个jwt，存入ResponseResult返回
    LoginUser loginUser = (LoginUser)authenticate.getPrincipal();
    String id = loginUser.getUser().getId().toString();
    
    //根据用户id生成token
    String jwt = JwtUtil.createJWT(id);

    //把完整的用户信息存入redis，使用userId作为key
    redisCache.setCacheObject("login:"+id,loginUser);

    ResponseResult responseResult = new ResponseResult();
    responseResult.setCode(200);
    responseResult.setMsg("登入成功");
    Map<String,String> map = new HashMap<>();
    map.put("token",jwt);
    responseResult.setData(map);

    return responseResult;
  }

在执行 Authentication authenticate = authenticationManager.authenticate(token);时，会调用security框架的loadUserByUsername方法查询用户信息，这里我们重写loadUserByUsername方法

@Service
public class UserDetailsServiceImpl implements UserDetailsService {

  @Autowired
  private UserMapper userMapper;

  @Autowired
  private MenuMapper menuMapper;

  @Override
  public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {

    //查询用户信息
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    lambdaQueryWrapper.eq(User::getUserName,username);
    User user = userMapper.selectOne(lambdaQueryWrapper);

    //如果没有查询到用户就抛出异常
    if (Objects.isNull(user)){
      throw new RuntimeException("用户名或密码错误");
    }

    //查询对应的权限信息
    List<String> list = menuMapper.selectPermsByUserId(user.getId());

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

这样执行完loadUserByUsername方法之后，就把权限信息封装到LoginUser中

效果展示

调用接口之后返回一个token信息

{
    "code": 200,
    "msg": "登入成功",
    "data": {
        "token": "eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiJiODhkZmIxZjExMDg0NmZhOTJlN2I5OTM4M2Q3ZTQ5NyIsInN1YiI6IjQiLCJpc3MiOiJ3aHMiLCJpYXQiOjE3MTg2MjQyMTAsImV4cCI6MTcxODYyNzgxMH0.Z-qa-1rD6dIOxKSaeZ_wjHFKs_TY31hFgZnl2Yld4M4"
    }
}

题外话

看以下UsernamePasswordAuthenticationToken源码的实现思想

public class UsernamePasswordAuthenticationToken extends AbstractAuthenticationToken {
    
}

public abstract class AbstractAuthenticationToken implements Authentication, CredentialsContainer {
    
}

这段代码同时可以参考ArrayList的实现思想

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{ 
}


public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
}

思想理论基础

抽象类是一种特殊的类，它的方法体包含抽象方法和非抽象方法
- 抽象方法是一种没有具体实现的方法，必须在子类被重写实现
- 非抽象方法是有具体实现的方法，可以在子类中被继承使用
- 抽象类的主要目的是为了被继承和重写，而不是被实例化
当一个类继承了一个抽象类和实现了一个接口之后，如果抽象类和接口都有方法A()，这个类是否需要实现方法A()呢？
- 答案是不需要。因为当抽象类和接口中含有相同的方法名、参数列表和返回类型时候，这个类并不需要强制重写这个方法。
- 接口默认方法和抽象类中的抽象方法是不同的概念，它们可以共存而不会产生冲突

优点

extends抽象类提供了基础实现
抽象类可以包含部分已实现的方法和成员变量，使子类能够继承这些实现，减少重复代码。例如：

abstract class Animal {
    String name;
    void sleep() {
        System.out.println(name + " is sleeping.");
    }
    abstract void makeSound();
}

implements接口提供了灵活性
接口定义了一组方法，子类必须实现这些方法。这强制子类提供具体实现，同时接口可以用于实现多重继承，因为一个类可以实现多个接口。例如：

interface Pet {
    void play();
}

组合使用的话：
抽象类提供基础功能，接口提供额外功能

public class Dog extends Animal implements Pet {
    public Dog(String name) {
        this.name = name;
    }
    @Override
    void makeSound() {
        System.out.println(name + " says: Woof!");
    }
    @Override
    public void play() {
        System.out.println(name + " is playing.");
    }
}

灵活的接口实现
通过实现接口，一个类可以被视为实现该接口的对象类型，这使得代码更加灵活和松耦合

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
        dog.sleep(); // Animal类的方法
        dog.makeSound(); // Dog类实现的抽象方法
        dog.play(); // Pet接口的方法

        Pet pet = dog; // 可以用接口类型引用对象
        pet.play(); // 接口的方法
    }
}

设计模式的支持
这种组合模式在策略模式和模板方法模式得到了广泛应用。抽象类可以提供通用的算法结构，接口可以定义可替换的行为。

总结

代码复用：继承抽象类可以重用父类的代码。
灵活性：实现接口可以实现多重继承，提供额外功能。
松耦合：接口使得代码更加灵活和易于扩展。
支持设计模式：这种组合在很多设计模式中被广泛应用，提高代码的可维护性和可扩展性。

请求解析token

前端登入获取token之后，之后其他请求在访问接口时候都需要带上token

主要思想

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

代码实现

开启配置

在SecurityConfig类上加上如下注解

@EnableGlobalMethodSecurity(prePostEnabled = true)

在接口上加@PreAuthorize注解

  /**
   * 测试
   * @return
   */
  @RequestMapping("/hello")
  @PreAuthorize("ex.hasAuthority('sysytem:dept:list')")
  public String hello(){
    return "hello";
  }

重写认证过滤器，解析token

@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) {
      throw new RuntimeException("token非法");
    }

    //从redis中获取用户信息
    String redisKey = "login:"+userId;
    LoginUser loginUser = redisCache.getCacheObject(redisKey);
    if(Objects.isNull(loginUser)){
      throw new RuntimeException("用户未登入");
    }

    //存入SecurityContextHolder
    //获取权限信息，封装到Authentication中
    UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(loginUser,null,loginUser.getAuthorities());
    SecurityContextHolder.getContext().setAuthentication(authenticationToken);

    //放行
    filterChain.doFilter(request,response);

  }
}