Struts2(一)

2020-06-04

1. Struts2基本概念

1.1 三层架构和三大框架各自的位置

1.1.1 三层架构

我们的开发架构一般都是基于两种形式，一种是C/S架构，也就是客户端/服务器，另一种是B/S架构，也就是浏览器/服务器。在JavaEE开发中，几乎全都是基于B/S架构的开发。那么在B/S架构中，系统标准的三层架构包括：表现层、业务层、持久层。三层架构在我们的实际开发中使用的非常多。

三层架构中，每一层各司其职，接下来我们就说说每层都负责哪些方面：

表现层：

也就是我们常说的web层。它负责接收客户端请求，向客户端响应结果，通常客户端使用http协议请求web层，web需要接收http请求，完成http响应。

表现层包括展示层和控制层：控制层负责接收请求，展示层负责结果的展示。

表现层依赖业务层，接收到客户端请求一般会调用业务层进行业务处理，并将处理结果响应给客户端。

表现层的设计一般都使用MVC模型。（MVC是表现层的设计模型，和其他层没有关系）
业务层：

也就是我们常说的service层。它负责业务逻辑处理，和我们开发项目的需求息息相关。web层依赖业务层，但是业务层不依赖web层。

业务层在业务处理时可能会依赖持久层，如果要对数据持久化需要保证事务一致性。（也就是我们说的，事务应该放到业务层来控制）
持久层：

也就是我们是常说的dao层。负责数据持久化，包括数据层即数据库和数据访问层，数据库是对数据进行持久化的载体，数据访问层是业务层和持久层交互的接口，业务层需要通过数据访问层将数据持久化到数据库中。

通俗的讲，持久层就是和数据库交互，对数据库表进行曾删改查的。

1.1.2 三大框架和三层架构的关系

1.2 Struts2概述

Struts2是一种基于MVC模式的轻量级Web框架，它自问世以来，就受到了广大Web开发者的关注，并广泛应用于各种企业系统的开发中。目前掌握Struts2框架几乎成为Web开发者的必备技能之一。

在介绍Struts2之前，先来认识一下Struts1。Struts1是最早的基于MVC模式的轻量级Web框架，它能够合理的划分代码结构，并包含验证框架、国际化框架等多种实用工具框架。但是随着技术的进步，Struts1的局限性也越来越多的暴露出来。为了符合更加灵活、高效的开发需求，Struts2框架应运而生。

Struts2是Struts1的下一代产品，是在 Struts1和WebWork技术的基础上进行合并后的全新框架（WebWork是由OpenSymphony组织开发的，致力于组件化和代码重用的J2EE Web框架，它也是一个MVC框架）。虽然Struts2的名字与Struts1相似，但其设计思想却有很大不同。实质上，Struts2是以WebWork为核心的，它采用拦截器的机制来处理用户的请求。这样的设计也使得业务逻辑控制器能够与ServletAPI完全脱离开，所以Struts2可以理解为WebWork的更新产品。

Struts2拥有优良的设计和功能，其优势具体如下：

项目开源，使用及拓展方便，天生优势。
提供Exception处理机制。
Result方式的页面导航，通过Result标签很方便的实现重定向和页面跳转。
通过简单、集中的配置来调度业务类，使得配置和修改都非常容易。
提供简单、统一的表达式语言来访问所有可供访问的数据。
提供标准、强大的验证框架和国际化框架。
提供强大的、可以有效减少页面代码的标签。
提供良好的Ajax支持。
拥有简单的插件，只需放入相应的JAR包，任何人都可以扩展Struts2框架，比如自定义拦截器、自定义结果类型、自定义标签等，为Struts2定制需要的功能，不需要什么特殊配置，并且可以发布给其他人使用。
拥有智能的默认设置，不需要另外进行繁琐的设置。使用默认设置就可以完成大多数项目程序开发所需要的功能。

2. Struts2的入门

2.1 Struts2环境搭建

2.1.1 下载struts2开发包

Struts2的官网: https://struts.apache.org/

2.1.2 Struts2开发包目录介绍

解压后的目录结构如下：

2.1.3 搭建步骤

2.1.3.1 第一步：拷贝struts2必备jar包到web工程的lib目录

要进行struts2的基本的开发，可以参考struts-2.3.24中的apps下的一些示例代码，其中struts2-blank.war是一个struts2的空的工程。我们只需要将struts2-blank.war解压后进入到WEB-INF下的lib中查看。

2.1.3.2 第二步：在类的根路径下创建一个名称为struts.xml的文件，并导入约束

在开发中需要将struts.xml文件引入到工程的src下，因为src下内容发布到web服务器中就是WEB-INF下的classes中。

<?xml version="1.0" encoding="UTF-8"?>
<!-- 导入约束：
    约束的位置：在struts2的核心jar包中
            struts2-core-2.3.24.jar中包含一个名称为：
                struts-2.3.dtd的约束文件
-->
<!DOCTYPE struts PUBLIC
	"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
	"http://struts.apache.org/dtds/struts-2.3.dtd">
<struts></struts>

2.1.3.3 第三步：在web.xml配置struts2的核心控制器

Struts2框架要想执行，所有的请求都需要经过这个前端控制器（核心过滤器）

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <!-- 配置struts2的核心过滤器 -->
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>

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

2.1.3.4 验证搭建成功与否

把应用部署到tomcat中，启动tomcat，不报异常则表示搭建成功。

2.2 Struts2入门案例

2.2.1 案例需求

通过点击超链接发送请求，由Struts2中类来负责接收，并且在控制台输出接收到了的语句。

2.2.2 案例实现

2.2.2.1 第一步：编写index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>struts2的入门案例</title>
</head>
<body>
<%--struts2的核心控制默认会处理以.action为后缀的url，或者是没有任何后缀的url --%>
<a href="${pageContext.request.contextPath}/hello">访问第一个struts2应用</a>
<a href="${pageContext.request.contextPath}/hello.action">访问第一个struts2应用.action</a>
</body>
</html>

2.2.2.2 第二步：编写Class

/**
 * 我们的第一个动作类。 
 * 动作类： 
 *    它就是一个概念。它就是struts2框架中用于处理请求的类。
 *    我们以后处理请求都写动作类。
 * 
 * @author wgy
 */
public class HelloAction {

	/**
	 * 我们的第一个动作方法
	 * 动作方法：
	 * 	 动作类中用于处理请求的方法
	 * 动作方法有编写规范：
	 * 	1、访问修饰符都是public
	 * 	2、方法的返回值一般都是String(但是可以是void)
	 *  3、方法都没有参数
	 * @return
	 */
	public String sayHello(){
		System.out.println("HelloAction的sayHello方法执行了。。。。"+this);
		return "success";
	}
}

2.2.2.3 第三步：在配置文件中配置我们的动作类

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
        "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
    <!-- 配置文件 -->
    <package name="p1" extends="struts-default">
        <action name="hello" class="com.wgy.web.action.HelloAction" method="sayHello">
            <result name="success" type="dispatcher">/success.jsp</result>
        </action>
    </package>
</struts>

2.2.2.4 第四步：编写success.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>执行结果页面</title>
</head>
<body>执行成功！
</body>
</html>

2.2.2.5 第五步：启动tomcat测试访问结果

2.3 Struts2的执行过程

2.3.1 执行时序

首先是，启动tomcat服务器，这时候会加载web.xml，当读到filter标签时，会创建过滤器对象。

Struts2的核心过滤器（StrutsPrepareAndExecuteFilter）会负责加载类路径下的struts.xml配置文件。

接下来，从客户端发送请求过来先经过前端控制器（核心过滤器StrutsPrepareAndExecuteFilter），前端控制器会根据请求的名称在struts.xml中找到对应的配置，创建我们的动作类对象（每次访问时都会创建新的Action对象），然后执行指定的方法，根据方法的返回值找到Result的配置进行页面的跳转.最后响应浏览器。

2.3.2 内部执行流程

Struts2框架在默认情况下核心控制器（StrutsPrepareAndExecuteFilter）默认会拦截以.action为后缀的请求，或者是没有任何后缀的请求。当拦截下来后，送入Struts2的核心内部。如下图所示：

我们通过上面的图解，应该明确在实际开发中我们用struts2要做哪些：

写动作类
写jsp
写配置文件

其中，又以配置文件为重。

3. Struts2的配置文件详解

3.1 Struts2中的配置文件

3.1.1 配置文件说明

在struts2中给我们提供了6个配置文件。他们的加载时机是tomcat启动服务一加载我们的应用时，就加载struts2的配置文件。

他们的加载顺序入如下：

顺序	配置文件名	所在位置	说明
1	default.properties	struts2-core-2.3.15.3.jar\org\apache\struts2	不能修改
2	struts-default.xml	struts2-core-2.3.15.3.jar	不能修改
3	strtuts-plugin.xml	在struts2提供的插件jar包中	不能修改
4	struts.xml	我们的应用中	我们修改的：推荐
5	struts.properties	我们的应用中	我们修改的
6	web.xml	我们的应用中	我们修改的，可以给过滤器配置参数

3.1.2 配置文件的注意事项

Struts2提供了两种配置的方式。一种是key=value的方式，即使用.properties文件。另一种是xml文件配置。我们推荐使用xml文件（它能描述层级关系）。
当多个配置文件中，有相同的参数，后加载的会把前面的值给覆盖了。

3.1.3 Struts2中的常用常量

常量定义在了default.properties配置文件中，体现形式都是key=value。所有的struts2应用都会用到这些常量。

常用的：

常量名	常量值	说明
struts.i18n.encoding	UTF-8	应用中使用的编码
struts.objectFactory.spring.autoWire	name	和spring框架整合有关
struts.multipart.parser	jakarta	指定文件上传用的组件
struts.multipart.maxSize	2097152	文件上传总文件大小限制：2M
struts.action.extension	action,,	能进入Struts2框架内部的url地址后缀名。多个值用逗号分隔
struts.enable.DynamicMethodInvocation	false	是否允许动态方法调用
struts.devMode	false	是否是开发模式。开发模式：改了配置文件，不需要重启。输出更多的错误信息。开发阶段建议为true
struts.ui.theme	xhtml	页面展示用的主题

3.2 Struts.xml中的标签详解

3.2.1 constant标签

<!-- constant标签：
    作用：
        用于修改struts2中的常量
    属性：
        name：指定常量的key
        value：指定常量的值
-->
<!-- 开启开发者模式 -->
<constant name="struts.devMode" value="true"></constant>

3.2.2 package标签

<!-- package标签：
    作用：给访问的action进行分包管理。把配置文件按照面向对象的思想来管理。
    属性：
        name：指定包的名称。必须写，并且必须唯一。
        extends：指定当前包的父包。子包自动具备父包所定义的配置。我们的包一般都需要继承struts-default包。
        该包在struts-defaul.xml文件中定义着。如果不继承该包，则不能使用struts2的核心功能。
        abstract：把当前包声明为抽象包。抽象包就是用来被继承的。里面定义一般都是公共的配置。
                  只有没有action标签的包，才能定义为抽象包。
        namespace：指定当前包的名称空间。它可以让我们的访问URL模块化。当我们指定了该属性，访问URL就变成了：名称空间+/hello
                   名称空间的写法：第一个字符必须是/，后面紧跟的字符必须是一个字母。其余内容可以是字母，也可以是数字。
                    例如：我们访问用户
                        /user/addUser.action
                        /user/updateUser.action
                    名称空间有默认值。默认值是：""
-->
<package name="p1" extends="struts-default" namespace="/n1">
	<action name="hello" class="com.wgy.web.action.HelloAction" method="sayHello">
		<result name="success" type="dispatcher">/success.jsp</result>
	</action>
</package>

3.2.3 action标签

<!-- action标签：
	作用：建立动作名称，动作类和动作方法的对应关系
	属性：
        name:指定动作名称。它是唯一的
        class:指定动作类的全限定类名
        method：指定动作方法名称
-->
<action name="hello" class="com.wgy.web.action.HelloAction" method="sayHello">
	<result name="success" type="dispatcher">/success.jsp</result>
</action>

3.3 action的三种创建方式

3.3.1 第一种：无侵入式创建(实际开发中基本不用)

/**
 * 我们的第一个动作类
 * 动作类的第一种创建方式：
 *  无侵入式的创建。
 */
public class HelloAction {

	public String sayHello(){
		System.out.println(this);
		System.out.println("HelloAction中的sayHello方法执行了。。。。");
		return "success";
	}
}

1
2
3

<action name="hello" class="com.wgy.web.action.HelloAction" method="sayHello">
	<result name="success" type="dispatcher">/success.jsp</result>
</action>

3.3.2 第二种：实现Action接口的定义方式 (实际开发中用的也不多)

/**
 * 通过实现接口的方式创建动作类
 *
 * @author wgy
 */
public class Hello2Action implements Action {

    @Override
    public String execute() throws Exception {
        System.out.println("Hello2Action的execute方法执行了。。。。");
        return SUCCESS;
    }
}

<!-- 默认动作方法：当我们要是执行的是execute方法时，method属性可以不写。 -->
<action name="hello2" class="com.wgy.web.action.Hello2Action">
	<result name="success" type="dispatcher">/success.jsp</result>
</action>

Action接口中的常量

SUCCESS：一般多用于成功

ERROR：一般多用于动作方法执行失败

LOGIN：一般多用于返回登录页面

NONE：一般用于不返回任何结果视图，和return null作用是一样的

INPUT：一般多用于数据回显，也是struts2中数据回显时的默认返回值。

3.3.3 第三种：继承ActionSupport (实际开发中采用的方式)

/**
 * 通过继承ActionSupport的方式创建动作类
 *
 * @author wgy
 */
public class Hello3Action extends ActionSupport {

}

1
2
3

<action name="hello3" class="com.wgy.web.action.Hello3Action">
	<result name="success" type="dispatcher">/success.jsp</result>
</action>

3.3.4 默认动作类：ActionSupport类

<!-- 通过struts-default.xml中我们知道默认的动作类是ActionSupport，所以如果实现该类的execute方法，则可以不用指定class和method属性 -->
<action name="hello4">
	<result name="success" type="dispatcher">/success.jsp</result>
</action>

3.4 action的三种访问方式

/**
 * 用户的动作类
 *
 * @author wgy
 */
public class UserAction extends ActionSupport {

    /**
     * 保存
     * @return
     */
    public String addUser() {
        System.out.println("保存了用户");
        return SUCCESS;
    }

    /**
     * 更新
     * @return
     */
    public String updateUser() {
        System.out.println("更新了用户");
        return SUCCESS;
    }

    /**
     * 查询
     * @return
     */
    public String deleteUser() {
        System.out.println("删除了用户");
        return SUCCESS;
    }

    /**
     * 删除
     * @return
     */
    public String findUser() {
        System.out.println("查询了用户");
        return SUCCESS;
    }
}

3.4.1 第一种：全匹配配置访问方式

<a href="${pageContext.request.contextPath}/addUser">添加用户</a>
<hr/>
<a href="${pageContext.request.contextPath}/updateUser">更新用户</a>
<hr/>
<a href="${pageContext.request.contextPath}/deleteUser">删除用户</a>
<hr/>
<a href="${pageContext.request.contextPath}/findUser">查询用户</a>

<package name="user" extends="struts-default">
    <action name="addUser" class="com.wgy.web.action.UserAction" method="addUser">
    	<result name="success">/success.jsp</result>
    </action>
    <action name="updateUser" class="com.wgy.web.action.UserAction" method="updateUser">
    	<result name="success">/success.jsp</result>
    </action>
    <action name="deleteUser" class="com.wgy.web.action.UserAction" method="deleteUser">
    	<result name="success">/success.jsp</result>
    </action>
    <action name="findUser" class="com.wgy.web.action.UserAction" method="findUser">
    	<result name="success">/success.jsp</result>
    </action>
</package>

3.4.2 第二种：使用通配符的方式*

通配符基本用法

<a href="${pageContext.request.contextPath}/addUser">添加用户</a>
<hr/>
<a href="${pageContext.request.contextPath}/updateUser">更新用户</a>
<hr/>
<a href="${pageContext.request.contextPath}/deleteUser">删除用户</a>
<hr/>
<a href="${pageContext.request.contextPath}/findUser">查询用户</a>

<!-- 通配符基本用法 -->
<package name="user" extends="struts-default">
    <action name="*" class="com.wgy.web.action.UserAction" method="{1}">
    	<result name="success">/success.jsp</result>
    </action>
</package>

通配符的高级用法

<a href="${pageContext.request.contextPath}/add_User">添加用户</a>
<hr/>
<a href="${pageContext.request.contextPath}/update_User">更新用户</a>
<hr/>
<a href="${pageContext.request.contextPath}/delete_User">删除用户</a>
<hr/>
<a href="${pageContext.request.contextPath}/find_User">查询用户</a>

<!-- 通配符的高级用法 -->
<package name="user" extends="struts-default">
    <action name="*_*" class="com.wgy.web.action.{2}Action" method="{1}{2}">
    	<result name="success">/success.jsp</result>
    </action>
</package>

3.4.3 第三种：使用动态方法调用的方式

<a href="${pageContext.request.contextPath}/user!addUser">添加用户</a>
<hr/>
<a href="${pageContext.request.contextPath}/user!updateUser">更新用户</a>
<hr/>
<a href="${pageContext.request.contextPath}/user!deleteUser">删除用户</a>
<hr/>
<a href="${pageContext.request.contextPath}/user!findUser">查询用户</a>

<!-- 使用动态方法调用的方式 -->
<constant name="struts.enable.DynamicMethodInvocation" value="true"/>
<package name="user" extends="struts-default">
    <action name="user" class="com.wgy.web.action.UserAction">
    	<result name="success">/success.jsp</result>
	</action>
</package>

4. 案例：Strut2+Hibernate查询客户列表

4.1 第一步：搭建hibernate开发环境并准备实体类和映射配置

可参考Hibernate环境搭建。

Hibernate开发环境

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <!-- 配置SessionFactory-->
    <session-factory>
        <!-- 第一部分：连接数据库的信息 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/struts2</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">root</property>
        <!-- 数据库的方言 -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

        <!-- 第二部分：hibernate的可选配置 -->
        <!-- 是否显示hibernate生成的SQL语句 -->
        <property name="hibernate.show_sql">true</property>
        <!-- 是否使用格式化输出sql语句到控制台 -->
        <property name="hibernate.format_sql">false</property>
        <!-- 配置hibernate采用何种方式生成DDL语句 -->
        <!-- update表示检测实体类的映射配置和数据库的表结构是否一致，如果不一致，更新表结构 -->
        <property name="hibernate.hbm2ddl.auto">update</property>
        <!-- 设置hibernate的连接池提供商 -->
        <property name="hibernate.connection.provider_class">org.hibernate.c3p0.internal.C3P0ConnectionProvider</property>
        <!-- 把session和线程绑定，从而实现一个线程只有一个Session -->
        <property name="hibernate.current_session_context_class">thread</property>

        <!-- 第三部分：映射配置文件的位置 -->
        <mapping class="com.wgy.domain.Customer"/>
    </session-factory>
</hibernate-configuration>

实体类和映射配置

/**
 * 客户的实体类
 *
 * @author wgy
 */
@Entity
@Table(name = "cst_customer")
public class Customer implements Serializable {

    @Id
    @Column(name = "cust_id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long custId;

    @Column(name = "cust_name")
    private String custName;

    @Column(name = "cust_source")
    private String custSource;

    @Column(name = "cust_industry")
    private String custIndustry;

    @Column(name = "cust_level")
    private String custLevel;

    @Column(name = "cust_address")
    private String custAddress;

    @Column(name = "cust_phone")
    private String custPhone;
    ...
}

4.2 第二步：搭建struts2环境

参考2.1.3章节的步骤去做。

4.3 第三步：导入crm的jsp页面

把下图中红框内文件夹下所有内容都拷贝到WebContent目录中

<TR> 
    <TD class=menuSmall>
        <A class=style2 href="${pageContext.request.contextPath}/customer/findAllCustomer.action" target=main>－ 客户列表</A>
    </TD>
</TR>

4.5 第五步：在配置文件中配置findAllCustomer.action

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
        "http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
    <!-- 开启开发者模式 -->
    <constant name="struts.devMode" value="true"></constant>
    <!--  动作配置 -->
    <package name="customer" extends="struts-default" namespace="/customer">
        <action name="findAllCustomer" class="com.wgy.web.action.CustomerAction" method="findAllCustomer">
            <result name="findAllCustomer">/jsp/customer/list.jsp</result>
        </action>
    </package>
</struts>

4.6 第六步：创建动作类并提供动作方法

/**
 * 客户的动作类
 *
 * @author wgy
 */
public class CustomerAction extends ActionSupport {

    private ICustomerService customerService = new CustomerServiceImpl();

    /**
     * 查询所有客户
     * @return
     */
    public String findAllCustomer(){
        //1.调用service查询客户
        List<Customer> customers = customerService.findAllCustomer();
        //2.获取request对象
        HttpServletRequest request = ServletActionContext.getRequest();
        //3.把查询的结果存入请求域中
        request.setAttribute("customers", customers);
        //4.返回
        return "findAllCustomer";
    }
}

4.7 第七步：编写service接口和实现类

/**
 * 客户的业务层接口
 *
 * @author wgy
 */
public interface ICustomerService {

    /**
     * 查询所有客户
     *
     * @return
     */
    List<Customer> findAllCustomer();
}

/**
 * 客户的业务层实现类
 * 事务控制在业务层的
 *
 * @author wgy
 */
public class CustomerServiceImpl implements ICustomerService {

    private ICustomerDao customerDao = new CustomerDaoImpl();

    @Override
    public List<Customer> findAllCustomer() {
        Session s = null;
        Transaction tx = null;
        try{
            //1.获取Session
            s = HibernateUtil.getCurrentSession();
            //2.开启事务
            tx = s.beginTransaction();
            //3.执行操作
            List<Customer> customers = customerDao.findAllCustomer();
            //4.提交事务
            tx.commit();
            //5.返回结果
            return customers;
        }catch(Exception e){
            //回滚事务
            tx.rollback();
            throw new RuntimeException(e);
        }
    }
}

4.8 第八步：编写dao接口和实现类

/**
 * 客户的持久层接口
 *
 * @author wgy
 */
public interface ICustomerDao {

    /**
     * 查询所有客户
     *
     * @return
     */
    List<Customer> findAllCustomer();
}

/**
 * 客户的持久层实现类
 *
 * @author wgy
 */
public class CustomerDaoImpl implements ICustomerDao {

    @Override
    public List<Customer> findAllCustomer() {
        return HibernateUtil.getCurrentSession().createQuery("from Customer").list();
    }
}

4.9 第九步：页面展示jsp/customer/list.jsp

<c:forEach items="${customers}" var="customer">
    <TR>
        <TD>${customer.custName }</TD>
        <TD>${customer.custLevel }</TD>
        <TD>${customer.custSource }</TD>
        <TD>${customer.custIndustry }</TD>
        <TD>${customer.custAddress }</TD>
        <TD>${customer.custPhone }</TD>
    </TR>	
</c:forEach>

-------------本文结束感谢您的阅读-------------

本文作者： Wgy
本文标题： Struts2(一)
本文链接： https://wgy1993.gitee.io/archives/90bb5282.html
版权声明： 本作品采用 CC BY-NC-SA 4.0 进行许可。转载请注明出处！