编程杂谈-----struts_编程struts-CSDN博客

我想要学会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

1，dispatcher:默认值 ,内部定向

<result>/WEB-INF/page/employeeAdd.jsp</result>

2，redirect:浏览器重定向（相当于用户直接访问路径）

<result type="redirect">/index.jsp</result>

3, redirectAction 重定向到action
//同一个包下的
<result type="redirectAction">actionname</result>
//不同包下的
<result type="redirectAction">
<param name="actionName">XXX</param>
<param name="namespace" >XXX</param>

</result>

4, plainText:输出视图的代码
<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处理的请求后缀

Struts2常量的具体用法实例

<!- 国际化-把资源文件定为全局变量 baseName为名字-->

<!--指定加载struts2配置文件管理器，默认为org.apache.struts2.config.DefaultConfiguration

开发者可以自定义配置文件管理器，该类要实现Configuration接口，可以自动加载struts2配置文件-->

<!--指定spring框架的装配模式，装配方式有: name, type, auto, and constructor (name是默认装配模式)>

<!--该属性指定Struts2应用加载用户自定义的属性文件，该自定义属性文件指定的属性不会覆盖struts.properties文件中指定的属性。如果需要加载多个自定义属性文件，多个自定义属性文

件的文件名以英文逗号（,）隔开。(也就是说不要改写struts.properties!) -->

<!-- 指定请求url与action映射器，默认为org.apache.struts2.dispatcher.mapper.DefaultActionMapper ->

转载来自http://my.oschina.net/u/260725/blog/101501

如何为应用指定多个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文件中定义拦截器，拦截器栈：

<interceptor-stack name="拦截器栈名">

<interceptor-ref name="拦截器一"/>

<interceptor-ref name="拦截器二"/>

</interceptor-stack>

</interceptors>

......

</package>

3. 使用拦截器

一旦定义了拦截器和拦截器栈后，就可以使用这个拦截器或拦截器栈来拦截Action了。拦截器的拦截行为将会在Action的exceute方法执行之前被执行。

<result name="success">/success.jsp</result>

<result name="error">/error.jsp</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">

</interceptors>

<global-results>

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

</global-results>

<result name="success">/listall.jsp</result>

<interceptor-ref name="defaultStack"/>

<interceptor-ref name="authority"/>

</action>

<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">

<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>

<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>

<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}