我想要学会struts,就要从本质原理理解struts框架的内涵。要想了解struts的内涵,首先就要了解mvc是怎么回事。
Model:模型表示应用程序的状态和业务逻辑的处理,在一般的web应用中,用JavaBean或者EJB来实现系统的业务逻辑,在Struts框架中,模型层也是用JavaBean或者EJB实现。
View:JSP页面。
Controller:Struts中主要的控制器是ActionServlet,它处客户端发送过来的所有请求。当ActionServlet接收到来自浏览器的请求应用以后,会根据struts-config.xml这个配置文件需找匹配的URL,然后把用户的请求发送到合适的控制器中。
Struts框架就是通过控制器ActionServlet完成模型层和业务逻辑层的分离,从而降低了web应用程序的耦合度,实现了MVC的经典架构。
关于struts:
struts2 与 struts1的不同之处之一,struts1是通过servlet启动的,struts2是通过filter启动的。
搭建struts环境:
1导包
2struts配置文件
3在web.xml中添加struts启动配置
struts的作用就是将jsp页面与action的java代码相联系。
下面两段代码的作用就是访问指定路径后,访问特定的action,通过action给出代码的内在逻辑,链接<result>
</result>中的jsp页面。
namespace是命名空间,可以避免重复书写相同的路径。
struts.xml:
<struts>
<package name="itcast" namespace="/test" extends="struts-default">
<action name="helloworld" class="cn.itcast.action.HelloWorldAction" method="execute" >
<result name="success">/WEB-INF/page/hello.jsp</result>
</action>
</package>
</struts>
action:
package cn.itcast.action;
public class HelloWorldAction {
private String msg;
public String getMessage() {
return msg;
}
public String execute(){
msg = "第一个struts2应用";
return "success";
}
}
struts2之Action名称的搜索顺序
1.获得请求路径的URI,例如url是:http://server/struts2/path1/path2/path3/test.action
2.首先寻找namespace为/path1/path2/path3的package,如果存在这个package,则在这个package中寻找名字为test的action,如果不存在这个package则转步骤3;
3.寻找namespace为/path1/path2的package,如果存在这个package,则在这个package中寻找名字为test的action,如果不存在这个package,则转步骤4;
4.寻找namespace为/path1的package,如果存在这个package,则在这个package中寻找名字为test的action,如果仍然不存在这个package,就去默认的namaspace的package下面去找名字为test的action,如果还是找不到,页面提示找不到action。
Action配置中的各项默认值
1>如果没有为action指定class,默认值是ActionSupport
2>如果没有为action指定method,默认执行action中的execute()方法
3>如果没有指定result的name属性,默认值为success
action中result各种转发类型,result类似于struts1中的forward
<result>/WEB-INF/page/employeeAdd.jsp</result>
<result type="redirect">/index.jsp</result>
//同一个包下的
<result type="redirectAction">actionname</result>
//不同包下的
<result type="redirectAction">
<param name="actionName">XXX</param>
<param name="namespace" >XXX</param>
</result>
<result type="plainText">/index.jsp</result>
//指定编码
<result type="plainText">
<param name="location">/index.jsp</param>
<param name="charSet">UTF-8</param>
</result>
5,<global-results> 全局视图
//为了能让所有的包,都可以使用该视图
<package name="base" extends="struts-default">
<global-results >
<result name="message">/WEB-INF/page/message.jsp</result>
</global-results>
</package>
//然后其他包继承该包就可以了
6,为action注入属性值
<action name="helloworld" class="cn.itcast.action.HelloWorldAction" method="execute" >
<param name="savepath">/image</param>
<result name="success">/WEB-INF/page/MyJsp.jsp</result>
</action>
【Struts2】为Action的属性注入值
public class HelloWorldAction {
private String savePath;
public String getSavePath() {
return savePath;
}
public void setSavePath(String savePath) {
this.savePath = savePath;
}
}
<package name="test" namespace="/test" extends="struts-default">
<action name="helloworld" class="com.ljq.action.HelloWorldAction" >
<!-- 为Action的属性注入值 -->
<param name="savePath">/images</param>
<result name="success">/WEB-INF/page/hello.jsp</result>
</action>
</package>
上面通过<param>节点为action的savePath属性注入“/images”
指定需要struts2处理的请求后缀
<constant name="struts.action.extension" value="do"/>
<constant name="struts.action.extension" value="do,action"/>
<!-- 指定Web应用的默认编码集,相当于调用HttpServletRequest的setCharacterEncoding方法 -->
<constant name="struts.i18n.encoding" value="UTF-8" />
<!- 国际化-把资源文件定为全局变量 baseName为名字-->
<constant name="struts.custom.i18n.resources" value="baseName" />
<!--该属性指定需要Struts 2处理的请求后缀,该属性的默认值是action,即所有匹配*.action的请求都由Struts2处理。 如果用户需要指定多个请求后缀,则多个后缀之间以英文逗号(,)隔开-->
<constant name="struts.action.extension" value="do,action,htm,html,jsp" />
<!-- 设置浏览器是否缓存静态内容,默认值为true(生产环境下使用),开发阶段最好关闭 -->
<constant name="struts.serve.static.browserCache" value="false" />
<!-- 当struts的配置文件修改后,系统是否自动重新加载该文件,默认值为false(生产环境下使用),开发阶段最好打开-->
<constant name="struts.configuration.xml.reload" value="true" />
<!-- 开发模式下使用,这样可以打印出更详细的错误信息 -->
<constant name="struts.devMode" value="true" />
<!-- 默认的视图主题 -->
<constant name="struts.ui.theme" value="simple" />
<!-- spring 托管 -->
<constant name="struts.objectFactory" value="spring" />
<!--指定加载struts2配置文件管理器,默认为org.apache.struts2.config.DefaultConfiguration
开发者可以自定义配置文件管理器,该类要实现Configuration接口,可以自动加载struts2配置文件-->
<constant name="struts.configuration" value="org.apache.struts2.config.DefaultConfiguration" />
<!-- 设置默认的locale和字符编码 -->
<constant name="struts.locale" value="zh_CN" />
<constant name="struts.i18n.encoding" value="GBK" />
<!--指定spring框架的装配模式,装配方式有: name, type, auto, and constructor (name是默认装配模式)>
<constant name="struts.objectFactory.spring.autoWire" value="name" />
<!-- 该属性指定整合spring时,是否对bean进行缓存,值为true or false,默认为true -->
<cosntant name="struts.objectFactory.spring.useClassCache" value="true"/>
<!-- 指定类型检查,包含tiger和notiger -->
<cosntant name="struts.objectTypeDeterminer" value="tiger" />
<!-- 该属性指定处理 MIME-type multipart/form-data,文件上传 -->
<constant name="struts.multipart.parser" value="cos" />
<constant name="struts.multipart.parser" value="pell" />
<constant name="struts.multipart.parser" value="jakarta" />
<!-- 指定上传文件时的临时目录,默认使用 javax.servlet.context.tempdir -->
<constant name="struts.multipart.saveDir" value="/tmpuploadfiles" />
<!-- 该属性指定Struts 2文件上传中整个请求内容允许的最大字节数 -->
<constant name="struts.multipart.maxSize" value="2097152" />
<!--该属性指定Struts2应用加载用户自定义的属性文件,该自定义属性文件指定的属性不会覆盖struts.properties文件中指定的属性。如果需要加载多个自定义属性文件,多个自定义属性文
件的文件名以英文逗号(,)隔开。(也就是说不要改写struts.properties!) -->
<constant name="struts.custom.properties"value="application,org/apache/struts2/extension/custom" />
<!-- 指定请求url与action映射器,默认为org.apache.struts2.dispatcher.mapper.DefaultActionMapper ->
<constant name="struts.mapper.class" value="org.apache.struts2.dispatcher.mapper.DefaultActionMapper" />
<!-- 设置是否支持动态方法调用,true为支持,false不支持. -->
<constant name="struts.enable.DynamicMethodInvocation" value="true" />
<!-- 设置是否可以在action中使用斜线,默认为false不可以,想使用需设置为true. -->
<constant name="struts.enable.SlashesInActionNames" value="true" />
<!-- 是否允许使用表达式语法,默认为true. -->
<constant name="struts.tag.altSyntax" value="true" />
<!-- 设置当struts.xml文件改动时,是否重新加载 -->
<cosntant name="struts.configuration.xml.reload" value="true" />
如何为应用指定多个struts配置文件
如何为应用指定多个struts配置文件
在大部分应用里,随着应用规模的增加,
系统中Action的数量也会大量增加,导致struts.xml配置文件变得非常臃肿,
为了避免struts.xml文件过于庞大、臃肿,提高Struts.xml文件的可读性,
我们可以将一个struts.xml配置文件分解成多个配置文件,
然后再struts.xml文件中包含其他配置文件。
通过<include>元素指定多个配置文件
<struts>
<include file="department.xml"/> 一个模块使用一个配置文件
<include file="employee.xml"/>
</struts>
--------------------------------------------------------------------------------------------------------
动态方法调用
使用通配符定义Action即*
<package name="employee" namespace="/control/employee" extends="struts-default">
<action name="list_*" class="cn.itcast.action.HelloWorldAction" method="{1}">
<result name="success">/WEB-INF/page/message.jsp</result>
</action>
</package>
通过通配符动态调用方法
Struts2动态方法调用
动态方法调用
在Struts2中动态方法调用有三种方式,动态方法调用就是为了解决一个Action对应多个请求的处理,以免Action太多
第一种方式:指定method属性
这种方式我们前面已经用到过,类似下面的配置就可以实现
<action name="chainAction" class="chapter2.action.Chapter2Action"
method="chainAction">
<result name="chainAction" type="chain">redirect</result>
</action>
<action name="plainText" class="chapter2.action.Chapter2Action"
method="plainText">
<result name="plainText" type="plainText">/WEB-INF/JspPage/chapter2/plaintext.jsp</result>
</action>
第二种方式:感叹号方式(需要开启),官网不推荐使用这种方式,建议大家不要使用.
用这种方式需要先开启一个开关
<constant name="struts.enable.DynamicMethodInvocation" value="true" />
将此常量设置为true,这种方式才能使用,使用见示例
Action
package chapter3.action;
public class Chapter3Action {
public String result1(){
return "result1";
}
public String result2(){
return "result2";
}
}
Jsp中访问方式
<body>
<a href="
basePath/chapter3/chapter3Action!result1">result1</a><br><ahref="
{basePath}/chapter3/chapter3Action!result2">result2</a><br>
</body>
如果配置了后缀,必须这样写:
/chapter4/chapter4Action!create.action
XML中配置方式
<package name="chapter3" namespace="/chapter3" extends="struts-default">
<action name="chapter3Action" class="chapter3.action.Chapter3Action">
<result name="result1">/WEB-INF/JspPage/chapter3/result1.jsp</result>
<result name="result2">/WEB-INF/JspPage/chapter3/result2.jsp</result>
<result name="chapter3">/WEB-INF/JspPage/chapter3/chapter3.jsp</result>
</action>
</package>
第三种方式:通配符方式(官网推荐使用)
首先得关闭开关
<constant name="struts.enable.DynamicMethodInvocation" value="false" />
这一种方式是由第一种转变过来的,我们可以看到,第一种方式有很多重复的代码,那么我们可以进行变形,看下面的代码
<action name="chapter3_*" class="chapter3.action.Chapter3Action"
method="{1}">
<result name="test">/…/test.jsp</result>
</action>
chapter3_*这里的*就是你呆会要匹配的字符串,即你在后面的请求中得这样写
http://...../ chapter3_create 或 http://...../ chapter3_update
注意,这时你action中必须有create和update方法与之匹配,甚至还可以这样匹配
<action name="chapter3_*" class="chapter3.action.Chapter3Action"
method="{1}">
<result name="test">/…/{1}.jsp</result>
</action>
但是这时一定要有对应的JSP页面存在,并且相应的路径不能错,这就对我们的命名进行了强制性的规定,一定要规范.
课堂示例:
Action
public class Chapter4Action extends ActionSupport {
public String list(){
return "list";
}
public String create(){
return "create";
}
public String index(){
return "index";
}
}
XML:
<action name="chapter4_*" class="chapter4.action.Chapter4Action" method="{1}">
<result name="{1}">/WEB-INF/JspPage/chapter4/chapter4_{1}.jsp</result>
</action>
访问Servlet API
有时我们需要用到Request, Response, Session,Page, ServletContext这些我们以前常用的对象,那么在Struts2中怎么样使用到这些对象呢,通常有三种方式.
间接访问1
//向Session中放
ActionContext.getContext().getSession().put("wdpc", "Session中的WDPC");
//向request中放
ActionContext.getContext().put("wdpc","request中的WDPC");
//向application中放
ActionContext.getContext().getApplication().put("wdpc", "Application中的WDPC");
取值方式:
ActionContext.getContext().getSession().get("wdpc");
间接访问2
Struts2中提供了一个静态类,他里面的方法可以获取到我们的HttpServletResponse, HttpServletRequest, 然后呢就可以还原到我们以前的使用方式了.
直接访问
虽然Struts2提供了ActionContext来访问Servlet API,但是这种方式毕竟不能直接获取Servelt API实例,为了在Action中直接访问Servlet API,Struts2还提供了一系列接口
ServletContextAware 实现此接口后,可以取得ServletContext
ServletRequestAware 实现此接口后,可以取得HttpServletRequest
ServletResponseAware 实现此接口后,可以取得HttpServletResponse
SessionAware 实现此接口后,可以取得HttpSession,注意,这里有点特殊,取得的是一个Map<String,Object> session,拦截器负责将session中存储的键值进行解析,并一一对应.
所以我们通常的做法是:
public class BaseAction implements ServletResponseAware, ServletRequestAware,
SessionAware {
protected HttpServletResponse response;
protected HttpServletRequest request;
protected Map<String, Object> session;
public void setServletResponse(HttpServletResponse response) {
this.response = response;
}
public void setServletRequest(HttpServletRequest request) {
this.request = request;
}
public void setSession(Map<String, Object> session) {
this.session = session;
}
public HttpServletResponse getResponse() {
return response;
}
public void setResponse(HttpServletResponse response) {
this.response = response;
}
public HttpServletRequest getRequest() {
return request;
}
public void setRequest(HttpServletRequest request) {
this.request = request;
}
public Map<String, Object> getSession() {
return session;
}
}
为了让BaseAction能有验证的功能,并且不能被实例化,开发中我们会这样做:
public abstract class BaseAction extends ActionSupport implements
ServletResponseAware, ServletRequestAware, SessionAware
然后让我们每个模块的Action来继承这个BaseAction类,然后我们就可以在Action中直接使用Servelt的API了.
Struts拦截器
1. 理解拦截器
1.1. 什么是拦截器:
拦截器,在AOP(Aspect-Oriented Programming)中用于在某个方法或字段被访问之前,进行拦截然后在之前或之后加入某些操作。拦截是AOP的一种实现策略。
在Webwork的中文文档的解释为——拦截器是动态拦截Action调用的对象。它提供了一种机制可以使开发者可以定义在一个action执行的前后执行的代码,也可以在一个action执行前阻止其执行。同时也是提供了一种可以提取action中可重用的部分的方式。
谈到拦截器,还有一个词大家应该知道——拦截器链(Interceptor Chain,在Struts 2中称为拦截器栈Interceptor Stack)。拦截器链就是将拦截器按一定的顺序联结成一条链。在访问被拦截的方法或字段时,拦截器链中的拦截器就会按其之前定义的顺序被调用。
1.2. 拦截器的实现原理:
大部分时候,拦截器方法都是通过代理的方式来调用的。Struts 2的拦截器实现相对简单。当请求到达Struts 2的ServletDispatcher时,Struts 2会查找配置文件,并根据其配置实例化相对的拦截器对象,然后串成一个列表(list),最后一个一个地调用列表中的拦截器。如下图:
2. 拦截器的配置
Struts 2已经为您提供丰富多样的,功能齐全的拦截器实现。大家可以至struts2的jar包内的struts-default.xml查看关于默认的拦截器与拦截器链的配置。
Struts2(XWork)提供的拦截器的功能说明:
拦截器 | 名字 | 说明 |
Alias Interceptor | alias | 在不同请求之间将请求参数在不同名字件转换,请求内容不变 |
Chaining Interceptor | chain | 让前一个Action的属性可以被后一个Action访问,现在和chain类型的result(<result type=”chain”>)结合使用。 |
Checkbox Interceptor | checkbox | 添加了checkbox自动处理代码,将没有选中的checkbox的内容设定为false,而html默认情况下不提交没有选中的checkbox。 |
Cookies Interceptor | cookies | 使用配置的name,value来是指cookies |
Conversion Error Interceptor | conversionError | 将错误从ActionContext中添加到Action的属性字段中。 |
Create Session Interceptor | createSession | 自动的创建HttpSession,用来为需要使用到HttpSession的拦截器服务。 |
Debugging Interceptor | debugging | 提供不同的调试用的页面来展现内部的数据状况。 |
Execute and Wait Interceptor | execAndWait | 在后台执行Action,同时将用户带到一个中间的等待页面。 |
Exception Interceptor | exception | 将异常定位到一个画面 |
File Upload Interceptor | fileUpload | 提供文件上传功能 |
I18n Interceptor | i18n | 记录用户选择的locale |
Logger Interceptor | logger | 输出Action的名字 |
Message Store Interceptor | store | 存储或者访问实现ValidationAware接口的Action类出现的消息,错误,字段错误等。 |
Model Driven Interceptor | model-driven | 如果一个类实现了ModelDriven,将getModel得到的结果放在Value Stack中。 |
Scoped Model Driven | scoped-model-driven | 如果一个Action实现了ScopedModelDriven,则这个拦截器会从相应的Scope中取出model调用Action的setModel方法将其放入Action内部。 |
Parameters Interceptor | params | 将请求中的参数设置到Action中去。 |
Prepare Interceptor | prepare | 如果Acton实现了Preparable,则该拦截器调用Action类的prepare方法。 |
Scope Interceptor | scope | 将Action状态存入session和application的简单方法。 |
Servlet Config Interceptor | servletConfig | 提供访问HttpServletRequest和HttpServletResponse的方法,以Map的方式访问。 |
Static Parameters Interceptor | staticParams | 从struts.xml文件中将<action>中的<param>中的内容设置到对应的Action中。 |
Roles Interceptor | roles | 确定用户是否具有JAAS指定的Role,否则不予执行。 |
Timer Interceptor | timer | 输出Action执行的时间 |
Token Interceptor | token | 通过Token来避免双击 |
Token Session Interceptor | tokenSession | 和Token Interceptor一样,不过双击的时候把请求的数据存储在Session中 |
Validation Interceptor | validation | 使用action-validation.xml文件中定义的内容校验提交的数据。 |
Workflow Interceptor | workflow | 调用Action的validate方法,一旦有错误返回,重新定位到INPUT画面 |
Parameter Filter Interceptor | N/A | 从参数列表中删除不必要的参数 |
Profiling Interceptor | profiling | 通过参数激活profile |
在struts.xml文件中定义拦截器,拦截器栈:
<package name="my" extends="struts-default" namespace="/manage"> <interceptors> <!-- 定义拦截器 --> <interceptor name="拦截器名" class="拦截器实现类"/> <!-- 定义拦截器栈 --> <interceptor-stack name="拦截器栈名"> <interceptor-ref name="拦截器一"/> <interceptor-ref name="拦截器二"/> </interceptor-stack> </interceptors> ...... </package> |
3. 使用拦截器
一旦定义了拦截器和拦截器栈后,就可以使用这个拦截器或拦截器栈来拦截Action了。拦截器的拦截行为将会在Action的exceute方法执行之前被执行。
<action name="userOpt" class="org.qiujy.web.struts2.action.UserAction"> <result name="success">/success.jsp</result> <result name="error">/error.jsp</result> <!-- 使用拦截器,一般配置在result之后, --> <!-- 引用系统默认的拦截器 --> <interceptor-ref name="defaultStack"/> <interceptor-ref name="拦截器名或拦截器栈名"/> </action> |
此处需要注意的是,如果为Action指定了一个拦截器,则系统默认的拦截器栈将会失去作用。为了继续使用默认拦截器,所以上面配置文件中手动引入了默认拦截器。
4. 自定义拦截器
作为“框架(framework)”,可扩展性是不可或缺的。虽然,Struts 2为我们提供如此丰富的拦截器实现,但是这并不意味我们失去创建自定义拦截器的能力,恰恰相反,在Struts 2自定义拦截器是相当容易的一件事。
4.1. 实现拦截器类:
所有的Struts 2的拦截器都直接或间接实现接口com.opensymphony.xwork2.interceptor.Interceptor。该接口提供了三个方法:
1) void init(); 在该拦截器被初始化之后,在该拦截器执行拦截之前,系统回调该方法。对于每个拦截器而言,此方法只执行一次。
2) void destroy();该方法跟init()方法对应。在拦截器实例被销毁之前,系统将回调该方法。
3) String intercept(ActionInvocation invocation) throws Exception; 该方法是用户需要实现的拦截动作。该方法会返回一个字符串作为逻辑视图。
除此之外,继承类com.opensymphony.xwork2.interceptor.AbstractInterceptor是更简单的一种实现拦截器类的方式,因为此类提供了init()和destroy()方法的空实现,这样我们只需要实现intercept方法。
4.2. 使用自定义拦截器:
两个步骤:
l 通过<interceptor …>元素来定义拦截器。
l 通过<interceptor-ref …>元素来使用拦截器。
5. 自定义拦截器示例
5.1. 问题描述:
使用自定义拦截器来完成用户权限的控制:当浏览者需要请求执行某个操作时,应用需要先检查浏览者是否登录,以及是否有足够的权限来执行该操作。
5.2. 实现权限控制拦截器类:
AuthorizationInterceptor.java
package org.qiujy.common;
import java.util.Map;
import com.opensymphony.xwork2.Action; import com.opensymphony.xwork2.ActionInvocation; import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
/** * 权限检查拦截器 * * @author qiujy * @version 1.0 */ public class AuthorizationInterceptor extends AbstractInterceptor {
/* * 拦截Action处理的拦截方法 * */ public String intercept(ActionInvocation invocation) throws Exception {
Map session = invocation.getInvocationContext().getSession(); String userName = (String) session.get("userName");
if (null != userName && userName.equals("test")) { System.out.println("拦截器:合法用户登录---"); return invocation.invoke(); } else { System.out.println("拦截器:用户未登录---"); return Action.LOGIN; } } } |
5.3. 配置权限控制拦截器:
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="my" extends="struts-default">
<interceptors> <!-- 定义权限控制拦截器 --> <interceptor name="authority" class="org.qiujy.common.AuthorizationInterceptor"/> </interceptors>
<!-- 定义全局处理结果 --> <global-results> <!-- 逻辑名为login的结果,映射到/login.jsp页面 --> <result name="login">/login.jsp</result> </global-results>
<action name="listall" class="org.qiujy.web.struts2.action.UserAction" method="listAllUser"> <result name="success">/listall.jsp</result> <!-- 使用拦截器 --> <interceptor-ref name="defaultStack"/> <interceptor-ref name="authority"/> </action>
<action name="userOpt" class="org.qiujy.web.struts2.action.UserAction"> <result name="success">/success.jsp</result> </action> </package> </struts> |
其它页面见源代码。
5.4. 运行调试:
在浏览器地址栏直接输入http://localhost:8080/AuthorityInterceptorDemo/listall.action 来访问,此动作配置了权限拦截器,所有被转到登录页面。
登录后:
再访问http://localhost:8080/AuthorityInterceptorDemo/listall.action 这个链接:
如果为了简化struts.xml文件的配置,避免在每个Action重复配置该拦截器,可以将拦截器配置成了一个默认拦截器栈。如下:
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd"> <struts> <package name="my" extends="struts-default">
<interceptors> <!-- 定义权限控制拦截器 --> <interceptor name="authority" class="org.qiujy.common.AuthorizationInterceptor" /> <!-- 定义一个包含权限控制的拦截器栈 --> <interceptor-stack name="mydefault"> <interceptor-ref name="defaultStack" /> <interceptor-ref name="authority" /> </interceptor-stack> </interceptors>
<!-- 定义默认拦截器 --> <default-interceptor-ref name="mydefault" />
<!-- 定义全局处理结果 --> <global-results> <!-- 逻辑名为login的结果,映射到/login.jsp页面 --> <result name="login">/login.jsp</result> </global-results>
<action name="listall" class="org.qiujy.web.struts2.action.UserAction" method="listAllUser"> <result name="success">/listall.jsp</result> </action> </package>
<package name="font" extends="struts-default"> <action name="userOpt" class="org.qiujy.web.struts2.action.UserAction"> <result name="success">/success.jsp</result> </action> </package> </struts> |
一旦在某个包下定义了默认拦截器栈,在该包下的所有action都会使用此拦截器栈。对于那些不想使用些拦截器栈的action,则应该将它放置在其它的包下。
对action的所有方法进行校验或者对action的
指定方法进行校验
- 在struts2中,我们可以实现。
- 对于输入校验struts2提供了两种实现方法:
- 1. 采用手工编写代码实现。
- 2. 基于XML配置方式实现。
- 方法一实例:
- index.jsp
- <%@ page language="java" contentType="text/html; charset=UTF-8"
- pageEncoding="UTF-8"%>
- <%@ taglib uri="/struts-tags" prefix="s" %>
- <!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>
- <!-- 用于显示错误信息 -->
- <s:fielderror/>
- <form action="${pageContext.request.contextPath }/test/helloword.do
- " method="post">
- 用户名:<input type="text" name="username"/><br/>
- 手机号:<input type="text" name="mobile"/><br/>
- <input type="submit" value="提交"/>
- </form>
- </body>
- </html>
- struts.xml文件
- <action name="helloword" class="cn.itcast.action.HelloWordAction" method="save">
- <result name="input">/index.jsp</result>
- <result name="success">/WEB-INF/page/message.jsp</result>
- </action>
- HelloWord.java
- 定义两个属性
- private String username;
- private String mobile;
- 在此省略以上两个属性的set和get方法
- public String update(){
- ActionContext.getContext().put("message", "更新成功");
- return "success";
- }
- public String save(){
- ActionContext.getContext().put("message", "保存成功");
- return "success";
- }
- @Override
- public void validate() {//会对action中的所有方法校验
- if(this.username==null || "".equals(username.trim())){
- //添加错误信息
- this.addFieldError("username", "用户名不能为空");
- }
- if(this.mobile==null || "".equals(mobile.trim())){
- this.addFieldError("mobile", "手机号不能为空");
- }else{
- if(!Pattern.compile("^1[358]\\d{9}$").matcher(mobile).matches()){
- this.addFieldError("mobile", "手机号格式不正确");
- }
- }
- }
- message.jsp
- ${message}