本篇文章为你整理了Spring Security 认证授权(黑马讲义)（spring security authority）的详细内容，包含有springsecurity认证授权体系 spring security authority spring security app认证token spring security authorization Spring Security 认证授权(黑马讲义)，希望能帮助你了解 Spring Security 认证授权(黑马讲义)。
用户认证就是判断一个用户的身份是否合法的过程，用户去访问系统资源时系统要求验证用户的身份信息，身份合法方可继续访问，不合法则拒绝访问。常见的用户身份认证方式有：用户名密码登录，二维码登录，手机短信登录，指纹认证等方式。
1.2 什么是授权
认证是为了保证用户身份的合法性，授权则是为了更细粒度的对隐私数据进行划分，授权是在认证通过后发生的，控制不同的用户能够访问不同的资源。
授权是用户认证通过根据用户的权限来控制用户访问资源的过程，拥有资源的访问权限则正常访问，没有 权限则拒绝访问。
1.3 授权的数据模型
授权可简单理解为Who对What(which)进行How操作，包括如下：
Who，即主体（Subject），主体一般是指用户，也可以是程序，需要访问系统中的资源。
What，即资源 （Resource），如系统菜单、页面、按钮、代码方法、系统商品信息、系统订单信息等。系统菜单、页面、按 钮、代码方法都属于系统功能资源，对于web系统每个功能资源通常对应一个URL；系统商品信息、系统订单信息 都属于实体资源（数据资源），实体资源由资源类型和资源实例组成，比如商品信息为资源类型，商品编号 为001 的商品为资源实例。
How，权限/许可（Permission），规定了用户对资源的操作许可，权限离开资源没有意义， 如用户查询权限、用户添加权限、某个代码方法的调用权限、编号为001的用户的修改权限等，通过权限可知用户 对哪些资源都有哪些操作许可。
主体、资源、权限关系如下图：
修改后数据模型之间的关系如下图：
1.4 RBAC
如何实现授权？业界通常基于RBAC实现授权。
1.4.1 基于角色的访问控制
RBAC基于角色的访问控制（Role-Based Access Control）是按角色进行授权，
比如：主体的角色为总经理可以查 询企业运营报表，查询员工工资信息等，访问控制流程如下:
根据上图中的判断逻辑，授权代码可表示如下：
if(主体.hasRole("总经理角色id")){
查询工资
如果上图中查询工资所需要的角色变化为总经理和部门经理，此时就需要修改判断逻辑为“判断用户的角色是否是 总经理或部门经理”，修改代码如下：
if(主体.hasRole("总经理角色id") 主体.hasRole("部门经理角色id")){
查询工资
上边的例子发现，当需要修改角色的权限时就需要修改授权的相关代码，系统可扩展性差。
1.4.2 基于资源的访问控制
RBAC基于资源的访问控制（Resource-Based Access Control）是按资源（或权限）进行授权，
比如：用户必须 具有查询工资权限才可以查询员工工资信息等，访问控制流程如下：
根据上图中的判断，授权代码可以表示为：
if(主体.hasPermission("查询工资权限标识")){
查询工资
优点：系统设计时定义好查询工资的权限标识，即使查询工资所需要的角色变化为总经理和部门经理也不需要修改 授权代码，系统可扩展性强。
2 基于Session的认证方式
2.1 认证流程
基于Session认证方式的流程是，用户认证成功后，在服务端生成用户相关的数据保存在session(当前会话)，而发 给客户端的 sesssion_id 存放到 cookie 中，这样用客户端请求时带上 session_id 就可以验证服务器端是否存在 session 数据，以此完成用户的合法校验。当用户退出系统或session过期销毁时,客户端的session_id也就无效了。
基于Session的认证机制由Servlet规范定制，Servlet容器已实现，用户通过HttpSession的操作方法即可实现，如 下是HttpSession相关的操作API。
project.build.sourceEncoding UTF-8 /project.build.sourceEncoding
maven.compiler.source 1.8 /maven.compiler.source
maven.compiler.target 1.8 /maven.compiler.target
/properties
dependencies
dependency
groupId org.springframework /groupId
artifactId spring-webmvc /artifactId
version 5.1.5.RELEASE /version
/dependency
dependency
groupId javax.servlet /groupId
artifactId javax.servlet-api /artifactId
version 3.0.1 /version
scope provided /scope
/dependency
dependency
groupId org.projectlombok /groupId
artifactId lombok /artifactId
version 1.18.8 /version
/dependency
/dependencies
build
finalName security-springmvc /finalName
pluginManagement
plugins
plugin
groupId org.apache.tomcat.maven /groupId
artifactId tomcat7-maven-plugin /artifactId
version 2.2 /version
/plugin
plugin
groupId org.apache.maven.plugins /groupId
artifactId maven-compiler-plugin /artifactId
configuration
source 1.8 /source
target 1.8 /target
/configuration
/plugin
plugin
artifactId maven-resources-plugin /artifactId
configuration
encoding utf-8 /encoding
useDefaultDelimiters true /useDefaultDelimiters
resources
resource
directory src/main/resources /directory
filtering true /filtering
includes
include **/* /include
/includes
/resource
resource
directory src/main/java /directory
includes
include **/*.xml /include
/includes
/resource
/resources
/configuration
/plugin
/plugins
/pluginManagement
/build
2.2.2 Spring 容器配置
在config包下定义ApplicationConfig.java，它对应web.xml中ContextLoaderListener的配置
@Configuration //相当于applicationContext.xml
@ComponentScan(basePackages = "com.itheima.security.springmvc",excludeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION,value = Controller.class)})
public class ApplicationConfig {
//在此配置除了Controller的其它bean，比如：数据库链接池、事务管理器、业务bean等。
2.2.3 servletContext配置
它对应s对应于DispatcherServlet配置
@Configuration//就相当于springmvc.xml文件
@EnableWebMvc
@ComponentScan(basePackages = "com.itheima.security.springmvc"
,includeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION,value = Controller.class)})
public class WebConfig implements WebMvcConfigurer {
@Autowired
SimpleAuthenticationInterceptor simpleAuthenticationInterceptor;
//视频解析器
@Bean
public InternalResourceViewResolver viewResolver(){
InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
viewResolver.setPrefix("/WEB-INF/view/");
viewResolver.setSuffix(".jsp");
return viewResolver;
@Override
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/").setViewName("login");
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(simpleAuthenticationInterceptor).addPathPatterns("/r/**");
2.2.4 加载 Spring容器
在init包下定义Spring容器初始化类SpringApplicationInitializer，此类实现WebApplicationInitializer接口， Spring容器启动时加载WebApplicationInitializer接口的所有实现类。
public class SpringApplicationInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
//spring容器，相当于加载 applicationContext.xml
@Override
protected Class ? [] getRootConfigClasses() {
return new Class[]{ApplicationConfig.class};
//servletContext，相当于加载springmvc.xml
@Override
protected Class ? [] getServletConfigClasses() {
return new Class[]{WebConfig.class};
//url-mapping
@Override
protected String[] getServletMappings() {
return new String[]{"/"};
SpringApplicationInitializer相当于web.xml，使用了servlet3.0开发则不需要再定义web.xml， ApplicationConfig.class对应以下配置的application-context.xml，WebConfig.class对应以下配置的spring- mvc.xml，
web.xml的内容参考：
web‐app
listener
listener‐class org.springframework.web.context.ContextLoaderListener /listener‐class
/listener
context‐param
param‐name contextConfigLocation /param‐name
param‐value /WEB‐INF/application‐context.xml /param‐value
/context‐param
servlet
servlet‐name springmvc /servlet‐name
servlet‐class org.springframework.web.servlet.DispatcherServlet /servlet‐class
init‐param
param‐name contextConfigLocation /param‐name
param‐value /WEB‐INF/spring‐mvc.xml /param‐value
/init‐param
load‐on‐startup 1 /load‐on‐startup
/servlet
servlet‐mapping
servlet‐name springmvc /servlet‐name
url‐pattern / /url‐pattern
/servlet‐mapping
/web‐app
2.3.实现认证功能
2.3.1 认证页面
在webapp/WEB-INF/views下定义认证页面login.jsp，本案例只是测试认证流程，页面没有添加css样式，页面实 现可填入用户名，密码，触发登录将提交表单信息至/login，
内容如下：
%@ page contentType="text/html;charset=UTF-8" pageEncoding="utf-8" %
html
head
title 用户登录 /title
/head
body
form action="login" method="post"
用户名： input type="text" name="username" br
密 nbsp; nbsp; nbsp;码:
input type="password" name="password" br
input type="submit" value="登录"
/form
/body
/html
启动项目，访问/路径地址，进行测试
2.3.2 认证接口
用户进入认证页面，输入账号和密码，点击登录，请求/login进行身份认证。
（1）定义认证接口，此接口用于对传来的用户名、密码校验，若成功则返回该用户的详细信息，否则抛出错误异 常：
public interface AuthenticationService {
* 用户认证
* @param authenticationRequest 用户认证请求，账号和密码
* @return 认证成功的用户信息
UserDto authentication(AuthenticationRequest authenticationRequest);
认证请求结构：
@Data
public class AuthenticationRequest {
//认证请求参数，账号、密码。。
* 用户名
private String username;
* 密码
private String password;
认证成功后返回的用户详细信息，也就是当前登录用户的信息：
@Data
@AllArgsConstructor
public class UserDto {
public static final String SESSION_USER_KEY = "_user";
//用户身份信息
private String id;
private String username;
private String password;
private String fullname;
private String mobile;
* 用户权限
private Set String authorities;
（2）认证实现类，根据用户名查找用户信息，并校验密码，这里模拟了两个用户：
@Service
public class AuthenticationServiceImpl implements AuthenticationService{
* 用户认证，校验用户身份信息是否合法
* @param authenticationRequest 用户认证请求，账号和密码
* @return 认证成功的用户信息
@Override
public UserDto authentication(AuthenticationRequest authenticationRequest) {
//校验参数是否为空
if(authenticationRequest == null
StringUtils.isEmpty(authenticationRequest.getUsername())
StringUtils.isEmpty(authenticationRequest.getPassword())){
throw new RuntimeException("账号和密码为空");
//根据账号去查询数据库,这里测试程序采用模拟方法
UserDto user = getUserDto(authenticationRequest.getUsername());
//判断用户是否为空
if(user == null){
throw new RuntimeException("查询不到该用户");
//校验密码
if(!authenticationRequest.getPassword().equals(user.getPassword())){
throw new RuntimeException("账号或密码错误");
//认证通过，返回用户身份信息
return user;
//根据账号查询用户信息
private UserDto getUserDto(String userName){
return userMap.get(userName);
//用户信息
private Map String,UserDto userMap = new HashMap ();
Set String authorities1 = new HashSet ();
authorities1.add("p1");//这个p1我们人为让它和/r/r1对应
Set String authorities2 = new HashSet ();
authorities2.add("p2");//这个p2我们人为让它和/r/r2对应
userMap.put("zhangsan",new UserDto("1010","zhangsan","123","张三","133443",authorities1));
userMap.put("lisi",new UserDto("1011","lisi","456","李四","144553",authorities2));
（3）登录Controller，对/login请求处理，它调用AuthenticationService完成认证并返回登录结果提示信息：
@RestController
public class LoginController {
@Autowired
AuthenticationService authenticationService;
@RequestMapping(value = "/login",produces = "text/plain;charset=utf-8")
public String login(AuthenticationRequest authenticationRequest, HttpSession session){
UserDto userDto = authenticationService.authentication(authenticationRequest);
//存入session
session.setAttribute(UserDto.SESSION_USER_KEY,userDto);
return userDto.getUsername() +"登录成功";
@GetMapping(value = "/logout",produces = {"text/plain;charset=UTF-8"})
public String logout(HttpSession session){
session.invalidate();
return "退出成功";
@GetMapping(value = "/r/r1",produces = {"text/plain;charset=UTF-8"})
public String r1(HttpSession session){
String fullname = null;
Object object = session.getAttribute(UserDto.SESSION_USER_KEY);
if(object == null){
fullname = "匿名";
}else{
UserDto userDto = (UserDto) object;
fullname = userDto.getFullname();
return fullname+"访问资源r1";
@GetMapping(value = "/r/r2",produces = {"text/plain;charset=UTF-8"})
public String r2(HttpSession session){
String fullname = null;
Object userObj = session.getAttribute(UserDto.SESSION_USER_KEY);
if(userObj != null){
fullname = ((UserDto)userObj).getFullname();
}else{
fullname = "匿名";
return fullname + " 访问资源2";
启动项目，访问/路径地址，进行测试
2.4.实现会话功能
会话是指用户登入系统后，系统会记住该用户的登录状态，他可以在系统连续操作直到退出系统的过程。
认证的目的是对系统资源的保护，每次对资源的访问，系统必须得知道是谁在访问资源，才能对该请求进行合法性 拦截。因此，在认证成功后，一般会把认证成功的用户信息放入Session中，在后续的请求中，系统能够从Session 中获取到当前用户，用这样的方式来实现会话机制。
（1）增加会话控制 首先在UserDto中定义一个SESSION_USER_KEY，作为Session中存放登录用户信息的key。
然后修改LoginController，认证成功后，将用户信息放入当前会话。并增加用户登出方法，登出时将session置为 失效。
（2）增加测试资源 修改LoginController，增加测试资源1，它从当前会话session中获取当前登录用户，并返回提示信息给前台。
（3）测试
未登录情况下直接访问测试资源/r/r1： 匿名访问资源1
成功登录的情况下访问测试资源/r/r1：xx访问资源1
2.5.实现授权功能
现在我们已经完成了用户身份凭证的校验以及登录的状态保持，并且我们也知道了如何获取当前登录用户(从 Session中获取)的信息，接下来，用户访问系统需要经过授权，即需要完成如下功能：
匿名用户（未登录用户）访问拦截：禁止匿名用户访问某些资源。
登录用户访问拦截：根据用户的权限决定是否能访问某些资源。
（1）增加权限数据 为了实现这样的功能，我们需要在UserDto里增加权限属性，用于表示该登录用户所拥有的权限，同时修改 UserDto的构造方法
并在AuthenticationServiceImpl中为模拟用户初始化权限，其中张三给了p1权限，李四给了p2权限。
（2）增加测试资源 我们想实现针对不同的用户能访问不同的资源，前提是得有多个资源，因此在LoginController中增加测试资源2。
（3）实现授权拦截器
在interceptor包下定义SimpleAuthenticationInterceptor拦截器，实现授权拦截：
1、校验用户是否登录
2、校验用户是否拥有操作权限
@Component
public class SimpleAuthenticationInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//在这个方法中校验用户请求的url是否在用户的权限范围内
//取出用户身份信息
Object object = request.getSession().getAttribute(UserDto.SESSION_USER_KEY);
if(object == null){
//没有认证，提示登录
writeContent(response,"请登录");
UserDto userDto = (UserDto) object;
//请求的url
String requestURI = request.getRequestURI();
if( userDto.getAuthorities().contains("p1") requestURI.contains("/r/r1")){
return true;
if( userDto.getAuthorities().contains("p2") requestURI.contains("/r/r2")){
return true;
writeContent(response,"没有权限，拒绝访问");
return false;
//响应信息给客户端
private void writeContent(HttpServletResponse response, String msg) throws IOException {
response.setContentType("text/html;charset=utf-8");
PrintWriter writer = response.getWriter();
writer.print(msg);
writer.close();
在WebConfig中配置拦截器，匹配/r/**
的资源为受保护的系统资源，访问该资源的请求进入 SimpleAuthenticationInterceptor拦截器。
（4）测试
未登录情况下，/r/r1与/r/r2均提示 “请先登录”。
张三登录情况下，由于张三有p1权限，因此可以访问/r/r1，张三没有p2权限，访问/r/r2时提示 权限不足 。
李四登录情况下，由于李四有p2权限，因此可以访问/r/r2，李四没有p1权限，访问/r/r1时提示 权限不足 。
测试结果全部符合预期结果。
3.Spring Security
3.1 Spring Security介绍
Spring Security是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。由于它 是Spring生态系统中的一员，因此它伴随着整个Spring生态系统不断修正、升级，在spring boot项目中加入spring security更是十分简单，使用Spring Security 减少了为企业系统安全控制编写大量重复代码的工作。
3.2 创建工程
3.2.1 创建maven工程
创建maven工程 security-spring-security
引入依赖： 在security-springmvc的基础上增加spring-security的依赖：
dependency
groupId org.springframework.security /groupId
artifactId spring-security-web /artifactId
version 5.1.4.RELEASE /version
/dependency
dependency
groupId org.springframework.security /groupId
artifactId spring-security-config /artifactId
version 5.1.4.RELEASE /version
/dependency
3.2.2 Spring容器配置
创建一个config包，写配置类
@Configuration //相当于applicationContext.xml
@ComponentScan(basePackages = "com.itheima.security.springmvc"
,excludeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION,value = Controller.class)})
public class ApplicationConfig {
//在此配置除了Controller的其它bean，比如：数据库链接池、事务管理器、业务bean等。
3.2.3 Servlet Context配置
在config再写springmvc配置文件
@Configuration//就相当于springmvc.xml文件
@EnableWebMvc
@ComponentScan(basePackages = "com.itheima.security.springmvc"
,includeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION,value = Controller.class)})
public class WebConfig implements WebMvcConfigurer {
public InternalResourceViewResolver viewResolver(){
InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
viewResolver.setPrefix("/WEB-INF/view/");
viewResolver.setSuffix(".jsp");
return viewResolver;
@Override
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/").setViewName("redirect:/login");
3.2.4 加载 Spring容器
在init包下定义Spring容器初始化类SpringApplicationInitializer，此类实现WebApplicationInitializer接口， Spring容器启动时加载WebApplicationInitializer接口的所有实现类。
public class SpringApplicationInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
//spring容器，相当于加载 applicationContext.xml
@Override
protected Class ? [] getRootConfigClasses() {
return new Class[]{ApplicationConfig.class, WebSecurityConfig.class};
//servletContext，相当于加载springmvc.xml
@Override
protected Class ? [] getServletConfigClasses() {
return new Class[]{WebConfig.class};
//url-mapping
@Override
protected String[] getServletMappings() {
return new String[]{"/"};
3.3 认证
3.3.1 认证页面
springSecurity默认提供认证页面，不需要额外开发。
3.3.2.安全配置
spring security提供了用户名密码登录、退出、会话管理等认证功能，只需要配置即可使用。
在config包下定义WebSecurityConfig，安全配置的内容包括：用户信息、密码编码器、安全拦截机制。
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
//定义用户信息服务（查询用户信息）
@Bean
public UserDetailsService userDetailsService(){
InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
manager.createUser(User.withUsername("zhangsan").password("123").authorities("p1").build());
manager.createUser(User.withUsername("lisi").password("456").authorities("p2").build());
return manager;
//密码编码器
@Bean
public PasswordEncoder passwordEncoder(){
return NoOpPasswordEncoder.getInstance();
//安全拦截机制（最重要）
@Override
protected void configure(HttpSecurity http) throws Exception {
http.authorizeRequests()
.antMatchers("/r/r1").hasAuthority("p1")
.antMatchers("/r/r2").hasAuthority("p2")
.antMatchers("/r/**").authenticated()//所有/r/**的请求必须认证通过
.anyRequest().permitAll()//除了/r/**，其它的请求可以访问
.and()
.formLogin()//允许表单登录
.successForwardUrl("/login-success");//自定义登录成功的页面地址
在userDetailsService()方法中，我们返回了一个UserDetailsService给spring容器，Spring Security会使用它来 获取用户信息。我们暂时使用InMemoryUserDetailsManager实现类，并在其中分别创建了zhangsan、lisi两个用 户，并设置密码和权限。
而在configure()中，我们通过HttpSecurity设置了安全拦截规则，其中包含了以下内容：
url匹配/r/** 的资源，经过认证后才能访问。
2.其他url完全开放。
3.支持form表单认证，认证成功后转向/login-success。
关于HttpSecurity的配置清单请参考附录 HttpSecurity。
修改SpringApplicationInitializer的getRootConfigClasses()方法，添加WebSecurityConfig.class：
3.3.2.Spring Security初始化
Spring Security初始化，这里有两种情况
若当前环境没有使用Spring或Spring MVC，则需要将 WebSecurityConfig(Spring Security配置类) 传入超 类，以确保获取配置，并创建spring context。
相反，若当前环境已经使用spring，我们应该在现有的springContext中注册Spring Security(上一步已经做将 WebSecurityConfig加载至rootcontext)，此方法可以什么都不做。
在init包下定义SpringSecurityApplicationInitializer：
public class SpringSecurityApplicationInitializer
extends AbstractSecurityWebApplicationInitializer {
public SpringSecurityApplicationInitializer() {
//super(WebSecurityConfig.class);
3.3.3.默认根路径请求
在WebConfig.java中添加默认请求根路径跳转到/login，此url为spring security提供：
默认Url根路径跳转到/login，此url为spring security提供,spring security默认提供的登录页面。
3.3.4.认证成功页面
在安全配置中，认证成功将跳转到/login-success，代码如下：
spring security支持form表单认证，认证成功后转向/login-success。
在LoginController中定义/login-success:
实现授权需要对用户的访问进行拦截校验，校验用户的权限是否可以操作指定的资源，Spring Security默认提供授权实现方法。
在LoginController添加/r/r1或/r/r2
@RestController
public class LoginController {
@RequestMapping(value = "/login-success",produces = {"text/plain;charset=UTF-8"})
public String loginSuccess(){
return " 登录成功";
* 测试资源1
* @return
@GetMapping(value = "/r/r1",produces = {"text/plain;charset=UTF-8"})
public String r1(){
return " 访问资源1";
* 测试资源2
* @return
@GetMapping(value = "/r/r2",produces = {"text/plain;charset=UTF-8"})
public String r2(){
return " 访问资源2";
在安全配置类WebSecurityConfig.java中配置授权规则：
.antMatchers("/r/r1").hasAuthority("p1")表示：访问/r/r1资源的 url需要拥有p1权限。 .antMatchers("/r/r2").hasAuthority("p2")表示：访问/r/r2资源的 url需要拥有p2权限。
3.3.5 测试
启动项目，访问http://localhost:8080/security-spring-security/路径地址
退出登录，直接logout就ok了
4 Spring Security 集成SpringBoot
4.1 集成SpringBoot
4.1.1 Spring Boot
Spring Boot是一套Spring的快速开发框架，基于Spring 4.0设计，使用Spring Boot开发可以避免一些繁琐的工程 搭建和配置，同时它集成了大量的常用框架，快速导入依赖包，避免依赖包的冲突。基本上常用的开发框架都支持 Spring Boot开发，例如：MyBatis、Dubbo等，Spring 家族更是如此，例如：Spring cloud、Spring mvc、 Spring security等，使用Spring Boot开发可以大大得高生产率，所以Spring Boot的使用率非常高。
通过Spring Boot开发Spring Security应用，Spring Boot提供spring-boot-starter-security用于开 发Spring Security应用。
4.1.2 创建maven工程
引入以下依赖：
dependencies
!-- 以下是 spring boot依赖--
dependency
groupId org.springframework.boot /groupId
artifactId spring-boot-starter-web /artifactId
/dependency
!-- 以下是 spring security依赖--
dependency
groupId org.springframework.boot /groupId
artifactId spring-boot-starter-security /artifactId
/dependency
!-- 以下是jsp依赖--
dependency
groupId javax.servlet /groupId
artifactId javax.servlet-api /artifactId
scope provided /scope
/dependency
!--jsp页面使用jstl标签 --
dependency
groupId javax.servlet /groupId
artifactId jstl /artifactId
/dependency
dependency
groupId org.springframework.boot /groupId
artifactId spring-boot-starter-tomcat /artifactId
scope provided /scope
/dependency
!--用于编译jsp --
dependency
groupId org.apache.tomcat.embed /groupId
artifactId tomcat-embed-jasper /artifactId
scope provided /scope
/dependency
dependency
groupId org.projectlombok /groupId
artifactId lombok /artifactId
version 1.18.0 /version
/dependency
dependency
groupId org.springframework.boot /groupId
artifactId spring-boot-starter-test /artifactId
scope test /scope
/dependency
dependency
groupId org.springframework.boot /groupId
artifactId spring-boot-starter-jdbc /artifactId
/dependency
dependency
groupId mysql /groupId
artifactId mysql-connector-java /artifactId
version 5.1.47 /version
/dependency
/dependencies
build
finalName security-springboot /finalName
pluginManagement
plugins
plugin
groupId org.apache.tomcat.maven /groupId
artifactId tomcat7-maven-plugin /artifactId
version 2.2 /version
/plugin
plugin
groupId org.apache.maven.plugins /groupId
artifactId maven-compiler-plugin /artifactId
configuration
source 1.8 /source
target 1.8 /target
/configuration
/plugin
plugin
artifactId maven-resources-plugin /artifactId
configuration
encoding utf-8 /encoding
useDefaultDelimiters true /useDefaultDelimiters
resources
resource
directory src/main/resources /directory
filtering true /filtering
includes
include **/* /include
/includes
/resource
resource
directory src/main/java /directory
includes
include **/*.xml /include
/includes
/resource
/resources
/configuration
/plugin
/plugins
/pluginManagement
/build
4.1.3 spring 容器配置
SpringBoot工程启动会自动扫描启动类所在包下的所有Bean，加载到spring容器。
Spring Boot配置文件
在resources下添加application.properties，内容如下：
server.port=8080
server.servlet.context-path=/security-springboot
spring.application.name = security-springboot
spring.mvc.view.prefix=/WEB-INF/view/
spring.mvc.view.suffix=.jsp
spring.datasource.url=jdbc:mysql://localhost:3306/user_db
spring.datasource.username=root
spring.datasource.password=mysql
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
4.1.4 Servlet Context配置
由于Spring boot starter自动装配机制，这里无需使用@EnableWebMvc与@ComponentScan，WebConfig如下
@Configuration//就相当于springmvc.xml文件
public class WebConfig implements WebMvcConfigurer {
@Override
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/").setViewName("redirect:/login-view");
registry.addViewController("/login-view").setViewName("login");
视频解析器配置在application.properties中
4.1.5 安全配置
由于Spring boot starter自动装配机制，这里无需使用@EnableWebSecurity，WebSecurityConfig内容如下
@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
//定义用户信息服务（查询用户信息）
@Bean
public UserDetailsService userDetailsService(){
InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
manager.createUser(User.withUsername("zhangsan").password("123").authorities("p1").build());
manager.createUser(User.withUsername("lisi").password("456").authorities("p2").build());
return manager;
//密码编码器
@Bean
public PasswordEncoder passwordEncoder(){
return NoOpPasswordEncoder.getInstance();
//安全拦截机制（最重要）
@Override
protected void configure(HttpSecurity http) throws Exception {
http.authorizeRequests()
.antMatchers("/r/r1").hasAuthority("p1")
.antMatchers("/r/r2").hasAuthority("p2")
.antMatchers("/r/**").authenticated()//所有/r/**的请求必须认证通过
.anyRequest().permitAll()//除了/r/**，其它的请求可以访问
.and()
.formLogin()//允许表单登录
.successForwardUrl("/login-success");//自定义登录成功的页面地址
4.1.6 测试
@RestController
public class LoginController {
@RequestMapping(value = "/login-success",produces = {"text/plain;charset=UTF-8"})
public String loginSuccess(){
return " 登录成功";
* 测试资源1
* @return
@GetMapping(value = "/r/r1",produces = {"text/plain;charset=UTF-8"})
public String r1(){
return " 访问资源1";
* 测试资源2
* @return
@GetMapping(value = "/r/r2",produces = {"text/plain;charset=UTF-8"})
public String r2(){
return " 访问资源2";
4.2 工作原理
4.2.1 结构总览
Spring Security所解决的问题就是安全访问控制，而安全访问控制功能其实就是对所有进入系统的请求进行拦截， 校验每个请求是否能够访问它所期望的资源。根据前边知识的学习，可以通过Filter或 AOP等技术来实现，Spring Security对Web资源的保护是靠Filter实现的，所以从这个Filter来入手，逐步深入Spring Security原理。
当初始化Spring Security时，会创建一个名为 javaSpringSecurityFilterChain 的Servlet过滤器，类型为 org.springframework.security.web.FilterChainProxy，它实现了javax.servlet.Filter，因此外部的请求会经过此 类，下图是Spring Security过虑器链结构图：
FilterChainProxy是一个代理，真正起作用的是FilterChainProxy中SecurityFilterChain所包含的各个Filter，同时 这些Filter作为Bean被Spring管理，它们是Spring Security核心，各有各的职责，但他们并不直接处理用户的认证，也不直接处理用户的授权，而是把它们交给了认证管理器（AuthenticationManager）和决策管理器 （AccessDecisionManager）进行处理，下图是FilterChainProxy相关类的UML图示。
spring Security功能的实现主要是由一系列过滤器链相互配合完成。
下面介绍过滤器链中主要的几个过滤器及其作用：
SecurityContextPersistenceFilter 这个Filter是整个拦截过程的入口和出口（也就是第一个和最后一个拦截 器），会在请求开始时从配置好的 SecurityContextRepository 中获取 SecurityContext，然后把它设置给 SecurityContextHolder。在请求完成后将 SecurityContextHolder 持有的 SecurityContext 再保存到配置好 的 SecurityContextRepository，同时清除 securityContextHolder 所持有的 SecurityContext；
UsernamePasswordAuthenticationFilter 用于处理来自表单提交的认证。该表单必须提供对应的用户名和密 码，其内部还有登录成功或失败后进行处理的 AuthenticationSuccessHandler 和 AuthenticationFailureHandler，这些都可以根据需求做相关改变；
FilterSecurityInterceptor 是用于保护web资源的，使用AccessDecisionManager对当前用户进行授权访。
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。