Spring Security 入门原理及实战

时间  2019-11-13
标签 spring security 入门 原理 实战 栏目 Spring 繁體版
原文   原文链接

目录html

在web应用开发中，安全无疑是十分重要的，选择Spring Security来保护web应用是一个很是好的选择。Spring Security 是spring项目之中的一个安全模块，能够很是方便与spring项目无缝集成。特别是在spring boot项目中加入spring security更是十分简单。本篇咱们介绍spring security，以及spring security在web应用中的使用。前端

从一个Spring Security的例子开始

建立不受保护的应用

假设咱们如今建立好了一个springboot的web应用，有一个控制器以下：java

@Controller
public class AppController {

    @RequestMapping("/hello")
    @ResponseBody
    String home() {
        return "Hello ,spring security!";
    }
}

咱们启动应用，假设端口是8080，那么当咱们在浏览器访问http://localhost:8080/hello的时候能够在浏览器看到Hello ,spring security!。mysql

加入spring security 保护应用

此时，/hello是能够自由访问。假设，咱们须要具备某个角色的用户才能访问的时候，咱们能够引入spring security来进行保护。加入以下依赖，并重启应用：react

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

再次访问/hello，咱们能够获得一个http-basic的认证弹窗，以下：web

http basic认证窗口

说明spring security 已经起做用了。若是咱们点击取消，则会看到错误信息，以下所示：算法

There was an unexpected error (type=Unauthorized, status=401).

关闭security.basic ,使用form表单页面登陆

咱们在实际项目中不可能会使用，上面http-basic方式的弹窗来让用户完成登陆，而是会有一个登陆页面。因此，咱们须要关闭http-basic的方式，关闭http-basic方式的认证弹窗的配置以下：spring

security.basic.enabled=false

spring security 默认提供了表单登陆的功能。咱们新建一个类SecurityConfiguration,并加入一些代码，以下所示：sql

@Configuration
@EnableWebSecurity
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {

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

上面的代码其实就是 一种配置，authorizeRequests() 定义哪些URL须要被保护、哪些不须要被保护。 formLogin() 定义当须要用户登陆时候，转到的登陆页面。此时，咱们并无写登陆页面，可是spring security默认提供了一个登陆页面，以及登陆控制器。数据库

加完了上面的配置类以后，咱们重启应用。而后继续访问http://localhost:8080/hello。会发现自动跳转到一个登陆页面了，以下所示：

login form

这个页面是spring security 提供的默认的登陆页面，其的html内容以下：

<html><head><title>Login Page</title></head><body onload='document.f.username.focus();'>
<h3>Login with Username and Password</h3><form name='f' action='/login' method='POST'>
<table>
    <tr><td>User:</td><td><input type='text' name='username' value=''></td></tr>
    <tr><td>Password:</td><td><input type='password' name='password'/></td></tr>
    <tr><td colspan='2'><input name="submit" type="submit" value="Login"/></td></tr>
    <input name="_csrf" type="hidden" value="635780a5-6853-4fcd-ba14-77db85dbd8bd" />
</table>
</form></body></html>

咱们能够发现，这里有个form 。action="/login"，这个/login依然是spring security提供的。form表单提交了三个数据：

  • username 用户名
  • password 密码
  • _csrf CSRF保护方面的内容，暂时先不展开解释

为了登陆系统，咱们须要知道用户名密码，spring security 默认的用户名是user，spring security启动的时候会生成默认密码（在启动日志中能够看到）。本例，咱们指定一个用户名密码，在配置文件中加入以下内容：

# security
security.basic.enabled=false
security.user.name=admin
security.user.password=admin

重启项目，访问被保护的/hello页面。自动跳转到了spring security 默认的登陆页面，咱们输入用户名admin密码admin。点击Login按钮。会发现登陆成功并跳转到了/hello。除了登陆，spring security还提供了rememberMe功能，这里不作过多解释。

角色-资源 访问控制

一般状况下，咱们须要实现“特定资源只能由特定角色访问”的功能。假设咱们的系统有以下两个角色：

  • ADMIN 能够访问全部资源
  • USER 只能访问特定资源

如今咱们给系统增长“/product” 表明商品信息方面的资源（USER能够访问）；增长"/admin"代码管理员方面的资源（USER不能访问）。代码以下：

@Controller
@RequestMapping("/product")
public class ProductTestController {

    @RequestMapping("/info")
    @ResponseBody
    public String productInfo(){
        return " some product info ";
    }
}
-------------------------------------------
@Controller
@RequestMapping("/admin")
public class AdminTestController {

    @RequestMapping("/home")
    @ResponseBody
    public String productInfo(){
        return " admin home page ";
    }
}

在正式的应用中，咱们的用户和角色是保存在数据库中的；本例为了方便演示，咱们来建立两个存放于内存的用户和角色。咱们在上一步中建立的SecurityConfiguration中增长角色用户，以下代码：

@Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth
                .inMemoryAuthentication()
                .withUser("admin1") // 管理员，同事具备 ADMIN,USER权限，能够访问全部资源
                    .password("admin1")
                    .roles("ADMIN", "USER")
                    .and()
                .withUser("user1").password("user1") // 普通用户，只能访问 /product/**
                    .roles("USER");
    }

这里，咱们增长了 管理员（admin1，密码admin1），以及普通用户（user1,密码user1）

继续增长“连接-角色”控制配置，代码以下:

@Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                    .antMatchers("/product/**").hasRole("USER")
                    .antMatchers("/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated()
                .and()
                .formLogin().and()
                .httpBasic();
    }

这个配置在上一步中登陆配置的基础上增长了连接对应的角色配置。上面的配置，咱们能够知道：

  • 使用 user1 登陆，只能访问/product/**
  • 使用 admin1登陆，能够访问全部。

下面来验证一下普通用户登陆，重启项目，在浏览器中输入：http://localhost:8080/admin/home。一样，咱们会到达登陆页面，咱们输入用户名user1,密码也为user1 结果错误页面了，拒绝访问了，信息为：

There was an unexpected error (type=Forbidden, status=403).
Access is denied

咱们把浏览器中的uri修改为：/product/info，结果访问成功。能够看到some product info。说明 user1只能访问 product/** ,这个结果与咱们预期一致。

再来验证一下管理员用户登陆，重启浏览器以后，输入http://localhost:8080/admin/home。在登陆页面中输入用户名admin1，密码admin1，提交以后，能够看到admin home page,说明访问管理员资源了。咱们再将浏览器uri修改为/product/info,刷新以后，也能看到some product info,说明 admin1用户能够访问全部资源，这个也和咱们的预期一致。

获取当前登陆用户信息

上面咱们实现了“资源 - 角色”的访问控制，效果和咱们预期的一致，可是并不直观，咱们不妨尝试在控制器中获取“当前登陆用户”的信息，直接输出，看看效果。以/product/info为例，咱们修改其代码，以下：

@RequestMapping("/info")
    @ResponseBody
    public String productInfo(){
        String currentUser = "";
        Object principl = SecurityContextHolder.getContext().getAuthentication().getPrincipal();
        if(principl instanceof UserDetails) {
            currentUser = ((UserDetails)principl).getUsername();
        }else {
            currentUser = principl.toString();
        }
        return " some product info,currentUser is: "+currentUser;
    }

这里，咱们经过SecurityContextHolder来获取了用户信息，并拼接成字符串输出。重启项目，在浏览器访问http://localhost:8080/product/info. 使用 admin1的身份登陆，能够看到浏览器显示some product info,currentUser is: admin1.

小结

至此，咱们已经对spring security有了一个基本的认识了。了解了如何在项目中加入spring security，以及如何控制资源的角色访问控制。spring security原不止这么简单，咱们才刚刚开始。为了可以更好的在实战中使用spring security 咱们须要更深刻的了解。下面咱们先来了解spring security的一些核心概念。

Spring Security 核心组件

spring security核心组件有：SecurityContext、SecurityContextHolder、Authentication、Userdetails 和 AuthenticationManager，下面分别介绍。

SecurityContext

安全上下文，用户经过Spring Security 的校验以后，验证信息存储在SecurityContext中，SecurityContext的接口定义以下：

public interface SecurityContext extends Serializable {
    /**
     * Obtains the currently authenticated principal, or an authentication request token.
     *
     * @return the <code>Authentication</code> or <code>null</code> if no authentication
     * information is available
     */
    Authentication getAuthentication();

    /**
     * Changes the currently authenticated principal, or removes the authentication
     * information.
     *
     * @param authentication the new <code>Authentication</code> token, or
     * <code>null</code> if no further authentication information should be stored
     */
    void setAuthentication(Authentication authentication);
}

能够看到SecurityContext接口只定义了两个方法，实际上其主要做用就是获取Authentication对象。

SecurityContextHolder

SecurityContextHolder看名知义，是一个holder,用来hold住SecurityContext实例的。在典型的web应用程序中，用户登陆一次，而后由其会话ID标识。服务器缓存持续时间会话的主体信息。在Spring Security中，在请求之间存储SecurityContext的责任落在SecurityContextPersistenceFilter上，默认状况下，该上下文将上下文存储为HTTP请求之间的HttpSession属性。它会为每一个请求恢复上下文SecurityContextHolder，而且最重要的是，在请求完成时清除SecurityContextHolder。SecurityContextHolder是一个类，他的功能方法都是静态的（static）。

SecurityContextHolder能够设置指定JVM策略（SecurityContext的存储策略），这个策略有三种：

  • MODE_THREADLOCAL：SecurityContext 存储在线程中。
  • MODE_INHERITABLETHREADLOCAL：SecurityContext 存储在线程中，但子线程能够获取到父线程中的 SecurityContext。
  • MODE_GLOBAL：SecurityContext 在全部线程中都相同。

SecurityContextHolder默认使用MODE_THREADLOCAL模式，即存储在当前线程中。在spring security应用中，咱们一般能看到相似以下的代码：

SecurityContextHolder.getContext().setAuthentication(token);

其做用就是存储当前认证信息。

Authentication

authentication 直译过来是“认证”的意思，在Spring Security 中Authentication用来表示当前用户是谁，通常来说你能够理解为authentication就是一组用户名密码信息。Authentication也是一个接口，其定义以下：

public interface Authentication extends Principal, Serializable {
 
    Collection<? extends GrantedAuthority> getAuthorities();
    Object getCredentials();
    Object getDetails();
    Object getPrincipal();
    boolean isAuthenticated();
    void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException;
}

接口有4个get方法，分别获取

  • Authorities, 填充的是用户角色信息。
  • Credentials，直译，证书。填充的是密码。
  • Details ，用户信息。
  • ,Principal 直译，形容词是“主要的，最重要的”，名词是“负责人，资本，本金”。感受很别扭，因此，仍是不翻译了，直接用原词principal来表示这个概念，其填充的是用户名。

所以能够推断其实现类有这4个属性。这几个方法做用以下：

  • getAuthorities: 获取用户权限，通常状况下获取到的是用户的角色信息。
  • getCredentials: 获取证实用户认证的信息，一般状况下获取到的是密码等信息。
  • getDetails: 获取用户的额外信息，（这部分信息能够是咱们的用户表中的信息）
  • getPrincipal: 获取用户身份信息，在未认证的状况下获取到的是用户名，在已认证的状况下获取到的是 UserDetails (UserDetails也是一个接口，里边的方法有getUsername,getPassword等)。
  • isAuthenticated: 获取当前 Authentication 是否已认证。
  • setAuthenticated: 设置当前 Authentication 是否已认证（true or false）。

UserDetails

UserDetails，看命知义，是用户信息的意思。其存储的就是用户信息，其定义以下：

public interface UserDetails extends Serializable {

    Collection<? extends GrantedAuthority> getAuthorities();
    String getPassword();
    String getUsername();
    boolean isAccountNonExpired();
    boolean isAccountNonLocked();
    boolean isCredentialsNonExpired();
    boolean isEnabled();
}

方法含义以下：

  • getAuthorites：获取用户权限，本质上是用户的角色信息。
  • getPassword: 获取密码。
  • getUserName: 获取用户名。
  • isAccountNonExpired: 帐户是否过时。
  • isAccountNonLocked: 帐户是否被锁定。
  • isCredentialsNonExpired: 密码是否过时。
  • isEnabled: 帐户是否可用。

UserDetailsService

提到了UserDetails就必须得提到UserDetailsService, UserDetailsService也是一个接口，且只有一个方法loadUserByUsername，他能够用来获取UserDetails。

一般在spring security应用中，咱们会自定义一个CustomUserDetailsService来实现UserDetailsService接口，并实现其public UserDetails loadUserByUsername(final String login);方法。咱们在实现loadUserByUsername方法的时候，就能够经过查询数据库（或者是缓存、或者是其余的存储形式）来获取用户信息，而后组装成一个UserDetails,(一般是一个org.springframework.security.core.userdetails.User，它继承自UserDetails) 并返回。

在实现loadUserByUsername方法的时候，若是咱们经过查库没有查到相关记录，须要抛出一个异常来告诉spring security来“善后”。这个异常是org.springframework.security.core.userdetails.UsernameNotFoundException。

AuthenticationManager

AuthenticationManager 是一个接口，它只有一个方法，接收参数为Authentication，其定义以下：

public interface AuthenticationManager {
    Authentication authenticate(Authentication authentication)
            throws AuthenticationException;
}

AuthenticationManager 的做用就是校验Authentication,若是验证失败会抛出AuthenticationException异常。AuthenticationException是一个抽象类，所以代码逻辑并不能实例化一个AuthenticationException异常并抛出，实际上抛出的异常一般是其实现类，如DisabledException,LockedException,BadCredentialsException等。BadCredentialsException可能会比较常见，即密码错误的时候。

小结

这里，咱们只是简单的了解了spring security中有哪些东西，先混个脸熟。这里并不须要咱们一会儿全记住这些名词和概念。先大概看看，有个印象。

Spring Security的一些工做原理

在第一节中，咱们经过在pom文件中增长spring-boot-starter-security依赖，便使得咱们的项目收到了spring security保护，又经过增长SecurityConfiguration实现了一些安全配置，实现了连接资源的个性化访问控制。那么这是如何实现的呢？了解其原理，可使咱们使用起来驾轻就熟。

spring security 在web应用中是基于filter的

在spring security的官方文档中，咱们能够看到这么一句话：

Spring Security’s web infrastructure is based entirely on standard servlet filters.

咱们能够得知，spring security 在web应用中是基于filter的。filter咱们就很熟了，在没有struts,没有spring mvc以前，咱们就是经过一个个servlet,一个个filter来实现业务功能的，一般咱们会有多个filter，他们按序执行，一个执行完以后，调用filterChain中的下一个doFilter。Spring Security 在 Filter 中建立 Authentication 对象，并调用 AuthenticationManager 进行校验

spring security 维护了一个filter chain，chain中的每个filter都具备特定的责任，并根据所需的服务在配置总添加。filter的顺序很重要，由于他们之间存在依赖关系。spring security中有以下filter(按顺序的):

  • ChannelProcessingFilter,由于它可能须要重定向到不一样的协议
  • SecurityContextPersistenceFilter，能够在web请求开头的SecurityContextHolder中设置SecurityContext，而且SecurityContext的任何更改均可以复制到HttpSession当web请求结束时（准备好与下一个web请求一块儿使用）
  • ConcurrentSessionFilter，
  • 身份验证处理-UsernamePasswordAuthenticationFilter,CasAuthenticationFilter,BasicAuthenticationFilter等。以便SecurityContextHolder能够修改成包含有效的Authentication请求令牌
  • SecurityContextHolderAwareRequestFilter
  • JaasApiIntegrationFilter
  • RememberMeAuthenticationFilter，记住我服务处理
  • AnonymousAuthenticationFilter，匿名身份处理，更新SecurityContextHolder
  • ExceptionTranslationFilter，获任何Spring Security异常，以即可以返回HTTP错误响应或启动适当的AuthenticationEntryPoint
  • FilterSecurityInterceptor，用于保护web URI并在访问被拒绝时引起异常

这里咱们列举了几乎全部的spring security filter。正是这些filter完成了spring security的各类功能。目前咱们只是知道了有这些filter，并不清楚他们是怎么集成到应用中的。在继续深刻了解以前，咱们须要了解一下DelegatingFilterProxy。

DelegatingFilterProxy

DelegatingFilterProxy是一个特殊的filter，存在于spring-web模块中。DelegatingFilterProxy经过继承GenericFilterBean使得本身变为了一个Filter（由于GenericFilterBean implements Filter）。它是一个Filter，其命名却以proxy结尾。很是有意思，为了了解其功能，咱们看一下它的使用配置：

<filter>
    <filter-name>myFilter</filter-name>
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
</filter>
<filter-mapping>
    <filter-name>myFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

这个配置是咱们使用web.xml配置Filter时作法。可是与普通的Filter不一样的是DelegatingFilterProxy并无实际的过滤逻辑，他会尝试寻找filter-name节点所配置的myFilter，并将过滤行为委托给myFilter来处理。这种方式可以利用Spring丰富的依赖注入工具和生命周期接口，所以DelegatingFilterProxy提供了web.xml与应用程序上下文之间的连接。很是有意思，能够慢慢体会。

spring security入口——springSecurityFilterChain

spring security的入口filter就是springSecurityFilterChain。在没有spring boot以前，咱们要使用spring security的话，一般在web.xml中添加以下配置：

<filter>
       <filter-name>springSecurityFilterChain</filter-name>
       <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
   </filter>

   <filter-mapping>
       <filter-name>springSecurityFilterChain</filter-name>
       <url-pattern>/*</url-pattern>
   </filter-mapping>

看到没，这里配置的是DelegatingFilterProxy。有了上面的介绍以后，咱们就知道，它实际上会去找到filter-name节点中的Filter——springSecurityFilterChain，并将实际的过滤工做交给springSecurityFilterChain处理。

在使用spring boot以后，这一xml配置被Java类配置给代替了。咱们前面在代码种使用过@EnableWebSecurity 注解，经过跟踪源码能够发现@EnableWebSecurity会加载WebSecurityConfiguration类,而WebSecurityConfiguration类中就有建立springSecurityFilterChain这个Filter的代码：

@Bean(name = {"springSecurityFilterChain"})
    public Filter springSecurityFilterChain() throws Exception {
        boolean hasConfigurers = this.webSecurityConfigurers != null && !this.webSecurityConfigurers.isEmpty();
        if (!hasConfigurers) {
            WebSecurityConfigurerAdapter adapter = (WebSecurityConfigurerAdapter)this.objectObjectPostProcessor.postProcess(new WebSecurityConfigurerAdapter() {
            });
            this.webSecurity.apply(adapter);
        }

        return (Filter)this.webSecurity.build();
    }

这里，咱们介绍了spring security的入口——springSecurityFilterChain，也介绍了它的两种配置形式。可是，springSecurityFilterChain是谁，怎么起做用的，咱们还不清楚，下面继续看。

FilterChainProxy 和SecurityFilterChain

在spring的官方文档中，咱们能够发现这么一句话：

Spring Security’s web infrastructure should only be used by delegating to an instance of FilterChainProxy. The security filters should not be used by themselves.

spring security 的web基础设施（上面介绍的那一堆filter）只能经过委托给FilterChainProxy实例的方式来使用。而不能直接使用那些安全filter。

这句话彷佛透漏了一个信号，上面说的入口springSecurityFilterChain其实就是FilterChainProxy,若是不信，调试一下 代码也能发现，确实就是FilterChainProxy。它的全路径名称是org.springframework.security.web.FilterChainProxy。打开其源码，第一行注释是这样：

Delegates {@code Filter} requests to a list of Spring-managed filter beans.

因此，没错了。它就是DelegatingFilterProxy要找的人，它就是DelegatingFilterProxy要委托过滤任务的人。下面贴出其部分代码：

public class FilterChainProxy extends GenericFilterBean {
   
   private List<SecurityFilterChain> filterChains;// 

   public FilterChainProxy(SecurityFilterChain chain) {
      this(Arrays.asList(chain));
   }

   public FilterChainProxy(List<SecurityFilterChain> filterChains) {
      this.filterChains = filterChains;
   }

   public void doFilter(ServletRequest request, ServletResponse response,
         FilterChain chain) throws IOException, ServletException {
         doFilterInternal(request, response, chain);
   }

   private void doFilterInternal(ServletRequest request, ServletResponse response,
         FilterChain chain) throws IOException, ServletException {

      FirewalledRequest fwRequest = firewall
            .getFirewalledRequest((HttpServletRequest) request);
      HttpServletResponse fwResponse = firewall
            .getFirewalledResponse((HttpServletResponse) response);
        
      List<Filter> filters = getFilters(fwRequest);

      if (filters == null || filters.size() == 0) {
         fwRequest.reset();
         chain.doFilter(fwRequest, fwResponse);
         return;
      }

      VirtualFilterChain vfc = new VirtualFilterChain(fwRequest, chain, filters);
      vfc.doFilter(fwRequest, fwResponse);
   }

   private List<Filter> getFilters(HttpServletRequest request) {
      for (SecurityFilterChain chain : filterChains) {
         if (chain.matches(request)) {
            return chain.getFilters();
         }
      }
      return null;
   }

}

能够看到，里边有个SecurityFilterChain的集合。这个才是众多security filter藏身之处，doFilter的时候会从SecurityFilterChain取出第一个匹配的Filter集合并返回。

小结

说到这里，可能有点模糊了。这里小结一下，梳理一下。

  • spring security 的核心是基于filter
  • 入口filter是springSecurityFilterChain(它会被DelegatingFilterProxy委托来执行过滤任务)
  • springSecurityFilterChain其实是FilterChainProxy （一个filter）
  • FilterChainProxy里边有一个SecurityFilterChain集合，doFIlter的时候会从其中取。

到这里，思路清楚多了，如今还不知道SecurityFilterChain是怎么来的。下面介绍。

再说SecurityFilterChain

前面咱们介绍了springSecurityFilterChain，它是由xml配置的，或者是由@EnableWebSecurity注解的做用下初始化的（@Import({WebSecurityConfiguration.class））。具体是在WebSecurityConfiguration类中。上面咱们贴过代码，你能够返回看，这里再次贴出删减版：

@Bean( name = {"springSecurityFilterChain"})
    public Filter springSecurityFilterChain() throws Exception {
        // 删除部分代码
        return (Filter)this.webSecurity.build();
    }

最后一行，发现webSecurity.build() 产生了FilterChainProxy。所以，推断SecurityFilterChain就是webSecurity里边弄的。贴出源码：

public final class WebSecurity extends
      AbstractConfiguredSecurityBuilder<Filter, WebSecurity> implements
      SecurityBuilder<Filter>, ApplicationContextAware {
    
    @Override
    protected Filter performBuild() throws Exception {
        int chainSize = ignoredRequests.size() + securityFilterChainBuilders.size();
        // 咱们要找的 securityFilterChains
        List<SecurityFilterChain> securityFilterChains = new ArrayList<SecurityFilterChain>(
                chainSize);
        for (RequestMatcher ignoredRequest : ignoredRequests) {
            securityFilterChains.add(new DefaultSecurityFilterChain(ignoredRequest));
        }
        for (SecurityBuilder<? extends SecurityFilterChain> securityFilterChainBuilder : securityFilterChainBuilders) {
            securityFilterChains.add(securityFilterChainBuilder.build());
        }
        // 建立 FilterChainProxy  ，传入securityFilterChains
        FilterChainProxy filterChainProxy = new FilterChainProxy(securityFilterChains);
        if (httpFirewall != null) {
            filterChainProxy.setFirewall(httpFirewall);
        }
        filterChainProxy.afterPropertiesSet();

        Filter result = filterChainProxy;
        postBuildAction.run();
        return result;
    }
}

至此，咱们清楚了，spring security 是怎么在spring web应用中工做的了。具体的细节就是执行filter里的代码了，这里再也不继续深刻了。咱们的目的是摸清楚他是怎么工做的，大体的脉路是怎样，目前整理的内容已经达到这个目的了。

Spring Security 的一些实战

下面开始一些实战使用spring security 的实例。依然依托开篇的例子，并在此基础上调整。

经过数据库查询,存储用户和角色实现安全认证

开篇的例子中，咱们使用了内存用户角色来演示登陆认证。可是实际项目咱们确定是经过数据库完成的。实际项目中，咱们可能会有3张表：用户表，角色表，用户角色关联表。固然，不一样的系统会有不一样的设计，不必定非得是这样的三张表。本例演示的意义在于：若是咱们想在已有项目中增长spring security的话，就须要调整登陆了。主要是自定义UserDetailsService,此外，可能还须要处理密码的问题，由于spring并不知道咱们怎么加密用户登陆密码的。这时，咱们可能须要自定义PasswordEncoder，下面也会提到。

添加spring-data-jpa , 建立数据表，并添加数据

继续完善开篇的项目，如今给项目添加spring-data-jpa，并使用MySQL数据库。所以在POM文件中加入以下配置：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

在application.properties文件中加入数据库链接信息：

spring.datasource.url=jdbc:mysql://localhost:3306/yourDB?useUnicode=true&characterEncoding=UTF-8
spring.datasource.username=dbuser
spring.datasource.password=******
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

这里，为了简单方便演示，咱们只建立一张表，字段以下：

@Entity
public class User implements java.io.Serializable{

    @Id
    @Column
    private Long id;
    @Column
    private String login;
    @Column
    private String password;
    @Column
    private String role;
    // 省略get set 等
}

而后咱们添加2条数据，以下：

id login password role
1 user1 $2a$10$PhynBxXaIYdBzd/OgXrKzeVr3Bj4fiDxdii14fMOVIwJTqoDoFL1e USER
2 admin $2a$10$PhynBxXaIYdBzd/OgXrKzeVr3Bj4fiDxdii14fMOVIwJTqoDoFL1e ADMIN

密码这里都是使用了BCryptPasswordEncoder 需在SecurityConfiguration中加入配置，后面会贴。

自定义UserDetailsService

前面咱们提到过，UserDetailsService，spring security在认证过程当中须要查找用户，会调用UserDetailsService的loadUserByUsername方法获得一个UserDetails，下面咱们来实现他。代码以下：

@Component("userDetailsService")
public class CustomUserDetailsService implements UserDetailsService {

    @Autowired
    UserRepository userRepository;

    @Override
    public UserDetails loadUserByUsername(String login) throws UsernameNotFoundException {
         // 1. 查询用户
        User userFromDatabase = userRepository.findOneByLogin(login);
        if (userFromDatabase == null) {
            //log.warn("User: {} not found", login);
         throw new UsernameNotFoundException("User " + login + " was not found in db");
            //这里找不到必须抛异常
        }
        // 2. 设置角色
        Collection<GrantedAuthority> grantedAuthorities = new ArrayList<>();
        GrantedAuthority grantedAuthority = new SimpleGrantedAuthority(userFromDatabase.getRole());
        grantedAuthorities.add(grantedAuthority);
         
        return new org.springframework.security.core.userdetails.User(login,
                userFromDatabase.getPassword(), grantedAuthorities);
    }
}

这个方法作了2件事情，查询用户以及设置角色，一般一个用户会有多个角色，即上面的userFromDatabase.getRole()一般是一个list，因此设置角色的时候，就是for循环new 多个SimpleGrantedAuthority并设置。（本例为了简单没有设置角色表以及用户角色关联表，只在用户中增长了一个角色字段，因此grantedAuthorities只有一个）

同时修改以前的SecurityConfiguration,加入CustomUserDetailsServicebean配置，以下：

@Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService)// 设置自定义的userDetailsService
                .passwordEncoder(passwordEncoder());
        /*auth
            .inMemoryAuthentication()
            .withUser("admin1")
                .password("admin1")
                .roles("ADMIN", "USER")
                .and()
            .withUser("user1").password("user1")
                .roles("USER");*/
    }

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

验证效果

上面咱们自定义了userDetailsService,此时，spring security 在其做用流程中会调用，不出意外的话，重启系统，咱们使用user1登陆能够看到/product/info，可是不能看/admin/home。下面咱们来重启项目验证一下。

先输入user1，以及错误密码，结果以下：

Alt text

再输入user1 ，以及正确密码，结果以下：

再将浏览器连接修改成/admin/home，结果显示：

There was an unexpected error (type=Forbidden, status=403).
Access is denied

这与咱们的预期彻底一致，至此，咱们已经在项目中加入了spring security，而且可以经过查询数据库用户，角色信息交给spring security完成认证受权。

spring security session 无状态

还记得咱们开篇所举的例子吗？咱们使用管理员帐号密码登陆以后，就能够访问/admin/home了，此时修改浏览器地址栏为/product/info以后刷新页面，仍然能够访问，说明认证状态被保持了；若是关闭浏览器从新输入/admin/home就会提示咱们从新登陆，这有点session的感受。若是此时，咱们将浏览器cookie禁用掉，你会发现登陆以后自动跳转只会获得403，403是拒绝访问的意思，是没有权限的意思，说明这种状况下受权状态和session是挂钩的。即这时spring security使用了session。可是不是全部的系统都须要session，咱们能让spring security不适用session吗？答案是能够！

使用spring security 咱们能够准确控制session什么时候建立以及Spring Security如何与之交互：

  • always – a session will always be created if one doesn’t already exist，没有session就建立。
  • ifRequired – a session will be created only if required (default)，若是须要就建立（默认）。
  • never – the framework will never create a session itself but it will use one if it already exists
  • stateless – no session will be created or used by Spring Security 不建立不使用session

这里，咱们要关注的是 stateless，一般称为无状态的。为啥要关注这个stateless无状态的状况的呢？由于目前，咱们的应用基本都是先后端分离的应用。比方说，你的一套java api是给react前端、安卓端、IOS端 调用的。这个时候你还提什么session啊，这时候咱们须要的是无状态，一般以一种token的方式来交互。

spring security 配置stateless 的方式以下，依然是修改咱们以前定义的SecurityConfiguration:

http
    .sessionManagement()
    .sessionCreationPolicy(SessionCreationPolicy.STATELESS)

先后端分离应用中自定义token整合spring security

上面咱们提到了stateless，实际中咱们的先后端分离项目都是无状态的，并无登陆状态保持，服务器经过客户端调用传递的token来识别调用者是谁。

一般咱们的系统流程是这样的：

  1. 客户端（react前端，IOS，安卓）调用“登陆接口”得到一个包含token的响应（一般是个JSON，如 {"token":"abcd","expires":1234567890}）
  2. 客户端获取数据，并携带 token参数。
  3. 服务端根据token发现token过时/错误，返回"请登陆"状态码
  4. 服务器发现token正常，并解析出来是A，返回A的数据。
  5. ……

若是咱们想在spring security项目中使用自定义的token，那么咱们须要思考下面的问题：

  1. 怎么发token（即怎么登陆？）
  2. 发token怎么和spring security整合。
  3. spring security怎么根据token获得受权认证信息。

下面从登陆发token开始，这里须要使用到UsernamePasswordAuthenticationToken,以及SecurityContextHolder,代码以下：

@RequestMapping(value = "/authenticate",method = RequestMethod.POST)
    public Token authorize(@RequestParam String username, @RequestParam String password) {
        // 1 建立UsernamePasswordAuthenticationToken
        UsernamePasswordAuthenticationToken token 
                           = new UsernamePasswordAuthenticationToken(username, password);
        // 2 认证
        Authentication authentication = this.authenticationManager.authenticate(token);
        // 3 保存认证信息
        SecurityContextHolder.getContext().setAuthentication(authentication);
        // 4 加载UserDetails
        UserDetails details = this.userDetailsService.loadUserByUsername(username);
        // 5 生成自定义token
        return tokenProvider.createToken(details);
    }
    @Inject
    private AuthenticationManager authenticationManager;

上面代码中1,2,3,4步骤都是和spring security交互的。只有第5步是咱们本身定义的，这里tokenProvider就是咱们系统中token的生成方式（这个彻底是个性化的，一般是个加密串，一般可能会包含用户信息，过时时间等）。其中的Token也是咱们自定义的返回对象，其中包含token信息相似{"token":"abcd","expires":1234567890}.

咱们的tokenProvider一般至少具备两个方法，即：生成token，验证token。大体以下：

public class TokenProvider {

    private final String secretKey;
    private final int tokenValidity;

    public TokenProvider(String secretKey, int tokenValidity) {
        this.secretKey = secretKey;
        this.tokenValidity = tokenValidity;
    }
   // 生成token
    public Token createToken(UserDetails userDetails) {
        long expires = System.currentTimeMillis() + 1000L * tokenValidity;
        String token =  computeSignature(userDetails, expires);
        return new Token(token, expires);
    }
    // 验证token
   public boolean validateToken(String authToken, UserDetails userDetails) {
        check token
        return true or false;
    }
     // 从token中识别用户
    public String getUserNameFromToken(String authToken) {
        // ……
        return login;
    }
    public String computeSignature(UserDetails userDetails, long expires) {
        // 一些特有的信息组装 ,并结合某种加密活摘要算法
        return 例如 something+"|"+something2+MD5(s);
    }

}

至此，咱们客户端能够经过调用http://host/context/authenticate来得到一个token了，相似这样的：{"token":"abcd","expires":1234567890}。那么下次请求的时候，咱们带上 token=abcd这个参数（或者也能够是自定义的请求头中）如何在spring security中复原“session”呢。咱们须要一个filter：

public class MyTokenFilter extends GenericFilterBean {

    private final Logger log = LoggerFactory.getLogger(XAuthTokenFilter.class);

    private final static String XAUTH_TOKEN_HEADER_NAME = "my-auth-token";

    private UserDetailsService detailsService;

    private TokenProvider tokenProvider;
    public XAuthTokenFilter(UserDetailsService detailsService, TokenProvider tokenProvider) {
        this.detailsService = detailsService;
        this.tokenProvider = tokenProvider;
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        try {
            HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
            String authToken = httpServletRequest.getHeader(XAUTH_TOKEN_HEADER_NAME);
            if (StringUtils.hasText(authToken)) {
               // 从自定义tokenProvider中解析用户
                String username = this.tokenProvider.getUserNameFromToken(authToken);
                // 这里仍然是调用咱们自定义的UserDetailsService，查库，检查用户名是否存在，
                // 若是是伪造的token,可能DB中就找不到username这我的了，抛出异常，认证失败
                UserDetails details = this.detailsService.loadUserByUsername(username);
                if (this.tokenProvider.validateToken(authToken, details)) {
                    log.debug(" validateToken ok...");
                    UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(details, details.getPassword(), details.getAuthorities());
                    // 这里仍是上面见过的，存放认证信息，若是没有走这一步，下面的doFilter就会提示登陆了
                    SecurityContextHolder.getContext().setAuthentication(token);
                }
            }
            // 调用后续的Filter,若是上面的代码逻辑未能复原“session”，SecurityContext中没有想过信息，后面的流程会检测出"须要登陆"
            filterChain.doFilter(servletRequest, servletResponse);
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }
}

目前为止，咱们实现了自定义的token生成类，以及经过一个filter来拦截客户端请求，解析其中的token，复原无状态下的"session"，让当前请求处理线程中具备认证受权数据，后面的业务逻辑才能执行。下面，咱们须要将自定义的内容整合到spring security中。

首先编写一个类，继承SecurityConfigurerAdapter:

public class MyAuthTokenConfigurer extends SecurityConfigurerAdapter<DefaultSecurityFilterChain, HttpSecurity> {

    private TokenProvider tokenProvider;  // 咱们以前自定义的 token功能类
    private UserDetailsService detailsService;// 也是我实现的UserDetailsService
    
    public MyAuthTokenConfigurer(UserDetailsService detailsService, TokenProvider tokenProvider) {
        this.detailsService = detailsService;
        this.tokenProvider = tokenProvider;
    }

    @Override
    public void configure(HttpSecurity http) throws Exception {
        MyAuthTokenFilter customFilter = new MyAuthTokenFilter(detailsService, tokenProvider);
        http.addFilterBefore(customFilter, UsernamePasswordAuthenticationFilter.class);
    }
}

在 SecurityConfiguration配置类中加入以下内容：

// 增长方法
    private MyAuthTokenConfigurer securityConfigurerAdapter() {
      return new MyAuthTokenConfigurer(userDetailsService, tokenProvider);
    }
    // 依赖注入
    @Inject
    private UserDetailsService userDetailsService;

    @Inject
    private TokenProvider tokenProvider;

     //方法修改 ， 增长securityConfigurerAdapter
     @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                .anyRequest().authenticated()
                  // .... 其余配置
                .and()
                 .apply(securityConfigurerAdapter());// 这里增长securityConfigurerAdapter
                
    }

至此咱们就完成了无状态应用中token认证结合spring security。

总结

本篇内容，咱们经过一个小例子开始介绍了如何给web应用引入spring security保护；在展现了http-basic验证以后，咱们使用了内存用户实验了“角色-资源”访问控制；而后咱们介绍了spring security的一些核心概念；以后咱们介绍了spring security 是经过filter的形式在web应用中发生做用的，并列举了filter列表，介绍了入口filter，介绍了springboot是如何载入spring security入口filter的。最后咱们经过两个实战中的例子展现了spring security的使用。

spring security 功能也很是强大，可是仍是挺复杂的，本篇内容若有差错还请指出。

参考文档：

spring security 官方文档

spring-security-session

其余推荐：
SpringMVC是怎么工做的,SpringMVC的工做原理
Mybatis Mapper接口是如何找到实现类的-源码分析

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程