Spring Security 入门原理及实战

最新推荐文章于 2024-04-22 20:46:26 发布

MR_YANGMIN

最新推荐文章于 2024-04-22 20:46:26 发布

阅读量350

点赞数 1

文章标签： spring boot spring java

本文链接：https://blog.csdn.net/weixin_45239670/article/details/113881613

版权

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

从一个Spring Security的例子开始

创建不受保护的应用

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

我们启动应用，假设端口是8080，那么当我们在浏览器访问http://localhost:8080/hello的时候可以在浏览器看到Hello ,spring security!。
加入spring security 保护应用

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

再次访问/hello，我们可以得到一个页面，如下：
在这里插入图片描述

说明spring security 已经起作用了，我们需要登陆才能访问。我们可以查看下这个页面的源代码，是这样：

<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>

上面的html中有个form ，其中action="/login"，这个/login依然是spring security提供的。form表单提交了三个数据：
username : 用户名
password : 密码
_csrf : CSRF保护方面的内容，暂时先不展开解释
为了登录系统，我们需要知道用户名密码，spring security 默认的用户名是user，spring security启动的时候会生成默认密码（在启动日志中可以看到）。本例，我们指定一个用户名密码，在配置文件中加入如下内容

2021-01-19 22:29:59.325  INFO 83794 --- [           main] .s.s.UserDetailsServiceAutoConfiguration : 
 
Using generated security password: cc7d4605-75db-49aa-aa9a-b95953b5c1e8
 
2021-01-19 22:29:59.424  INFO 83794 --- [           main] o.s.s.web.DefaultSecurityFilterChain     :

我们在登陆狂输入user和密码cc7d4605-75db-49aa-aa9a-b95953b5c1e8。可以登录成功，并能访问/hello的内容。

自定义security配置

@Configuration
@EnableWebSecurity
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
 
	@Override
	protected void configure(HttpSecurity http) throws Exception {
		http
				.authorizeRequests()
				.anyRequest().authenticated()
				.and()
				.formLogin().and()
				.httpBasic();
	}
  
   @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
      auth.
        inMemoryAuthentication()
        .withUser("spring")
        .password("{noop}123456").roles("USER");
 
    }
}

上面的配置其实和默认情况的配置几乎一样，只是这里定义了一个用户spring，和密码123456 。（说明：密码前面的{noop}表示的是指定的PasswordEncoder,对密码不进行加密）此时我们启动项目，便可以使用spring这个用户及123456密码登录了。

角色-资源访问控制

通常情况下，我们需要实现“特定资源只能由特定角色访问”的功能。假设我们的系统有如下两个角色：

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 ";
	}
}

现在我们希望实现：admin可以访问所有页面，而普通用户只能方法/product页面。配置如下：

@Configuration
@EnableWebSecurity
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
 
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                    .antMatchers("/product/**").hasRole("USER")
                    .antMatchers("/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated()
                .and()
                .formLogin().and()
                .httpBasic();
     }
 
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth
            .inMemoryAuthentication()
            .withUser("admin").password("{noop}adminpass").roles("ADMIN", "USER") 
            .and()
            .withUser("spring").password("{noop}123456").roles("USER");
 
     }
 
}

这里，我们增加了管理员（admin，密码admin），以及普通用户spring,密码123456）

同时，我们增加了链接对应的角色配置。上面的配置，我们可以知道：

使用 USER角色的用户登录，只能访问/product/**
使用 ADMIN角色的用户登录，可以访问所有。
下面来验证一下普通用户登录，重启项目，在浏览器中输入：http://localhost:8080/admin/home。同样，我们会到达登录页面，我们输入用户名spring,密码也为123456 结果错误页面了，拒绝访问了，信息为：

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

我们把浏览器中的uri修改成：/product/info，结果访问成功。可以看到some product info。说明 spring这个USER角色只能访问 product/** ,这个结果与我们预期一致。

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

获取当前登录用户信息

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

/**
     * @return 返回登录的用户信息
     */
    @RequestMapping("/info")
    public String productInfo() {
        String currentUser = "";
        /**
         * 获取用户主体, springSecurity默认的用户实体为UserDetails(接口)
         */
        Object principl = SecurityContextHolder.getContext().getAuthentication().getPrincipal();
        if (principl instanceof UserDetails) {
            currentUser = ((UserDetails) principl).getUsername();
        } else {
            currentUser = principl.toString();
        }
        //认证信息
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        //用户的角色信息
        Collection<? extends GrantedAuthority> authorities = auth.getAuthorities();
        System.out.println("权限角色:" + authorities.toString());
        System.out.println("用户信息:" + principl.toString());
        Object credentials = auth.getCredentials();
        System.out.println("直译，证书。填充的是密码:" + credentials);
        Object details = auth.getDetails();
        System.out.println("details:" + details);
        boolean authenticated = auth.isAuthenticated();
        System.out.println("是否被授权:" + authenticated);
        return " some product info,currentUser is: " + currentUser;
    }

这里，我们通过SecurityContextHolder来获取了用户信息，并拼接成字符串输出。重启项目，在浏览器访问http://localhost:8080/product/info. 使用 admin的身份登录，可以看到浏览器显示some product info,currentUser is: admin。,控制台打印出的用户信息如下:

权限角色:[ROLE_ADMIN, ROLE_APP, ROLE_USER]
用户信息:org.springframework.security.core.userdetails.User [Username=admin, Password=[PROTECTED], Enabled=true, AccountNonExpired=true, credentialsNonExpired=true, AccountNonLocked=true, Granted Authorities=[ROLE_ADMIN, ROLE_APP, ROLE_USER]]
直译，证书。填充的是密码:null
details:WebAuthenticationDetails [RemoteIpAddress=0:0:0:0:0:0:0:1, SessionId=20B232C48F28DB1768DA40784A791D5A]
是否被授权:true

小结
至此，我们已经对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();
    }

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 的一些实战

通过数据库查询,存储用户和角色实现安全认证(我这里通过静态类模拟)
开篇的例子中，我们使用了内存用户角色来演示登录认证。但是实际项目我们肯定是通过数据库完成的。实际项目中，我们可能会有3张表：用户表，角色表，用户角色关联表。当然，不同的系统会有不同的设计，不一定非得是这样的三张表。本例演示的意义在于：如果我们想在已有项目中增加spring security的话，就需要调整登录了。主要是自定义UserDetailsService,此外，可能还需要处理密码的问题，因为spring并不知道我们怎么加密用户登录密码的。这时，我们可能需要自定义PasswordEncoder，下面也会提到。

依赖导入:

<?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.4.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.yangmin</groupId>
    <artifactId>seruritydemo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>seruritydemo</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
        <commons-lang3.version>3.4</commons-lang3.version>
        <common-collections.version>3.2.2</common-collections.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- Commons -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>${commons-lang3.version}</version>
        </dependency>
        <!-- collections -->
        <dependency>
            <groupId>commons-collections</groupId>
            <artifactId>commons-collections</artifactId>
            <version>${common-collections.version}</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>
        </plugins>
    </build>

</project>

application.properties文件中加入数据库连接信息: 我把数据放到了一个map中,没有用数据库,不需要配置配置文件

private static Map<String, com.yangmin.seruritydemo.securityuser.User> userMap = new HashMap<>();

    static {
        userMap.put("spring", new com.yangmin.seruritydemo.securityuser.User(1L, "spring", MD5Util.pwdMd5("123456"), "ROLE_USER"));
        userMap.put("admin", new com.yangmin.seruritydemo.securityuser.User(2L, "admin", MD5Util.pwdMd5("admin"), "ROLE_ADMIN,ROLE_USER,ROLE_APP"));
    }

注意:角色的命名规则为ROLE_角色

2.自定义UserDetailsService
前面我们提到过，UserDetailsService，spring security在认证过程中需要查找用户，会调用UserDetailsService的loadUserByUsername方法得到一个UserDetails，下面我们来实现他。代码如下：

package com.yangmin.seruritydemo.securityuser;

import com.yangmin.seruritydemo.utils.MD5Util;
import org.apache.commons.lang3.StringUtils;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author yangmin
 * @deprecated 认证的业务逻辑
 */
@Component("userDetailsService")
public class CustomUserDetailsServiceImpl implements UserDetailsService {
    private GrantedAuthority DEFAULT_ROLE = new SimpleGrantedAuthority("ROLE_USER");

    private static Map<String, com.yangmin.seruritydemo.securityuser.User> userMap = new HashMap<>();

    static {
        userMap.put("spring", new com.yangmin.seruritydemo.securityuser.User(1L, "spring", MD5Util.pwdMd5("123456"), "ROLE_USER"));
        userMap.put("admin", new com.yangmin.seruritydemo.securityuser.User(2L, "admin", MD5Util.pwdMd5("admin"), "ROLE_ADMIN,ROLE_USER,ROLE_APP"));
    }

    /**
     * 查询用户信息,并封装为UserDetails返回
     *
     * @param login 用户名
     * @return  其存储的就是用户信息 (getAuthorites：获取用户权限，本质上是用户的角色信息。
     * getPassword: 获取密码。
     * getUserName: 获取用户名。
     * isAccountNonExpired: 账户是否过期。
     * isAccountNonLocked: 账户是否被锁定。
     * isCredentialsNonExpired: 密码是否过期。
     * isEnabled: 账户是否可用。)
     * @throws UsernameNotFoundException 用户没有查询到异常
     */
    @Override
    public UserDetails loadUserByUsername(String login) throws UsernameNotFoundException {
        //todo  模拟数据库查询用户信息
        com.yangmin.seruritydemo.securityuser.User user = userMap.get(login);
        if (user == null) {
            throw new UsernameNotFoundException("用户 " + login + " 未查到");
        }
        // 2. 设置角色
        List<GrantedAuthority> grantedAuthorities = new ArrayList<>();
        String dbRole = user.getRole();
        if (StringUtils.isEmpty(dbRole)) {
            grantedAuthorities.add(DEFAULT_ROLE);
        } else {
            String[] roles = dbRole.split(",");
            for (String r : roles) {
            //每一个角色被封装到一个GrantedAuthority
                GrantedAuthority grantedAuthority = new SimpleGrantedAuthority(r);
                grantedAuthorities.add(grantedAuthority);
            }
        }
        return new org.springframework.security.core.userdetails.User(login,
                user.getPassword(), grantedAuthorities);
    }
}

这个方法做了2件事情，查询用户以及设置角色。

现在我们来修改之前的SecurityConfiguration配置, 加入CustomUserDetailsServicebean配置，如下：

package com.yangmin.seruritydemo.securityconfig;

import com.yangmin.seruritydemo.utils.MD5Util;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.password.NoOpPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

/**
 * @author yangmin
 */
@Configuration
@EnableWebSecurity
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {

    @Autowired
    UserDetailsService userDetailsService;

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

    /**
     * 把用户信息放入内存中
     * @param auth
     * @throws Exception
     */
/*    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.
                inMemoryAuthentication()
                .withUser("spring").password("{noop}123456").roles("USER")
                .and()
                .withUser("admin").password("{noop}admin").roles("ADMIN", "USER");

    }*/
    /**
     * 
     *
     * @param auth
     * @throws Exception
     */
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        // 设置自定义的userDetailsService
        auth.userDetailsService(userDetailsService)
                //设置自定义密码检验规则
                .passwordEncoder(new PasswordEncoder() {
                    /**
                     * 密码加密采用MD5加密
                     * @param charSequence  页面输入的密码
                     * @return
                     */
                    @Override
                    public String encode(CharSequence charSequence) {
                        return MD5Util.pwdMd5((String) charSequence);
                    }

                    /**
                     * 进行密码校验
                     * @param charSequence 页面输入的密码
                     * @param s 数据库查询出用户的密码(用户在注册的时候,对密码进行了加密处理)
                     * @return
                     */
                    @Override
                    public boolean matches(CharSequence charSequence, String s) {
                        boolean equals = s.equals(encode(charSequence));
                        return equals;
                    }
                });
    }


    /**
     *  为了演示方便，我们使用NoOpPasswordEncoder（这个就是不加密）
     * @return
     *//*
    @Bean
    public PasswordEncoder passwordEncoder() {
        return NoOpPasswordEncoder.getInstance();
    }*/
}

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

先输入spring，以及错误密码，可以看到页面报错：Bad credentials。再输入spring ，以及正确密码123456，结果：some product info,currentUser is: spring

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

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

这与我们的预期完全一致，至此，我们已经在项目中加入了spring security，并且能够通过查询数据库用户，角色信息交给spring security完成认证授权。

MR_YANGMIN

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring Security 入门原理及实战

在web应用开发中，安全无疑是十分重要的，选择Spring Security来保护web应用是一个非常好的选择。Spring Security 是spring项目之中的一个安全模块，可以非常方便与spring项目无缝集成。特别是在spring boot项目中加入spring security更是十分简单。本篇我们介绍spring security，以及spring security在web应用中的使用。从一个Spring Security的例子开始创建不受保护的应用@Controllerpublic
复制链接

扫一扫