web框架习题知识点合集

知识点

struts2

1.Struts2框架应用在javaee三层结构中的web层框架
2.Struts2框架在struts1和webwork基础上发展的全新框架
3.Struts2所解决的问题：
在以往实现一个功能时，都需要些很多的servlet，从而造成后期维护上的不方便

在Struts2中action就相当于以往开发中的Servlet
4.web层常见架构
struts和SrpingMVC

Struts架构入门

1.创建action

public class HelloAction{
public String execute(){
return "ok";
}
}
1.每次访问servlet时，都会执行service方法
2.访问Action，每次访问Action时，默认执行名称为execute的方法

2.配置action类的访问路径
（1）创建struts2核心配置文件，该核心配置文件位置和名称是固定的
（2）引入dtd约束
访问路径：http：//域名/端口号/项目名/action名.action
3.配置Struts2的过滤器

<filter>
 <filter-name>struts2</fileter-name>
  <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
  </filter>
  <filter-mapping>
   <filer-name>struts2</filter-name>
    <url-pattern>*</url-pattern>
  </filter-mapping>

4.Struts2执行过程

struts2配置

struts2的核心配置文件

1.名称和位置是固定的
2.在配置文件中主要有三个标签，package、action、result，以及各个标签内的其他属性

标签package
1.类似于代码包，区别不同的action，要配置action，必须首先写package标签，在package里面才能配置action
2.package标签属性
（1）name属性，那么属性的值跟功能本身没有关系，在一个配置文件中可以写多个package标签，但是name的属性值不能相同
（2）extends属性，该属性值是固定的，在package里面配置的类具有action功能
（3）namespace属性，该属性值和action标签里面的name属性值构成访问路径。

标签action
1.action标签配置action访问路径
2.action标签属性
（1）name属性
namespace属性值和action标签里面的name属性值构成访问路径。在package标签里面可以写多个action标签，但是action的属性name值不能够相同
（2）class属性
action的全路径，即包名+类名
（3）method属性
比如在action里面默认执行的方法是execute方法，但在里面写其他方法，让action里面多个方法执行，使用method进行配置

标签result
1.根据方法的返回值，配置到不同的路径下
2.result标签属性
（1）name属性
和action中的method所调用的方法返回值一样
（2）type属性
配置如何到路径中（转发、重定向），该属性值的默认是做转发操作

标签constant
1.是一种常量标签
2.修改Struts2的默认常量值
（1）常用方法
在struts.xml中进行配置
< constant name=“struts.i18n.encoding” value=“utf-8”>< /constant >
（2）其他的两种方法
1.在src下面创建struts.properties文件并修改
2.在web.xml中进行修改
（3）Struts2最常用的常量
struts.il8n.encoding=UTF-8，解决表单在通过post方式提交中文时，中文乱码的问题

分模块开发
1.单独写配置文件，把配置文件引入到核心配置文件中，从而解决多人操作一个核心文件的问题
2.配置用法
在.xml文件中加入< include file=“文件路径”></ include>即可

Action的编写方式
action有三种编写方式
第一种 创建普通类，这个不继承任何类，不实现任何接口
第二种 创建类 实现Action接口，实现execute方法
第三种 创建类 继承ActionSupport

访问action的方法
第一种 使用action标签的method属性，在这个属性里写要执行的action方法
第二种 使用通配符实现（提高代码复用性）
第三种 动态访问实现

结果页面的配置（result标签）

1.作用：result标签配置action方法的返回值到不同的路径里
2.全局页面的使用：当在result标签中返回的值和路径是一致的时候，就可以使用全局页面。
（1）配置方法：
在package标签下配置

<global-results>
 <result name="success">/ hello.jsp</ result>
 </global-results>

（2）注意：该标签只能在一个package标签中使用，如果有多个标签，需要重新定义。
3.局部结果页面：指的就是在action标签里配置
（1）配置方法：
在action标签下配置

<action name="book" class="cn.itcast.action.BookAction">
 <result name=“success”>/ hello.jsp </result>
 </action>

(2)注意：如果改变了全局，又配置了局部，会以局部为准，全局不起作用
4.type属性
（1）作用：如何到路径里面（即定义转发还是重定向）
（2）属性值：
1.默认值：dispatcher，一般没有写就是转发操作，浏览器地址栏不会变
2.重定向：redirect，浏览器地址栏会改变
3.chain：转发到action，一般不使用，因为有缓存
4.redirectAction：重定向到action

2.使用Action获取表单提交的数据
1.action获取表单数据的三种主要方式
（1）使用actioncontext类。
【1】主要使用方法：

Map <String,(Object> getParameters()
返回一个包含所有HttpServl

因为该方法是对象方法，所以需要一个ActionContext对象来调用，因而创建ActionContext对象可以使用该类的一个静态方法来创造。

static ActionContext getContext()
获取当前线程的ActionConText对象

（2）使用ServletAction类。
1.主要使用方法：

static HttpServletRequest getRequest():
获取Web应用的HttpServletRequest对象
static HttpServeletResponse getResponse()：
获取web应用的HttpServeletResponse对象
static ServletContext getServletContext（）:
获取web应用的ServletContext()：
static PageContext getPageContext（）:
获取web应用的PageContext对象

3.在Action中的操作对象
（1）在servlet中的三个域对象
request、session、servletContext
（2）操作的三个域对象
1.request对象
使用ServletActionContext类的静态方法getRequest(),得到该对象。
2.session对象
先使用ServletActionContext类的静态方法getRequest(),得到request对象，在通过request对象获取到该对象。
3.servletContext
同二

4.使用Struts2封装获取表单数据
（1）属性封装
【1】步骤
{1}在类里定义私有成员变量，变量名必须和表单中的name的值一致
{2}使用get和set方法进行封装即可
【2】缺点：不能把数据直接封装到实体类的对象里面

（2）模型驱动封装
【1】操作：可以直接把表单数据封装到实体类对象里面
【2】操作步骤：
{1}action实现接口ModelDriven
{2}实现该接口的getModel方法
{3}在action里面创建实体类对象
{4}注意：表单输入项name的属性值和实体类属性名要一致

(3)表达式封装
【1】作用：可以把表单数据封装到实体类对象里面
【2】步骤
{1}在action类里面声明实体类
{2}生成实体类变量的get和set方法
{3}在表单输入项的name属性值里面写表达式形式的数据
【3】优点：可以把数据封装到不同的实体类对象里面

5.表单数据封装到集合里面
【1】封装数据到List集合
{1}操作步骤
在action中声明List集合
生成该集合变量的get和set方法
在表单输入项的name属性里写表达式

【2】封装数据到Map集合
操作步骤
1.在action中声明Map集合
2.生成该集合变量的get和set方法
3.在表单输入项的name属性里写表达式

Struts2拦截器

1.概述
拦截器就是Struts2框架中封装的功能容器。在Struts2框架中有很多功能，所以就有很多的拦截器，并不是每次执行所有的拦截器，它只会执行一些默认的拦截器
2.拦截器的执行时间
在Action对象创建之后，action方法执行之前
3.拦截器的原理
（1）AOP思想：即面向切面编程，当在基本的功能上扩展其他功能时，不通过改源代码来实现扩展功能的方式
（2）责任链模式
概念：属于java设计模式的一种，和过滤链原理类似
过滤链：一个请求可以有多个过滤器进行过滤，只有每个过滤器执行放行操作，该请求才能到下一个过滤器
（3）AOP原理和责任链模式如何运用到拦截器
在Action中并没有执行拦截器的方法，而是用配置文件实现的
在进入拦截器的过程中，只有每个拦截器执行放行操作后才能进入到下一个拦截器
4.拦截器和过滤器的区别
过滤器理论上可以过滤任何内容，如html，jsp，servlet，图片路径等
拦截器只能拦截action
5.自定义拦截器
（1）拦截器的结构

继承类
class modelDrivenInterceptor extends AbstractInterceptor
class AbstractInterceptor implements Interceptor
在接口内的三个抽象方法
void init();初始化操作
void destroy();销毁
String intercept(ActionInvocation invocation):拦截逻辑操作

（2）自定义拦截器方法
1.写一个类继承MethodFilterceptor类
2.通过编写配置文件的方式让拦截器和Action产生关系
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>
   <constant name="struts.devMode" value="true" />
   <package name="helloworld" extends="struts-default">
      <action name="hello" 
         class="cn.w3cschool.struts2.HelloWorldAction"
         method="execute">
         <interceptor-ref name="params"/>
         <interceptor-ref name="timer" />
         <result name="success">/HelloWorld.jsp</result>
      </action>
   </package>
</struts>

执行定义的action。如果你去查看生成的日志，会看到以下文本

INFO: Server startup in 3539 ms
27/08/2011 8:40:53 PM 
com.opensymphony.xwork2.util.logging.commons.CommonsLogger info
INFO: Executed action [//hello!execute] took 109 ms.

这里的最后一行是由timer拦截器生成的，是表示ation总共需要109ms来执行。

自定义拦截器

在你的应用程序中使用自定义拦截器是提供跨切割应用程序功能的简洁方式。创建自定义拦截器很容易，需要扩展的是以下Interceptor接口：

public interface Interceptor extends Serializable{
   void destroy();
   void init();
   String intercept(ActionInvocation invocation)
   throws Exception;
}

init()方法提供了一种初始化拦截器的方法，而destroy()方法为拦截器清理提供了一个工具。与action不同，拦截器在请求之间重复使用，需要线程安全，特别是intercept()方法。
ActionInvocation对象可访问运行时的环境。它允许访问action本身以及方法来调用action，并确定action是否已被调用。
如果你不需要初始化或清理代码，可以扩展AbstractInterceptor类，以实现init()和destroy()的默认的无操作指令。

创建拦截器

package cn.w3cschool.struts2;

import java.util.*;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;

public class MyInterceptor extends AbstractInterceptor {

   public String intercept(ActionInvocation invocation)throws Exception{

      /* let us do some pre-processing */
      String output = "Pre-Processing"; 
      System.out.println(output);

      /* let us call action or next interceptor */
      String result = invocation.invoke();

      /* let us do some post-processing */
      output = "Post-Processing"; 
      System.out.println(output);

      return result;
   }
}

你可以发现，实际中action将通过拦截器使用invocation.invoke()调用执行，所以你可以根据你的需求做一些预处理和一些后处理。
框架本身通过第一次调用ActionInvocation对象的invoke()来启动进程。每次调用invoke()时，ActionInvocation都会查询其状态，并执行下一个拦截器。当所有配置的拦截器都被调用时，invoke()将使得action本身被执行。以下图表通过请求流显示了所说的概念：

然后在Struts.xml中package中注册，在action中使用

 <interceptors>
         <interceptor name="myinterceptor"
            class="cn.w3cschool.struts2.MyInterceptor" />
      </interceptors>
//注册
      <interceptor-ref name="params"/>
         <interceptor-ref name="myinterceptor" />
        //使用

结果可以在生成日志上看到：

Pre-Processing
Inside action....
Post-Processing

习题

请编写一个拦截器，该拦截器可以获取用户输入的用户名这个数据，业务逻辑为逐个判断用户名中是否包含”你“、“我”、“他”三个数据，如果包含则直接返回输入页面，如果不包含则运行至PersonAction
答案：
拦截器类：

import java.util.*;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;

public class PersonInterceptor extends AbstractInterceptor {

   public String intercept(ActionInvocation invocation)throws Exception{

      ActionContext ac = invocation.getInvocationContext();
      Map parameters = ac.getParameters();
      String[] params=(String[] )parameters.get("username");
      String username=params[0];
      if(username.contains("你"))||username.contains("我")||username.contain("他")){
      return "index";
      }
     else
     {
     PersonAction action = (PersonAction)invocation.getAction();
     action.setUsername(username);
     return invocation.invoke();
     }
   }
}

Struts.xml

<?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>
   <constant name="struts.devMode" value="true" />
   <package name="helloworld" extends="struts-default">

      <interceptors>
         <interceptor name="personIcpt"
            class="cn.w3cschool.struts2.PersonInterceptor" />
      </interceptors>

      <action name="person" 
         class="cn.w3cschool.struts2.PersonAction" 
         method="execute">
         <interceptor-ref name="params"/>
         <interceptor-ref name="myinterceptor" />
         <result name="success">/success.jsp</result>
      </action>

   </package>
</struts>

Hibernate

概述

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。
Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用。
最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。

1.Hibernate 是一个优秀的Java 持久化层解决方案
2.Hibernate是当今主流的对象—关系映射工具
3.Hibernate 简化了JDBC 繁琐的编码
4.Hibernate 将数据库的连接信息都存放在配置文件中

作用：
Hibernate框架作为一个ORM的具体实现，是Java应用和关系数据库之间的桥梁，主要用来实现Java对象持久化操作，在Java应用中使用Hibernate主要有以下几个步骤：
（1）创建持久化类；
（2）创建对象-关系映射文件；
（3）创建Hibernate配置文件；
（4）使用Hibernate API编写访问数据库的业务逻辑代码。

核心组件

SessionFactory：单个数据库映射关系经过编译后的内存镜像。
Session：它是应用程序和持久存储层之间交互操作的一个单线程对象
瞬态对象：系统进行new关键字进行创建的Java 实例，没有Session 相关联，此时处于瞬态
持久化对象：如果PO 实例与Session实例关联起来，且该实例关联到数据库的记录
脱管对象：如果PO实例曾经与Session实例关联过，但是因为Session的关闭等原因，PO实例脱离了Session 的管理

事务(Transaction)
代表一次原子操作，它具有数据库事务的概念
但它通过抽象，将应用程序从底层的具体的JDBC、JTA和CORBA事务中隔离开。
一个Session 之内可能包含多个Transaction对象。
所有的持久化操作都应该在事务管理下进行，即使是只读操作。
连接提供者(ConnectionProvider)
生成JDBC的连接的工厂，同时具备连接池的作用
他通过抽象将底层的DataSource和DriverManager隔离开。这个对象仅在应用程序需要扩展时使用。
事务工厂(TransactionFactory)：生成Transaction对象实例的工厂

从流程图中可以看出，Hibernate的执行过程如下：
（1）配置好hibernate的配置文件和与类对应的配置文件后，启动服务器。
（2）服务器通过实例化Configeration对象，读取cfg.xml文件的配置内容，并根据相关的需求建好表或者和表建立好映射关系。
（3）通过实例化的Configeration对象创建一个sessionFactory实例。
（4）通过sessionFactory实例可以创建session对象。
（5）得到session之后，便可以开始一个事务，然后就可以通过Session接口提供的各种方法操纵对数据库的访问。除了比较复杂的全文搜索外，简单的操作都可以通过hibernate封装好的session内置方法来实现。
（6）操作完成后，提交数据库操作结果，关闭Session连接。

SessionFactory对象
SessionFactroy接口负责初始化Hibernate。它充当数据存储源的代理，并负责创建Session对象。可以通过Configuration实例构建SessionFactory对象。
SessionFactory是生成Session的工厂;当客户端发送一个请求线程时，SessionFactory生成一个Session 对象来处理客户请求。
SessionFactory在应用初始化时被创建，是一个重量级的类，它在多个应用线程间进行被共享，通常情况下，整个应用只有唯一的一个会话工厂，然而，如果你使用Hibernate访问多个数据库，你需要对每一个数据库使用一个会话工厂。
SessionFactory是线程安全的，可以被多个线程调用。
Configuration cfg=new Configuration().configure();
SessionFactory sf=cfg.buildSessionFactory();

Session 对象
Session对象是Hibernate技术的核心，持久化对象的生命周期、事务的管理和持久化对象的查询、更新和删除都是通过Session对象来完成的。
Session 是应用程序与数据库之间交互操作的一个单线程对象，是 Hibernate 运作的中心，所有持久化对象必须在 session 的管理下才可以进行持久化操作。此对象的生命周期很短
Hibernate在操作数据库之前必须先取得Session对象，相当于JDBC在操作数据库之前必须先取得Connection对象一样
Session对象通过SessionFactory对象的getCurrentSession()或者openSession()方法获取 Configuration cfg= new Configuration().configure();
SessionFactory sf= cfg.buildSessionFactory();
Session session=sf.openSession();
一个持久化类从定义上与普通的JavaBean类没有任何区别，但是它与Session关联起来后，就具有了持久化的能力。当然，这种持久化操作是受Session控制的，即通过Session对象装载、保存、创建或查询持久化对象
Session 类方法的用途可分为以下5类：
取得持久化对象的方法： get() load()
持久化对象都得保存，更新和删除：save(),update(),saveOrUpdate(),delete()
开启事务: beginTransaction().
管理 Session 的方法：isOpen(),flush(), clear(), evict(), close()等

Transaction对象
Transaction将应用代码从底层的事务实现中抽象出来——可能是一个JDBC事务或一个JTA事务，这有助于保持Hibernate应用在不同类型的执行环境或容器中的可移植性。
使用Hibernate进行操作时（增、删、改）必须显示的调用Transaction（默认：autoCommit=false）。
Transaction的运行与Session接口相关，可调用Session的beginTransaction()方法生成一个Transanction实例。
Transaction tx = session.beginTransaction();
常用方法:
commit():提交相关联的session实例
rollback():撤销事务操作
wasCommitted():检查事务是否提交

填空题

1.Struts2架构由Struts2和WEBWork架构发展而来
2.Struts2以webwork为核心，采用拦截器的机制来处理用户的请求
3.构建Struts2应用中的最基础的几个类库是struts2-core、 commoms-logging、xwork-core、freamarker、ognl
4.Struts2中的控制器类是一个普通的Class
5.如果要在JSP页面中使用Struts2提供的标签库，首先必须在页面中使用taglib编译指令导入标签库，其中taglib编译指令是==<%taglib uri="/struts-tags" profix=“s”%>==
6.在struts2表单标签中，表单标签为==< s: form>==
7.ActionSupport类实现了Action和Validateable等接口
8.通过控制器类中的validate（）来输入效验错误信息
9.在控制器中一般需要添加相应属性的setter和getter方法
10.控制器需要在web.xml中配置
11.在JSP页面中可以通过Struts2提供的==< s : text>标签来输出国际化信息
12.资源文件的后缀名是Properties==
13.Struts的和核心机制是过滤器
14.在Hibernate中级联操作的属性值none、save-update、all
15.hibernate的会话接口是session接口，它由接口SessionFactory接口创建；hibernate处理事务的接口是Transaction接口；封装HQL的接口是Criteria接口。
16.注入资源的注释是 @resource
17.目前最经典的基于MVC的javaWeb框架技术是Struts2
18.Struts2属于Apache基金会
19.在MVC设计模式中控制器部分是Servelt
20.Struts的业务控制器是Action
21.Struts2的核心配置文件是struts.xml
22.Struts2扩展组件是通过配置文件和Ioc来管理的
23.在struts.xml文件中，能够把其他配置文件包含进来的元素是 < include >
24.在struts.xml配置文件中，对业务控制器进行配置的元素是 < action >

25.在struts.xml配置文件中，配置逻辑视图和物理视图映射关系元素是 < result>
26.在struts2中ACtion接口提供的一个实现类是== actionsupport==
27.在struts2中常用的表达式语言是OGNL
28.加载国际化资源文件时使用的拦截器是I18N
29.加载文件上传时使用的拦截器是fileupdate
30.Struts2架构中的抽象拦截器类是AbstractInterceptor
31.Hibernate 1 版本发布于 2001
32.Hibernate中存放类库的子目录是lib
33.Hibernate中用于加载配置文件的是Configuration
34.HIbernate的默认配置文件是hibernate.cfg.xml
35.Hibernate的Configuration类主要用来加载hibernate.cfg.xml
36.Hibernate中的SessionFactory对象是线程安全的
37.一对一关联关系在Hibernate中的实现方式有两种他们是主键和外键关联
38.一对多关联关系在Hibernate中的实现有单向和双向关联
39.JAVAWEB三大经典框架中用于降低模块之间耦合度的框架是Spring3
40.Spring3的核心部分是IOC
41.依赖注入是DI
42.是Spring3框架中用于切面处理的是AOP
43.通知被切入的对象成为目标
44.影响了目标对对象的行为定义，直接增加目标对象的职责的是引入
45.Struts2是基于MVC设计模式的框架
46.MVC设计模式是IBM公司推出的
47.Struts2框架有两种文件配置格式：struts.xml和Struts.Properties
48.Struts2加载常量的顺序是Struts.xml、struts.properties和web.xml
49.在Struts2框架中，通过包配置来管理Action和拦截器
50.Struts2中Action与Servlet是（非耦合的）ServletActionContext（辅助类）
51.Struts2中直接访问Servlet有IOC和非IOC两种
52.Struts2中提供两种动态方法的调用方式：指定method属性和不指定method方式
53.OGNL有三个参数，分别是表达式、根对象、和上下文环境
54.按标签库提供的功能可将Struts2标签库分为三大类：UI标签、非UI标签、Ajax标签
55.Struts2国际化资源文件的后缀是properties
56.在Struts框架中，拦截器的设计思路来源于AOP（面向切面）
57.Struts2框架中，对用户输入数据的效验分为两种：客户端效验和服务器端效验
58.Hibernate是封装了JDBC和ORM的持久层解决方案
59.Hibernate的配置文件格式有hibernate.cfg.xml和hibernate.properties
60.Hibernate中的映射文格式是==*.hbm.xml和xxx.gbm.xml==
61.Hibernate中的PO对象的三种状态是临时状态、持久化状态和托管状态
62.Hibernate中获取持久化对象的方法主要有get（）方法和load方法（）
63.Hibernate的每一个表对应一个扩展名为hbm.xml的映射文件
64.数据对象之间的关联关系有一对一、一对多和多对多
65.Spring的上下文是一个配置文件
66.Ioc主要组件有Bean、配置文件、BeanFactory接口以及其相关类和ApplicationContext接口及其相关类

编程分析

例子

Action类分析

Actions是Struts2框架的核心，因为它们适用于任何MVC（Model View Controller）框架。 每个URL映射到特定的action，其提供处理来自用户的请求所需的处理逻辑。
但action还有另外两个重要的功能。 首先，action在将数据从请求传递到视图（无论是JSP还是其他类型的结果）方面起着重要作用。 第二，action必须协助框架确定哪个结果应该呈现在响应请求的视图中。

public class HelloWorldAction{
   private String name;

   public String execute() throws Exception {
      return "success";
   }
   //最基础的方法，直接返回success
   public String getName() {
      return name;
   }

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

Struts2 框架将创建一个“HelloWorldAction”类的对象，并调用execute方法来响应用户的动作。你把你的业务逻辑放进execute方法里，最后会返回字符串常量。简单的描述每个URL，你需要实现一个Action类，你也可以用类名直接作为你的动作名，或者如下面内容所示使用 struts.xml 文件映射到其他name上。

如果想使特定用户才能登陆，n我们可以把execute()改为，同时struts要为error设置转跳页面

public String execute() throws Exception {
      if ("xxxx".equals(name))
      {
         return SUCCESS;
      }else{
         return ERROR;  
      }
   }

当你的页面需要多个功能时，你需要创建多个action来满足需求

  class MyAction extends ActionSupport{
    public static String GOOD = SUCCESS;
    public static String BAD = ERROR;
 }

 public class HelloWorld extends ActionSupport{
    ...
    public String execute()
    {
       if ("SECRET".equals(name)) return MyAction.GOOD;
       return MyAction.BAD;
    }
    ...
 }

 public class SomeOtherClass extends ActionSupport{
    ...
    public String execute()
    {
       return MyAction.GOOD;
    }
    ...
 }

注意每一个结果要在struts.xml中进行配置

视图类的分析

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
   pageEncoding="ISO-8859-1"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
   <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Hello World</title>
</head>
<body>
   <h1>Hello World From Struts2</h1>
   <form action="hello">
      <label for="name">Please enter your name</label><br/>
      <input type="text" name="name"/>
      <input type="submit" value="Say Hello"/>
   </form>
</body>
</html>

< form action="hello " >在Struts.xml中设定名字
上面视图文件里定义的hello action将通过struts.xml文件影射到HelloWorldAction类及其execute方法。当用户点击提交按钮时，将使得Struts2框架运行HelloWorldAction类中的execute方法，并基于该方法的返回值，选择一个适当的视图作为响应进行呈现。

<%@ page contentType="text/html; charset=UTF-8" %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<head>
<title>Hello World</title>
</head>
<body>
   Hello World, <s:property value="name"/>
</body>
</html>

Taglib指令告知Servlet容器这个页面将使用Struts2 标签，并且这些标签会被s放在前面。s:property 标签显示Action类“name”属性的值，这个值是使用HelloWorldAction类的 getName() 方法返回的

配置文件

<?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>
<constant name="struts.devMode" value="true" />
   <package name="helloworld" extends="struts-default">
     
      <action name="hello" 
            class="cn.w3cschool.struts2.HelloWorldAction" 
            method="execute">
            <result name="success">/HelloWorld.jsp</result>
      </action>
   </package>
</struts>

< action name=“hello”
class=“cn.w3cschool.struts2.HelloWorldAction”
method=“execute”>
< result name=“success”>/HelloWorld.jsp< /result>
HelloWorldAction.class的execute方法就是当URL /hello.action被调用时运行。如果execute方法返回的结果为“success”，那么我们带用户进入HelloWorld.jsp。