SpringSecurity安全框架（配置类版）

1. 前言

1.1 SpringSecurity 框架用法简介

用户登录系统时我们协助 SpringSecurity 把用户对应的角色、权限组装好，同时把各个资源所要求的权限信息设定好，剩下的“登录验证”、“权限验证”等等工作都交给 SpringSecurity

1.2 权限管理过程中的相关概念

1.2.1 主体

英文单词：principal

使用系统的用户或设备或从其他系统远程登录的用户等等。简单说就是谁使用系统谁就是主体

1.2.2 认证

英文单词：authentication

权限管理系统确认一个主体的身份，允许主体进入系统。简单说就是“主体”证明自己是谁。笼统的认为就是以前所做的登录操作。

1.2.3 授权

英文单词：authorization

将操作系统的“权力”“授予”“主体”，这样主体就具备了操作系统中特定功能的能力。所以简单来说，授权就是给用户分配权限。

1.3 security的特点

Spring 技术栈的组成部分，通过提供完整可扩展的认证和授权支持保护你的应用程序。官网地址：

https://spring.io/projects/spring-security

SpringSecurity 特点：

1）和 Spring 无缝整合。

2）全面的权限控制。

3）专门为 Web 开发而设计。

4）旧版本不能脱离 Web 环境使用。

5）新版本对整个框架进行了分层抽取，分成了核心模块和 Web 模块。单独引入核心模块就可以脱离 Web 环境。

6）重量级

2. 环境准备

2.1 新建工程

2.1.1 引入SpringMVC依赖

<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.bjc</groupId>
	<artifactId>springsecuryti-web</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>

	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>4.3.20.RELEASE</version>
		</dependency> 
		<!-- 引入 Servlet 容器中相关依赖 -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>2.5</version>
			<scope>provided</scope>
		</dependency> 
		<!-- JSP 页面使用的依赖 -->
		<dependency>
			<groupId>javax.servlet.jsp</groupId>
			<artifactId>jsp-api</artifactId>
			<version>2.1.3-b06</version>
			<scope>provided</scope>
		</dependency>

	</dependencies>

</project>

2.1.2 MVC的xml配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">

	<context:component-scan
		base-package="com.bjc.security"></context:component-scan>

	<bean
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/WEB-INF/views/"></property>
		<property name="suffix" value=".jsp"></property>
	</bean>

	<mvc:annotation-driven></mvc:annotation-driven>
	<mvc:default-servlet-handler />

</beans>

2.1.3 web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	version="2.5">

	<servlet>
		<servlet-name>springDispatcherServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:spring-mvc.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet> 
	<!-- Map all requests to the DispatcherServlet for handling -->
	<servlet-mapping>
		<servlet-name>springDispatcherServlet</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>

</web-app>

然后引入静态资源等文件。访问，如图：

2.2 引入security框架

2.2.1 引入security依赖

<!-- 添加security依赖 -->
<!-- SpringSecurity 对 Web 应用进行权限管理 -->
<dependency>
	<groupId>org.springframework.security</groupId>
	<artifactId>spring-security-web</artifactId>
	<version>4.2.10.RELEASE</version>
</dependency> 
<!-- SpringSecurity 配置 -->
<dependency>
	<groupId>org.springframework.security</groupId>
	<artifactId>spring-security-config</artifactId>
	<version>4.2.10.RELEASE</version>
</dependency> 
<!-- SpringSecurity 标签库 -->
<dependency>
	<groupId>org.springframework.security</groupId>
	<artifactId>spring-security-taglibs</artifactId>
	<version>4.2.10.RELEASE</version>
</dependency>

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

2.2.3 security配置类

package com.bjc.security.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
@EnableWebSecurity  // 启动web环境下的权限控制功能
public class WebApplicationSecurityConfig extends WebSecurityConfigurerAdapter{
	
}

然后启动项目，访问，如图：

发现，需要输入用户名和密码才能进入首页了，这说明security已经生效了。

3. 放行首页和静态资源

我们只需要在配置类中重写父类的configure方法即可，例如：

@Configuration
@EnableWebSecurity  // 启动web环境下的权限控制功能
public class WebApplicationSecurityConfig extends WebSecurityConfigurerAdapter{

	@Override
	protected void configure(HttpSecurity security) throws Exception {
		security
			.authorizeRequests()			// 对请求进行授权
			.antMatchers("/index.jsp")		// 针对 /index.jsp路径进行授权
			.permitAll()					// 可以无条件访问
			.antMatchers("/layui/**")		// 针对 /layui目录下的静态资源进行授权
			.permitAll()					// 设置其可以无条件访问
			.and()
			.authorizeRequests()			// 对请求进行授权
			.anyRequest()					// 任意的请求
			.authenticated()				// 都需要登录之后才能访问
			;
	}
	
}

再次访问系统，如图：

可以正常访问了。

4. 指定登录页面

4.1 无权限跳转到自带的登录页

使用formLogin

访问无权限的野蛮，如图：

4.2 无权限跳转到指定的登录页

4.2.1 loginPage

通过loginPage方法指定登录页面（如果没有指定会访问security自带的登录页面），其可以修改security默认的登录请求地址

指定登录页前后 SpringSecurity 登录地址变化：

指定前	/login GET - the login form
	/login POST - process the credentials and if valid authenticate the user
	/login?error GET - redirect here for failed authentication attempts
	/login?logout GET - redirect here after successfully logging out
指定后	/index.jsp GET - the login form
	/index.jsp POST - process the credentials and if valid authenticate the user
	/index.jsp?error GET - redirect here for failed authentication attempts
	/index.jsp?logout GET - redirect here after successfully logging out

例如：

4.2.2 loginProcessingUrl

通过调用 loginProcessingUrl()方法指定登录地址。如果指定了loginProcessingUrl，那么其值就会覆盖loginPage方法中设置的默认值（index.jsp POST）

例如：

4.3 设置登录用户名和密码

实现思路，如图：

通过上面的分析，我们知道，我们要实现登录，我们需要form表单的用户名和密码的name属性是一个约定好的值。如果是采用默认的，就是

SpringSecurity 默认账号的请求参数名：username 
SpringSecurity 默认密码的请求参数名：password

如果需要定制的话，我们需要配置一下。

4.3.1 定制登录用户名密码

1）我们可以在配置类中指定参数，并指定登录成功跳转的路径例如：

注意：loginProcessingUrl后面的permitAll可以省略不要。

2）在jsp中，指定登录用户名和密码的参数名，如图：

注意：标签

<input type="hidden" name="${_csrf.parameterName}" value="${_csrf.token}"/>

需要加上，用于跨域验证的。在配置版中有过csrf的介绍

3）配置授权信息

在配置类中，重写另一个configure方法，并设置用户名和密码以及对应的角色和权限，例如：

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
	auth
		.inMemoryAuthentication()		// 内存授权
		.withUser("tom")				// 设置账号
		.password("123456")				// 设置密码
		.roles("ADMIN")					// 设置角色
		.and()
		.withUser("marry")				// 设置另一个用户
		.password("123456")				// 密码
		.authorities("SAVE","EDIT")		// 设置权限
		;
}

使用账号tom/123456访问，可以成功的进入系统，如图：

目前为止完整的配置类如下：

package com.bjc.security.config;

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;

@Configuration
@EnableWebSecurity  // 启动web环境下的权限控制功能
public class WebApplicationSecurityConfig extends WebSecurityConfigurerAdapter{
	
	// 授权
	@Override
	protected void configure(AuthenticationManagerBuilder auth) throws Exception {
		auth
			.inMemoryAuthentication()		// 内存授权
			.withUser("tom")				// 设置账号
			.password("123456")				// 设置密码
			.roles("ADMIN")					// 设置角色
			.and()
			.withUser("marry")				// 设置另一个用户
			.password("123456")				// 密码
			.authorities("SAVE","EDIT")		// 设置权限
			;
	}

	// 认证
	@Override
	protected void configure(HttpSecurity security) throws Exception {
		security
			.authorizeRequests()			// 对请求进行授权
			.antMatchers("/index.jsp")		// 针对 /index.jsp路径进行授权
			.permitAll()					// 可以无条件访问
			.antMatchers("/layui/**")		// 针对 /layui目录下的静态资源进行授权
			.permitAll()					// 设置其可以无条件访问
			.and()
			.authorizeRequests()			// 对请求进行授权
			.anyRequest()					// 任意的请求
			.authenticated()				// 都需要登录之后才能访问
			.and()
			.formLogin()					// 无权限跳转到自带的登录页
			/**
			   *  关于loginPage方法的特殊说明：
			 * 	指定登录页的同时会影响到：提交表单的地址、退出登录地址、登录失败的地址
			   *        如果指定loginPage的值为/index.jsp，那么，
			 *  1）去登录页：/index.jsp  Get
			 *  2）提交登录表单：/index.jsp  POST
			 *  3）登录失败：/index.jsp?error
			 *  4）退出登录：/index.jsp?logout
			 * */
			.loginPage("/index.jsp")		// 指定登录页面（如果没有指定会访问security自带的登录页面）
			/*
			 * loginProcessingUrl的说明：
			 * 		如果指定了loginProcessingUrl，那么其值就会覆盖loginPage方法中设置的默认值（index.jsp POST）
			 * */
			.loginProcessingUrl("/do/login.html")   // 指定提交登录表单的地址
			.permitAll()							// 允许登录地址访问（可以不要）
			.usernameParameter("loginAcct")			// 指定登录账号的请求参数名
			.passwordParameter("loginPwd")			// 指定登录密码号的请求参数名
			.defaultSuccessUrl("/main.html")		// 设置登录成功去到的页面
			;
	}
	
}

4.4 退出登录

4.4.1 禁用csrf的退出登录

csrf是security默认开启的，我们需要禁用掉它。如果 CSRF 功能没有禁用，那么退出请求必须是 POST 方式。如果禁用了 CSRF 功能则任何请求方式都可以。所以，我们可以直接使用a标签并指定退出url即可实现退出功能了。

我们可以使用logout()方法开启注销功能，使用logoutUrl()方法来自定义注销功能的 URL 地址。

1）配置

2）页面

<a id="logoutAnchor" href="${pageContext.request.contextPath }/do/logout.html">退出</a>

4.4.2 启用csrf功能退出登录

如果 CSRF 功能没有禁用，那么退出请求必须是 POST 方式。

1）配置

2）form表单

<li class="layui-nav-item">
	<form id="logoutForm" action="${pageContext.request.contextPath }/do/logout.html" method="post">
		<input type="hidden" name="${_csrf.parameterName}" value="${_csrf.token}"/>
	</form>
	<a id="logoutAnchor" href="">退出</a>
	<script type="text/javascript">
		window.onload = function() {
			// 点击a标签，提交表单
			document.getElementById("logoutAnchor").onclick = function() {
				
				document.getElementById("logoutForm").submit();
				
				// 阻止a标签的默认执行动作
				return false;
				
			};
			
		};
	</script>
</li>

同时，我们可以自定义退出登录的处理器

1）addLogoutHandler()方法：添加退出处理器

2）logoutSuccessHandler()方法：退出成功处理器

5. 基于角色或权限访问控制

我们可以给特定资源指定特定的权限或者角色才能访问。例如：

5.1 指定特定的资源需要哪些角色或者权限

注意：要先设置小范围的授权在设置大范围的，即anyRequest()放在后面，如上图。

5.2 指定用户具备的权限或者角色

所以，用户ton可以访问level1目录的内容，marry可以访问level2目录下的内容

如图：

1）tom用户

访问level1下的内容

访问level2下的内容

2）marry用户

访问lever1目录下的内容

访问level2目录下的内容

注意：SpringSecurity 会在角色字符串前面加“ROLE_”前缀，查看security源码，如图：

之所以要强调这个事情，是因为将来从数据库查询得到的用户信息、角色信息、权限信息需要我们自己手动组装。手动组装时需要我们自己给角色字符串前面加“ROLE_” 前缀。

5.3 自定义403页面

当我们访问的资源没有权限的时候，security默认给我们跳转到一个403的错误页面，这个体验极度不好，所以，我们需要自定义该页面。

5.3.1 访问被拒绝之后直接跳转到页面

controller

@RequestMapping("/to/no/auth/page.html")
public String toNoAuthPage() {
	return "no_auth";
}

效果：

5.3.2 访问被拒绝后走处理器

该方式可以带一些数据到页面，当然，上一种也可以，只是带的数据是通用的数据，该方式可以根据不同的异常携带不同的数据，我们可以通过accessDeniedHandler方法来定制。

例如：

访问没权限的资源，如：

6. 记住我功能（不重要）

6.1 内存版本

HttpSecurity 对象调用 rememberMe()方法，登录表单携带名为 remember-me 的请求参数即可。例如：

页面

这时候，在登录页，会有一个记住我的选择框，勾选之后，发起请求，就会在浏览器写入一个名为remember-me的cookie，再次在登录的时候，就根据这个 Cookie 的 value 在服务器端找到以前登录的 User，而且这个 Cookie 被设置为存储 2 个星期。

当我们关闭浏览器，再次访问的时候，就可以直接进入系统了，不需要在输入用户名和密码。

6.2 数据库版（不重要）

为了让服务器重启也不影响记住登录状态，将用户登录状态信息存入数据库

6.2.1 引入数据库相关依赖

<!-- 引入数据库相关依赖 -->
<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>druid</artifactId>
	<version>1.1.12</version>
</dependency> 
<!-- mysql 驱动 --> <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>5.1.47</version>
</dependency>
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-orm</artifactId>
	<version>4.3.20.RELEASE</version>
</dependency>

6.2.2 配置数据源

<!-- 配置数据源 -->
<bean id="dataSource"
	class="com.alibaba.druid.pool.DruidDataSource">
	<property name="username" value="root"></property>
	<property name="password" value="root"></property>
	<property name="url" value="jdbc:mysql://localhost:3306/security?useSSL=false"></property>
	<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
</bean> 
<!-- jdbcTemplate -->
<bean id="jdbcTemplate"
	class="org.springframework.jdbc.core.JdbcTemplate">
	<property name="dataSource" ref="dataSource"></property>
</bean>

6.2.3 创建数据库

CREATE DATABASE `security` CHARACTER SET utf8;

CREATE TABLE persistent_logins (
  username VARCHAR (64) NOT NULL,
  series VARCHAR (64) PRIMARY KEY,
  token VARCHAR (64) NOT NULL,
  last_used TIMESTAMP NOT NULL
) ;

6.2.4 配置类

1）在 WebAppSecurityConfig 类中注入数据源

@Autowired
private DataSource dataSource;

2）启用令牌仓库功能

repository是JdbcTokenRepositoryImpl对象

JdbcTokenRepositoryImpl repository = new JdbcTokenRepositoryImpl(); 
repository.setDataSource(dataSource);

然后，重启服务器，登录成功，查看数据库，如图：

数据已经正确存入数据库，再次重启服务器，访问，一样可以不用登录就可以进入系统。

注意：表来自于JdbcTokenRepositoryImpl类，如图：

既然该类已经有了建表语句，为什么我们还需要手动建表了，我们看源码，如图：

有一个init方法，可以自动创建表，但是，问题来了，该方法用protected修饰的，该类是框架提供的，我们只能继承该类，才能调用到该方法，但是，这样做比较不划算，所以，我们还不如自己创建一个表算了。

完整的配置类：

package com.bjc.security.config;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.access.AccessDeniedException;
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.web.access.AccessDeniedHandler;
import org.springframework.security.web.authentication.rememberme.JdbcTokenRepositoryImpl;

@Configuration
@EnableWebSecurity  // 启动web环境下的权限控制功能
public class WebApplicationSecurityConfig extends WebSecurityConfigurerAdapter{
	
	@Autowired
	private DataSource dataSource;
	
	// 授权  确定用户有什么权限和角色
	@Override
	protected void configure(AuthenticationManagerBuilder auth) throws Exception {
		auth
			.inMemoryAuthentication()		// 内存授权
			.withUser("tom")				// 设置账号
			.password("123456")				// 设置密码
			.roles("ADMIN","门徒")			// 设置角色
			.and()
			.withUser("marry")				// 设置另一个用户
			.password("123456")				// 密码
			.authorities("SAVE","UPDATE")	// 设置权限
			;
	}
 
	// 认证  确定资源需要什么权限和角色才能访问
	@Override
	protected void configure(HttpSecurity security) throws Exception {
		
		JdbcTokenRepositoryImpl repository = new JdbcTokenRepositoryImpl(); 
		repository.setDataSource(dataSource);
		
		security
			.authorizeRequests()			// 对请求进行授权
			.antMatchers("/index.jsp")		// 针对 /index.jsp路径进行授权
			.permitAll()					// 可以无条件访问
			.antMatchers("/layui/**")		// 针对 /layui目录下的静态资源进行授权
			.permitAll()					// 设置其可以无条件访问
			// .and()
			// .authorizeRequests()			// 对请求进行授权
			.antMatchers("/level1/**")		// 访问level1下的资源
			.hasRole("门徒")					// 需要角色是门徒的才能访问
			.antMatchers("/level2/**")		// 访问level2下的资源
			.hasAuthority("UPDATE")			// 需要用户具备UPDATE权限才能访问
			.anyRequest()					// 其他未设置的全部请求
			.authenticated()				// 都需要登录之后才能访问
			.and()
			.formLogin()					// 无权限跳转到自带的登录页
			/**
			   *  关于loginPage方法的特殊说明：
			 * 	指定登录页的同时会影响到：提交表单的地址、退出登录地址、登录失败的地址
			   *        如果指定loginPage的值为/index.jsp，那么，
			 *  1）去登录页：/index.jsp  Get
			 *  2）提交登录表单：/index.jsp  POST
			 *  3）登录失败：/index.jsp?error
			 *  4）退出登录：/index.jsp?logout
			 * */
			.loginPage("/index.jsp")		// 指定登录页面（如果没有指定会访问security自带的登录页面）
			/*
			 * loginProcessingUrl的说明：
			 * 		如果指定了loginProcessingUrl，那么其值就会覆盖loginPage方法中设置的默认值（index.jsp POST）
			 * */
			.loginProcessingUrl("/do/login.html")   // 指定提交登录表单的地址
			.permitAll()							// 允许登录地址访问（可以不要）
			.usernameParameter("loginAcct")			// 指定登录账号的请求参数名
			.passwordParameter("loginPwd")			// 指定登录密码号的请求参数名
			.defaultSuccessUrl("/main.html")		// 设置登录成功去到的页面
			.and()
			//.csrf()
			//.disable()								// 禁用csrf功能
			.logout()								// 开启退出功能
			.logoutUrl("/do/logout.html")			// 指定退出url
			.logoutSuccessUrl("/index.jsp")			// 指定退出成功之后去到的url
			.and()
			.exceptionHandling()						// 指定异常处理器
			// .accessDeniedPage("/to/no/auth/page.html")	// 访问被拒绝的时候，前往的页面
			.accessDeniedHandler(new AccessDeniedHandler() {
				@Override
				public void handle(HttpServletRequest request, HttpServletResponse response,
						AccessDeniedException accessDeniedException) throws IOException, ServletException {
					// 携带数据到页面，页面用${message}接收数据
					request.setAttribute("message", "抱歉，您没有权限访问该页面，请找管理员配置合适的权限在访问。。。");
					// 转发
					request.getRequestDispatcher("/WEB-INF/views/no_auth.jsp").forward(request, response);
				}
			})
			.and()
			.rememberMe()		// 记住我
			.tokenRepository(repository);
			;
	}
	
}

7. 数据库登录

前面我们的登录是采用的内存登录方式，适用于系统指定用户且用户量较少的系统适用，现在我们需要查询数据库，适用数据库中的用户来进行登录。

7.1 默认实现（了解）

SpringSecurity 的默认实现已经将 SQL 语句硬编码在了 JdbcDaoImpl 类中，所以，默认方法显得比较刻板，源码如下：

可以知道，默认实现表结构等都是规定好的，相当不方便。这种情况下，我们有下面三种选择

1）按照 JdbcDaoImpl 类中 SQL 语句设计表结构。

2）修改 JdbcDaoImpl 类的源码。

3）不使用 jdbcAuthentication()。

auth.jdbcAuthentication().usersByUsernameQuery("tom")

7.2 自定义数据库查询方式

自定义数据库查询方式也很简单，只需要执行auth.userDetailsService(userDetailsService);即可，其中userDetailsService需要自定义实现UserDetailsService接口的类并自动装配。

7.2.1 自定义userDetailsService

package com.bjc.security.config;

import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
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 com.bjc.security.entity.Admin;

@Component
public class MyUserDetailServiceImpl implements UserDetailsService{
	@Autowired
	private JdbcTemplate jdbcTemplate;
	
	// 总目标：根据表单提交的用户名查询User对象，并装配角色、权限等信息
	// username  表单提交的用户名
	@Override
	public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
		// 1.从数据库查询Admin对象
		String sql = "SELECT id,loginacct,userpswd,username,email FROM t_admin WHERE loginacct=?";
		
		List<Admin> list = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Admin.class), username);
		
		Admin admin = list.get(0);
		
		// 2.给Admin设置角色权限信息
		List<GrantedAuthority> authorities = new ArrayList<>();
		
		// 角色前面需要添加ROLE_  这里应该查询对应的角色表的
		authorities.add(new SimpleGrantedAuthority("ROLE_ADMIN"));
		// 权限前面不需要添加前缀
		authorities.add(new SimpleGrantedAuthority("UPDATE"));
		
		// 3.把admin对象和authorities封装到UserDetails中
		
		String userpswd = admin.getUserpswd();
		
		// User是UserDetails的实现类
		return new User(username, userpswd, authorities);
	}

}

7.2.2 设置

访问，使用数据库中的用户名和密码，可以成功访问。

8. 密码加密

加密我们需要通过passwordEncoder方法指定加密算法。

8.1 普通MD5加密

8.1.1 加密算法类

package com.bjc.security.config;

import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Component;

/**
 *加密类
 *
 */
@Component
public class MyPasswordEncoder implements PasswordEncoder {

	/**
	 *   加密方法：采用MD5加密
	 */
	@Override
	public String encode(CharSequence rawPassword) {
		return generatePwd(rawPassword);
	}

	/**
	 *   校验方法
	 *   1. rawPassword ：明文
	 *   2. encodedPassword：数据库查询出来的密文
	 */
	@Override
	public boolean matches(CharSequence rawPassword, String encodedPassword) {
		return encodedPassword.equals(generatePwd(rawPassword));
	}
	
	// 加密方法
	private String generatePwd(CharSequence rawPassword) {
		String pwd = (String)rawPassword;
		try {
			// 获取MD5加密类
			MessageDigest instance = MessageDigest.getInstance("MD5");
			// 得到加密后的密码字节数组
			byte[] afterPwd = instance.digest(pwd.getBytes());
			// 转换成16位
			return new BigInteger(1,afterPwd).toString(16);
		} catch (NoSuchAlgorithmException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}

}

8.1.2 配置

1）引入加密算法

2）设置加密算法

8.2 带盐值的加密

SpringSecutiry中，给我们提供了一个类bCryptPasswordEncoder，我们可以很方便的对密码进行加密，其比Md5更安全，采用的是动态“盐”机制。

使用起来很简单，直接将我们自定义的那个加密类替换成bCryptPasswordEncoder即可。

例如：

注意：我们需要将该类注入到spring容器中

也可以直接调用getBCryptPasswordEncoder()传参。

配置类最终版

package com.bjc.security.config;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.access.AccessDeniedException;
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.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.security.web.authentication.rememberme.JdbcTokenRepositoryImpl;

@Configuration
@EnableWebSecurity  // 启动web环境下的权限控制功能
public class WebApplicationSecurityConfig extends WebSecurityConfigurerAdapter{
	
	@Autowired
	private DataSource dataSource;
	
	@Autowired
	private MyUserDetailServiceImpl userDetailsService;
	
	/*
	 * @Autowired private MyPasswordEncoder passwordEncoder;
	 */
	
	@Autowired
	private BCryptPasswordEncoder bCryptPasswordEncoder;
	
	@Bean
	public BCryptPasswordEncoder getBCryptPasswordEncoder() {
		return new BCryptPasswordEncoder();
	}
	
	// 授权  确定用户有什么权限和角色
	@Override
	protected void configure(AuthenticationManagerBuilder auth) throws Exception {
		/*auth
			.inMemoryAuthentication()		// 内存授权
			.withUser("tom")				// 设置账号
			.password("123456")				// 设置密码
			.roles("ADMIN","门徒")			// 设置角色
			.and()
			.withUser("marry")				// 设置另一个用户
			.password("123456")				// 密码
			.authorities("SAVE","UPDATE")	// 设置权限
			;*/
		
		// 装配userDetailsService
		auth.userDetailsService(userDetailsService).passwordEncoder(bCryptPasswordEncoder);
	}
 
	// 认证  确定资源需要什么权限和角色才能访问
	@Override
	protected void configure(HttpSecurity security) throws Exception {
		
		JdbcTokenRepositoryImpl repository = new JdbcTokenRepositoryImpl(); 
		repository.setDataSource(dataSource);
		
		security
			.authorizeRequests()			// 对请求进行授权
			.antMatchers("/index.jsp")		// 针对 /index.jsp路径进行授权
			.permitAll()					// 可以无条件访问
			.antMatchers("/layui/**")		// 针对 /layui目录下的静态资源进行授权
			.permitAll()					// 设置其可以无条件访问
			// .and()
			// .authorizeRequests()			// 对请求进行授权
			.antMatchers("/level1/**")		// 访问level1下的资源
			.hasRole("门徒")					// 需要角色是门徒的才能访问
			.antMatchers("/level2/**")		// 访问level2下的资源
			.hasAuthority("UPDATE")			// 需要用户具备UPDATE权限才能访问
			.anyRequest()					// 其他未设置的全部请求
			.authenticated()				// 都需要登录之后才能访问
			.and()
			.formLogin()					// 无权限跳转到自带的登录页
			/**
			   *  关于loginPage方法的特殊说明：
			 * 	指定登录页的同时会影响到：提交表单的地址、退出登录地址、登录失败的地址
			   *        如果指定loginPage的值为/index.jsp，那么，
			 *  1）去登录页：/index.jsp  Get
			 *  2）提交登录表单：/index.jsp  POST
			 *  3）登录失败：/index.jsp?error
			 *  4）退出登录：/index.jsp?logout
			 * */
			.loginPage("/index.jsp")		// 指定登录页面（如果没有指定会访问security自带的登录页面）
			/*
			 * loginProcessingUrl的说明：
			 * 		如果指定了loginProcessingUrl，那么其值就会覆盖loginPage方法中设置的默认值（index.jsp POST）
			 * */
			.loginProcessingUrl("/do/login.html")   // 指定提交登录表单的地址
			.permitAll()							// 允许登录地址访问（可以不要）
			.usernameParameter("loginAcct")			// 指定登录账号的请求参数名
			.passwordParameter("loginPwd")			// 指定登录密码号的请求参数名
			.defaultSuccessUrl("/main.html")		// 设置登录成功去到的页面
			.and()
			//.csrf()
			//.disable()								// 禁用csrf功能
			.logout()								// 开启退出功能
			.logoutUrl("/do/logout.html")			// 指定退出url
			.logoutSuccessUrl("/index.jsp")			// 指定退出成功之后去到的url
			.and()
			.exceptionHandling()						// 指定异常处理器
			// .accessDeniedPage("/to/no/auth/page.html")	// 访问被拒绝的时候，前往的页面
			.accessDeniedHandler(new AccessDeniedHandler() {
				@Override
				public void handle(HttpServletRequest request, HttpServletResponse response,
						AccessDeniedException accessDeniedException) throws IOException, ServletException {
					// 携带数据到页面，页面用${message}接收数据
					request.setAttribute("message", "抱歉，您没有权限访问该页面，请找管理员配置合适的权限在访问。。。");
					// 转发
					request.getRequestDispatcher("/WEB-INF/views/no_auth.jsp").forward(request, response);
				}
			})
			.and()
			.rememberMe()		// 记住我
			.tokenRepository(repository);
			;
	}
	
}

9. security标签

我们需要在页面中显示security提供的信息，可以使用security提供的标签库来显示相应的信息，例如，显示登录用户的名称

9.1 导入标签库

<%@ taglib uri="http://www.springframework.org/security/tags" prefix="security" %>

9.2 使用标签

如图，security给我们提供了如下几个标签

以security:authentication为例，标签写法如下：

<security:authentication property="xxx"/>

property属性为表达式，这个表达式怎么写了，我们暂时用xxx代替，看页面显示什么，启动项目，如图：

页面报错了，我们看最下面的错误信息，如图：

可以知道，该标签获取的属性是类UsernamePasswordAuthenticationToken中的属性，打开该类，如图，发现了2个get方法

我们在页面中获取一下principal（主体），看看它是何方神圣，如图：

SecurityAdmin是我们定义的一个继承了User的类，由此可以得出一个结论：

SpringSecurity处理完登录操作之后把登录成功的User对象以principal属性名存入了UsernamePasswordAuthenticationToken对象

知道了这里的主体是什么了，表达式就好写了，例如：

显示用户昵称：

<security:authentication property="principal.originalAdmin.userName"/>

注意：这里没有使用credentials，是因为credentials是密码擦除，最后程序将其置为了null，所以页面访问会报错。

10 权限控制

10.1 使用角色控制

10.1.1 配置方式

指定某个连接必须具有某个角色或者权限才能访问

10.1.2 注解方式

为了方便，我们往往在控制层（Controller）使用注解来进行权限控制，值得注意的是，使用注解方式，需要在配置类中开启注解权限功能

1）开启注解权限功能

在配置类上加上如下注解

@EnableGlobalMethodSecurity(prePostEnabled = true)

例如：

2）在需要控制的地方加上注解

例如：我们希望访问/role/getPageInfo.json需要有部长的角色才能访问

我们只需要在方法上添加如下注解

@PreAuthorize("hasRole('部长')")

例如：

10.2 使用权限进行权限控制

同使用角色，只是单词不同，例如：

1）配置类方式

.antMatchers("/admin/getByPageInfo.html")
.hasAuthority("user:get")

2）注解方式

@PreAuthorize("hasAuthority('user:get')")

10.3 使用角色与权限进行权限控制

在配置中，我们可以access来使用角色与权限联合权限控制

例如：只有是经理角色，并具有user:get的用户才能访问

.access("hasRole('经理') OR hasAuthority('user:get')")

11. 其他注解

11.1 @PostAuthorize

先执行方法然后根据方法返回值判断是否具备权限

例如：查询一个 Admin 对象，在@PostAuthorize 注解中和当前登录的 Admin 对象进行比较，如果不一致，则判断为不能访问。实现“只能查自己”效果。

@PostAuthorize("returnObject.data.loginAcct == principal.username")

注意：使用 returnObject 获取到方法返回值，使用 principal 获取到当前登录用户的主体对象

11.2 @PreFilter

在方法执行前对传入的参数进行过滤。只能对集合类型的数据进行过滤。

@PreFilter(value="filterObject%2==0") 
@ResponseBody 
@RequestMapping("/admin/test/pre/filter") 
public ResultEntity<List<Integer>> saveList(@RequestBody List<Integer> valueList) { 
	return ResultEntity.successWithData(valueList); 
}

11.3 @PostFilter

在方法执行后对方法返回值进行过滤。只能对集合类型的数据进行过滤。

12. 页面元素的权限控制

我们可以使用标签根据用户不同的权限来显示不同的内容，当然，前提是我们需要引入标签库

<%@ taglib uri="http://www.springframework.org/security/tags" prefix="security" %>

使用标签<security:authorize>来实现，例如：

<!-- 有经理角色的才能看到 -->
<security:authorize access="hasRole('经理')">
    <div class="col-xs-6 col-sm-3 placeholder">
      <img data-src="holder.js/200x200/auto/sky" class="img-responsive" alt="Generic placeholder thumbnail">
      <h4>Label</h4>
      <span class="text-muted">Something else</span>
    </div>
</security:authorize>
<!-- 有部长角色的才能看到 -->
<security:authorize access="hasRole('部长')">
    <div class="col-xs-6 col-sm-3 placeholder">
      <img data-src="holder.js/200x200/auto/vine" class="img-responsive" alt="Generic placeholder thumbnail">
      <h4>Label</h4>
      <span class="text-muted">Something else</span>
    </div>
</security:authorize>
<!-- 有user:get权限的才能看到 -->
<security:authorize access="hasAuthority('user:get')">
    <div class="col-xs-6 col-sm-3 placeholder">
      <img data-src="holder.js/200x200/auto/sky" class="img-responsive" alt="Generic placeholder thumbnail">
      <h4>Label</h4>
      <span class="text-muted">Something else</span>
   </div>
</security:authorize>