SpringSecurity详解，实现自定义登录接口

1 SpringSecurity概述

1.1 权限框架

目前市面上比较流行的权限框架主要实Shiro和Spring Security，这两个框架各自侧重点不同，各有各的优劣。

1.1.1 Apache Shiro

Apache Shiro是一个开源安全框架，提供身份验证、授权、密码学和会话管理。Shiro框架直观、易用，同时也能提供健壮的安全性。

特点:

Shiro的特点：

易于理解的Java Security APl
简单的身份认证（登录)，支持多种数据源(LDAP，JDBC，Kerberos，ActiveDirectory等)
对角色的简单的签权(访问控制)，支持细粒度的签权
支持一级缓存，以提升应用程序的性能
内置的基于POJO企业会话管理，适用于Web 以及非 Web的环境
异构客户端会话访问
非常简单的加密API
不跟任何的框架或者容器捆绑，可以独立运行

1.1.2 SpringSecurity

Spring Security是一个能够为基于Spring的企业应用系统提供描述性安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了Spring IoC（依赖注入，也称控制反转）和AOP（面向切面编程）功能，为应用系统提供声明式的安全访问控制功能，减少了为企业系统安全控制编写大量重复代码的工作。

Spring Security是Spring家族中的一个安全管理框架。相比与另外一个安全框架Shiro，它提供了更丰富的功能，社区资源也比shiro丰富。一般Web应用的需要进行认证和授权。而认证和授权也是SpringSecurity作为安全框架的核心功能。

SpringSecurity的特点：

与Spring Boot集成非常简单。
功能强大，高度可定制化。
支持OAuth2.0。
强大的加密ARI。
防止跨站请求伪造攻击（CSRF)。
提供Spring Cloud分布式组件。

1.2 授权和认证

一般来说，Web应用的安全性包括用户认证（Authentication）和用户授权（Authorization）两个部分，这两点也是SpringSecurity重要核心功能。

（1）用户认证：验证某个用户是否为系统中的合法主体，也就是说用户能否访问该系统。用户认证一般要求用户提供用户名和密码。系统通过校验用户名和密码来完成认证过程。

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

RBAC (Role Based Access Control)基于角色的访问控制，通过抽象出“用户、角色、权限”"三个概念，实现用户分配角色，角色分配权限的权限管理方式，也是目前企业中权限管理主要实现方案。

案例如下图所示：

在这里插入图片描述

1.3 SpringSecurity的功能

Spring Security对Web安全性的支持大量地依赖于Servlet过滤器。这些过滤器拦截进入请求，并且在应用程序处理该请求之前进行某些安全处理。 Spring Security提供有若干个过滤器，它们能够拦截Servlet请求，并将这些请求转给认证和访问决策管理器处理，从而增强安全性。

如今的Spring Security已经成为Spring Framework下最成熟的安全系统，它为我们提供了强大而灵活的企业级安全服务，如：

认证授权机制
Web资源访问控制
业务方法调用访问控制
领域对象访问控制Access Control List（ACL）
单点登录（Central Authentication Service）
信道安全（Channel Security）管理等功能

2 认证原理及流程

2.1 项目引入SpringSecurity

项目中单纯整合SpringSecurity很简单，先添加spring-boot-starter-security依赖

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

引入依赖后我们在尝试访问系统的任何接口就会自动跳转到一个SpringSecurity的默认登陆页面，默认用户名是user,密码会输出在控制台。必须登陆之后才能对接口进行访问。

在这里插入图片描述

那是添加了该依赖如何就能实现对所有接口的拦截呢？

SpringSecurity的原理其实就是一个过滤器链，内部包含了提供各种功能的过滤器。我们看下一个简单的过滤器链：

在这里插入图片描述

UsernamePasswordAuthenticationFilter：负责处理我们在登陆页面填写了用户名密码后的登陆请求。入门案例的认证工作主要有它负责。

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

FilterSecurityInterceptor：负责权限校验的过滤器。

以上只是列举了主要的几个过滤器，详细流程如下。

2.2 认证流程详解

在这里插入图片描述

Authentication接口：它的实现类，表示当前访问系统的用户，封装了用户相关信息。

AuthenticationManager接口：定义了认证Authentication的方法。

UserDetailsService接口：加载用户特定数据的核心接口。里面定义了一个根据用户名查询用户信息的方法loadUserByUsername(String username)。

UserDetails接口：提供核心用户信息。通过UserDetailsService根据用户名获取处理的用户信息要封装成UserDetails对象返回。然后将这些信息封装到Authentication对象中。

可以看到整个过程过滤器UsernamePasswordAuthenticationFilter先拦截用户的请求，调用AuthenticationManager接口的authenticate方法将用户信息传递；调用AuthenticationProvider接口(AbstractUserDetailsAuthenticationProvider是它的实现类，DaoAuthenticationProvider是实现类的实现类)；在调用userDetailsService的loadUserByUsername()方法根据用户名查询对应用户和权限信息，默认走的是InMemoryUserDetailsManager实现类，及在内存中查找；将信息封装成对象一层层返回。

可以看到众多过滤器一层接一层。那我们如果要自己实现登录接口，从哪介入呢？

能介入最主要的地方一个是开头一个是UserDetailsService层。

3 自定义登录接口

3.1 理论讲解

要实现自定义登录，最主要是两个地方：

要在自己写的页面手动调用登录接口同时还要进行附加操作。
UserDetailsService层不可能从内存中查询用户，需要跟实际的权限数据库关联。

对应的解决方法如下：

编写登录接口，在其中调用ProviderManager.authenticate()方法。该接口需要再未登录的情况下可调用，所以要放开权限。
编写个UserDetailsService的实现类，重写loadUserByUsername()方法，在改方法中根据传来的用户名去自己的权限数据库查询用户信息。封装到用户实体类中。

完整流程如下：

在前后端分离中我们一般采用token验证，先调用我们要自定义登录接口，通过自定义接口调用调用ProviderManager的方法进行认证，如果认证通过生成jwt，然后将jwt返回给前端，同时将用户信息包括用户权限信息等存入到redis数据库中，redis数据库作为缓存读取速度远远大于从数据库中进行读取用户信息。然后通过我们创建的UserDetailsServiceImpl实现类中去查询数据库。除此之外我们还需要定义JWT认证过滤器，从前端请求头中获取token，解析token获取其中的userid，然后根据userid从redis中获取用户信息存入SecurityContextHolder。具体流程如下图：

在这里插入图片描述

3.2 代码实战

定义一个UserDetails的实体类用来存放用户信息。

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.SpringSecurityCoreVersion;
import org.springframework.security.core.userdetails.UserDetails;

import java.io.Serializable;
import java.util.Collection;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements UserDetails, Serializable {
      
      
    private static final long serialVersionUID = SpringSecurityCoreVersion.SERIAL_VERSION_UID;

    private static final Log logger = LogFactory.getLog(org.springframework.security.core.userdetails.User.class);

    private LoginUser loginUser;


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

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

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

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

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

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

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

自己定义UserDetailsService的实现类，重写loadUserByUsername方法，在其中查询自己的数据库。

import com.project.business.userDetailsService.entity.User;
import com.project.business.userDetailsService.mapper.UserMapper;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;

import javax.annotation.Resource;

public class UserDetailsServiceImpl implements UserDetailsService {
      
      

    @Resource
    private UserMapper userMapper;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
      
      
        LoginUser loginUser = userMapper.loadUserByUsername(username);
        //查询不到该用户信息抛异常
        if(loginUser == null) {
      
      
            throw new RuntimeException("用户名或者密码错误");
        }
        User user = new User(loginUser);
        return user;
    }
}

自定义登录接口

我们需要自定义登陆接口，然后让SpringSecurity对这个接口放行，让用户访问这个接口的时候不用登录也能访问。

在接口中我们通过AuthenticationManager的authenticate方法来进行用户认证,所以需要在SecurityConfig中配置把AuthenticationManager注入容器。认证成功的话要生成一个jwt即token，放入响应中返回。并且为了让用户下回请求时能通过jwt识别出具体的是哪个用户，我们需要把用户信息存入redis有效时间为30分钟，可以把用户id作为key。登录后在访问时，后台会根据token解析出用户的userid去redis中查询，判断用户是否登陆过。

登录接口代码如下：

@RestController
@RequestMapping("/user")
public class LoginController {
      
      

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private AuthenticationManager authenticationManager;

    private static final String USER_PREFIX = "login:";


    @PostMapping("/login")
    public Result login(@RequestBody LoginUser loginUser) {
      
      
        //通过AuthenticationManager的authenticate方法来进行用户认证
        UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(loginUser.getUsername(), loginUser.getPassword());
        Authentication authenticate = authenticationManager.authenticate(usernamePasswordAuthenticationToken);
        if (authenticate == null) {
      
      
            return Result.error(401, "登录校验失败");
        } else {
      
      
            //获取用户信息
            User user = (User) authenticate.getPrincipal();
            //获取用户id
            Long id = user.getLoginUser().getId();
            //根据用户id生成token
            String token = JwtUtil.createJWT(id.toString());
            //将token放在redis中
            redisTemplate.opsForValue().set(USER_PREFIX + String.valueOf(id),user,30, TimeUnit.MINUTES);
            return Result.ok("登录成功，返回token").put("token", token);
        }
    }
}

让Security放开user/login访问权限

public class SecurityConfig extends WebSecurityConfigurerAdapter {
      
      
    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
      
      
        return super.authenticationManagerBean();

    }

    /**
     * @param http
     * @throws Exception
     */

    @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认证

至此第一次登录就成功了，那之后调用接口怎么能判断是登陆过的不会再被springsecurity拦截了呢。

思路：

之后所有发送的请求，请求头中会带着token，需要自定义一个优先级靠前的过滤器，这个过滤器会去获取请求头中的token，对token进行解析取出其中的userid，去上一步存到的redis(或其他库)中查询，如果能查到代表之前登陆过了不需要再认证，封装Authentication对象存入SecurityContextHolder，之后springsecurity自己的过滤器会通过SecurityContextHolder获取信息判断是否登陆过；如果没查到说明没登录或登录过期，需要再次认证。

过滤器

@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
      
      

    @Resource
    private RedisTemplate redisTemplate;

    private static final String USER_PREFIX = "login:";

    @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 = USER_PREFIX + userid;
        JSONObject jsonObject = (JSONObject) redisTemplate.opsForValue().get(redisKey);
        User user = JSONObject.parseObject(jsonObject.toJSONString(), User.class);
        if(Objects.isNull(user)){
      
      
            throw new RuntimeException("用户未登录");
        }
        //存入SecurityContextHolder
        //获取权限信息封装到Authentication中
        UsernamePasswordAuthenticationToken authenticationToken =
                new UsernamePasswordAuthenticationToken(user,null,null);
        SecurityContextHolder.getContext().setAuthentication(authenticationToken);
        //放行
        filterChain.doFilter(request, response);
    }
}

要把过滤器添加进配置，并且放到UsernamePasswordAuthenticationFilter前面，因为UsernamePasswordAuthenticationFilter过滤器是security过滤器链首位的，在他之前就要把用户状态存进SecurityContextHolder。

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
      
      
    @Resource
    private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
    @Override
    protected void configure(HttpSecurity http) throws Exception {
      
      
        //此行要和上面配置文件中该方法中的内容写在一块，此处为了省略篇幅不都粘过来了
        http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
    }
}

3.3 接口测试

在调用user/login登录接口之前其他接口都访问不了，汇报403,Forbidden。此时调用登录接口。
在这里插入图片描述

可以看到，登录接口调用成功，返回一个根据userId生成的token，且redis中存储了登录用户的信息，30分钟过期。在这30分钟内，携带请求头token就可以正常访问其他接口。
在这里插入图片描述
更换加密方式

上述示例中采用的是明文方式比对。测试的时候在密码前加{noop}代表明文比对。

实际项目中一般不会在数据库中存储明文，会对其进行加密，就需要替换PasswordEncoder。
我们一般使用SpringSecurity为我们提供的BCryptPasswordEncoder。
我们只需要使用把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验。

我们可以在刚才创建的SecurityConfig配置类中注入BCryptPasswordEncoder对象。

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
      
      

    @Bean
    public PasswordEncoder passwordEncoder(){
      
      
        return new BCryptPasswordEncoder();
    }
}

可以先用其加密入库，再次登录依旧对比成功。
在这里插入图片描述