SSM项目集成Spring Security 4.X版本（使用spring-security.xml 配置文件方式）

目录

前言

实战开发：

[一、Spring Security整合到SSM项目](#一、Spring Security整合到SSM项目)

[1. pom文件引入包](#1. pom文件引入包)

[2. web.xml 配置](#2. web.xml 配置)

[3. 添加 spring-security.xml 文件](#3. 添加 spring-security.xml 文件)

[二、Spring Security实战应用](#二、Spring Security实战应用)

[1. 项目结构](#1. 项目结构)

[2. pom文件引入](#2. pom文件引入)

[3. web.xml 配置](#3. web.xml 配置)

[4. Spring 配置 applicationContext.xml](#4. Spring 配置 applicationContext.xml)

[5. spring-security.xml 配置](#5. spring-security.xml 配置)

[6. springmvc.xml 配置](#6. springmvc.xml 配置)

[7. 创建实体类](#7. 创建实体类)

[8. DAO层实现数据查询](#8. DAO层实现数据查询)

[9. SystemDao 接口编写（数据层接口类）](#9. SystemDao 接口编写（数据层接口类）)

[10. SystemService接口及实现类SystemServiceImpl编写](#10. SystemService接口及实现类SystemServiceImpl编写)

[11. SystemController 控制器编写](#11. SystemController 控制器编写)

[12. SpringSecurity实战讲解](#12. SpringSecurity实战讲解)

[13. 运行项目查看效果](#13. 运行项目查看效果)

---

前言

实战前提条件：

基础的SSM项目已集成完毕。在此基础上集成Spring Security实现web项目的安全保护 。

本文版本说明：

JDK：1.8

spring.version：5.2.12.RELEASE

Spring Security.version：4.2.5.RELEASE

Spring Security标签库：4.2.3.RELEASE

实战目标：

Authentication：认证，实现用户认证登录

Authorization：授权，设定用户的资源，访问权限。

---

实战开发：

一、Spring Security整合到SSM项目

1. pom文件引入包

        <!-- Spring Security，此处引入4.2.5.RELEASE版本。
        因为spring security 5.X版本需要提供一个PasswordEncorder的实例，否则后台会报错。
        当然你也可以提供PasswordEncorder的实例 使用5.X版本-->
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-web</artifactId>
            <version>4.2.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-config</artifactId>
            <version>4.2.5.RELEASE</version>
        </dependency>

        <!-- Spring Security 标签库-->
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-taglibs</artifactId>
            <version>4.2.3.RELEASE</version>
        </dependency>

注：本项目完整的pom文件稍后附上

2. web.xml 配置

注：先说说web.xml配置文件中Spring家族的加载顺序。
先启动spring ioc容器 --> 再启动spring-security --> 然后启动springmvc

<!--  https://blog.csdn.net/qyb19970829/article/details/110100544 配置时注意关于spring容器加载顺序的问题，
 applicationContext.xml，spring-security.xml，springmvc.xml 即这几个配置文件加载顺序
 -->
  <!-- SpringSecurity过滤器链 -->
  <filter>
    <filter-name>springSecurityFilterChain</filter-name>
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>springSecurityFilterChain</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <!--配置Spring的监听器，启动spring容器-->
  <display-name>Archetype Created Web Application</display-name>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!--配置加载类路径的配置文件，注意加载顺序 先加载spring-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>
      classpath:spring/applicationContext.xml <!-- Spring配置文件 -->
      classpath:spring/spring-security.xml <!-- SpringSecurity配置文件 -->
    </param-value>
  </context-param>

注：本项目完整的web.xml配置稍后附上

3. 添加 spring-security.xml 文件

注：本文件使用form-login的方式进行认证，在项目resources文件下新建spring文件夹（如果没有的话）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:security="http://www.springframework.org/schema/security"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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">

    <!--spring过滤器链配置
        1) 需要拦截什么资源
        2) 什么资源对应什么角色权限
        3) 定制认证方式: HttpBasic or FormLogin
        4) 自定义登录页面,定义登录请求地址,定义错误处理方式
    -->
    <security:http>
        <!-- 使用http-basic的方式进行认证 -->
        <!--<security:http-basic/>-->
        <!-- 使用form-login的方式进行认证 -->
        <security:form-login/>

        <!-- 配置资源拦截规则
            pattern属性指定资源目录: 即需要拦截的资源  /* 代表根目录下的一级目录  /** 代表根目录下的所有目录
            access(SpEL)方法执行Spring EL表达式。提供如下表达式：
                permitALL():设置那些路径可以直接访问，不需要认证。直接返回true
                isAnonymous():只有匿名用户可以访问，登录用户不可访问
                isAuthenticated()：需要身份认证成功才能访问。如果认证用户不是匿名用户，则返回true，认证通过
                isFullyAuthenticated():需要身份认证成功才能访问。如果认证用户不是匿名用户或记住我的用户，则返回true，认证通过
                其它自行查找......
        -->
        <security:intercept-url pattern="/**" access="isAuthenticated()"/>
    </security:http>

    <!--身份验证管理器-->
    <security:authentication-manager>
        <!--自定义授权提供源，实际开发中提供 自定义用户详情查询获取接口-->
        <security:authentication-provider>
            <security:user-service>
                <security:user name="admin" password="123456" authorities="ROLE_USER"/>
            </security:user-service>
        </security:authentication-provider>
    </security:authentication-manager>

</beans>

以上为spring-security.xml 的基础配置，到此Spring Security整合到SSM项目中已经完毕！运行项目后，所有资源会被拦截，跳转到默认登录页要求用户进行登录认证后才能访问项目资源。如图：

二、Spring Security实战应用

1. 项目结构

2. pom文件引入

<?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.wqbr</groupId>
    <artifactId>wqdemotwo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>wqdemotwo Maven Webapp</name>
    <!-- FIXME change it to the project's website -->
    <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>
        <spring.version>5.2.12.RELEASE</spring.version>
    </properties>

    <dependencies>
        <!--spring 包-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.8</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Spring Security，此处引入4.2.5.RELEASE版本。
        因为spring security 5.X版本需要提供一个PasswordEncorder的实例，否则后台会报错。
        当然你也可以提供PasswordEncorder的实例 使用5.X版本-->
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-web</artifactId>
            <version>4.2.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-config</artifactId>
            <version>4.2.5.RELEASE</version>
        </dependency>
        <!-- Spring Security 标签库-->
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-taglibs</artifactId>
            <version>4.2.3.RELEASE</version>
        </dependency>

        <!-- 引入jackson依赖包-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.13.4</version>
        </dependency>

       <!--JSP(Java Server Pages,Java服务端页面)-->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.0</version>
            <scope>provided</scope>
        </dependency>
        <!-- JSTL标准标签库(Jsp Standarded Tag Library),使用标签取代JSP里的JAVA代码 -->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <!--servlet API-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>

        <!-- junit测试包 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>

        <!--mybatis 相关包-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-core</artifactId>
            <version>1.3.5</version>
        </dependency>
        <!--mybatis和spring集成的依赖-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.7</version>
        </dependency>
        <!--oracle JDBC连接依赖-->
        <dependency>
            <groupId>com.oracle.database.jdbc</groupId>
            <artifactId>ojdbc8</artifactId>
            <version>21.3.0.0</version>
        </dependency>
        <dependency>
            <groupId>cn.easyproject</groupId>
            <artifactId>orai18n</artifactId>
            <version>12.1.0.2.0</version>
        </dependency>

        <!--阿里的连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.12</version>
        </dependency>

    </dependencies>

    <build>
        <finalName>wqdemotwo</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-source-plugin</artifactId>
                <version>2.1.1</version>
                <executions>
                    <execution>
                        <id>attach-sources</id>
                        <goals>
                            <goal>jar-no-fork</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <attach>true</attach>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>2.6</version>
                <configuration>
                    <includeEmptyDirectories>true</includeEmptyDirectories>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

3. web.xml 配置

配置web.xml，加载spring（applicationContext.xml --spring默认配置文件），加载spring-security，加载springmvc。

<?xml version="1.0" encoding="UTF-8"?>

<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
   http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
<!--  https://blog.csdn.net/qyb19970829/article/details/110100544 配置时注意关于spring容器加载顺序的问题，
 applicationContext.xml，spring-security.xml，springmvc.xml 即这几个配置文件加载顺序
 -->
  <!--字符编码过滤器一定要放在前面-->
  <filter>
    <filter-name>characterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
      <param-name>forceEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  <!--不拦截所有是html的页面请求，weblogic中部署去掉
  <servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>*.html</url-pattern>
  </servlet-mapping>-->

  <!-- SpringSecurity过滤器链 -->
  <filter>
    <filter-name>springSecurityFilterChain</filter-name>
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>springSecurityFilterChain</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <!--配置Spring的监听器，启动spring容器-->
  <!--配置加载类路径的配置文件，注意加载顺序-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>
      classpath:spring/applicationContext.xml
      classpath:spring/spring-security.xml
    </param-value>
  </context-param>
  <display-name>Archetype Created Web Application</display-name>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

  <!--配置前端控制器，对浏览器发送的请求进行统一处理-->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--加载springmvc.xml配置文件的位置和名称，配置的是Spring配置-->
    <init-param>
      <!--contextConfigLocation:上下文配置路径，固定值-->
      <param-name>contextConfigLocation</param-name>
      <!--classpath:类路径，指的是Java和resources文件夹-->
      <!--springmvc.xml:指的是配置文件的名称：需要配置springmvc.xml，在下面。
      spring默认配置文件为applicationContext.xml。当中配置spring创建容器时要扫描的包 已经整合到springmvc.xml中-->
      <param-value>
        classpath:spring/springmvc.xml
      </param-value>
    </init-param>
    <!--配置启动加载-->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

  <!--开启项目时打开的页面-->
<!--  <welcome-file-list>
    <welcome-file>/index.html</welcome-file>
  </welcome-file-list>-->


</web-app>

4. Spring 配置 applicationContext.xml

指定扫描包，数据源，整合集成接管mybatis。

<?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:p="http://www.springframework.org/schema/aop"
       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-3.1.xsd
                        http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context-3.1.xsd
                        http://www.springframework.org/schema/mvc
                        http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">
    <!--配置spring创建容器时要扫描的包--><!--同时也是 MyBatis托管的包路径-->
    <!-- use-default-filters 属性不写默认是为true,表示使用默认的过滤器规则
    use-default-filters="false"表示不扫描base-package指定下的所有java类，并不将注解annotation标注的类注册成IOC容器的bean。
    use-default-filters="true"表示扫描base-package指定下的所有java类，并将注解annotation标注的类注册成IOC容器的bean。
    要注意的是：若使用include-filter去定制扫描内容，要在use-default-filters="false"的情况下，不然会"失效"，被默认的过滤机制所覆盖
    <context:exclude-filter>：与<context:include-filter> 相反,用来告知哪些类不需要注册成Spring Bean，
    同样注意的是：在use-default-filters="false"的情况下，exclude-filter是针对include-filter里的内容进行排除。
    -->
    <context:component-scan base-package="com.wqbr" use-default-filters="true">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!-- 引入配置文件-->
    <bean id="propertyConfigurer"
          class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:spring/jdbc.properties" />
    </bean>

    <!--创建数据源 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${driver}"/>
        <property name="url" value="${url}"/>
        <property name="username" value="${username}"/>
        <property name="password" value="${password}"/>
    </bean>

    <!--<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
        <property name="jndiName">
            <value>testJNDI</value>
        </property>
    </bean>-->

    <!--创建sqlSessionFactory，接管了mybatis配置文件。整合Mybatis-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="mapperLocations" >
            <array>
                <!--映射在class编译路径下的TblsicardDao.xml全路径-->
                <value>classpath:mapping/SystemDao.xml</value>
            </array>
        </property>
    </bean>

    <!--创建DAO，扫描mybatis接口的实现，加入到ioc容器中-->
    <bean id="systemDao" class="org.mybatis.spring.mapper.MapperFactoryBean">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
        <property name="mapperInterface" value="com.wqbr.persistence.SystemDao"/>
    </bean>

</beans>

5. spring-security.xml 配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:security="http://www.springframework.org/schema/security"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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">

    <!--spring过滤器链配置
        1) 需要拦截什么资源
        2) 什么资源对应什么角色权限
        3) 定制认证方式: HttpBasic or FormLogin
        4) 自定义登录页面,定义登录请求地址,定义错误处理方式
    -->
    <security:http>

        <!--
            使用form-login的方式进行认证
                login-page:指定获取登录页面的url(需要编写controller返回登录页面)
                login-processing-url:指定登录页面中post请求提交到哪里的url(不需要编写controller，框架已实现)
                default-target-url:指定登录成功后，跳转到哪个url(需要编写controller)
                authentication-success-handler-ref:指定登录成功后，由哪个类来进行处理
                authentication-failure-handler-ref:指定登录失败后，由哪个类来进行处理
                username-parameter：指定登录表单中用户名的input中name值，如果这里不配置，则默认为username
                password-parameter：指定登录表单中密码的input中name值，如果这里不配置，则默认为password
        -->
        <security:form-login login-page="/login" login-processing-url="/spring_security_check"
                             authentication-success-handler-ref="myAuthenticationSuccessHandler"
                             authentication-failure-handler-ref="myAuthenticationFailureHandler"/>

        <!-- 关闭csrf的保护-->
        <security:csrf disabled="true"/>

        <!-- 配置资源拦截规则
            pattern属性指定资源目录: 即需要拦截的资源  /* 代表根目录下的一级目录  /** 代表根目录下的所有目录
            access(SpEL)方法执行Spring EL表达式。提供如下表达式：
                permitALL():设置那些路径可以直接访问，不需要认证。直接返回true
                isAnonymous():只有匿名用户可以访问，登录用户不可访问
                isAuthenticated()：需要身份认证成功才能访问。如果认证用户不是匿名用户，则返回true，认证通过
                isFullyAuthenticated():需要身份认证成功才能访问。如果认证用户不是匿名用户或记住我的用户，则返回true，认证通过
                其它自行查找......
        -->
        <!--开始配置拦截规则，注意拦截规则的位置顺序（如不需要身份认证的规则，要放在前面，需要身份认证的规则放在后面）-->
        <!--permitAll()不需要身份认证，无条件放行-->
        <security:intercept-url pattern="/login" access="permitAll()"/>
        <security:intercept-url pattern="/system/index" access="permitAll()"/>

        <!--进行权限划分：hasRole('ROLE_USER')：表示拥有 ROLE_USER 权限的用户可以访问
        hasRole('ROLE_ALL')：表示拥有 ROLE_ALL 权限的用户可以访问
        -->
        <security:intercept-url pattern="/system/add" access="hasAuthority('admin')"/>
        <security:intercept-url pattern="/system/list" access="hasAuthority('ROLE_ALL')"/>

        <!--permitAll()不需要身份认证，无条件放行静态资源-->
        <security:intercept-url pattern="/js/**" access="permitAll()"/>

        <!--拦截所有页面，需要身份认证成功才能访问。如果认证用户不是匿名用户或记住我的用户，则返回true，认证通过-->
        <security:intercept-url pattern="/**" access="isFullyAuthenticated()"/>
        <!--结束配置拦截规则-->

        <!-- 自定义用户访问权限不足的处理方式(需要编写controller返回权限不足的页面) -->
        <security:access-denied-handler error-page="/accessDeny"/>

        <!--加上Remember Me功能，token-validity-seconds：有效时间(秒)-->
        <!--<security:remember-me token-repository-ref="jdbcTokenRepository" token-validity-seconds="604800"/>-->

        <!--<security:logout/>：注销功能
        logout-url="/logout"：springSecurity内LogoutFilter要拦截的url(向这个url发送请求来注销)
        logout-success-url：用户退出后要被重定向的url
        invalidate-session：默认为true,用户在退出后Http session失效
        success-handler-ref：指定一个bean(需要实现LogoutSuccessHandler接口)，用来自定义退出成功后的操作-->
        <security:logout logout-url="/logout" logout-success-url="/login" invalidate-session="true"/>
    </security:http>

    <!--身份验证管理器-->
    <security:authentication-manager>
        <!--
            自定义授权提供类MyUserDetailsService，获得登录用户的用户详情信息。此类实现UserDetailsService接口。
            user-service-ref="myUserDetailsService" ： 指定 UserDetailsService 接口的实现类
            最终都要返回一个UserDetail，用户详情
        -->
        <security:authentication-provider user-service-ref="myUserDetailsService">
            <!-- 配置：加密算法对用户输入的密码进行加密，然后和数据库的密码进行配对 -->
            <!--<security:password-encoder ref="bCryptPasswordEncoder"/>-->
        </security:authentication-provider>
    </security:authentication-manager>

    <!--创建 springSecurity 密码加密工具类，使用PasswordEncoder 接口的实现，也可以使用别的-->
    <!--<bean id="bCryptPasswordEncoder" class="org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder"></bean>-->


    <!--springSecurity实现 remember me 功能：
        如果用户登录选择 remember me ，springSecurity会将其cookie值存入数据库，来实现remember me 功能
        JdbcTokenRepositoryImpl 用来存取cookie值-->
    <!--<bean id="jdbcTokenRepository" class="org.springframework.security.web.authentication.rememberme.JdbcTokenRepositoryImpl">
        <property name="dataSource" ref="dataSource"/> &lt;!&ndash;数据库数据源&ndash;&gt;
        &lt;!&ndash;<property name="createTableOnStartup" value="true"/>&ndash;&gt; &lt;!&ndash;createTableOnStartup属性是当项目启动时，springSecurity创建表存储remember me相关信息，第二次启动时要注释这个属性&ndash;&gt;
    </bean>-->

</beans>

6. springmvc.xml 配置

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

    <!--配置spring创建容器时要扫描的包-->
    <!-- use-default-filters 属性不写默认是为true,表示使用默认的过滤器规则
    use-default-filters="false"表示不扫描base-package指定下的所有java类，并不将注解annotation标注的类注册成IOC容器的bean。
    use-default-filters="true"表示扫描base-package指定下的所有java类，并将注解annotation标注的类注册成IOC容器的bean。
    要注意的是：若使用include-filter去定制扫描内容，要在use-default-filters="false"的情况下，不然会"失效"，被默认的过滤机制所覆盖
    <context:exclude-filter>：与<context:include-filter> 相反,用来告知哪些类不需要注册成Spring Bean，
    同样注意的是：在use-default-filters="false"的情况下，exclude-filter是针对include-filter里的内容进行排除。
    -->
    <context:component-scan base-package="com.wqbr" use-default-filters="false">
        <!--只扫描Controller注解的类-->
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!--处理映射器-->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
    <!--处理器适配器-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

    <!--配置JSP视图解析器-->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/"></property> <!--规定跳转页面路径的前缀-->
        <property name="suffix" value=".jsp"></property> <!--规定跳转页面的后缀-->
    </bean>

    <!-- 配置spring开启注解mvc的支持  默认就是开启的 ，要想让其他组件（不包含映射器、适配器、处理器）生效就必须需要配置了-->
    <mvc:annotation-driven/>
    <!-- 让默认servlet处理静态资源。将springMVC不能处理的请求交给servlet，一般用来放行静态资源 -->
    <mvc:default-servlet-handler/>

</beans>

7. 创建实体类

注：重点在SysUser实体类。实现UserDetails接口 复写接口的方法进行实现，建立各方法的对应属性到用户表中（不一定全建对应属性）。

我们先来看下UserDetails接口类的源码：

红色标注的3项建立在用户实体领域类中，如下SysUser 用户实体类代码：

package com.wqbr.domain;


import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;

/**
 * 系统用户，封装用户数据，实现 UserDetails 接口
 * @author lv
 * @date 2024年1月11日
 */
public class SysUser implements UserDetails {

  private static final long serialVersionUID = 1L;

  private String id;
  private String username; //从UserDetails的重写方法中返回
  private String password; //从UserDetails的重写方法中返回
  private Date addtime;
  private boolean accountnonexpired; //账户是否过期，从UserDetails的重写方法中返回
  private boolean accountnonlocked; //账户是否锁定，从UserDetails的重写方法中返回
  private boolean credentialsnonexpired; //密码是否过期，从UserDetails的重写方法中返回
  private boolean enabled; //账户是否可用，从UserDetails的重写方法中返回

  // 储存用户拥有的所有权限
  private List<GrantedAuthority> authorities = new ArrayList<>(); //从UserDetails的重写方法中返回


  public String getId() {
    return id;
  }

  public void setId(String id) {
    this.id = id;
  }

  public void setUsername(String username) {
    this.username = username;
  }

  public void setPassword(String password) {
    this.password = password;
  }

  public Date getAddtime() {
    return addtime;
  }

  public void setAddtime(Date addtime) {
    this.addtime = addtime;
  }

  // 返回用户权限，上面声明了权限集合对象 authorities
  @Override
  public Collection<? extends GrantedAuthority> getAuthorities() {
    return this.authorities;
  }

  public void setAuthorities(List<GrantedAuthority> authorities) {
    this.authorities = authorities;
  }

  // 返回用户密码，上面声明了属性 password
  @Override
  public String getPassword() {
    return password;
  }

  // 返回用户名，上面声明了属性 username
  @Override
  public String getUsername() {
    return username;
  }

  @Override
  public boolean isAccountNonExpired() {
    return accountnonexpired;
  }

  public void setAccountnonexpired(boolean accountnonexpired) {
    this.accountnonexpired = accountnonexpired;
  }

  @Override
  public boolean isAccountNonLocked() {
    return accountnonlocked;
  }

  public void setAccountnonlocked(boolean accountnonlocked) {
    this.accountnonlocked = accountnonlocked;
  }

  @Override
  public boolean isCredentialsNonExpired() {
    return credentialsnonexpired;
  }

  public void setCredentialsnonexpired(boolean credentialsnonexpired) {
    this.credentialsnonexpired = credentialsnonexpired;
  }

  @Override
  public boolean isEnabled() {
    return enabled;
  }

  public void setEnabled(boolean enabled) {
    this.enabled = enabled;
  }
}

注：private List\<GrantedAuthority\> authorities = new ArrayList\<\>(); 此属性稍后赋值演示

角色（SysRole ）和资源（SysPermission）实体类代码参见以下文章建立： spirng框架之spring security（二）insert 语句补充-CSDN博客https://blog.csdn.net/u011529483/article/details/135467110?spm=1001.2014.3001.5501

8. DAO层实现数据查询

SystemDao.xml，mybatis的mapper文件（映射SQL语句）

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--命名空间映射到com.wqbr.persistence.SystemDao 类-->
<mapper namespace="com.wqbr.persistence.SystemDao">
    <!--SysUser findByUsername(String username);方法的映射对应id="findByUsername"，resultType返回类型为SysUser实体类-->
    <select id="findByUsername" parameterType="String" resultType="com.wqbr.domain.SysUser">
        select *
        from SYS_USER
        where USERNAME = #{username}
    </select>

    <!--查询当前用户拥有的资源-->
    <select id="findPermissionByUsername" parameterType="String" resultType="com.wqbr.domain.SysPermission">
        select d.*
        from sys_user a, sys_user_role b, sys_role_permission c, sys_permission d
        where a.id = b.user_id and b.role_id = c.role_id and c.permission_id = d.id
          and a.username = #{username}
    </select>
</mapper>

9. SystemDao 接口编写（数据层接口类）

package com.wqbr.persistence;

import com.wqbr.domain.SysPermission;
import com.wqbr.domain.SysUser;

import java.util.List;

public interface SystemDao {
    /**
     * 查询当前用户对象
     */
    public SysUser findByUsername(String username);

    /**
     * 查询当前用户拥有的资源
     */
    public List<SysPermission> findPermissionByUsername(String username);
}

10. SystemService接口及实现类SystemServiceImpl编写

package com.wqbr.service;

import com.wqbr.domain.SysPermission;

import java.util.List;

/**
 * 系统服务接口
 * @author lv
 * @date 2024年1月11日
 */
public interface SystemService {
    /**
     * 查询当前用户拥有的资源
     */
    public List<SysPermission> findPermissionByUsername(String username);
}

package com.wqbr.service.impl;

import com.wqbr.domain.SysPermission;
import com.wqbr.persistence.SystemDao;
import com.wqbr.service.SystemService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;


/**
 * 系统服务接口实现
 * @author lv
 * @date 2024年1月11日
 */
@Service
public class SystemServiceImpl implements SystemService {

    @Autowired
    private SystemDao systemDao;

    @Override
    public List<SysPermission> findPermissionByUsername(String username) {
        return systemDao.findPermissionByUsername(username);
    }
}

11. SystemController 控制器编写

package com.wqbr.controller;

import com.wqbr.domain.Menus;
import com.wqbr.domain.SysPermission;
import com.wqbr.domain.SysUser;
import com.wqbr.service.SystemService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList;
import java.util.List;

/**
 * 系统用户控制器
 * @author lv
 * @date 2024年1月11日
 */
@Controller
@RequestMapping("/system")
public class SystemController {

    /**
     * 自动装配SystemService接口
     */
    @Autowired
    private SystemService systemService;

    /**
     * 处理超链接发送出来的请求
     * @param model
     * @return
     */
    @RequestMapping(path = "/hello")
    public String sayHello(Model model){
        System.out.println("入门方法执行了2...");
        // 配置了视图解析器后，写法
        return "main/index";
    }

    @RequestMapping(path = "/haa")
    public String haa(Model model){
        System.out.println("haa   *****bb 2 999999999999999999...");
        // 向模型中添加属性msg与值，可以在html页面中取出并渲染
        //model.addAttribute("msg","hello,SpringMVC");
        // 配置了视图解析器后，写法
        return "main/index";
    }

    @RequestMapping(path = "/index")
    public String index(){
        System.out.println("index 页面进入......");
        return "main/index";
    }

    @RequestMapping(path = "/list")
    public String list(){
        System.out.println("list方法进入......");
        return "main/list";
    }

    @RequestMapping(path = "/add")
    public String add(){
        System.out.println("add方法进入......");
        return "main/add";
    }

    @GetMapping("/findMenu")
    public ModelAndView findMenus(Authentication authentication, HttpServletRequest request, HttpServletResponse response) {
        ModelAndView model = new ModelAndView("main/menu");
        SysUser user = (SysUser) authentication.getPrincipal();
        String username=user.getUsername();
        if(username!=null){
            List<Menus> listMenu = new ArrayList<>();
            List<SysPermission> pList = systemService.findPermissionByUsername(username);
            System.out.println("=-----=大小为："+pList.size());
            for (SysPermission permission : pList) {
                if (permission.getResource_type().equals("menu")) {
                    Menus menu = new Menus();
                    menu.setId(Long.parseLong(permission.getId()));
                    menu.setName(permission.getName());
                    menu.setParentId(Long.parseLong(permission.getParent_id()));
                    menu.setParentIds(Long.parseLong(permission.getParent_ids()));
                    menu.setUrl(permission.getUrl());
                    listMenu.add(menu);
                }
            }
            //request.setAttribute("listMenus", listMenu);
            model.addObject("listMenu",listMenu);

//            for (Menus menus : listMenu) {
//                if (menus.getParentId() == 10000) { //10000为数据库中的值
//                    System.out.println("==" + menus.getName() + "[" + menus.getUrl() + "]");
//                    for (Menus menusch : listMenu) {
//                        if (menus.getId() == menusch.getParentId()) {
//                            System.out.println("---------" + menusch.getName() + "[" + menusch.getUrl() + "]");
//                        }
//                    }
//                }
//            }
        }
        return model;
    }
}

12. SpringSecurity实战讲解

现在请查看之前配置的spring-security.xml文件。

如图 spring-security.xml 文件中给出了 security:form-login 的4个属性。并禁用了 csrf 。且指定了 error-page 的路径。所以需要编写 Controller 实现 login-page 及 error-page。

• LoginController 控制器编写

package com.wqbr.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * 系统用户控制器
 * @author lv
 * @date 2024年1月16日
 */
@Controller
public class LoginController {

    @RequestMapping("/login")
    public String login(){
        System.out.println("初始 指定 进入登录页面！。。。。。。。。。。。。。。");
        return "login";
    }

    /**
     * 自定义用户访问权限不足的处理方式(需要编写controller返回权限不足的页面)
     * @return
     */
    @RequestMapping("/accessDeny")
    public String accessDeny(){
        System.out.println("自定义用户访问权限不足的处理方式(需要编写controller返回权限不足的页面)。。。。。。。。。。。。。。");
        return "accessdeny";
    }
}

• 编写 MyAuthenticationSuccessHandler 与 MyAuthenticationFailureHandler 类实现spring-security.xml 文件中 authentication-success-handler-ref 与 authentication-failure-handler-ref 属性指定的接口。（以json格式返回成功或失败）

package com.wqbr.service.impl;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import org.springframework.stereotype.Service;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

@Service
public class MyAuthenticationSuccessHandler implements AuthenticationSuccessHandler {

    // new 一个 jackson 的 对象
    private ObjectMapper objectMapper = new ObjectMapper();

    /**
     * 此方法会在登录成功后进行回调
     *
     * @param authentication：表示认证成功后的信息
     */
    @Override
    public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException {
        // 自己构造json字符串，返回给前端
        Map<String,Object> result = new HashMap<>();
        result.put("authStr", "success");
        String json = objectMapper.writeValueAsString(result);
        // 使用response设置响应头为JSON
        httpServletResponse.setContentType("text/json;charset=utf-8");
        // 回写数据
        httpServletResponse.getWriter().write(json);
    }
}

package com.wqbr.service.impl;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.stereotype.Service;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

@Service
public class MyAuthenticationFailureHandler implements AuthenticationFailureHandler {

    // new 一个 jackson 的 对象
    private ObjectMapper objectMapper = new ObjectMapper();

    /**
     * 此方法会在登录失败后进行回调
     *
     * @param authenticationException：表示认证失败后的信息
     */
    @Override
    public void onAuthenticationFailure(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException authenticationException) throws IOException, ServletException {
        // 自己构造json字符串，返回给前端
        Map<String,Object> result = new HashMap<>();
        result.put("authStr", "fail");
        String json = objectMapper.writeValueAsString(result);
        // 使用response设置响应头为JSON
        httpServletResponse.setContentType("text/json;charset=utf-8");
        // 回写数据
        httpServletResponse.getWriter().write(json);
    }
}

• 编写login.jsp页面，登录提交路径为 spring-security.xml 中指定的 login-processing-url="/spring_security_check" 路径。且运行项目后会根据 spring-security.xml 中的 login-page="/login" 访问 LoginController 控制器的方法跳转到 login.jsp 页。

<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="utf-8" %>
<%@ page isELIgnored="false" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>登录页面</title>
</head>
<body>
<h3>用户登录</h3>
<form action="${pageContext.request.contextPath}/spring_security_check" method="post">
    用户名：<input type="text" name="username"/><br>
    用户密码：<input type="password" name="password"/><br>
    <input type="submit" value="登 录"/>
</form>
</body>
</html>

• spring-security.xml文件中的拦截规则如图：

• spring-security.xml文件中的用户详情接口实现（自定义登录授权实现类）

MyUserDetailsService类实现UserDetailsService接口，重写loadUserByUsername方法，实现此方法（用户登录时调用此方法，通过用户输入的登录信息查找数据库用户表进行身份认证匹配）

package com.wqbr.service.impl;

import com.wqbr.domain.SysPermission;
import com.wqbr.domain.SysUser;
import com.wqbr.persistence.SystemDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * 系统用户控制器
 * @author lv
 * @date 2024年1月16日
 */
@Service
public class MyUserDetailsService implements UserDetailsService {

    @Autowired
    private SystemDao systemDao;

    /**
     * loadUserByUsername：读取用户信息
     * 返回值类型 UserDetails 是 SpringSecurity 用来封装用户数据的接口
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        System.out.println("-------loadUserByUsername方法加载中。。。。username："+username);
        /**
         * name： 用户名
         * password： 密码
         * authorities： 定义权限名称
         */
//        User user = new User("admin", "123456",
//                AuthorityUtils.commaSeparatedStringToAuthorityList("admin,normal,ROLE_ALL"));
//        return user;

        SysUser user=systemDao.findByUsername(username);
        System.out.println("user-====="+user);
        //判断
        if(user!=null){
            System.out.println(user.getUsername()+"---====---"+user.getPassword()+"----"+user.getAddtime());
/*            List<SysPermission> permList=systemDao.findPermissionByUsername(user.getUsername());
            StringBuffer sb = new StringBuffer();
            for (SysPermission sysPermission : permList) {
                sb.append(sysPermission.getUrl());
                sb.append(",");
            }
            sb.delete(sb.length()-1,sb.length());*/
            List<GrantedAuthority> list=AuthorityUtils.createAuthorityList("ROLE_USER","admin");
            user.setAuthorities(list); //设置权限列表
            return user;
        }
        throw new UsernameNotFoundException(username+"用户名不存在！");
    }
}

到此spring-security讲解完毕，接下来补全几个测试页面

accessdeny.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
用户访问权限不足！。。。。。。。。。。。。。。。。。。。。。。。
</body>
</html>

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="utf-8" %>
<%@ page isELIgnored="false" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>welcome!</title>
</head>
<body>
<h3>welcome! index页面</h3>
<form action="#" method="post">
</form>
</body>
</html>

add.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h2>add...!  内测页面 </h2>
</body>
</html>

list.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h2>list...!  列表 显示 </h2>
<h3>list...! || 列表 显示 </h3>
</body>
</html>

13. 运行项目查看效果

登录

输入错误的用户名、密码

输入正确的用户名、密码

登录成功后尝试访问/system/add 和 /system/list 方法请求

如图 /system/add 成功访问，/system/list 无法访问，因为权限不足。如下图用户详情类中没有给用户指定 ROLE_ALL 权限

现在我们关闭浏览器，重新打开浏览器。不登录的情况下访问控制器的 /system/add 请求 和 /system/index 请求。

访问 http://localhost:8080/wqdemotwo_war/system/add

跳回到登录页面。

访问 http://localhost:8080/wqdemotwo_war/system/index

成功访问。

好了关于 spring-security 就结束了。

---

下一篇讲讲用户认证登录进来以后如何根据角色获取菜单资源