1. 认证和授权概念

认证：认证就是提供用户名和密码进行登录，认证的目的是让系统知道你是谁。
授权：认证通过后，指定当前用户可以操作哪些功能

2. 权限模块数据模型


权限控制Spring Security - 图1
通过上图可以看到，权限模块共涉及到7张表。在这7张表中，角色表起到了至关重要的作用，其处于核心位置，因为用户、权限、菜单都和角色是多对多关系。

接下来我们可以分析一下在认证和授权过程中分别会使用到哪些表：

认证过程：只需要用户表就可以了，在用户登录时可以查询用户表t_user进行校验，判断用户输入的用户名和密码是否正确。

授权过程：用户必须完成认证之后才可以进行授权，首先可以根据用户查询其角色，再根据角色查询对应的菜单，这样就确定了用户能够看到哪些菜单。然后再根据用户的角色查询对应的权限，这样就确定了用户拥有哪些权限

3. Spring Security简介

Spring Security是 Spring提供的安全认证服务的框架。 使用Spring Security可以帮助我们来简化认证和授权的过程。官网：https://spring.io/projects/spring-security

对应的maven坐标：

  1. <dependency>
  2.   <groupId>org.springframework.security</groupId>
  3.   <artifactId>spring-security-web</artifactId>
  4.   <version>5.0.5.RELEASE</version>
  5. </dependency>
  6. <dependency>
  7.   <groupId>org.springframework.security</groupId>
  8.   <artifactId>spring-security-config</artifactId>
  9.   <version>5.0.5.RELEASE</version>
  10. </dependency>

常用的权限框架除了Spring Security，还有Apache的shiro框架。

4. Spring Security入门案例

4.0 springscurity入门案例整体流程图

springscurity入门案例.png

4.1 工程搭建

创建maven工程，打包方式为war，为了方便起见我们可以让入门案例工程依赖health_interface，这样相关的依赖都继承过来了。

pom.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  3. <project xmlns="http://maven.apache.org/POM/4.0.0"
  4.           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  5.           xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
  6.                              http://maven.apache.org/xsd/maven-4.0.0.xsd">
  7.   <modelVersion>4.0.0</modelVersion>
  9.   <groupId>com.itheima</groupId>
  10.   <artifactId>springsecuritydemo</artifactId>
  11.   <version>1.0-SNAPSHOT</version>
  12.   <packaging>war</packaging>
  14.   <name>springsecuritydemo Maven Webapp</name>
  15.   <url>http://www.example.com</url>
  17.   <properties>
  18.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  19.     <maven.compiler.source>1.8</maven.compiler.source>
  20.     <maven.compiler.target>1.8</maven.compiler.target>
  21.   </properties>
  23.   <dependencies>
  24.     <dependency>
  25.       <groupId>com.itheima</groupId>
  26.       <artifactId>health_interface</artifactId>
  27.       <version>1.0-SNAPSHOT</version>
  28.     </dependency>
  29.   </dependencies>
  30.   <build>
  31.     <plugins>
  32.       <plugin>
  33.         <groupId>org.apache.tomcat.maven</groupId>
  34.         <artifactId>tomcat7-maven-plugin</artifactId>
  35.         <configuration>
  36.           <!-- 指定端口 -->
  37.           <port>85</port>
  38.           <!-- 请求路径 -->
  39.           <path>/</path>
  40.         </configuration>
  41.       </plugin>
  42.     </plugins>
  43.   </build>
  44. </project>

提供index.html页面，内容为hello Spring Security!!

4.2 配置web.xml

在web.xml中主要配置SpringMVC的DispatcherServlet和用于整合第三方框架的DelegatingFilterProxy，用于整合Spring Security。

  1. <!DOCTYPE web-app PUBLIC
  2.  "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
  3.  "http://java.sun.com/dtd/web-app_2_3.dtd" >
  5. <web-app>
  6.   <display-name>Archetype Created Web Application</display-name>
  7.   <filter>
  8.     <!--
  9.       DelegatingFilterProxy用于整合第三方框架
  10.       整合Spring Security时过滤器的名称必须为springSecurityFilterChain，
  11.       否则会抛出NoSuchBeanDefinitionException异常
  12.     -->
  13.     <filter-name>springSecurityFilterChain</filter-name>
  14.     <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
  15.   </filter>
  16.   <filter-mapping>
  17.     <filter-name>springSecurityFilterChain</filter-name>
  18.     <url-pattern>/*</url-pattern>
  19.   </filter-mapping>
  20.   <servlet>
  21.     <servlet-name>springmvc</servlet-name>
  22.     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  23.     <!-- 指定加载的配置文件 ，通过参数contextConfigLocation加载 -->
  24.     <init-param>
  25.       <param-name>contextConfigLocation</param-name>
  26.       <param-value>classpath:spring-security.xml</param-value>
  27.     </init-param>
  28.     <load-on-startup>1</load-on-startup>
  29.   </servlet>
  30.   <servlet-mapping>
  31.     <servlet-name>springmvc</servlet-name>
  32.     <url-pattern>*.do</url-pattern>
  33.   </servlet-mapping>
  35. </web-app>

4.3 配置spring-security.xml

spring-security.xml中完成认证、鉴权、授权。

在spring-security.xml中主要配置Spring Security的拦截规则和认证管理器。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
  6.        xmlns:mvc="http://www.springframework.org/schema/mvc"
  7.        xmlns:security="http://www.springframework.org/schema/security"
  8.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  9.                         http://www.springframework.org/schema/beans/spring-beans.xsd
  10.                         http://www.springframework.org/schema/mvc
  11.                         http://www.springframework.org/schema/mvc/spring-mvc.xsd
  12.                         http://code.alibabatech.com/schema/dubbo
  13.                         http://code.alibabatech.com/schema/dubbo/dubbo.xsd
  14.                         http://www.springframework.org/schema/context
  15.                         http://www.springframework.org/schema/context/spring-context.xsd
  16.                           http://www.springframework.org/schema/security
  17.                           http://www.springframework.org/schema/security/spring-security.xsd">
  19.     <!--
  20.         http：用于定义相关权限控制
  21.         auto-config：是否自动配置
  22.                         设置为true时框架会提供默认的一些配置，例如提供默认的登录页面、登出处理等
  23.                         设置为false时需要显示提供登录表单配置，否则会报错
  24.         use-expressions：用于指定intercept-url中的access属性是否使用表达式
  25.     -->
  26.     <security:http auto-config="true" use-expressions="true">
  27.         <!--
  28.             intercept-url：定义一个拦截规则
  29.             pattern：对哪些url进行权限控制  /**表示拦截所有请求 支持拦截/a/b/c.html
  30.             access：在请求对应的URL时需要什么权限，默认配置时它应该是一个以逗号分隔的角色列表，
  31.                   请求的用户只需拥有其中的一个角色就能成功访问对应的URL
  32.            access：指定所需的访问角色或访问权限
  33.         -->
  34.         <security:intercept-url pattern="/**"  access="hasRole('ROLE_ADMIN')" />
  35.     </security:http>
  37.     <!--
  38.         authentication-manager：认证管理器，用于处理认证操作
  39.     -->
  40.     <security:authentication-manager>
  41.         <!--
  42.             authentication-provider：认证提供者，执行具体的认证逻辑
  43.         -->
  44.         <security:authentication-provider>
  45.             <!--
  46.                 user-service：用于获取用户信息，提供给authentication-provider进行认证
  47.             -->
  48.             <security:user-service>
  49.                 <!--
  50.                     user：定义用户信息，可以指定用户名、密码、角色，后期可以改为从数据库查询用户信息
  51.                   {noop}：表示当前使用的密码为明文
  52.                   authorities：上述用户名和密码认证通过后，赋予什么样的角色
  53.                 -->
  54.                 <security:user name="admin" 
  55.                                password="{noop}admin" 
  56.                                authorities="ROLE_ADMIN">
  57.                   </security:user>
  58.             </security:user-service>
  59.         </security:authentication-provider>
  60.     </security:authentication-manager>
  61. </beans>

自己测试发现：
双标签中不能有存在空格，否则会报错：

元素 ‘security:user’ 必须不含字符或元素信息项 [子级], 因为该类型的内容类型为空。

4.4 测试

登录页面，是不会鉴权管理的；而访问其他页面时，都会拦截进行鉴权（intercept-url pattern=”/**”表示对所有资源进行拦截）

访问http://localhost:85/index.html页面，因为没有权限，自动跳转到spring security默认的登录页面
image.png
登录成功跳转到 favicon.ico页面
image.png
重新访问http://localhost:85/index.html，访问成功
image.png

5 对入门案例改进

前面我们已经完成了Spring Security的入门案例，通过入门案例我们可以看到，Spring Security将我们项目中的所有资源都保护了起来（intercept-url pattern=”/**”表示对所有资源进行拦截），要访问这些资源必须要完成认证而且需要具有ROLE_ADMIN角色。

但是入门案例中的使用方法离我们真实生产环境还差很远，还存在如下一些问题：

1、项目中我们将所有的资源（所有请求URL）都保护起来，实际环境下往往有一些资源不需要认证也可以访问，也就是可以匿名访问。

2、登录页面是由框架生成的，而我们的项目往往会使用自己的登录页面。

3、直接将用户名和密码配置在了配置文件中，而真实生产环境下的用户名和密码往往保存在数据库中。

4、在配置文件中配置的密码使用明文，这非常不安全，而真实生产环境下密码需要进行加密。

本章节需要对这些问题进行改进。

5.1 配置可匿名访问的资源

第一步：在项目中创建pages目录，在pages目录中创建a.html和b.html

第二步：在spring-security.xml文件中配置，指定哪些资源可以匿名访问(不登录也可以访问)

  1. <!--
  2.   http：用于定义相关权限控制
  3.   指定哪些资源不需要进行权限校验，可以使用通配符
  4.   security="none" 不进行权限校验
  5. -->
  6. <security:http security="none" pattern="/pages/a.html" />
  7. <security:http security="none" pattern="/paegs/b.html" />
  8. <security:http security="none" pattern="/pages/**"></security:http>

通过上面的配置可以发现，pages目录下的文件可以在没有认证的情况下任意访问。

5.2 使用指定的登录页面

权限框架登录页面优化.png

第一步：提供login.html作为项目的登录页面

  1. <html>
  2. <head>
  3.     <title>登录</title>
  4. </head>
  5. <body>
  6.     <form action="/login.do" method="post">
  7.         username：<input type="text" name="username"><br>
  8.         password：<input type="password" name="password"><br>
  9.         <input type="submit" value="submit">
  10.     </form>
  11. </body>
  12. </html>

第二步：修改spring-security.xml文件，指定login.html页面可以匿名访问

  1. <security:http security="none" pattern="/login.html" />

第三步：修改spring-security.xml文件，加入表单登录信息的配置

  1. <!--
  2.   如果我们要使用自己指定的页面作为登录页面，必须配置登录表单 页面提交的登录表单请求是由框架负责处理
  3.   form-login：定义表单登录信息
  4. -->
  5. <security:form-login login-page="/login.html"
  6.                      username-parameter="username"
  7.                      password-parameter="password"
  8.                      login-processing-url="/login.do"
  9.                      default-target-url="/index.html"
  10.                      authentication-failure-url="/login.html"
  11.                      />

第四步：修改spring-security.xml文件，关闭CsrfFilter过滤器

  1. <!--
  2.   默认登录页 ：它里边是有隐藏域的csrf 的值 ，而一旦你使用了自己写的登录页面后，没有csrf 的隐藏域的值，校验就无法通过
  4.   csrf：对应CsrfFilter过滤器
  5.   disabled：是否启用CsrfFilter过滤器，如果使用自定义登录页面需要关闭此项，否则登录操作会被禁用（403）
  6. -->
  7. <security:csrf disabled="true"></security:csrf>

使用权限框架自动生成的登录页面时，自带的隐藏域csrf的值
362.png
权限框架自己生成的登录页面 ，在页面上会有隐藏域的csrf 的值，同时内存中也保存一份csrf 的值。会比对这两个值是否相同。

  1. 比对相同，代表该登录页面由权限框架本身提供，安全，允许认证；
  3. 比对不同，认为当前请求页面有问题，不允许认证，并返回一个403<br />![35.png](https://cdn.nlark.com/yuque/0/2021/png/12382395/1612687955860-2d6abc34-1c06-4fe9-83c2-5ef4ab07f4f9.png#align=left&display=inline&height=402&margin=%5Bobject%20Object%5D&name=35.png&originHeight=402&originWidth=1527&size=155229&status=done&style=none&width=1527)

因此在使用我们自己的登录页面时，由于不会携带csrf 的值，所以需要关闭CsrfFilter过滤器。

5.3 从数据库查询用户信息

如果我们要从数据库动态查询用户信息，就必须按照spring security框架的要求提供一个实现UserDetailsService接口的实现类，并按照框架的要求进行配置即可。框架会自动调用实现类中的方法并自动进行密码校验。

实现类代码：

  1. package com.itheima.security;
  3. import org.springframework.security.core.GrantedAuthority;
  4. import org.springframework.security.core.authority.SimpleGrantedAuthority;
  5. import org.springframework.security.core.userdetails.User;
  6. import org.springframework.security.core.userdetails.UserDetails;
  7. import org.springframework.security.core.userdetails.UserDetailsService;
  8. import org.springframework.security.core.userdetails.UsernameNotFoundException;
  9. import java.util.ArrayList;
  10. import java.util.HashMap;
  11. import java.util.List;
  12. import java.util.Map;
  14. public class UserService implements UserDetailsService {
  15.     //模拟数据库中的用户数据
  16.     public  static  Map<String, com.itheima.pojo.User> map = new HashMap<>();
  17.     static {
  18.         com.itheima.pojo.User user1 = new com.itheima.pojo.User();
  19.         user1.setUsername("admin");
  20.         user1.setPassword("admin");
  22.         com.itheima.pojo.User user2 = new com.itheima.pojo.User();
  23.         user2.setUsername("xiaoming");
  24.         user2.setPassword("1234");
  26.         map.put(user1.getUsername(),user1);
  27.         map.put(user2.getUsername(),user2);
  28.     }
  29.     /**
  30.      * 根据用户名加载用户信息
  31.      * 根据用户名查询数据库获得用户信息（包含数据库中存储的密码信息）
  32.      * @param username
  33.      * @return
  34.      * @throws UsernameNotFoundException
  35.      */
  36.     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
  37.         System.out.println("username:" + username);
  38.         com.itheima.pojo.User userInDb = map.get(username);//模拟根据用户名查询数据库
  39.         if(userInDb == null){
  40.             //根据用户名没有查询到用户
  41.             return null;
  42.         }
  44.         //模拟数据库中的密码，后期需要查询数据库
  45.         String passwordInDb = "{noop}" + userInDb.getPassword();
  47.         List<GrantedAuthority> list = new ArrayList<>();
  48.         //授权，后期需要改为查询数据库动态获得用户拥有的权限和角色
  49.         list.add(new SimpleGrantedAuthority("add"));//授权
  50.         list.add(new SimpleGrantedAuthority("delete"));
  51.         if（username.equals("admin")){
  52.             //用户名是admin时，授予角色，完成认证
  53.             //如果输入的用户名是xiaoming，那么没有角色，不能完成认证
  54.             list.add(new SimpleGrantedAuthority("ROLE_ADMIN"));//授予角色，以ROLE_开头表示角色
  55.         }
  57.         UserDetails user = new User(username,passwordInDb,list);
  58.         return user;
  59.     }
  60. }

spring-security.xml：

  1. <!--
  2.   authentication-manager：认证管理器，用于处理认证操作
  3. -->
  4. <security:authentication-manager>
  5.   <!--
  6.     authentication-provider：认证提供者，执行具体的认证逻辑
  7.   -->
  8.   <security:authentication-provider user-service-ref="userService">
  9.   </security:authentication-provider>
  10. </security:authentication-manager>
  12. <bean id="userService" class="com.itheima.security.UserService"></bean>

本章节我们提供了UserService实现类，并且按照框架的要求实现了UserDetailsService接口。在spring配置文件中注册UserService，指定其作为认证过程中根据用户名查询用户信息的处理类。当我们进行登录操作时，spring security框架会调用UserService的loadUserByUsername方法查询用户信息，并根据此方法中提供的密码和用户页面输入的密码进行比对来实现认证操作。

5.4 对密码进行加密

前面我们使用的密码都是明文的，这是非常不安全的。一般情况下用户的密码需要进行加密后再保存到数据库中。

常见的密码加密方式有：

3DES、AES、DES：使用对称加密算法，可以通过解密来还原出原始密码

MD5、SHA1：使用单向HASH算法，无法通过计算还原出原始密码，但是可以建立彩虹表进行查表破解

bcrypt：将salt随机并混入最终加密后的密码，验证时也无需单独提供之前的salt，从而无需单独处理salt问题

加密后的格式一般为：

  1. $2a$10$/bTVvqqlH9UiE0ZJZ7N2Me3RIgUCdgMheyTgV0B4cMCSokPa.6oCa

加密后字符串的长度为固定的60位。其中：$是分割符，无意义；2a是bcrypt加密版本号；10是cost的值；而后的前22位是salt值；再然后的字符串就是密码的密文了。

实现步骤：

第一步：在spring-security.xml文件中指定密码加密对象

  1. <!--配置密码加密对象-->
  2. <bean id="passwordEncoder" 
  3.       class="org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder" />
  5. <!--认证管理器，用于处理认证操作-->
  6. <security:authentication-manager>
  7.   <!--认证提供者，执行具体的认证逻辑-->
  8.   <security:authentication-provider user-service-ref="userService">
  9.     <!--指定密码加密策略-->
  10.     <security:password-encoder ref="passwordEncoder" />
  11.   </security:authentication-provider>
  12. </security:authentication-manager>
  13. <!--开启spring注解使用  因为使用到了@Autowired-->
  14. <context:annotation-config></context:annotation-config>

第二步：修改UserService实现类

  1. package com.itheima.security;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.security.core.GrantedAuthority;
  5. import org.springframework.security.core.authority.SimpleGrantedAuthority;
  6. import org.springframework.security.core.userdetails.User;
  7. import org.springframework.security.core.userdetails.UserDetails;
  8. import org.springframework.security.core.userdetails.UserDetailsService;
  9. import org.springframework.security.core.userdetails.UsernameNotFoundException;
  10. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
  11. import java.util.ArrayList;
  12. import java.util.HashMap;
  13. import java.util.List;
  14. import java.util.Map;
  16. public class UserService implements UserDetailsService {
  17.     @Autowired
  18.     private BCryptPasswordEncoder passwordEncoder;
  20.     public  Map<String, com.itheima.pojo.User> map = new HashMap<>();//模拟数据库中的用户数据
  22.     public void initData(){
  23.         com.itheima.pojo.User user1 = new com.itheima.pojo.User();
  24.         user1.setUsername("admin");
  25.         user1.setPassword(passwordEncoder.encode("admin"));
  27.         com.itheima.pojo.User user2 = new com.itheima.pojo.User();
  28.         user2.setUsername("xiaoming");
  29.         user2.setPassword(passwordEncoder.encode("1234"));
  31.         map.put(user1.getUsername(),user1);
  32.         map.put(user2.getUsername(),user2);
  33.     }
  34.     /**
  35.      * 根据用户名加载用户信息
  36.      * @param username
  37.      * @return
  38.      * @throws UsernameNotFoundException
  39.      */
  40.     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
  41.         initData();
  42.         System.out.println("username:" + username);
  43.         com.itheima.pojo.User userInDb = map.get(username);//模拟根据用户名查询数据库
  44.         if(userInDb == null){
  45.             //根据用户名没有查询到用户
  46.             return null;
  47.         }
  49.         String passwordInDb = userInDb.getPassword();//模拟数据库中的密码，后期需要查询数据库
  51.         List<GrantedAuthority> list = new ArrayList<>();
  52.         //授权，后期需要改为查询数据库动态获得用户拥有的权限和角色
  53.         list.add(new SimpleGrantedAuthority("add"));
  54.         list.add(new SimpleGrantedAuthority("delete"));
  55.         list.add(new SimpleGrantedAuthority("ROLE_ADMIN"));
  56.         UserDetails user = new User(username,passwordInDb,list);
  57.         return user;
  58.     }
  59. }

5.5 配置多种校验规则

为了测试方便，首先在项目中创建a.html、b.html、c.html、d.html几个页面

修改spring-security.xml文件：

  1. <!--只要认证通过就可以访问-->
  2. <security:intercept-url pattern="/index.jsp"  access="isAuthenticated()" />
  3. <security:intercept-url pattern="/a.html"  access="isAuthenticated()" />
  5. <!--拥有add权限就可以访问b.html页面-->
  6. <security:intercept-url pattern="/b.html"  access="hasAuthority('add')" />
  8. <!--拥有ROLE_ADMIN角色就可以访问c.html页面-->
  9. <security:intercept-url pattern="/c.html"  access="hasRole('ROLE_ADMIN')" />
  11. <!--拥有ROLE_ADMIN角色就可以访问d.html页面，
  12.     注意：此处虽然写的是ADMIN角色，框架会自动加上前缀ROLE_-->
  13. <security:intercept-url pattern="/d.html"  access="hasRole('ADMIN')" />

在真实开发中，一般只会授予角色，不会再授予权限。因为在数据库中角色表已经与权限表进行关联，授予角色就相当于授权了一定的权限。

5.6 注解方式权限控制

Spring Security除了可以在配置文件中配置权限校验规则，还可以使用注解方式控制类中方法的调用。例如Controller中的某个方法要求必须具有某个权限才可以访问，此时就可以使用Spring Security框架提供的注解方式进行控制。

实现步骤：
1607996745504.png

第一步：在spring-security.xml文件中配置组件扫描，用于扫描Controller

  1. <mvc:annotation-driven></mvc:annotation-driven>
  2. <context:component-scan base-package="com.itheima.controller"></context:component-scan>

第二步：在spring-security.xml文件中开启权限注解支持

  1. <!--开启注解方式权限控制-->
  2. <security:global-method-security pre-post-annotations="enabled" />

第三步：创建Controller类并在Controller的方法上加入注解进行权限控制

  1. package com.itheima.controller;
  3. import org.springframework.security.access.prepost.PreAuthorize;
  4. import org.springframework.web.bind.annotation.RestController;
  5. import org.springframework.web.bind.annotation.RequestMapping;
  7. @RestController
  8. @RequestMapping("/hello")
  9. public class HelloController {
  10.     @RequestMapping("/add")
  11.     @PreAuthorize("hasAuthority('add')")//表示用户必须拥有add权限才能调用当前方法
  12.     public String add(){
  13.         System.out.println("add...");
  14.         return "success";
  15.     }
  17.     @RequestMapping("/delete")
  18.     @PreAuthorize("hasRole('ROLE_ADMIN')")//表示用户必须拥有ROLE_ADMIN角色才能调用当前方法
  19.     public String delete(){
  20.         System.out.println("delete...");
  21.         return "success";
  22.     }
  23. }

5.7 退出登录

用户完成登录后Spring Security框架会记录当前用户认证状态为已认证状态，即表示用户登录成功了。那用户如何退出登录呢？我们可以在spring-security.xml文件中进行如下配置：

  1. <!--
  2.   logout：退出登录
  3.   logout-url：退出登录操作对应的请求路径
  4.   logout-success-url：退出登录后的跳转页面
  5.   底层是通过过滤器来实现的，过滤器名为loginOutFilter
  6. -->
  7. <security:logout logout-url="/logout.do" 
  8.                  logout-success-url="/login.html" invalidate-session="true"/>

通过上面的配置可以发现，如果用户要退出登录，只需要请求/logout.do这个URL地址就可以，同时会将当前session失效，最后页面会跳转到login.html页面。
权限框架优化-前三条.png

6. 传智健康整合springsecurity

6.1 整体流程图

spring security权限框架中：
最重要的是编写类，实现UserDetailsService，并重写方法loadUserByUsername
传智健康整合springscurity.png

6.2 显示用户名

前面我们已经完成了认证和授权操作，如果用户认证成功后需要在页面展示当前用户的用户名。Spring Security在认证成功后会将用户信息保存到框架提供的上下文对象中，所以此处我们就可以调用Spring Security框架提供的API获取当前用户的username并展示到页面上。

实现步骤：

第一步：在main.html页面中修改，定义username模型数据基于VUE的数据绑定展示用户名，发送ajax请求获取username

  1. <script>
  2.     new Vue({
  3.         el: '#app',
  4.         data:{
  5.             username:null,//用户名
  6.             menuList:[]
  7.         },
  8.         created(){
  9.             //发送请求获取当前登录用户的用户名
  10.             axios.get('/user/getUsername.do').then((response)=>{
  11.                 this.username = response.data.data;
  12.             });
  13.         }
  14.     });
  15. </script>
  1. <div class="avatar-wrapper">
  2.   <img src="../img/user2-160x160.jpg" class="user-avatar">
  3.   <!--展示用户名-->
  4.   {{username}}
  5. </div>

第二步：创建UserController并提供getUsername方法

  1. package com.itheima.controller;
  3. import com.itheima.constant.MessageConstant;
  4. import com.itheima.entity.Result;
  5. import org.springframework.security.core.context.SecurityContextHolder;
  6. import org.springframework.security.core.context.SecurityContextImpl;
  7. import org.springframework.web.bind.annotation.RequestMapping;
  8. import org.springframework.web.bind.annotation.RestController;
  10. @RestController
  11. @RequestMapping("/user")
  12. public class UserController {
  13.     //获取当前登录用户的用户名
  14.     @RequestMapping("/getUsername")
  15.     public Result getUsername()throws Exception{
  16.         //Spring Security在认证成功后，会将用户信息保存到框架提供的上下文对象中
  17.         //底层的实现原理是session会话
  18.         try{
  19.             org.springframework.security.core.userdetails.User user =
  20.                     (org.springframework.security.core.userdetails.User)
  21.                     SecurityContextHolder.getContext().getAuthentication().getPrincipal();
  22.             return new Result(true, MessageConstant.GET_USERNAME_SUCCESS,user.getUsername());
  23.         }catch (Exception e){
  24.             return new Result(false, MessageConstant.GET_USERNAME_FAIL);
  25.         }
  26.     }
  27. }

通过debug调试可以看到Spring Security框架在其上下文中保存的用户相关信息：

1.png

6.3 用户退出

第一步：在main.html中提供的退出菜单上加入超链接

  1. <el-dropdown-item divided>
  2.   <span style="display:block;"><a href="/logout.do">退出</a></span>
  3. </el-dropdown-item>

第二步：在spring-security.xml文件中配置

  1. <!--
  2.   logout：退出登录
  3.   logout-url：退出登录操作对应的请求路径
  4.   logout-success-url：退出登录后的跳转页面
  5. -->
  6. <security:logout logout-url="/logout.do" 
  7.                  logout-success-url="/login.html" invalidate-session="true"/>