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

目录

前言

实战开发：

一、Spring Security整合到SSM项目

1. pom文件引入包

2. web.xml 配置

3. 添加 spring-security.xml 文件

二、Spring Security实战应用

1. 项目结构

2. pom文件引入

3. web.xml 配置

4. Spring 配置 applicationContext.xml

5. spring-security.xml 配置

6. springmvc.xml 配置

7. 创建实体类

8. DAO层实现数据查询

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

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

11. SystemController 控制器编写

12. SpringSecurity实战讲解

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 就结束了。

下一篇讲讲用户认证登录进来以后如何根据角色获取菜单资源文章来源地址https://www.toymoban.com/news/detail-820617.html

到了这里，关于SSM项目集成Spring Security 4.X版本（使用spring-security.xml 配置文件方式）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！