SpringSecurity的简单使用使用案列说明

SpringSecurity

Spring Security是 Spring提供的安全认证服务的框架。 使用Spring Security可以帮助我们来简化认证
和授权的过程。官网：https://spring.io/projects/spring-security
认证:识别每一次请求是谁在发起
授权:鉴别某个功能或数据,当前用户是否有权限访问

RBAC是什么？

RBAC 是基于角色的访问控制（Role-Based Access Control ）在 RBAC 中，权限与角色相关联，用户通过成为适当角色的成员而得到这些角色的权限。这就极大地简化了权限的管理。这样管理都是层级相互依赖的，权限赋予给角色，而把角色又赋予用户，这样的权限设计很清楚，管理起来很方便。

权限模块数据模型(表的设计)

授权过程：用户必须完成认证之后才可以进行授权，首先可以根据用户查询其角色，再根据角色查询对应的菜单，这样就确定了用户能够看到哪些菜单。然后再根据用户的角色查询对应的权限，这样就确定了用户拥有哪些权限。
要实现最终的权限控制，需要有一套表结构支撑：
用户表t_user、权限表t_permission、角色表t_role、菜单表t_menu、用户角色关系表t_user_role、角
色权限关系表t_role_permission、角色菜单关系表t_role_menu。
表之间关系如下图：

搭建maven项目

pom.xml

<?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.fs</groupId>
  <artifactId>Spring-Security-Demo</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <!-- 集中定义依赖版本号 -->
  <properties>
  <!--        指定编译字符集,jdk版本-->
  <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>
<!--   导入springMVC的 依耐-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <!--  导入spring-security的依耐-->
    <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>
    <dependency>
      <groupId>org.springframework.security</groupId>
      <artifactId>spring-security-taglibs</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <configuration>
          <!-- 指定端口 -->
          <port>89</port>
          <!-- 请求路径 -->
          <path>/</path>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

web.xml

注意事项:
DelegatingFilterProxy用于整合第三方框架
整合Spring Security时过滤器的名称必须为springSecurityFilterChain，
否则会抛出NoSuchBeanDefinitionException异常
在web.xml中主要配置SpringMVC的DispatcherServlet和用于整合第三方框架的
DelegatingFilterProxy，用于整合Spring Security。

<!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>
  <filter>
    <!--
      DelegatingFilterProxy用于整合第三方框架
      整合Spring Security时过滤器的名称必须为springSecurityFilterChain，
	  否则会抛出NoSuchBeanDefinitionException异常
    -->
    <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>

<!--  加载spring 的容器-->
  <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>
    </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>

spring-security.xml

在spring-security.xml中主要配置Spring Security的拦截规则和认证管理器。
我们真实生产环境还差很远，还存在如下一些问题：
1、项目中我们将所有的资源（所有请求URL）都保护起来，实际环境下往往有一些资源不需要认证也可以访问，也就是可以匿名访问。
2、登录页面是由框架生成的，而我们的项目往往会使用自己的登录页面。
3、直接将用户名和密码配置在了配置文件中，而真实生产环境下的用户名和密码往往保存在数据库中。
4、在配置文件中配置的密码使用明文，这非常不安全，而真实生产环境下密码需要进行加密。本章节需要对这些问题进行改进。

配置可匿名访问的资源
第一步：在项目中创建pages目录，在pages目录中创建a.html和b.html
第二步：在spring-security.xml文件中配置，指定哪些资源可以匿名访问
使用指定的登录页面
第一步：提供login.html作为项目的登录页面
第二步：修改spring-security.xml文件，指定login.html页面可以匿名访问
第三步：修改spring-security.xml文件，加入表单登录信息的配置

对密码进行加密
前面我们使用的密码都是明文的，这是非常不安全的。一般情况下用户的密码需要进行加密后再保存到
数据库中。
常见的密码加密方式有：
3DES、AES、DES：使用对称加密算法，可以通过解密来还原出原始密码
MD5、SHA1：使用单向HASH算法，无法通过计算还原出原始密码，但是可以建立彩虹表进行查表破
解
bcrypt：将salt随机并混入最终加密后的密码，验证时也无需单独提供之前的salt，从而无需单独处理
salt问题

加密后的格式一般为：$2a$10$/bTVvqqlH9UiE0ZJZ7N2Me3RIgUCdgMheyTgV0B4cMCSokPa.6oCa
实现方法:在spring-security.xml文件中指定密码加密对象

配置多种校验规则
为了测试方便，首先在项目中创建a.html、b.html、c.html几个页面
修改spring-security.xml文件：

注解方式权限控制:使用场景多
提供的注解方式进行控制。
实现步骤：
第一步：在spring-security.xml文件中配置组件扫描，用于扫描Controller
第二步：在spring-security.xml文件中开启权限注解支持
第三步：创建Controller类并在Controller的方法上加入注解进行权限控制

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

通过配置可以发现，如果用户要退出登录，只需要请求/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:security="http://www.springframework.org/schema/security"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/security
       http://www.springframework.org/schema/security/spring-security.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">

<!--开启spring的包扫描-->
    <context:component-scan base-package="com.fs"/>
<!--    开启注解配置-->
    <context:annotation-config/>
<!--    开启mvc的注解-->
    <mvc:annotation-driven/>
<!--    开启注解方式的权限控制,不开启默认是禁用-->
    <security:global-method-security pre-post-annotations="enabled"/>



<!--
        http：用于定义相关权限控制,可以配置多个
        security:当设置为‘none’时，与pattern属性匹配的请求将被Spring忽略安全。将不会应用任何安全过滤器，也不会提供任何SecurityContext。
        pattern:指定哪些资源不需要进行权限校验，可以使用通配符
-->
    <security:http security="none" pattern="/login.html"/>
    <security:http security="none" pattern="/js/**" />
    <security:http security="none" pattern="/css/**" />
    <security:http security="none" pattern="/img/**" />
    <security:http security="none" pattern="/plugins/**" />
<!--    <security:http security="none" pattern="/pages/a.html"/>-->
<!--    <security:http security="none" pattern="/pages/b.html"/>-->
<!--    使用通配符-->
<!--    <security:http security="none" pattern="/pages/**"/>-->

<!--、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、-->
<!--
    security:http标签
        用于定义相关权限控制
        相关属性
            auto-config:则默认为“false”。设置为true时,框架会提供一些配置,建议配置为true,可以进源码查看注释
            use-expressions:则默认为“true”.用于指定intercept-url中的access属性是否使用表达式如果启用时，每个属性应该包含一个布尔表达式。如果表达式计算为“true”时，将授予访问权限。
-->
    <security:http auto-config="true" use-expressions="true">

<!-- 配置多钟校验规则:security:intercept-url这个标签
        isAuthenticated:只要认证通过就可以访问index.jsp
        hasAnyAuthority:拥有add或者find权限就可以访问a.html
        hasRole:拥有ROLE_ADMIN角色就可以访问b.html页面
 -->
        <security:intercept-url pattern="/index.html" access="isAuthenticated()"/>
        <security:intercept-url pattern="/pages/a.html" access="hasAnyAuthority('add','find')"/>
        <security:intercept-url pattern="/pages/b.html" access="hasRole('ROLE_ROOT')"/>
<!--     拥有ROLE_XIAOFU角色就可以访问d.html页面，
 注意：此处虽然写的是XIAOFU角色，框架会自动加上前缀ROLE_-->
        <security:intercept-url pattern="/pages/c.html" access="hasRole('XIAOFU')"/>

<!--
    security:intercept-url标签:定义一个拦截规则
        属性
            pattern:对哪些url进行权限控制,/**就是对所有的请求都进行权限控制
            access:在请求对应的url时需要什么权限,默认配置时,它应该是一个以逗号分隔的角色列表,
                    当配置多个角色时,请求的用户只需要有一个角色对应,就能成功访问对应的url
-->
<!--        <security:intercept-url pattern="/**" access="hasRole('ROLE_ROOT')"/>-->
        <security:intercept-url pattern="/**" access="hasAnyRole('ROLE_ROOT','ROLE_XIAOFU')"/>

<!--
        配置指定的登录页面访问url,如果我们要使用我们自己指定的页面作为登录页面.必须配置登录表单url
            若我们不配置.会默认使用spring-security自带的登录权限页面
        login-page:指定登录页面
        username-parameter="username"  password-parameter="password" 指定收集表单提交的username和password
        login-processing-url: 表单提交的url
        default-target-url:身份验证成功后将重定向到的URL,未指定，默认为应用程序的根目录。
        authentication-failure-url:登录失败页面的URL。如果没有指定登录失败URL，则使用Spring安全性会自动创建一个失败的登录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"/>

<!--
        csrf：对应CsrfFilter过滤器
        disabled：是否启用CsrfFilter过滤器，如果使用自定义登录页面需要关闭此项，否则登录操作会被禁用（403)
-->
        <security:csrf disabled="true"/>

        <!--
        logout：退出登录
        logout-url：退出登录操作对应的请求路径
        logout-success-url：退出登录后的跳转页面
        invalidate-session:指定注销是否也会导致HttpSession失效。如果未指定，则默认为true。
        -->
        <security:logout logout-url="/logout.do"
                         logout-success-url="/login.html"
                         invalidate-session="true"/>
    </security:http>

<!--
    security:authentication-manager:标签
        认证管理器，用于处理认证操作
-->
    <security:authentication-manager>
<!--
    security:authentication-provider:标签
       认证提供者，执行具体的认证逻辑
        user-service-ref: 指定实现UserDetailsService接口的实现类
-->
        <security:authentication-provider user-service-ref="userService">

<!--
        user-service：标签
            用于获取用户信息，提供给authentication-provider进行认证
-->
            <!--
            <security:user-service>

                security:user:标签
                    name:定义用户信息，可以指定用户名、密码、角色，后期可以改为从数据库查询用户信息
                    password:{noop}标签当前使用密码明文
                    authorities:授予用户的多个权限之一。用逗号分隔

                    这里我是配置死的,真正是从数据库中查询出来

                <security:user name="xiaofu" password="{noop}123" authorities="ROLE_XIAOFU"/>

            </security:user-service>
            -->

<!--            指定对密码进行加密的对象.就是我们下面配置的加密对象-->
            <security:password-encoder ref="passwordEncoder"/>
        </security:authentication-provider>
    </security:authentication-manager>


<!--把自定义实现UserDetailsService接口的实现类交给IOC管理-->
    <bean id="userService" class="com.fs.service.UserService"/>


<!--对密码进行加密,配置密码加密对象,bcrypt：将salt随机并混入最终加密后的密码，验证时也无需单独提供之前的salt，从而无需单独处理salt问-->
    <bean id="passwordEncoder" class="org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder"/>
</beans>

UserService

从数据库查询用户信息(案列就使用集合模拟数据库中角色权限数据)

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

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

package com.fs.service;

import com.fs.pojo.Member;
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;

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

public class UserService implements UserDetailsService {

    //注入密码加密对象
    @Autowired
    private BCryptPasswordEncoder passwordEncoder;



    /**
     * 重写的方法,当用户提交表单后会走这个方法,
     * @param username 表单提交的username
     * @return
     * @throws UsernameNotFoundException
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        System.out.println("用户输入的:"+username);
        //----------------------------------------模拟数据库的数据-----------------------------------------------

        //模拟假数据,相当于这个数据是从
        Map<String, Object> memberMap = new HashMap<>();
        //明文密码,没有加密
//        Member xiaofu = new Member("xiaofu", "123");
//        Member member = new Member("root", "root");


        //使用BCryptPasswordEncoder对密码进行加密
        Member xiaofu = new Member("xiaofu", passwordEncoder.encode("123"));
        Member member = new Member("root", passwordEncoder.encode("root"));
        memberMap.put(xiaofu.getUsername(),xiaofu);
        memberMap.put(member.getUsername(),member);

        //---------------------------------------------------------------------------------------

        //根据用户名查询数据库的用户信息(包含数据库中存储的密码等user的所有的用户信息)
        Member memberDB = (Member) memberMap.get(username);
        //判断是否查出
        if (memberDB == null){
            //说明用户不存在,spring安全框架拿到null后,说明没有这个用户,他就会跳转到你设置的authentication-failure-url
            return null;
        }else {
            /*将用户信息返回框架,框架会进行密码对比(页面提交的密码和数据库中查询的密码进行对比)
                org.springframework.security.core.userdetails.User;
                这个对象是spring security提供的

                public User(String username, String password, Collection<? extends GrantedAuthority> authorities) {
                    this(username, password, true, true, true, true, authorities);
                }

                有三个参数的构造方法,
                    username:表单提交的username
                    password:数据库查询出的登录用户对象的密码
                    authorities:数据库查询出的用户权限的List集合(一个用户有多个权限)
             */
            //模拟数据库查询出的权限
            List<GrantedAuthority> list = new ArrayList<>();
            //模拟添加两个权限
            list.add(new SimpleGrantedAuthority("add"));//授权
            list.add(new SimpleGrantedAuthority("find"));

            //模拟当用户名是root的时候添加一个角色,这个角色在配置文件中配置了的,只能这个角色才能有权限访问
            // <security:intercept-url pattern="/**" access="hasRole('ROLE_ROOT')"/>
            if (username.equals("root")){
                list.add(new SimpleGrantedAuthority("ROLE_ROOT"));//授予角色ROLE_就表示角色
            }

            //模拟当前用户使小付的时候添加角色
            if (username.equals("xiaofu")){
                list.add(new SimpleGrantedAuthority("ROLE_XIAOFU"));
            }

            //这是没有加密需要在密码前加{noop}
//            User securityUser = new User(username,"{noop}"+member.getPassword(),list);

            //使用BCryptPasswordEncoder加密后,就需要{noop}了
            User securityUser = new User(username,memberDB.getPassword(),list);
            //框架进行密码进行校验(页面提交的密码,与数据库的密码比对)
            return securityUser;
        }
    }
}

Member实体会员类

package com.fs.pojo;
/*
会员账号密码
 */
public class Member {
    private String username;
    private String password;

	getset方法
}

HelloController(注解对方法实现权限控制)

package com.fs.controller;

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

@RestController
@RequestMapping("/hello")//要在配置文件中配置这个路径能被某个角色或者权限控制,否则403,<security:intercept-url pattern="/**" access="hasRole('ROLE_XIAOFU')"/>
//@PreAuthorize("hasRole('ROLE_ROOT')")//表示这个类上中的方法只能ROLE_ROOT这个角色访问
public class HelloController {


    @RequestMapping("/add")
    @PreAuthorize("hasAnyAuthority('add')")//表示访问这个方法需要add权限才能调用这个方法
    public String add(){
        System.out.println("add...");
        return "add...ok";
    }

    @RequestMapping("/find")
    @PreAuthorize("hasAnyAuthority('find')")//表示访问这个方法需要find权限才能调用这个方法
    public String find(){
        System.out.println("find...");
        return "find...ok";
    }

    @RequestMapping("/findOrAdd")
    @PreAuthorize("hasAnyAuthority('find','add')")//表示访问这个方法需要add或者find权限才能调用这个方法
    public String findOrAdd(){
        System.out.println("findOrAdd...");
        return "findOrAdd...ok";
    }

    @RequestMapping("/role")
    @PreAuthorize("hasRole('ROLE_ROOT')")//表示访问这个方法需要ROLE_ROOT这个角色才能访问
    public String role(){
        System.out.println("role...");
        return "role...ok";
    }
}

login.html,index.html,a.html,b.html,c.html

login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登录页面</title>
</head>
<body>
<form action="/login.do" method="post">
    用户名：<input type="text" name="username"><br>
    密码：<input type="password" name="password"><br>
    <input type="submit" value="登录">
</form>
</body>
</html>

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
HelloWorld
</body>
</html>

a.html,b.html,c.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
a.html
</body>
</html>

测试

启动tomcat发现,直接访问任意页面,都会跳转到login.html,然后登录(在UserService中使用list集合写死了登录用户名的)后,就能根据这个用户的角色权限去访问sping-security配置文件中配置的权限对应的页面或者@PreAuthorize注解对应的方法路径