读书笔记《spring-security-3-x-cookbook》第 2 章 Struts 的 Spring Security 2

第 2 章 Struts 的 Spring Security 2

在本章中，我们将介绍：

将 Struts 2 与 Spring Security 集成
具有基本 Spring Security 的 Struts 2 应用程序
将 Struts 2 与基于摘要/散列的 Spring Security 一起使用
在 Struts 2 中使用 Spring Security 注销
使用 Struts 2 和 Spring Security 对数据库进行身份验证
使用 Spring Security 在 Struts 2 中获取登录用户信息
在 Struts 2 中显示身份验证失败的自定义错误消息
使用 Spring Security 和 Struts 2 应用程序使用 ApacheDS 进行身份验证

介绍

我们在第 1 章，基本安全中学习了安全基础知识< /span>，帮助我们更好地理解 Spring Security 以及 Spring Framework 中 Spring Security 组件的由来。

在本章中，让我们看看如何使用 Spring Security 在基于 Struts 2 框架的 Web 应用程序中对用户进行身份验证。

Apache Struts 2 可以与 JSF 和 Spring 集成。它是一个非常灵活的 POJO 基于 Action 的 MVC 框架。 POJO 本身执行操作类的角色来满足请求。 Struts 2 源自另一个名为 WebWork 的框架，它与 servlet 过滤器一起工作，拦截请求和响应。

探索 Spring 包

您可以直接从 MAVEN 下载 JAR 或在您的 POM 文件中添加依赖项。

我们更喜欢使用来自 http://mvnrepository.com/artifact/org.springframework.security/spring-security-core/：

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

Spring Security 中的主要包

org.springframework.security.authentication：这是我们感兴趣的领域
org.springframework.security.crypto：这个是用来加解密的
org.springframework.security.util：这是 Spring Security API 使用的通用实用程序类
org.springframework.security.core：这包含与身份验证和授权相关的安全核心类
org.springframework.security.access：这包含基于投票者的安全访问控制注释和决策接口
org.springframework.security.provisioning：这包含用户和组配置接口

关键 Spring Security 功能

支持 JAAS。
支持数据库。
支持 MongoDB 身份验证。
使用 OpenID 提供身份验证。
显示多租户。
提供基本身份验证。
提供摘要式身份验证。
Spring Security 像一个独立的模块一样工作。身份验证代码由 Spring Security 框架独立处理。
支持使用 ApacheDS 进行身份验证。
支持使用 Open LDAP 进行身份验证。

身份验证机制

用户向系统提交他们的凭据；即用户名和密码。
org.springframework.security.authentication.UsernamePasswordAuthenticationToken 接受凭据并将它们传递给 org.springframework.security.authentication.AuthenticationManager验证。
系统对用户进行身份验证。
凭证流程如下：UsernamePasswordAuthenticationToken | AuthenticationManager | 身份验证。
最后返回一个完全加载的身份验证实例。
SecurityContextHolder 接受身份验证实例。
系统还检查角色或组的授权。
最后，允许用户根据他的授权访问系统。

将 Struts 2 与 Spring Security 集成

让我们首先建立一个Struts 2 应用程序并将Spring Security 与它集成。

准备好

Eclipse Indigo 或更高版本
JBoss 作为服务器
Struts 2 JAR：2.1.x
Spring 核心 JAR 3.1.4。发布和 Spring-Security 3.1.4.Release
Struts 2 Spring 插件 jar

怎么做...

在这个部分，我们将学习如何设置 Struts 2 应用程序基于表单的 Spring Security：

在您的 Eclipse IDE 中，创建一个动态 Web 项目并将其命名为 Spring_Security_Struts2。
在 src/main/java 创建一个源文件夹。
在源文件夹src/main/java下创建一个struts.xml文件。
要将 Struts 2 与 Spring 应用程序集成，请在此处添加 application-context.xml 文件引用。
在 web.xml 中添加 Struts 过滤器映射。还需要将 Spring 侦听器添加到 web.xml 文件中。监听器条目应该在 Struts 2 过滤器条目之上。
contextLoaderListener 将告诉 servletcontainer 关于 springcontextLoader 并跟踪事件.这也允许开发人员创建 BeanListeners，这允许它跟踪 Bean 中的事件。

在 web.xml 文件中，添加以下代码：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
<display-name>Struts2x</display-name>
<listener>  
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
</listener>
<!—to integrate spring with struts2->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
</filter>

<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

</web-app>

要设置基于表单的安全性，我们需要创建login.jsp。表单动作是j_spring_security_check：

<%@ taglib prefix="c" url="http://java.sun.com/jsp/jstl/core"%>
<html>
  <head>
  <title>Login Page</title>
  <style> .errorblock { color: #ff0000; background-color: #ffEEEE; border: 3px solid #ff0000; padding: 8px; margin: 16px; } </style>
  </head>
  <body onload='document.f.j_username.focus();'>
    <h3>Login with Username and Password (Custom Page)</h3>
    <% String error=request.getParameter("error");

    if(error!=null){
      %>

      <div class="errorblock">
      Your login attempt was not successful, try again.<br /> Caused :

      </div>

    <%} %>
    <form name='f' action="<c:url value='/j_spring_security_check'/>" method='POST'>

    <table>
      <tr>
        <td>User:</td>
        <td><input type='text' name='j_username' value=''>
        </td>
      </tr>
      <tr>
        <td>Password:</td>
        <td><input type='password' name='j_password' />
        </td>
      </tr>
      <tr>
        <td colspan='2'><input name="submit" type="submit" value="submit" />
        </td>
      </tr>
      <tr>
        <td colspan='2'><input name="reset" type="reset" />
        </td>
      </tr>
    </table>

    </form>
  </body>
</html>

创建文件夹并将其命名为 secure/hello.jsp。
使用 login.jsp 映射 login 操作。
使用 login.jsp?error=true 映射 loginfailed 操作。

将 welcome 动作与 secure/hello.jsp 映射到动作类-HelloWorld ：

struts.xml：

<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
  <package name="default" namespace="/" extends="struts-default">
  <action name="helloWorld">
    <result>success.jsp</result>
  </action>

  <action name="login">
    <result>login.jsp</result>
  </action>

  <action name="loginfailed">
    <result>login.jsp?error=true</result>
  </action>

  <action name="welcome" >
    <result>secure/hello.jsp</result>
  </action>
   
  </package>
</struts>

登录页面 URL 与 Struts 2 操作 '/login' 映射。
Security 应用于Struts 2 action '/欢迎'。
将提示用户登录。

role_user 的用户将被授权访问页面

Applicationcontext-security.xml：

<beans:beans xmlns="http://www.springframework.org /schema/security" xmlns:beans="http://www.springframework.org /schema/beans" 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-3.0.xsd http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring- security-3.1.xsd">
 
 <global-method-security pre-post-annotations="enabled">
        <!-- AspectJ pointcut expression that locates our "post" method and applies security that way <protect-pointcut expression="execution(* bigbank.*Service.post*(..))" access="ROLE_TELLER"/> -->
    </global-method-security>
   <http auto-config="true" use-expressions="true" >
          <intercept-url pattern="/welcome" access="hasRole('ROLE_USER')"/>
          <form-login login-page="/login" default-target- url="/welcome" authentication-failure- url="/loginfailed?error=true" />
          <logout/>
   </http>
    <authentication-manager>
     <authentication-provider>
       <user-service>
          <user name="anjana" password="packt123" authorities="ROLE_USER" />
       </user-service>
     </authentication-provider>
   </authentication-manager>

</beans:beans>

这个怎么运作...

只需运行应用程序。您将获得一个链接以访问受保护的页面。单击链接后，系统将提示您登录。这实际上是基于表单的登录。

在提交时，操作被发送到验证用户的 Spring 框架。

成功后，用户将看到经过身份验证的页面。

Struts 2 框架很容易与 Spring 框架及其模块相结合，只需非常小的修改。

读书笔记《spring-security-3-x-cookbook》第 2 章 Struts 的 Spring Security 2

也可以看看

带有基本 Spring Security 的 Struts 2 应用程序 配方
将 Struts 2 与基于摘要/散列的 Spring Security 结合使用 秘诀
在 Struts 2 中针对身份验证失败显示自定义错误消息 配方
使用 Struts 2 和 Spring Security 验证数据库 秘诀
使用 Spring Security 和 Struts 2 应用程序使用 ApacheDS 进行身份验证 秘诀
在 Struts 2 中使用 Spring Security 注销 秘诀
在 Struts 2 中使用 Spring Security 获取登录用户信息 秘诀

具有基本 Spring Security 的 Struts 2 应用程序

在这个部分中，我们将演示使用 Struts 2 进行的基本 Spring Security 身份验证。我们将创建一个示例 Struts 2 应用程序并将 Spring Security 功能添加到操作以使其安全。只有经过身份验证的授权用户才能访问它。

准备好

更新 Applicationcontext-security.xml 文件
在 Eclipse 中新建一个动态项目：Struts2_Spring_BASIC_Security_Recipe2

怎么做...

执行以下步骤以将 Struts 2 应用程序与 Spring Security 集成以实现基本身份验证：

修改 applicationcontext-security.xml 文件以支持基本安全性：

Applicationcontext-security.xml：

<beans:beans xmlns="http://www.springframework.org/schema/security" xmlns:beans="http://www.springframework.org/schema/beans" 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-3.0.xsd http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.1.xsd">
 
 <global-method-security pre-post-annotations="enabled">
        <!-- AspectJ pointcut expression that locates our "post" method and applies security that way <protect-pointcut expression="execution(* bigbank.*Service.post*(..))" access="ROLE_TELLER"/> -->
    </global-method-security>

  <http>
   <intercept-url pattern="/welcome" access="ROLE_TELLER" />
   <http-basic />
  </http>
   <authentication-manager>
     <authentication-provider>
       <user-service>
         <user name="anjana" password="123456" authorities="ROLE_TELLER" />
       </user-service>
     </authentication-provider>
   </authentication-manager>
</beans:beans>

这个怎么运作...

当用户运行Struts 2 应用程序并尝试访问安全资源时， Spring Security 上下文被初始化，Struts 2 操作被 Spring 的登录对话框中断，该对话框将请求用户名和密码。成功验证后，用户将被重定向到 Struts 2 操作页面。

以下是应用程序的工作流程：

浏览器上的 Struts 2 和 Spring 基本安全性：

也可以看看

将 Struts 2 与基于摘要/散列的 Spring Security 结合使用 秘诀

将 Struts 2 与基于摘要/散列的 Spring Security 一起使用

使用基于表单或基本的身份验证不会使基于 Struts 2 的应用程序安全，因为密码已暴露以纯文本形式发送给用户。是 Spring Security JAR 中的一个加密包。该包可以解密加密的密码，但我们需要告诉 Spring Security API 用于加密的算法。

准备好

在 Eclipse 中创建动态 Web 项目
添加 Struts 2 JAR
添加 Spring Security 相关的 JAR
web.xml、struts2.xml 和 JSP 设置与之前的应用程序保持一致

怎么做...

让我们加密密码：packt123456。

我们需要使用一个外部 JAR，JACKSUM，这意味着 Java 校验和。它同时支持 MD5 和 SHA1 加密。

下载 jacksum.zip 文件（http://www.jonelo.de/java/jacksum/ #Download) 和解压 ZIP 文件夹。

packt>java -jar jacksum.jar -a sha -q"txt:packt123456"

更新 applicationcontext-security.xml 文件：

<beans:beans xmlns="http://www.springframework.org/schema/security" xmlns:beans="http://www.springframework.org/schema/beans" 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-3.0.xsd http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.1.xsd">
 
 <global-method-security pre-post-annotations="enabled">
        <!-- AspectJ pointcut expression that locates our "post" method and applies security that way <protect-pointcut expression="execution(* bigbank.*Service.post*(..))" access="ROLE_TELLER"/> -->
    </global-method-security>
  <http>
   <intercept-url pattern="/welcome" access="ROLE_TELLER" />
   <http-basic />
  </http>
   <authentication-manager>
      <authentication-provider>
   <password-encoder hash="sha" />
      <user-service>
         <user name="anjana" password="bde892ed4e131546a2f9997cc94d31e2c8f18b2a" authorities="ROLE_TELLER" />
      </user-service>
   </authentication-provider>
   </authentication-manager>
</beans:beans>

这个怎么运作...

我们需要更新Applicationcontext-security.xml文件。观察到身份验证的类型是基本的但密码是使用算法散列 .我们希望 Spring Security 使用 SHA 算法对其进行解密并对用户进行身份验证。

Spring Security 在处理摘要身份验证方面非常灵活。您还可以看到没有基于容器的依赖项。

来自浏览器的基本身份验证可以在以下屏幕截图中看到：

Spring通过解密密码对用户进行了身份验证：

也可以看看

在 Struts 2 中针对身份验证失败显示自定义错误消息 配方
使用 Struts 2 和 Spring Security 验证数据库 秘诀
使用 Spring Security 和 Struts 2 应用程序使用 ApacheDS 进行身份验证 秘诀
在 Struts 2 中使用 Spring Security 注销 秘诀
在 Struts 2 中使用 Spring Security 获取登录用户信息 秘诀

在 Struts 2 中使用 Spring Security 注销

在本节中，让我们实现一个注销场景，登录的用户将从应用程序中注销。注销操作将由 Spring Security 框架处理。我们需要配置 struts.xml 文件来处理 j_spring_security_logout 动作。

准备好

在 Eclipse 中创建动态 Web 项目
添加 Struts 2 相关的 JAR
添加 Spring Security 相关的 JAR
web.xml、struts2.xml 和 JSP 设置与之前的应用程序保持一致

怎么做...

让我们更新安全页面，hello.jsp：

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@page import="java.security.Principal" %>
<html>
<body>
Hello .You are seeing a secured Page now.
   
   <a href="<c:url value="/j_spring_security_logout" />" > Logout</a>
 </body>
</html>

让我们用 struts.xml 映射 j_spring_security_logout文件：

当用户点击logout，用户将被注销并将被重定向到 index.jsp。

<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
   <package name="default" namespace="/" extends="struts-default">
        <action name="helloWorld">
            <result>success.jsp</result>
        </action>
        
      <action name="login">
                <result>login.jsp</result>
         </action>

         <action name="loginfailed">
                <result>login.jsp?error=true</result>
         </action>
         
         <action name="welcome" >
         <result>secure/hello.jsp</result>
         </action>
   
   <action name="j_spring_security_logout">
   <result>index.jsp</result>
         </action>
    </package>
</struts>

更新 applicationcontext-security.xml 文件：

<beans:beans xmlns="http://www.springframework.org/schema/security" xmlns:beans="http://www.springframework.org/schema/beans" 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-3.0.xsd http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.1.xsd">
 
 <global-method-security pre-post-annotations="enabled">
    </global-method-security>
  <http>
   <intercept-url pattern="/welcome" access="ROLE_TELLER" />
   <logout logout-success-url="/helloWorld" />
   <http-basic />
  </http>
   <authentication-manager>
      <authentication-provider>
   <password-encoder hash="sha" />
      <user-service>
         <user name="anjana" password="bde892ed4e131546a2f9997cc94d31e2c8f18b2a" authorities="ROLE_TELLER" />
      </user-service>
   </authentication-provider>
   </authentication-manager>
</beans:beans>

这个怎么运作...

Spring Security 还提供了处理注销的选项。当用户点击 logout 时，用户将被定向到分配的页面。

j_spring_secuurity_logout 为 Struts 2 应用程序提供注销选项。

Struts 2 应用程序具有地图和 URL 及其操作。

注销选项通常在安全页面中给出。

还有更多...

直到现在我们已经将认证信息存储在.xml 文件。我们还对密码进行了哈希处理。如何将信息存储在外部系统上并获取它？在下一节中，让我们看看 Struts 2 如何使用此数据库身份验证。

也可以看看

在 Struts 2 中针对身份验证失败显示自定义错误消息 配方
使用 Struts 2 和 Spring Security 验证数据库 秘诀
使用 Spring Security 和 Struts 2 应用程序使用 ApacheDS 进行身份验证 秘诀
在 Struts 2 中使用 Spring Security 获取登录用户信息 秘诀

使用 Struts 2 和 Spring Security 对数据库进行身份验证

在本节中，让我们使用存储在数据库中的信息授权登录到 Struts 2 应用程序的用户。 Spring Security 需要在 Struts 2 应用程序中进行配置，以便了解数据库的位置和需要执行的 SQL，以使用 Spring Security 对用户进行身份验证。

准备好

在 Eclipse 中创建动态网页项目： Struts2_Spring_DBAuthentication_Recipe4
复制 struts.xml 文件到src/main/java< /代码>
将 db-beans.xml 文件添加到 WEB-INF< /代码>
从上一个秘籍复制 webContent 文件夹
将以下 JAR 添加到 lib 文件夹中，或者如果您使用的是 maven，请更新您的 POM 文件：
- spring-jdbc-3.0.7.RELEASE
- mysql-connector-java-5.1.17
- commons-dbcp
- 公共池-1.5.4

怎么做...

要使用 Struts 2 和 Spring 执行数据库身份验证，我们需要创建一个 db-beans.xml 文件. db-beans.xml 文件 < /a>将有数据库信息：

<beans xmlns="http://www.springframework.org/schema/beans" 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-3.0.xsd">
    <bean id="MySqlDatasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
   <property name="driverClassName" value="com.mysql.jdbc.Driver" />
   <property name="url" value="jdbc:mysql://localhost:3306/test1" />
   <property name="username" value="root" />
   <property name="password" value="prdc123" />
   </bean>
 </beans>

在与 applicationcontext-security.xml 相同的位置添加 db-beans.xml 文件。更新 web.xml 文件以读取 db-beans.xml 文件：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>SpringStruts2Security</display-name>
 <context-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>
                /WEB-INF/db-beans.xml,
                /WEB-INF/applicationContext-security.xml
          </param-value>
   </context-param>

  <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>
  <filter>
    <filter-name>struts2</filter-name>
    <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
  </filter>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <filter-mapping>
    <filter-name>struts2</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  <error-page>
          <error-code>403</error-code>
          <location>/secure/denied.jsp</location>
   </error-page>
   
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>

运行以下您的数据库中的 SQL 脚本：

CREATE TABLE `users1` (  `USER_ID` INT(10) UNSIGNED NOT NULL,
  `USERNAME` VARCHAR(45) NOT NULL,
  `PASSWORD` VARCHAR(45) NOT NULL,
  `ENABLED` tinyint(1) NOT NULL,
  PRIMARY KEY (`USER_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
CREATE TABLE `user_roles` (
  `USER_ROLE_ID` INT(10) UNSIGNED NOT NULL,
  `USER_ID` INT(10) UNSIGNED NOT NULL,
  `ROLE` VARCHAR(45) NOT NULL,
  PRIMARY KEY (`USER_ROLE_ID`),
  KEY `FK_user_roles` (`USER_ID`),
  CONSTRAINT `FK_user_roles` FOREIGN KEY (`USER_ID`) REFERENCES `users` (`USER_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

INSERT INTO test1.users (USER_ID, USERNAME,PASSWORD, ENABLED)
VALUES (100, 'anjana', 'packt123456', TRUE);
 
INSERT INTO test1.user_roles (USER_ROLE_ID, USER_ID,AUTHORITY)
VALUES (1, 100, 'ROLE_TELLER');

更新 applicationContext-security.xml 文件到读取数据库配置：

<beans:beans xmlns="http://www.springframework.org/schema/security" xmlns:beans="http://www.springframework.org/schema/beans" 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-3.0.xsd http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.1.xsd">

 <global-method-security pre-post-annotations="enabled">
        <!-- AspectJ pointcut expression that locates our "post" method and applies security that way <protect-pointcut expression="execution(* bigbank.*Service.post*(..))" access="ROLE_TELLER"/> -->
    </global-method-security>

  <http>
   <intercept-url pattern="/welcome" access="ROLE_TELLER" />
   <logout logout-success-url="/helloWorld" />
   <http-basic />
  </http>

   <authentication-manager> 
      <authentication-provider> 
         <jdbc-user-service data-source-ref="MySqlDS" users-by-username-query=" select username,password, enabled from users1 where username=?" authorities-by-username-query=" select u.username, ur.role from users1 u, user_roles ur where u.user_id = ur.user_id and u.username =? " /> 
      </authentication-provider>
   </authentication-manager>
</beans:beans>

这个怎么运作...

Struts 2 框架提供了访问安全页面的链接。但是 Spring Security 框架中断并给出一个身份验证对话框。身份验证是由 Spring Security Framework 通过查询数据库完成。身份验证管理器配置有数据源 ref，它将加载安全框架的信息，以根据查询对用户进行身份验证。

还有更多...

到目前为止，我们只使用一个 JSP 文件应用了安全性，该文件在 struts2.xml 中被映射而无需操作。让我们看看如何用 JSP 映射一个动作类，然后与 Spring Security 集成。理想情况下，它应该以相同的方式工作。让我们在action类中获取登录用户信息，并显示在浏览器上。

也可以看看

在 Struts 2 中针对身份验证失败显示自定义错误消息 配方
使用 Spring Security 和 Struts 2 应用程序使用 ApacheDS 进行身份验证 秘诀
在 Struts 2 中使用 Spring Security 获取登录用户信息 秘诀

使用 Spring Security 在 Struts 2 中获取登录用户信息

到目前为止，在我们的示例中，我们还没有使用任何 Struts 2 动作类。

让我们创建一个操作类，看看 Security 如何处理这个操作类。我们将在这个秘籍中使用基于表单的身份验证。

准备好

到目前为止在我们的示例中，我们没有使用任何 Struts 2 动作类。

让我们创建一个动作类，看看这个动作类的安全性如何。我们将在这个秘籍中使用基于表单的身份验证：

创建动态 Web 项目：Struts2_Spring_Security_Recipe5
创建一个包：com.packt.action
从 src/main/java 中复制上一个秘籍中的 struts.xml 文件
同时复制 WebContent 文件夹
我们需要在包中添加一个动作类
更新 struts.xml 文件

怎么做...

HelloAction 文件如下：

package com.packt.action;
public class HelloAction {
         public String execute(){
         return "SUCCESS";
   }
}

使用 HelloAction 更新 Struts.xml 文件。因此，当用户通过身份验证时，它将请求传递给将执行 execute() 方法的操作类，然后将被重定向到 hello.jsp:

<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
   <package name="default" namespace="/" extends="struts-default">
        <action name="helloWorld">
            <result>success.jsp</result>
        </action>
        
      <action name="login">
               <result>login.jsp</result>
         </action>

         <action name="loginfailed">
               <result>login.jsp?error=true</result>
         </action>
         
         <action name="welcome" class="com.packt.action.HelloAction">
         <result name="SUCCESS">secure/hello.jsp</result>
         </action>
   
    </package>
</struts>

获取登录用户：
我们可以在操作类中获取登录的用户名，我们可以将其显示在页面上或在我们的应用程序中进一步使用。
我们可以在我们的操作类中使用 request.getUserPrincipal 来获取登录的用户信息。

对于项目设置：

在 Eclipse 中创建动态 Web 项目：Struts2_Spring_Security_Recipe6
从上一个秘籍复制 src/main/java 文件夹
从上一个秘籍复制 Web content 文件夹

修改 HelloAction.java 文件

package com.packt.action;
import javax.servlet.http.HttpServletRequest;
import org.apache.struts2.ServletActionContext;
public class HelloAction {
   private String name;
               public String execute(){
               HttpServletRequest request = ServletActionContext.getRequest();
               String logged_in_user=request.getUserPrincipal().getName();
               setName(logged_in_user);
               return "SUCCESS";
         }

         public String getName() {
               return name;
         }

         public void setName(String name) {
               this.name = name;
         }
}

修改 secure/Hello.jsp 文件：

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@taglib uri="/struts-tags" prefix="s" %>
<%@page import="java.security.Principal" %>
<html>
  <body>
    Hello <h1><s:property value="name" /></h1>.You are seeing a secured Page now.
    <a href="<c:url value="/j_spring_security_logout" />" > Logout</a>
  </body>
</html>

这个怎么运作...

用户信息存储在主体中：

在浏览器上显示登录用户：

还有更多...

在显示用户信息后，我们可以向用户显示自定义错误信息关于身份验证失败。

也可以看看

在 Struts 2 中针对身份验证失败显示自定义错误消息 配方
使用 Spring Security 和 Struts 2 应用程序使用 ApacheDS 进行身份验证 秘诀

在 Struts 2 中显示身份验证失败的自定义错误消息

在这部分，我们将在我们的捕获来自Spring Security的认证失败消息。 Struts 2 应用程序，看看如何将其显示给用户。

准备好

身份验证失败时重定向到失败操作
向用户显示自定义消息

怎么做...

执行以下步骤，在 JSP 应用程序中捕获 Spring Security 的身份验证失败消息：

在 applicationcontext.xml 文件中，我们可以将 URL 重定向到另一个操作：Authentication-failure-url="/loginfailed?error=true" 。

<http auto-config="true" use-expressions="true" >
         <intercept-url pattern="/welcome" access="hasRole('ROLE_TELLER')"/>
         <form-login login-page="/login" default-target-url="/welcome" authentication-failure-url="/loginfailed?error=true" />
         <logout/>
   </http>

使用以下代码更新 login.jsp 页面：

<% String error=request.getParameter("error");
 
 if(error!=null){
 %>

          <div class="errorblock">
                Your login attempt was not successful, try again.<br /> Caused :
                
          </div>

 <%} %>

这个怎么运作...

登录失败操作与 struts2.xml 中的 login.jsp 文件映射。 authentication-failure-url 被添加到 application-context.xml 中。当用户输入错误的凭据时，身份验证失败，用户被重定向到登录页面并显示错误消息。

错误消息配置在 JSP 文件中完成。

也可以看看

使用 Spring Security 和 Struts 2 应用程序使用 ApacheDS 进行身份验证 秘诀

使用 Spring Security 和 Struts 2 应用程序使用 ApacheDS 进行身份验证

在这个部分，我们将存储用户凭据和角色Apache 目录 server 中的信息。 Spring Security 必须找到服务器并登录到服务器。它应该通过比较用户提交的凭据与 Apache 目录服务器中存在的凭据和角色信息来验证用户。

准备好

在 Eclipse 中创建动态 Web 项目
src/main/java 文件夹和 WebContent 文件夹保持不变
安装 Apache 目录工作室：1.5.3
安装 Apache 目录服务器：2.0
10389 是 apache-ds 端口
将 LDAP 相关的安全 JAR 添加到 WebContent Lib 文件夹
spring-ldap-core-tiger-1.3.X 发布
spring-ldap-odm-1.3.X 发布
spring-security-ldap-1.3.X 发布
spring-ldap-ldif-batch-1.3.X 发布
spring-ldap-test-1.3.X 发布
spring-ldap-core-1.3.X 发布
spring-ldap-ldif-core-1.3.X 发布

怎么做...

执行设置 Apache 目录以使用 Spring Security 在 Struts 2 应用程序中验证用户的步骤：

安装上述先决条件后配置 Apache DS 服务器。
使用以下步骤创建分区：
- 打开 server.xml 文件：C:\Program Files\Apache Directory Server\instances\default\conf\server.xml .
- 添加 JDM 分区：。
- 您可以重新启动 Apache DS 服务器以查看更改。然后使用 Apache Directory Studio 连接到 Apache DS。右键单击 DIT。从 Scratch 创建 Entry。选择 Organization，选择 o 并在值输入packt。选择 Finish 并刷新 DIT 以查看更新。
配置 Apache 目录工作室。
连接到 Apache 目录服务器。
Apache DS 在 10389 上运行。
创建两个组 ou=groups 和 ou=user。
这里，object class 是用于将条目添加到 ou=groups，因为这样可以保持角色：
这里，object class 是添加条目到ou=people：

将角色分配给用户由添加UniqueMember到cn=admin< /代码>。

Spring-security-ldap.xml：

<beans:beans xmlns="http://www.springframework.org/schema/security" xmlns:beans="http://www.springframework.org/schema/beans" 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-3.0.xsd http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.1.xsd">
 
 <global-method-security pre-post-annotations="enabled">
        <!-- AspectJ pointcut expression that locates our "post" method and applies security that way <protect-pointcut expression="execution(* bigbank.*Service.post*(..))" access="ROLE_TELLER"/> -->
    </global-method-security>
   <http auto-config="true" use-expressions="true" >
          <intercept-url pattern="/welcome" access="hasRole('ROLE_ADMIN')"/>
<!-- <intercept-url pattern="/admin" access="hasRole('ROLE_admin')"/> -->
   
   
         <form-login login-page="/login" default-target-url="/secure/common.jsp" authentication-failure-url="/loginfailed?error=true" />

<authentication-manager>
           <ldap-authentication-provider user-search-filter="(mail={0})" user-search-base="ou=people" group-search-filter="(uniqueMember={0})" group-search-base="ou=groups" group-role-attribute="cn" role-prefix="ROLE_">
           </ldap-authentication-provider>
   </authentication-manager>
   
   <ldap-server url="ldap://localhost:10389/o=sevenSeas" manager-dn="uid=admin,ou=system" manager-password="secret" />
</beans:beans>

这个怎么运作...

Spring Security-ldap.xml 将< /a> 包含关于服务器位置和域的详细信息。它应该连接以检索用户信息。域是 sevenSeas。 1039 是 LDAP 服务器的端口号。 Spring Security 使用 ldap-server 标签来提供关于 LDAP 的信息。它还提供了密码和它将连接的域。 Struts 2 请求将被 Spring Security 中断，并且为了进行身份验证，将从登录页面接收用户信息。 Spring 安全要求用户名使用LDAP；成功后，用户可以访问受保护的资源。

也可以看看

第 3 章，Spring Security with JSF

vlambda博客 学习文章列表