Spring Security权限控制

努力努力再努力鸭

已于 2022-07-28 14:01:32 修改

阅读量1.5k

点赞数

文章标签： spring java 数据库

于 2022-07-27 17:14:19 首次发布

本文链接：https://blog.csdn.net/qq_41783386/article/details/125976456

版权

文章目录

1、认证和授权
- 1.1 概念
- 1.2 权限模块数据模型
2、Spring Security简介

1、认证和授权

1.1 概念

（…backend工程）需要思考2个问题：

问题1：在生产环境下我们如果不登录后台系统就可以完成这些功能操作吗？

答案显然是否定的，要操作这些功能必须首先登录到系统才可以。

问题2：是不是所有用户，只要登录成功就都可以操作所有功能呢？

答案是否定的，并不是所有的用户都可以操作这些功能。不同的用户可能拥有不同的权限，这就需要进行授权了。

认证：系统提供的用于识别用户身份的功能，通常提供用户名和密码进行登录其实就是在进行认证，认证的目的是让系统知道你是谁。
授权：用户认证成功后，需要为用户授权，其实就是指定当前用户可以操作哪些功能。

权限控制本质就是对用户进行认证和授权。

1.2 权限模块数据模型

前面已经分析了认证和授权的概念，要实现最终的权限控制，需要有一套表结构支撑：

用户表t_user、权限表t_permission、角色表t_role、菜单表t_menu、用户角色关系表t_user_role、角色权限关系表t_role_permission、角色菜单关系表t_role_menu。
（t_role：权限的集合）

表之间关系如下图：
在这里插入图片描述
通过上图可以看到，权限模块共涉及到7张表。在这7张表中，角色表起到了至关重要的作用，其处于核心位置，因为用户、权限、菜单都和角色是多对多关系。

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

认证过程：只需要用户表就可以了，在用户登录时可以查询用户表t_user进行校验，判断用户输入的用户名和密码是否正确。
授权过程：用户必须完成认证之后才可以进行授权，首先可以根据用户查询其角色，再根据角色查询对应的菜单，这样就确定了用户能够看到哪些菜单。然后再根据用户的角色查询对应的权限，这样就确定了用户拥有哪些权限。所以授权过程会用到上面7张表。
常用的权限框架：Spring Security、Apache的shiro框架。

2、Spring Security简介

Spring Security是 Spring提供的安全认证服务的框架。使用Spring Security可以帮助我们来简化认证和授权的过程。
官网：https://spring.io/projects/spring-security
(可通过过滤器方式进行拦截，用来保护项目中资源，如页面、图片、Controller的访问路径…。也就是说若想要访问某个路径、访问某个页面、某个Controller可以(在spring-security.xml的access中)描述必须具有某个角色或具有某个权限，框架会进行判断)
注意：

1、实际环境下往往有一些资源（URL）不需要认证也可以访问，也就是可以匿名访问。
2、登录页面是由框架生成的，而我们的项目往往会使用自己的登录页面。
3、直接将用户名和密码配置在了配置文件中，而真实生产环境下的用户名和密码往往保存在数据库中。
4、在配置文件中配置的密码使用明文，这非常不安全，而真实生产环境下密码需要进行加密。

2.1 入门案例

（1）maven坐标：

<dependency>
  <groupId>org.springframework.security</groupId>
  <artifactId>spring-security-web</artifactId>
  <version>5.0.5.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework.security</groupId>
  <artifactId>spring-security-config</artifactId>
  <version>5.0.5.RELEASE</version>
</dependency>

（2）工程搭建

（2.1）创建maven工程，打包方式为war

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

<?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
                             http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.itheima</groupId>
  <artifactId>springsecuritydemo</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>springsecuritydemo Maven Webapp</name>
  <url>http://www.example.com</url>

  <properties>
    <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>com.itheima</groupId>
      <artifactId>health_interface</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <configuration>
          <!-- 指定端口 -->
          <port>85</port>
          <!-- 请求路径 -->
          <path>/</path>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

（2.2）页面

在项目中创建pages目录，在pages目录中创建a.html和b.html
提供index.html页面，内容为hello Spring Security!!（实现在不登陆情况下，无法访问此页面）

（3）配置web.xml

在web.xml中主要配置SpringMVC的DispatcherServlet和用于整合第三方框架的DelegatingFilterProxy，用于整合Spring Security。
（DelegatingFilterProxy：Spring提供的专门用于整合第三方框架的
DispatcherServlet：）

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>
  <!--DelegatingFilterProxy-->
  <filter>
    <!--
      DelegatingFilterProxy用于整合第三方框架
      整合Spring Security时过滤器的名称必须为springSecurityFilterChain，
	  否则会抛出NoSuchBeanDefinitionException异常

		DelegatingFilterProxy：根据springSecurityFilterChain去Spring工厂中找bean，后面需配置这个bean
    -->
    <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>
  <!--DispatcherServlet-->
  <servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 指定加载的配置文件 ，通过参数contextConfigLocation加载 -->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:spring-security.xml</param-value><!--DispatcherServlet加载spring-security.xml文件-->
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>

</web-app>

（4）配置spring-security.xml

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

拦截规则；
认证管理器；

<?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:dubbo="http://code.alibabatech.com/schema/dubbo"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:security="http://www.springframework.org/schema/security"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
						http://www.springframework.org/schema/beans/spring-beans.xsd
						http://www.springframework.org/schema/mvc
						http://www.springframework.org/schema/mvc/spring-mvc.xsd
						http://code.alibabatech.com/schema/dubbo
						http://code.alibabatech.com/schema/dubbo/dubbo.xsd
						http://www.springframework.org/schema/context
						http://www.springframework.org/schema/context/spring-context.xsd
                          http://www.springframework.org/schema/security
                          http://www.springframework.org/schema/security/spring-security.xsd">

  	<!-- 1.security:http-->
    <!--
        http：用于定义相关权限控制
        auto-config：是否自动配置
                        设置为true时框架会提供默认的一些配置，例如提供默认的登录页面、登出处理等
                        设置为false时需要显示提供登录表单配置，否则会报错
        use-expressions：用于指定intercept-url中的access属性是否使用表达式来描述权限
    -->
    <!-- 1.1 配置哪些资源可以匿名访问（不登录也可以访问）-->
	<security:http security="none" pattern="/pages/**"><!--pages下的所有资源都不需要权限校验--></security:http>
	
    <security:http auto-config="true" use-expressions="true">
        <!--
		  Spring Security框架底层是基于过滤器实现的。
            intercept-url：定义一个拦截规则
            pattern：对哪些url进行权限控制  
				（pattern="/**"：拦截所有请求 注意是**，因为一个*只能代表一个层次，例如：只能拦截/a.html这种，不能拦截/a/b/c.html）
            access：在请求对应的URL时需要什么权限，默认配置时它应该是一个以逗号分隔的角色列表，
				 请求的用户只需拥有其中的一个角色就能成功访问对应的URL
					(如：access="hasRole('角色名')：检查是否具有...角色(后面需授予这个角色)，如果检查到没有此角色，则访问会被拒绝)
        -->
        <security:intercept-url pattern="/**"  access="hasRole('ROLE_ADMIN')" />
    </security:http>

    <!-- 2.配置认证管理器
        authentication-manager：认证管理器，用于处理认证操作 -->
    <security:authentication-manager>
        <!-- 2.1配置认证提供者
            authentication-provider：认证提供者，执行具体的认证逻辑 -->
        <security:authentication-provider>
            <!--
                user-service：用于获取用户信息，提供给authentication-provider进行认证-->
            <security:user-service>
                <!-- 这里需改进，这里写死了，但应从数据库中查找
                    user：定义用户信息，可以指定用户名、密码、角色，后期可以改为从数据库查询用户信息
				  					{noop}：表示当前使用的密码为明文
 										authorities：分配ROLE_ADMIN角色-->
                <security:user name="admin" 
                               password="{noop}admin" 
                               authorities="ROLE_ADMIN"/>
            </security:user-service>
        </security:authentication-provider>
    </security:authentication-manager>
</beans>

2.2 对入门案例改进

前面我们已经完成了Spring Security的入门案例，通过入门案例我们可以看到，Spring Security将我们项目中的所有资源都保护了起来，要访问这些资源必须要完成认证而且需要具有ROLE_ADMIN角色。

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

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

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

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

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

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

2.2.1 配置可匿名访问的资源

（1）页面

在项目中创建pages目录，在pages目录中创建a.html和b.html…

（2）配置可访问资源

在spring-security.xml文件中配置，指定哪些资源可以匿名访问

<!--
  http：用于定义相关权限控制
  指定哪些资源不需要进行权限校验，可以使用通配符
-->
<security:http security="none" pattern="/pages/a.html" />
<security:http security="none" pattern="/paegs/b.html" />
<security:http security="none" pattern="/pages/**"><!--pages下的所有资源都不需要权限校验-->
</security:http>

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

（3）配置多种校验规则

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

(3.1) 简述

认证通过就可访问…页面 “isAuthenticated()”

<security:intercept-url pattern="/a.html"  access="isAuthenticated()" />

拥有…权限就可访问…页面 “hasAuthority(‘…’)”

<security:intercept-url pattern="/b.html"  access="hasAuthority('add')" />

拥有…角色就可访问…页面 “hasRole(‘’)”

<security:intercept-url pattern="/c.html"  access="hasRole('ROLE_ADMIN')" />

(3.2) 修改spring-security.xml文件：

<!--只要认证通过就可以访问-->
<security:intercept-url pattern="/index.jsp"  access="isAuthenticated()" />
<security:intercept-url pattern="/a.html"  access="isAuthenticated()" />

<!--拥有add权限就可以访问b.html页面-->
<security:intercept-url pattern="/b.html"  access="hasAuthority('add')" />

<!--拥有ROLE_ADMIN角色就可以访问c.html页面-->
<security:intercept-url pattern="/c.html"  access="hasRole('ROLE_ADMIN')" />

<!--拥有ROLE_ADMIN角色就可以访问d.html页面，
	注意：此处虽然写的是ADMIN角色，框架会自动加上前缀ROLE_-->
<security:intercept-url pattern="/d.html"  access="hasRole('ADMIN')" />

2.2.2 使用指定的登录页面

(1) 提供login.html作为项目的登录页面

<html>
<head>
    <title>登录</title>
</head>
<body>
    <form action="/login.do" method="post">
        username：<input type="text" name="username"><br>
        password：<input type="password" name="password"><br>
        <input type="submit" value="submit">
    </form>
</body>
</html>

(2) 修改spring-security.xml文件，指定login.html页面可以匿名访问

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

(3) 修改spring-security.xml文件，加入表单登录信息的配置

<!-- 配置登陆表单，使得用自己指定的页面作为登陆页面。（页面提交的登陆表单请求是由框架负责处理，不需自己去写Controller）
  form-login：定义表单登录信息
         login-page：指定登陆页面；
         username-parameter、password-parameter的值需与登陆表单的name属性一致；
         login-processing-url：表单提交地址；
         default-target-url：认证成功后跳转的页面
         authentication-failure-url：认证失败跳回登陆页面-->
<security:form-login login-page="/login.html"
                     username-parameter="username"
                     password-parameter="password"
                     login-processing-url="/login.do"
                     default-target-url="/index.html"
                     authentication-failure-url="/login.html"
                     />

(4) 修改spring-security.xml文件，关闭CsrfFilter过滤器

<!-- 因为现在要使用自己指定的登陆页面，若不关闭CsrfFilter过滤器，自己的登陆页面出不来
  csrf：对应CsrfFilter过滤器
  disabled：是否启用CsrfFilter过滤器，如果使用自定义登录页面需要关闭此项，否则登录操作会被禁用（403）
-->
<security:csrf disabled="true"></security:csrf>

2.2.3 从数据库查询用户信息

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

（1）实现类代码：

package com.itheima.security;

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 java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class UserService implements UserDetailsService {
    //模拟数据库中的用户数据  
    public  static  Map<String, com.lym.pojo.User> map = new HashMap<>();
    static {
        com.itheima.pojo.User user1 = new com.itheima.pojo.User();
        user1.setUsername("admin");
        user1.setPassword("admin");//明文

        com.itheima.pojo.User user2 = new com.itheima.pojo.User();
        user2.setUsername("xiaoming");
        user2.setPassword("1234");

        map.put(user1.getUsername(),user1);
        map.put(user2.getUsername(),user2);
    }
  
    /** loadUserByUsername方法不需要我们调用；
    			什么时候调用：在SpringSecurity框架拦截到请求后，就会处理请求，并调用实现类的此方法（是通过反射调用loadUserByUsername方法），并把页面中提交的用户名传到此方法。
     * 根据用户名加载用户信息
     * username ：此参数由框架传入
     * return: UserDetails接口对象，我们要返回的其实是UserDetails的实现类User(框架提供的，而不是自己写的User)（用户名,密码,权限）
     * @throws UsernameNotFoundException
     */
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
      // 1.根据用户名查询数据库 获得用户信息（包含密码）
        System.out.println("username:" + username);
        com.itheima.pojo.User userInDb = map.get(username);//模拟根据用户名查询数据库
        if(userInDb == null){
            //根据用户名没有查询到用户
            return null;
        }

        //模拟数据库中的密码，后期需要查询数据库  若明文密码则前面加{noop}前缀，否则会报错
        String passwordInDb = "{noop}" + userInDb.getPassword();
				// 2.授权
        List<GrantedAuthority> list = new ArrayList<>();
        //授权，后期需要改为查询数据库动态获得用户拥有的权限和角色
        list.add(new SimpleGrantedAuthority("add"));
        list.add(new SimpleGrantedAuthority("delete"));
      	if (username.equals("admin")){
            list.add(new SimpleGrantedAuthority("ROLE_ADMIN"));//授予角色
        }
      	// 3.将用户信息返回给框架、框架会进行密码比对(页面提交的密码和数据库中查询的密码进行比对)
        UserDetails user = new User(username,passwordInDb,list);//注意这里的User是框架的User
        return user;
    }
}

（2）spring-security.xml：（注册UserService）

<!-- 2.配置认证管理器 注册UserService
  authentication-manager：认证管理器，用于处理认证操作
-->
<security:authentication-manager>
  <!-- 2.2 配置认证提供者
    authentication-provider：认证提供者，执行具体的认证逻辑
		（调用UserService中的方法动态查询用户信息）
  -->
  <security:authentication-provider user-service-ref="userService">
  </security:authentication-provider>
</security:authentication-manager>
<!-- 2.1配置bean 但仅配置bean不行，因为只是spring框架初始化，但并不知登陆时要调用loadUserByUsername方法-->
<bean id="userService" class="com.lym.security.UserService"></bean>

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

2.2.4 对密码进行加密

(1)简介

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

常见的密码加密方式有：

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

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

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

加密后的格式一般为：

$2a$10$/bTVvqqlH9UiE0ZJZ7N2Me3RIgUCdgMheyTgV0B4cMCSokPa.6oCa

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

(2) 实现步骤：

(2.1)：在spring-security.xml文件中指定密码加密对象

<!-- 1.(密码加密)配置密码加密对象 （这只是告诉框架给我们创建这个对象）-->
<bean id="passwordEncoder" 
      class="org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder" />

<!--认证管理器，用于处理认证操作-->
<security:authentication-manager>
  <!--认证提供者，执行具体的认证逻辑-->
  <security:authentication-provider user-service-ref="userService">
    <!-- 2.(密码加密)指定密码加密策略（指定框架使用passwordEncoder进行加密，通过ref方式把它注给安全框架，这样安全框架就可以使用passwordEncoder对象，对密码进行加密）-->
    <security:password-encoder ref="passwordEncoder" />
  </security:authentication-provider>
</security:authentication-manager>
<!-- 3.(密码加密)开启spring注解使用-->
<context:annotation-config></context:annotation-config>

(2.2)：修改UserService实现类

package com.itheima.security;

import org.springframework.beans.factory.annotation.Autowired;
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.security.crypto.bcrypt.BCryptPasswordEncoder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class UserService implements UserDetailsService {
  //注入passwordEncoder（密码加密用）
    @Autowired
    private BCryptPasswordEncoder passwordEncoder;

    public  Map<String, com.itheima.pojo.User> map = new HashMap<>();//模拟数据库中的用户数据

    public void initData(){
        com.itheima.pojo.User user1 = new com.itheima.pojo.User();
        user1.setUsername("admin");
        user1.setPassword(passwordEncoder.encode("admin"));//使用bcrypt提供的方法对密码进行加密

        com.itheima.pojo.User user2 = new com.itheima.pojo.User();
        user2.setUsername("xiaoming");
        user2.setPassword(passwordEncoder.encode("1234"));

        map.put(user1.getUsername(),user1);
        map.put(user2.getUsername(),user2);
    }
    /**
     * 根据用户名加载用户信息
     * @param username
     * @return
     * @throws UsernameNotFoundException
     */
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        initData();
        System.out.println("username:" + username);
        com.itheima.pojo.User userInDb = map.get(username);//模拟根据用户名查询数据库
        if(userInDb == null){
            //根据用户名没有查询到用户
            return null;
        }

        String passwordInDb = userInDb.getPassword();//模拟数据库中的密码，后期需要查询数据库

        List<GrantedAuthority> list = new ArrayList<>();
        //授权，后期需要改为查询数据库动态获得用户拥有的权限和角色
        list.add(new SimpleGrantedAuthority("add"));
        list.add(new SimpleGrantedAuthority("delete"));
        list.add(new SimpleGrantedAuthority("ROLE_ADMIN"));
        UserDetails user = new User(username,passwordInDb,list);
        return user;
    }
}

2.2.5 配置多种校验规则(控制页面)

(1) 简述

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

认证通过就可访问…页面 isAuthenticated()

<security:intercept-url pattern="/a.html"  access="isAuthenticated()" />

拥有…权限就可访问…页面 hasAuthority(‘…’)

<security:intercept-url pattern="/b.html"  access="hasAuthority('add')" />

拥有…角色就可访问…页面

<security:intercept-url pattern="/c.html"  access="hasRole('ROLE_ADMIN')" />

(2) 修改spring-security.xml文件：

<!--只要认证通过就可以访问-->
<security:intercept-url pattern="/pages/a.html"  access="isAuthenticated()" />

<!--拥有add权限就可以访问b.html页面-->
<security:intercept-url pattern="/pages/b.html"  access="hasAuthority('add')" />

<!--拥有ROLE_ADMIN角色就可以访问c.html页面-->
<security:intercept-url pattern="/pages/c.html"  access="hasRole('ROLE_ADMIN')" />

<!--拥有ROLE_ADMIN角色就可以访问d.html页面，
	注意：此处虽然写的是ADMIN角色，框架会自动加上前缀ROLE_-->
<security:intercept-url pattern="/pages/d.html"  access="hasRole('ADMIN')" />

2.2.6 注解方式权限控制(可控制方法级别)🌟

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

实现步骤：

(1)：在spring-security.xml文件中配置组件扫描，用于扫描Controller

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

(2)：在spring-security.xml文件中开启权限注解支持

<!--开启注解方式权限控制
		(global-method-security对方法进行控制，pre-post-annotations="enabled启用注解方式)-->
<security:global-method-security pre-post-annotations="enabled" />

(3)：创建Controller类并在Controller的方法上加入注解进行权限控制

package com.itheima.controller;

import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;

@RestController
@RequestMapping("/hello")
public class HelloController {
    @RequestMapping("/add")
    @PreAuthorize("hasAuthority('add')")//表示用户必须拥有add权限才能调用当前方法
    public String add(){
        System.out.println("add...");
        return "add success";
    }

    @RequestMapping("/delete")
    @PreAuthorize("hasRole('ROLE_ADMIN')")//表示用户必须拥有ROLE_ADMIN角色才能调用当前方法
    public String delete(){
        System.out.println("delete...");
        return "delete success";
    }
}

2.2.7 退出登录

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

<!-- 退出登陆（注意放在<security:http>中）
  logout：退出登录
  logout-url：退出登录操作对应的请求路径，只要请求此路径，就会经过过滤器处理，将登陆状态销毁
  logout-success-url：退出登录后的跳转页面
(底层是有一个LogoutFilter,框架提供用于退出系统的过滤器)
-->
<security:logout logout-url="/logout.do"
                 logout-success-url="/login.html" invalidate-session="true"/>

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

2.3 小结

1）maven坐标+工程搭建

1.1）maven坐标：

<dependency>
  <groupId>org.springframework.security</groupId>
  <artifactId>spring-security-web</artifactId>
  <version>5.0.5.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework.security</groupId>
  <artifactId>spring-security-config</artifactId>
  <version>5.0.5.RELEASE</version>
</dependency>

1.2）创建maven工程，打包方式为war

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

<?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
                             http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.itheima</groupId>
  <artifactId>springsecuritydemo</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>springsecuritydemo Maven Webapp</name>
  <url>http://www.example.com</url>

  <properties>
    <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>com.itheima</groupId>
      <artifactId>health_interface</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <configuration>
          <!-- 指定端口 -->
          <port>85</port>
          <!-- 请求路径 -->
          <path>/</path>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

2）页面

提供login.html
提供index.html页面，内容为hello Spring Security!!（实现在不登陆情况下，无法访问此页面）
在项目中创建pages目录，在pages目录中创建a.html和b.html c.html d.html

3）配置web.xml

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>
  <!--DelegatingFilterProxy-->
  <filter>
    <!--
      DelegatingFilterProxy用于整合第三方框架
      整合Spring Security时过滤器的名称必须为springSecurityFilterChain，
	  否则会抛出NoSuchBeanDefinitionException异常

		DelegatingFilterProxy：根据springSecurityFilterChain去Spring工厂中找bean，后面需配置这个bean
    -->
    <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>
  <!--DispatcherServlet-->
  <servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 指定加载的配置文件 ，通过参数contextConfigLocation加载 -->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:spring-security.xml</param-value><!--DispatcherServlet加载spring-security.xml文件-->
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>

</web-app>

4）配置spring-security.xml

在spring-security.xml中主要配置Spring Security：

配置可匿名访问的资源；
如<security:http security=“none” pattern=“/pages/**”>(pages下的所有资源都不需要权限校验)
配置多种校验规则(控制页面)。
（xml中）“isAuthenticated()”、“hasAuthority(‘…’)”、“hasRole(‘…’)”
注解方式权限控制(可控制方法级别)；
配置组件扫描、开启权限注解支持、Controller的方法上加入注解进行权限控制
使用指定的登陆页面；
指定login.html页面可以匿名访问、加入表单登录信息的配置、关闭CsrfFilter过滤器
从数据库查询用户信息；
编写实现UserDetailsService接口的实现类、(xml中)注册UserService
密码加密；
(xml中) 指定密码加密对象、
退出登录；
如<security:logout logout-url=“/logout.do”
logout-success-url=“/login.html” invalidate-session=“true”/>（通过此配置可以发现，如果用户要退出登录，只需要请求/logout.do这个URL地址就可以，同时会将当前session失效，最后页面会跳转到login.html页面。）

<?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:dubbo="http://code.alibabatech.com/schema/dubbo"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:security="http://www.springframework.org/schema/security"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
						http://www.springframework.org/schema/beans/spring-beans.xsd
						http://www.springframework.org/schema/mvc
						http://www.springframework.org/schema/mvc/spring-mvc.xsd
						http://code.alibabatech.com/schema/dubbo
						http://code.alibabatech.com/schema/dubbo/dubbo.xsd
						http://www.springframework.org/schema/context
						http://www.springframework.org/schema/context/spring-context.xsd
                          http://www.springframework.org/schema/security
                          http://www.springframework.org/schema/security/spring-security.xsd">

    <!-- 1.security:http-->
    <!--
        http：用于定义相关权限控制
        auto-config：是否自动配置
                        设置为true时框架会提供默认的一些配置，例如提供默认的登录页面、登出处理等
                        设置为false时需要显示提供登录表单配置，否则会报错
        use-expressions：用于指定intercept-url中的access属性是否使用表达式来描述权限
    -->

    <!-- 1.1 配置哪些资源可以匿名访问（不登录也可以访问）-->
<!--    <security:http security="none" pattern="/pages/**">&lt;!&ndash;pages下的所有资源都不需要权限校验&ndash;&gt;</security:http>-->
    <!-- 1.2.1 指定登陆页面可以匿名访问-->
    <security:http security="none" pattern="/login.html" />


    <security:http auto-config="true" use-expressions="true">
        <!--
					Spring Security框架底层是基于过滤器实现的。
            intercept-url：定义一个拦截规则
            pattern：对哪些url进行权限控制
								（pattern="/**"：拦截所有请求 注意是**，因为一个*只能代表一个层次，例如：只能拦截/a.html这种，不能拦截/a/b/c.html）
            access：在请求对应的URL时需要什么权限，默认配置时它应该是一个以逗号分隔的角色列表，
				  请求的用户只需拥有其中的一个角色就能成功访问对应的URL
							(如：access="hasRole('角色名')：检查是否具有...角色(后面需授予这个角色)，如果检查到没有此角色，则访问会被拒绝)
        -->
<!--        <security:intercept-url pattern="/**"  access="hasRole('ROLE_ADMIN')" />-->
        <!--只要认证通过就可以访问-->
        <security:intercept-url pattern="/pages/a.html"  access="isAuthenticated()" />

        <!--拥有add权限就可以访问b.html页面-->
        <security:intercept-url pattern="/pages/b.html"  access="hasAuthority('add')" />

        <!--拥有ROLE_ADMIN角色就可以访问c.html页面-->
        <security:intercept-url pattern="/pages/c.html"  access="hasRole('ROLE_ADMIN')" />

        <!--拥有ROLE_ADMIN角色就可以访问d.html页面，
            注意：此处虽然写的是ADMIN角色，框架会自动加上前缀ROLE_-->
        <security:intercept-url pattern="/pages/d.html"  access="hasRole('ADMIN')" />

        <!-- 1.2.2  配置登陆表单，使得用自己指定的页面作为登陆页面。（页面提交的登陆表单请求是由框架负责处理，不需自己去写Controller）
                    form-login：定义表单登录信息
                        login-page：指定登陆页面；
                        username-parameter、password-parameter的值需与登陆表单的name属性一致；
                        login-processing-url：表单提交地址；
                        default-target-url：认证成功后跳转的页面
                        authentication-failure-url：认证失败跳回登陆页面-->
        <security:form-login login-page="/login.html"
                             username-parameter="username"
                             password-parameter="password"
                             login-processing-url="/login.do"
                             default-target-url="/index.html"
                             authentication-failure-url="/login.html"
        />
        <!-- 1.2.3 因为现在要使用自定义的登陆页面，若不关闭CsrfFilter过滤器，自己的登陆页面出不来
                    csrf：对应CsrfFilter过滤器 (默认开启)
                    disabled：是否启用CsrfFilter过滤器，如果使用自定义登录页面需要关闭此项，否则登录操作会被禁用（403）-->
        <security:csrf disabled="true"></security:csrf>

        <!-- 退出登陆（注意放在<security:http>中）
        logout：退出登录
        logout-url：退出登录操作对应的请求路径，只要请求此路径，就会经过过滤器处理，将登陆状态销毁
        logout-success-url：退出登录后的跳转页面
        (底层是有一个LogoutFilter,框架提供用于退出系统的过滤器) -->
        <security:logout logout-url="/logout.do"
                         logout-success-url="/login.html" invalidate-session="true"/>
    </security:http>


    <!-- 2.配置认证管理器 注册UserService
        authentication-manager：认证管理器，用于处理认证操作 -->
    <security:authentication-manager>
        <!-- 2.2配置认证提供者 (从数据库动态查询用户信息,框架自动调用实现类中的方法并自动进行密码校验)
            authentication-provider：认证提供者，执行具体的认证逻辑
		    (调用userService中的方法动态查询用户信息)-->
        <security:authentication-provider user-service-ref="userService">
            <!-- 2.(密码加密)指定密码加密策略（指定框架使用passwordEncoder进行加密，通过ref方式把它注给安全框架，这样安全框架就可以使用passwordEncoder对象，对密码进行加密）-->
            <security:password-encoder ref="passwordEncoder" />
        </security:authentication-provider>
    </security:authentication-manager>
    <!-- 2.1配置bean(从数据库动态查询用户信息,框架自动调用实现类中的方法并自动进行密码校验)-->
    <bean id="userService" class="com.lym.security.UserService"></bean>
    <!-- 1.(密码加密)配置密码加密对象 （这只是告诉框架给我们创建这个对象）-->
    <bean id="passwordEncoder"
          class="org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder" />

    <!-- 3.(密码加密)开启spring注解使用-->
    <context:annotation-config></context:annotation-config>

    <!-- 1.组件扫描(注解方式权限控制)-->
    <mvc:annotation-driven></mvc:annotation-driven>
    <context:component-scan base-package="com.lym.controller"></context:component-scan>
    <!-- 2.开启注解方式权限控制(注解方式权限控制)
		(global-method-security对方法进行控制，pre-post-annotations="enabled启用注解方式)-->
    <security:global-method-security pre-post-annotations="enabled" />

</beans>

5）UserService(从数据库查询用户信息)

/*如果我们要从数据库动态查询用户信息，就必须按照spring security框架的要求提供一个实现UserDetailsService接口的实现类，
并按照框架的要求进行配置即可。框架会自动调用实现类中的方法并自动进行密码校验。*/
public class UserService implements UserDetailsService {
    //注入passwordEncoder（密码加密用）
    @Autowired
    private BCryptPasswordEncoder passwordEncoder;
    //模拟数据库的内容
    private static Map<String,User> map = new HashMap<String,User>();
    public void initData(){
        User user1 = new User();
        user1.setUsername("admin");
        user1.setPassword(passwordEncoder.encode("admin"));

        User user2 = new User();
        user2.setUsername("zs");
        user2.setPassword(passwordEncoder.encode("zs"));

        map.put(user1.getUsername(),user1);
        map.put(user2.getUsername(),user2);
    }

    /** loadUserByUsername方法不需要我们调用；
     什么时候调用：在SpringSecurity框架拦截到请求后，就会处理请求，并调用实现类的此方法（是通过反射调用loadUserByUsername方法），并把页面中提交的用户名传到此方法。
     * 根据用户名加载用户信息
     * username ：此参数由框架传入
     * return: UserDetails接口对象，我们要返回的其实是UserDetails的实现类User(框架提供的，而不是自己写的User)（用户名,密码,权限）
     * @throws UsernameNotFoundException
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        initData();
        // 1.根据用户名查询数据库 获得用户信息（包含密码）
        com.lym.pojo.User userInDb = map.get(username);//模拟根据用户名查询数据库
        if(userInDb == null){
            //根据用户名没有查询到用户
            return null;
        }

        //模拟数据库中的密码，后期需要查询数据库
//        String passwordInDb = "{noop}" + userInDb.getPassword();// 若是明文密码则前面加{noop}前缀，否则会报错
        String passwordInDb = userInDb.getPassword();
        // 2.授权
        List<GrantedAuthority> list = new ArrayList<>();
        //授权，后期需要改为查询数据库动态获得用户拥有的权限和角色
        list.add(new SimpleGrantedAuthority("add"));
        list.add(new SimpleGrantedAuthority("delete"));
        if (username.equals("admin")){
            list.add(new SimpleGrantedAuthority("ROLE_ADMIN"));//授予角色
        }

        UserDetails user = new org.springframework.security.core.userdetails.User(username,passwordInDb,list);
        return user;
    }
}

6）Controller(注解方式权限控制(可控制方法级别))

@RestController
@RequestMapping("/hello")
public class HelloController {

    @RequestMapping("/add")
    @PreAuthorize("hasAuthority('add')")
    public String add(){
        System.out.println("add...");
        return "add seccess";
    }

    @RequestMapping("/delete")
    @PreAuthorize("hasRole('ROLE_ADMIN')")
    public String delete(){
        System.out.println("delete...");
        return "delete success";
    }
}

2.4 将Spring Security框架应用到后台系统中进行权限控制，本质是认证和授权。

要进行认证和授权需要前面课程中提到的权限模型涉及的7张表支撑，因为用户信息、权限信息、菜单信息、角色信息、关联信息等都保存在这7张表中，也就是这些表中的数据是我们进行认证和授权的依据。所以在真正进行认证和授权之前需要对这些数据进行管理，即我们需要开发如下一些功能：

1、权限数据管理（增删改查）

2、菜单数据管理（增删改查）

3、角色数据管理（增删改查、角色关联权限、角色关联菜单）

4、用户数据管理（增删改查、用户关联角色）

2.5 权限不足时，页面

//权限不足提示
showMessage(r){
//'Error: Request failed with status code 403'固定写法，安全框架往上抛的
  if(r == 'Error: Request failed with status code 403'){
    //权限不足
    this.$message.error('无访问权限');
    return;
  }else{
    this.$message.error('未知错误');
    return;
  }
}