BlogJava-sakrua`s java 世界 -文章分类-struts

跟菜鸟学Struts(4)-action

风の使者 — Sun, 18 Nov 2007 05:32:00 GMT

在以前的例子中，我们每一个action都只有一个动作，例如execute函数，那么有没有其它的方法让一个Action有多个动作昵，

当然那些设计者也不是SB，那么我们看看API文档，在包org.apache.struts.actions中我们会发现有很多的Action

org.apache.struts.actions
Interfaces
DownloadAction.StreamInfo
Classes
ActionDispatcher
BaseAction
DispatchAction
DownloadAction
DownloadAction.FileStreamInfo
DownloadAction.ResourceStreamInfo
EventActionDispatcher
EventDispatchAction
ForwardAction
IncludeAction
LocaleAction
LookupDispatchAction
MappingDispatchAction
SwitchAction

我们从字面的意思看上去，好像第三个有的像，那么我们来看看 org.apache.struts.actions.DispatchAction

来看看下面的英文注解：

An abstract Action that dispatches to a public method that is named by the request parameter whose name is specified by the parameter property of the corresponding ActionMapping. This Action is useful for developers who prefer to combine many similar actions into a single Action class, in order to simplify their application design.
To configure the use of this action in your struts-config.xml file, create an entry like this:

which will use the value of the request parameter named "method" to pick the appropriate "execute" method, which must have the same signature (other than method name) of the standard Action.execute method. For example, you might have the following three methods in the same action:

public ActionForward delete(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception
public ActionForward insert(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception
public ActionForward update(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception

and call one of the methods with a URL like this:
http://localhost:8080/myapp/saveSubscription.do?method=update
NOTE - All of the other mapping characteristics of this action must be shared by the various handlers. This places some constraints over what types of handlers may reasonably be packaged into the same DispatchAction subclass.
NOTE - If the value of the request parameter is empty, a method named unspecified is called. The default action is to throw an exception. If the request was cancelled (a html:cancel button was pressed), the custom handler cancelled will be used instead. You can also override the getMethodName method to override the action's default handler selection.
从第一段可以知道，这就是我们所要找的那个它了，

还有这里有一个配置的例子，它的意思就是说，这个Action提供了一个方法让我们跟椐parameter="method" （这里是method）让我们调用Action中的不同的方法，当然这些方法跟我们的execute是一样的只是名字不一样。例如下面：
public ActionForward execute(ActionMapping arg0, ActionForm arg1,
        HttpServletRequest arg2, HttpServletResponse arg3) throws Exception {
    return super.execute(arg0, arg1, arg2, arg3);
}
//跟上面对比一下，是不是一样呢
public ActionForward sayHello(ActionMapping arg0, ActionForm form,
        HttpServletRequest request, HttpServletResponse response) throws Exception {
    response.getWriter().write("Hello ! DidpatchAction");
    response.flushBuffer();
    return null;
}
public ActionForward closeWindow(ActionMapping arg0, ActionForm form,
        HttpServletRequest request, HttpServletResponse response) throws Exception {
    String str ="IE Will Close";
    response.getWriter().write(str);
    response.flushBuffer();
    return null;
好下面我们在以前的例子的基础上完成这次的例子
新建一个struts-config-action.xml文件，下面为文件的内容：

          "-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
          "http://struts.apache.org/dtds/struts-config_1_3.dtd">


                 type="org.action.struts.DidpatchActionTest">



是不是看不习惯呢，没有Action的也没有forward。不过现在我告诉你这是完全可以的
我们把这个配置文件加到web.xml文件中

        config
        /WEB-INF/struts-config.xml,/WEB-INF/struts-config-file.xml,/WEB-INF/struts-config-action.xml


以这种目录结构建一个index.jsp文件
下面为jsp的内容：

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib uri="http://struts.apache.org/tags-bean" prefix="bean" %>
<%@ taglib uri="http://struts.apache.org/tags-html" prefix="html" %>
http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
http://www.w3.org/1999/xhtml">

Action Test

sayHello
closeWindow

没有什么好说的。
下面我们建一个Action，当然基类是org.apache.struts.actions.DispatchAction
下面为Action的内容：
package org.action.struts;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.actions.DispatchAction;
public class DidpatchActionTest extends DispatchAction {
    public ActionForward execute(ActionMapping arg0, ActionForm arg1,
            HttpServletRequest arg2, HttpServletResponse arg3) throws Exception {
        return super.execute(arg0, arg1, arg2, arg3);
    }
    //跟上面对比一下，是不是一样呢
    public ActionForward sayHello(ActionMapping arg0, ActionForm form,
            HttpServletRequest request, HttpServletResponse response) throws Exception {
        response.getWriter().write("");
        response.flushBuffer();
        return null;
    }
    public ActionForward closeWindow(ActionMapping arg0, ActionForm form,
            HttpServletRequest request, HttpServletResponse response) throws Exception {
        String str ="IE Will Close";
        response.getWriter().write(str);
        response.flushBuffer();
        return null;
    }
}
我们用response对象来输出页面的内容（这个与jsp的response对象是一样的);
下面为运行的结果

大家看到了没有，http://localhost:8080/Struts_HelloWorld/testAction.do?method=closeWindow
它会跟椐method中的参数来调用不同的函数

跟菜鸟学struts (3) - actionFrom

通常我们在Struts中是使用ActionForm来传送jsp页面的form中提交的数据的，在前面的例子中我们也用到了一个
ActionForm它们都是从org.apache.struts.action.ActionForm中继承来的，那么Struts就行帮我们把提交的数
据自动入到这个Form 中，我们在Action中就可以用form.getXXX()和form.setXXX()来处理数据了，好！下面我
们来做一下这个例子
新建一个文件struts-config-formtest.xml ，下面为文件的内容：

          "-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
          "http://struts.apache.org/dtds/struts-config_1_3.dtd">
























现在我们只要看到这一句就足够了，动态Form我们会在下面讲解

相信朋友们都清楚这个用来做什么的吧，不知道就看看我先前的文章。
下面为NormalForm.java的内容
package org.form.struts.form;
import org.apache.struts.action.ActionForm;
public class NormalForm extends ActionForm {
    private static final long serialVersionUID = -4017195510815090304L;
    private String userName;
    private String passWorld;
    private byte sex;
    private String email;
    private String phoneNum;
    private int age;
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getPassWorld() {
        return passWorld;
    }
    public void setPassWorld(String passWorld) {
        this.passWorld = passWorld;
    }
    public byte getSex() {
        return sex;
    }
    public void setSex(byte sex) {
        this.sex = sex;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public String getPhoneNum() {
        return phoneNum;
    }
    public void setPhoneNum(String phoneNum) {
        this.phoneNum = phoneNum;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
我们可以看到这个只是个从ActionForm派生来的javabean,下面把jsp页面也帖出来

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib uri="http://struts.apache.org/tags-bean" prefix="bean" %>
<%@ taglib uri="http://struts.apache.org/tags-html" prefix="html" %>
http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
http://www.w3.org/1999/xhtml">

请选择你要测试的form


        userName:

        passWorld:

        sex男
        女

        email

        phoneNum

        age

        normalForm submit

        dynaForm submit


这次不会讲它的目录结构，在最后我会放出下载地址
好，我们拉着反struts动态from也讲完再来看运行效果：
动态Form是什么意思呢，好就是让我们不用写上面的javabean面直接在xml配置文件中配置，下面为代码，其实上面也已经把代码帖出来了，下面我再帖一次，请注意高亮部分

          "-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
          "http://struts.apache.org/dtds/struts-config_1_3.dtd">
























我们可以看到form中的所有的内容都在xml文件中写出来了，


看看上面的两行有什么不一样，它们都是用来定义的都有name (相当于javabean中的一个property)
type 不用说了吧就是它的类型，不同的是在第一行中多了一个initial="0" 为什么呢，请记住在基本数据成员是要初始化的
就像局部变量一样。
其实这个东东没什么难度吧，下面讲一个我们初学者都出现的问题，
我们可以先找找这个关键字Cannot retrieve mapping for action 了解一下
下面我们进入正题吧：
web.xml的内容

    action
    org.apache.struts.action.ActionServlet

        config
        /WEB-INF/struts-config.xm


        config/formtest
        /WEB-INF/struts-config-formtest.xml

    1

我们可以看到这里有两个模块，问题就在这里了，（如果不清楚struts多个配置文件的使用可以看我另一个文章）
在配置文件中你们可以看到我们多了模块，在直接访问jsp文件时，struts只会在默认的模块中找Action所以我们只能
通过一个Action来做连接（好不爽啊）。
下面帖运行效果出来：

下面这个是找不到Action的效果



下载地址
Click to view this file

风の使者 2007-11-18 13:32 发表评论

跟菜鸟学struts (3) - actionFrom

风の使者 — Sun, 18 Nov 2007 04:12:00 GMT

通常我们在Struts中是使用ActionForm来传送jsp页面的form中提交的数据的，在前面的例子中我们也用到了一个
ActionForm它们都是从org.apache.struts.action.ActionForm中继承来的，那么Struts就行帮我们把提交的数
据自动入到这个Form 中，我们在Action中就可以用form.getXXX()和form.setXXX()来处理数据了，好！下面我
们来做一下这个例子
新建一个文件struts-config-formtest.xml ，下面为文件的内容：

          "-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
          "http://struts.apache.org/dtds/struts-config_1_3.dtd">
























现在我们只要看到这一句就足够了，动态Form我们会在下面讲解

相信朋友们都清楚这个用来做什么的吧，不知道就看看我先前的文章。
下面为NormalForm.java的内容
package org.form.struts.form;
import org.apache.struts.action.ActionForm;
public class NormalForm extends ActionForm {
    private static final long serialVersionUID = -4017195510815090304L;
    private String userName;
    private String passWorld;
    private byte sex;
    private String email;
    private String phoneNum;
    private int age;
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getPassWorld() {
        return passWorld;
    }
    public void setPassWorld(String passWorld) {
        this.passWorld = passWorld;
    }
    public byte getSex() {
        return sex;
    }
    public void setSex(byte sex) {
        this.sex = sex;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public String getPhoneNum() {
        return phoneNum;
    }
    public void setPhoneNum(String phoneNum) {
        this.phoneNum = phoneNum;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
我们可以看到这个只是个从ActionForm派生来的javabean,下面把jsp页面也帖出来

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib uri="http://struts.apache.org/tags-bean" prefix="bean" %>
<%@ taglib uri="http://struts.apache.org/tags-html" prefix="html" %>
http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
http://www.w3.org/1999/xhtml">

请选择你要测试的form


        userName:

        passWorld:

        sex男
        女

        email

        phoneNum

        age

        normalForm submit

        dynaForm submit


这次不会讲它的目录结构，在最后我会放出下载地址
好，我们拉着反struts动态from也讲完再来看运行效果：
动态Form是什么意思呢，好就是让我们不用写上面的javabean面直接在xml配置文件中配置，下面为代码，其实上面也已经把代码帖出来了，下面我再帖一次，请注意高亮部分

          "-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
          "http://struts.apache.org/dtds/struts-config_1_3.dtd">
























我们可以看到form中的所有的内容都在xml文件中写出来了，


看看上面的两行有什么不一样，它们都是用来定义的都有name (相当于javabean中的一个property)
type 不用说了吧就是它的类型，不同的是在第一行中多了一个initial="0" 为什么呢，请记住在基本数据成员是要初始化的
就像局部变量一样。
其实这个东东没什么难度吧，下面讲一个我们初学者都出现的问题，
我们可以先找找这个关键字Cannot retrieve mapping for action 了解一下
下面我们进入正题吧：
web.xml的内容

    action
    org.apache.struts.action.ActionServlet

        config
        /WEB-INF/struts-config.xm


        config/formtest
        /WEB-INF/struts-config-formtest.xml

    1

我们可以看到这里有两个模块，问题就在这里了，（如果不清楚struts多个配置文件的使用可以看我另一个文章）
在配置文件中你们可以看到我们多了模块，在直接访问jsp文件时，struts只会在默认的模块中找Action所以我们只能
通过一个Action来做连接（好不爽啊）。
下面帖运行效果出来：

下面这个是找不到Action的效果



下载地址
Click to view this file

风の使者 2007-11-18 12:12 发表评论

Struts 进阶之 ActionServlet深入探讨

风の使者 — Thu, 08 Nov 2007 14:50:00 GMT

Struts提供了一个缺省版本的ActionServlet类，你可以继承这个类，覆盖其中的一些方法来达到你的特殊处理的需要。ActionServlet继承与javax.servlet.http.HttpServlet，所以在本质上它和一个普通的servlet没有区别，你完全可以把它当做一个servlet来看待，只是在其中完成的功能不同罢了。ActionServlet主要完成如下功能：

将一个来自客户端的URI映射到一个相应的Action类
如果是这个Action类是第一次被调用，那么实例化一个并放入缓存
如果在配置文件(struts-config.xml)中指定了相应的ActionForm，那么从Request中抓取数据填充FormBean
调用这个Action类的perform()方法，传入ActionMapping的一个引用，对应的ActionForm、以及由容器传给ActionServlet的HttpServletRequest、HttpServletResponse对象。

缺省版本的ActionServlet会从配置文件web.xml中读取如下初始化参数：

application
应用使用的资源包(resources bundle)的基类
factory
用于创建应用的MessageResources对象的MessageResourcesFactory的类名。缺省是org.apache.struts.util.PropertyMessageResourcesFactory。
config
Struts的配置文件，缺省是/WEB-INF/struts-config.xml。注意这儿是与应用Context关联的相对路径。
content
定义了缺省的内容类型和编码格式，它会被自动地被设置到每个response中，如果JSP/Servlet中没有明确的设置。缺省是text/html。
debug
调试信息的级别。默认为0，比当前级别高的调试信息会被log到日志文件中。
detail
与debug的作用类似，只是这个detail是initMapping()时专用的。调试信息会被打印到System.out，而不是日志文件。
formBean
ActionFormBean的实现类，缺省为org.apache.struts.action.ActionFormBean
forward
应用中使用的ActionForward类，缺省是org.apache.struts.action.ActionForward。
locale
指定了缺省使用的Locale对象。设为true，当得到一个session时，会自动在session中存储一个以Action.LOCALE_KEY标示的Locale对象，如果session中还没有与Action.LOCALE_KEY绑定的Locale对象。
mapping
应用中使用的ActionMapping类，缺省是org.apache.struts.action.ActionMapping。
multipartClass
文件上传使用的MutipartRequestHandler的实现类。缺省为org.apache.struts.upload.DiskMultipartRequestHandler
nocache
如果设为true，那么ActionServlet会自动在每个到客户端的响应中添加nocache的HTML头，这样客户端就不会对应用中的页面进行缓存。缺省为false
null
如果设置为true，那么应用在得到一个未定义的message资源时，会返回null，而不是返回一个错误信息。缺省是true。
maxFileSize
文件上传的大小上限，缺省为250M
bufferSize
文件上传时的缓冲区的大小，缺省为4M
tempDir
设置用于上传时的临时目录。工作目录会作为一个Servlet环境（Context）的属性提供。
validate
Are we using the new configuration file format?缺省为true。
validating
在解析配置XML文件是是否进行有效性的验证。缺省为true

ActionServlet中应用了命令设计模式:

一个Servlet在由容器生成时，首先会调用init()方法进行初始化，在接到一个HTTP请求时，调用相应的方法进行处理；比如GET请求调用doGet()方法，POST请求调用doPost()方法。所以首先看看ActionServlet的init()方法，你就会很清楚为什么ActionServlet可以完成这些功能了。

在它的init()方法中，ActionServlet依次调用如下protected的方法完成初始化：
initActions() －大家可能还曾有这个疑问：Struts为什么可以找到一个请求URI对应的action类呢？答案就在这儿，ActionServlet有一个actions属性，类型为org.apache.struts.util.FastHashMap，用于存储以类的全名为key的已实例化的Action类。在init()时首先调用的就是initActions()方法，在这个方法中只是简单的清除map中的所有的名值对，
synchronized (actions) {
       actions.setFast(false);
       actions.clear();
       actions.setFast(true);
}
首先把actions设为slow模式，这时对FastHashMap的访问是线程同步的，然后清除actions中的所有的已存在的名/值对，最后再把actions的模式设为fast。由于FastHashMap是struts在java.util.HashMap的基础上的一个扩展类，是为了适应多线程、并且对HashMap的访问大部分是只读的特殊环境的需要。大家知道java.util.HashMap是非线程安全的，所以HashMap一般适用于单线程环境下。org.apache.struts.FastHashMap就是继承于java.util.HashMap，在其中添加多线程的支持产生的。在fast模式下的工作方式是这样的：读取是非线程同步的；写入时首先克隆当前map，然后在这个克隆上做写入操做，完成后用这个修改后的克隆版本替换原来的map。那么在什么时候会把Actions类添加到这个map中呢？我们已经提到了struts是动态的生成Action类的实例的，在每次ActionServlet接收到一个GET或POST的HTTP请求时，会在这个map中查找对应的Action类的实例，如果不存在，那么就实例化一个，并放入map中。可见这个actions属性起到了对Action类实例的缓存的作用。
initInternal() －初始化ActionServlet内部使用的资源包MessageResources，使用MessageResources.getMessageResources(internalName)得到 internalName为"org.apache.struts.action.ActionResources"对应的ActionResources.properties文件。这个资源包主要用于ActionServlet处理过程中的用到的提示信息，这儿不展开讨论。
initDebug() －从web.xml中读取本应用的debug级别参数getServletConfig().getInitParameter("debug")，然后赋给debug属性。
initApplication()－初始化应用资源包，并放置入ServletContext中。
String factory =getServletConfig().getInitParameter(“factory”);
String oldFacory = MessageResourcesFactory.getFactoryClass();
if (factory !=null)
MessageResourcesFactory.setFactoryClass(factory);
String value = getServletConfig().getInitParameter("application");
MessageResourcesFactory factoryObject = MessageResourcesFactory.createFactory();
application = factoryObject.createResources(value);
MessageResourcesFactory.setFactory(oldFactory);
getServletContext().setAttribute(Action.MESSAGES_KEY, application);
说明：文中引用的代码片断可能会省略了一些例外检查等非主线的内容，敬请注意。

首先从配置文件中读取factory参数，如果这个参数不为空，那么就在MessageResourcesFactory中使用这个指定的Factory类；否则，使用默认的工厂类org.apche.struts.util.PropertyMessageResourceFactory。然后调用MessageResourcesFactory的静态createFactory()方法，生成一个具体的MessageResourceFactory对象（注意：MessageResourcesFactory是抽象类）。这样就可以调用这个具体的MessageResourceFactory的createResource()方法得到配置文件(web.xml)中定义的资源文件了。
上面的application对象类型为MessageResources。在web.xml中在配置ActionServlet时可以指定一个特定的工厂类。不能直接MessageResourcesFactory的createResources()方法，因为这个方法是abstract的。创建factoryObject的过程如下：
MessageResourceFactory factoryObject=
MessageResourcesFactory.createFactory();
application = factoryObject.createResources(value);

initMapping() －为应用初始化mapping信息ActionServlet有一个protected的属性：mapping，封装了一个ActionMapping的对象集合，以便于管理、查找ActionMapping。mappings是org.apache.struts.action.ActionMappings类的实例。主要有两个方法：addMapping(ActionMapping mapping)和findMapping(String path)。ActionMapping也是使用上面提到的org.apache.struts.util.FastHashMap类来存储所有的ActionMapping对象。
mappings.setServlet(this);
……
// Initialize the name of our ActionFormBean implementation class
value = getServletConfig().getInitParameter("formBean");
if (value != null)
formBeanClass = value;
// Initialize the name of our ActionForward implementation class
value = getServletConfig().getInitParameter("forward");
if (value != null)
forwardClass = value;
// Initialize the name of our ActionMapping implementation class
value = getServletConfig().getInitParameter("mapping");
if (value != null)
mappingClass = value;
在initMapping()中，首先链接mappings对象到本servlet实例。其实这句话的作用很简单，在ActionMappings中会有一个ActionServlet类型的属性，这个属性就界定了这个ActionMappings对象所属的ActionServlet。Struts的实现比较灵活，其中的ActionFormBean、ActionForward、ActionMapping类你完全可以使用自己实现的子类，来定制Struts的工作方式。上面的代码就从配置文件（web.xml）中读取formBean、forward、mapping参数，这些参数就是你定制的ActionFormBean、ActionForward、ActionMapping类名。
// Initialize the context-relative path to our configuration resources
value = getServletConfig().getInitParameter("config");
if (value != null)
config = value;
// Acquire an input stream to our configuration resource
InputStream input = getServletContext().getResourceAsStream(config);
Digester digester = null;
digester = initDigester(detail);
try {
formBeans.setFast(false);
forwards.setFast(false);
mappings.setFast(false);
digester.parse(input);
mappings.setFast(true);
forwards.setFast(true);
formBeans.setFast(true);
} catch (SAXException e) {
throw new ServletException
(internal.getMessage("configParse", config), e);
} finally {
input.close();
}
从web.xml读取Struts的配置文件的位置。使用org.apache.struts.digester.Digester解析config参数标示的配置文件，通常为“/WEB-INF/struts-config.xml”，解析出所有的data-source、form-bean、action-mapping、forward。从上面的程序片断看到，Digester仅仅调用了一个parse()方法，那么，Digester是怎样把解析struts-config.xml文件并把解析的结果form-bean等信息存储到属性变量formBeans等中的呢？你可以注意到在调用digester.parse(InputStream)之前，首先调用了initDigester()方法：
Digester digester = new Digester();
digester.push(this);
digester.addObjectCreate("struts-config/action-mappings/action",
mappingClass, "className");
digester.addSetProperties("struts-config/action-mappings/action");
digester.addSetNext("struts-config/action-mappings/action",
"addMapping",
"org.apache.struts.action.ActionMapping");
digester.addSetProperty
("struts-config/action-mappings/action/set-property",
"property", "value");
在这个方法中首先生成一个Digester对象，然后设置解析的规则和回调，如果你对XML、SAX不是很熟，这儿不必纠缠太深。要注意的是addSetNext()方法，设置了每一个要解析元素的Set Next回调方法，而这个方法就是由digester解析器的父提供的。上面的片断中的“addMapping”就是ActionServlet本身定义的一个方法，将由Digester回调。Digester就是籍此把解析出的每一个FormBean、ActionForward、ActionMapping等存储到属性变量formBeans、forwards、mappings等中的。
initUpload() －初始化有关Upload的一些参数，比如：bufferSize、tempDir。
initDataSource() －取出在initMapping()中从配置文件中读取的每一个DataSource，设置LogWriter，如果为GenericDataSource的实例，则打开数据源。然后，把每个dataSource放入Context中。
dataSource.setLogWriter(scw)；
((GenericDataSource)dataSource).open();
getServletContext().setAttribute(key,dataSource);
initOther() －设置其它尚未初始化的的参数（content、locale、nocache），并发布formBeans、forwards、mappings到Context：
getServletContext().setAttribute(Action.FORM_BEANS_KEY, formBeans);
getServletContext().setAttribute(Action.FORWARDS_KEY, forwards);
getServletContext().setAttribute(Action.MAPPINGS_KEY, mappings);
initServlet() －初始化Controller Servlet的Servlet Mapping。这儿也使用了Digester工具，扫描web.xml所有的，寻找servlet-name与当前Servlet相同的mapping，置入Context。代码如下；
Digester digester = new Digester();
digester.push(this);
digester.setDebug(debug);
digester.setValidating(validating);
digester.addCallMethod(“web-appservlet-mapping”,“addServletMapping”, 2);
digester.addCallParm(“web-appservlet-mappingservlet-name”, 0);
digester.addCallParm(“web-appservlet-mappingurl-pattern”, 1);
InputStream is = getServletContext().getResourceAsStream(“/WEB-INFweb.xml”);
digester.parse(is);
getServletContext().setAttribute(Action.SERVLET_KEY,servletMapping);

风の使者 2007-11-08 22:50 发表评论

Struts 中配置到多个xml文件中

风の使者 — Thu, 08 Nov 2007 14:47:00 GMT

通常当我们的项目比较大，一个小的部分就会的struts配置文件的内容就会上百行，跟任何东西一样，一但多了，管理就会变得困难。因此在大型的项目中把配置文件分开更有利于管理和多人开发，下面我来讲讲在struts中是怎样实现的。
通常有两个方法：
      一是像这样：

    action
    org.apache.struts.action.ActionServlet

        config
        /WEB-INF/struts-config.xml , /WEB-INF/struts-config-dao.xml

    2

不过这样有一个不好的地方，那就是两个配置文件都是全局的，因此在有相同路径的Action就会产生冲突

     二是像这样

    action
    org.apache.struts.action.ActionServlet

        config
        /WEB-INF/struts-config.xml


        config/dao
        /WEB-INF/struts-config-dao.xml

    2

这样就不会出现那些问题了

风の使者 2007-11-08 22:47 发表评论

跟菜鸟学STRUTS(2)

风の使者 — Thu, 08 Nov 2007 14:43:00 GMT

上次刚完成了一个struts 的例子，大家都看到了，那么在上－次中我们到底做了什么呢，我现在为大家说说

先来看看我们的web.xml文件

http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    Struts_HelloWorld by sakrua


        action
        org.apache.struts.action.ActionServlet

            config
            /WEB-INF/struts-config.xml

        2

        action
        *.do



        index.html
        index.htm
        index.jsp
        default.html
        default.htm
        default.jsp

我们在文件中定义了一个 servlet 我们来看看这个类“org.apache.struts.action.ActionServlet” 这个是struts 的核心类

我们看到它也是从HttpServlet中继成来的，它为struts 完成如下的任务：

为到来的请求找到URI
URI映射到ActionMapping
创建或找到相关的ActionMapping 实例
如果有ActionFrom创建它
创建Action实例
最后execute返回ActionForwar

config
/WEB-INF/struts-config.xml

接着我们用下面的方法关连到我们的struts-config.xml中

看看我们的重点内容struts-config.xml文件

"-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
"http://struts.apache.org/dtds/struts-config_1_3.dtd">

上面是固定的，但我们可以看到我用的是1.3的dtd文件，也就是说我用的是struts的1.3x

定义一个form-beans,在from-beans中我们可以定义很多的form-bean

还记得我们的actionFrom吧，这里就是它的定义，在工作是struts 会为我们创建它

这样的定义在大多数我情况下已经足够了，但还是有很多的其它的内容的，这个我以后再说了

再下来就是定义一个action了，action都要从struts的类中继承，例如org.apache.struts.action.Action

我们的例子中用的就是这个下面来说一下这个

在action中我们完成业务中的工作，其有一个execute方法,我们要重写这个方法来完成我们想做的事情

例如我们的例子中的

package org.helloWorld.struts.action;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.helloWorld.struts.form.HelloWorldForm;
/**
* struts helloworld 的action form
* @author sakrua
* email :winds8@gmail.com msn:wind_s8@hotmail.com
* 2007年11月5日
*/
public class HelloWorldAction extends Action {
    private static final String FAIL ="fail";
    private static final String SUCCESS ="success";
    //action中所有的请求都会由这个函数处理
    public ActionForward execute(ActionMapping mapping, ActionForm form,
            HttpServletRequest request, HttpServletResponse response)
            throws Exception {
        //从actionForm 中取数据
        HelloWorldForm helloWorldForm =(HelloWorldForm)form;
        String userName = helloWorldForm.getUserName();
        String worldToSay = helloWorldForm.getWorldToSay();
        //如果没有协作输入转到错误页面
        if(userName.equals("")||worldToSay.equals("")){
            return mapping.findForward(FAIL);
        }
        //转到成功页面
        return mapping.findForward(SUCCESS);
    }
}

在中我们可以定义很多的action

请注意的事在Action中定义是name是指向某个ActionFrom的，type才是指向我们的Action类

在Action元素内我们定义了两个

与代码一同看，我们很容易想到这是让我们转到不同的页面中的

        //如果没有协作输入转到错误页面
        if(userName.equals("")||worldToSay.equals("")){
            return mapping.findForward(FAIL);
        }
        //转到成功页面
        return mapping.findForward(SUCCESS)；

下面现看看我们的页面吧，与其它的普通的HTML不一样的是我们这里多了struts的标签，来我们看一下例子

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>

<%@ taglib uri="http://struts.apache.org/tags-bean" prefix="bean" %>
<%@ taglib uri="http://struts.apache.org/tags-html" prefix="html" %>

http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
http://www.w3.org/1999/xhtml">

Welcome　you to use this demo

请输入你的用户名：

请输入你想说的话：

这个是index.jsp文件的代码，

我们先来讲讲标签

<%@ taglib uri="http://struts.apache.org/tags-bean" prefix="bean" %>
<%@ taglib uri="http://struts.apache.org/tags-html" prefix="html" %>

这两句让我们导入了struts 的标签

这样我拉就可以像下面一样使用了

请输入你的用户名：

请输入你想说的话：

也许有些人已经看到了一个东东，那就是标签中的property都与我们的ActionForm中定义的是一样的，

没错，只要这样，在数据提交的时候Struts就会为我们把数据填入Form中

再看回到struts-conf.xml文件

我们可以发现

这句话，这句定义了Struts的资源文件在国际化中我们会经常用到,同时在fail.jsp中我们也用到了

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib uri="http://struts.apache.org/tags-bean" prefix="bean" %>
<%@ taglib uri="http://struts.apache.org/tags-html" prefix="html" %>
http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
http://www.w3.org/1999/xhtml">

请输入完整的信息

转到转入页面

下面为properties.文件的内容

helloWorld.userNameRequire=请填写用户名
helloWorld.worldToSayRequire=请填写你想说的话

key 与其是对应的

到这里，我们大约看到了struts的一小部分的内容了，在后面我们会继续讲

例子下载
http://winds8.googlepages.com/Struts_HelloWorld.war
http://winds8.googlepages.com/servlet_Test_project.war

风の使者 2007-11-08 22:43 发表评论

跟菜鸟学STRUTS（1）

风の使者 — Thu, 08 Nov 2007 14:39:00 GMT

Struts 的MVC

1．Model 1 和Model 2简介

我们在开发Web应用时经常提到的一个概念是Model 1/Model 2，那么到底它是什么意思呢？其实它是对采用JSP技术构成Web应用的不同模型的描述。下面对这个概念做一个简单的介绍。

Model 1

在使用JAVA技术建立Web应用的实例中，由于JSP技术的发展，很快这种便于掌握和可实现快速开发的技术就成了创建Web应用的主要技术。JSP页面中可以非常容易地结合业务逻辑(jsp:useBean)、服务端处理过程（jsp:scriplet）和HTML()，在JSP页面中同时实现显示，业务逻辑和流程控制，从而可以快速地完成应用开发。现在很多的Web应用就是由一组JSP页面构成的。这种以JSP为中心的开发模型我们可以称之为Model 1。

当然这种开发模式在进行快速和小规模的应用开发时，是有非常大的优势，但是从工程化的角度考虑，它也有一些不足之处：

1. 应用的实现一般是基于过程的,一组JSP页面实现一个业务流程，如果要进行改动，必须在多个地方进行修改。这样非常不利于应用扩展和更新。

2. 由于应用不是建立在模块上的, 业务逻辑和表示逻辑混合在JSP页面中没有进行抽象和分离。所以非常不利于应用系统业务的重用和改动。

考虑到这些问题在开发大型的Web应用时必须采用不同的设计模式――这就是Model2

Model 2

Model 2 表示的是基于MVC模式的框架。MVC是Model－View－Controller的简写。"Model" 代表的是应用的业务逻辑（通过JavaBean，EJB组件实现）， "View" 是应用的表示面（由JSP页面产生），"Controller" 是提供应用的处理过程控制（一般是一个Servlet），通过这种设计模型把应用逻辑，处理过程和显示逻辑分成不同的组件实现。这些组件可以进行交互和重用。从而弥补了Model 1的不足。

Model 2具有组件化的优点从而更易于实现对大规模系统的开发和管理，但是开发MVC系统比简单的JSP开发要复杂许多，它需要更多的时间学习和掌握。

1. 必须基于MVC组件的方式重新思考和设计应用结构。原来通过建立一个简单的JSP页面就能实现的应用现在变成了多个步骤的设计和实现过程。

2. 所有的页面和组件必须在MVC框架中实现，所以必须进行附加地开发工作。

在开始讲struts 前,我们先了解一下servlet 为什么要看servlet 看到最后就知道了

1、环境的搭建就pass了

2、 open eclipse and follow me

create new project

新建一个Dynamic Web Project named servlet_Test_project

我用的是jdk1.6

接着next ….next完成

转到PackageExplor 我们看一下project 的目录结构

两个jar的环境

源文件目录

输出目录，也就是class的目录了（不多说了，不知道class是什么，学j2se吧）

Web目录

其中jsp等文件放在WebContent目录内（下面两个Web-INF、META-INF除外）

Lib目录为我们工程中用到的jar包的目录

下面为Projct explor下看到的目录结构，我们可以看看他的不同

好，少来费话，新建一个servlet 先

下面看图

包名为sakrua ，lass名为ServletHelloWorld，Superclass 为javax.servlet.http.HttpServlet

只有javax.servlet.http.HttpServlet这个父类吧，到下面再说

接着你可以点完成，我们next看看有什么

呵呵，好像没有什么，我们点完成（是finish 不要告诉我找不到完成，）

好，eclipse 为我们已经完成了大部分的代码了，不过我们先不看代码先（习惯先在后了）

我们再看看 Projct explor 有什么不同，不要让我说了，自己能看到的

其实这是web.xml文件中的内容，我们去 see see

http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    servlet_Test_project


        sakrua 的第一个servlet
        ServletHelloWorld

        ServletHelloWorld

        sakrua.ServletHelloWorld



        ServletHelloWorld

        /ServletHelloWorld




        index.html
        index.htm
        index.jsp
        default.html
        default.htm
        default.jsp

应该中国人都看得明

下面我们去看看Servlet 的代码

package sakrua;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class ServletHelloWorld extends javax.servlet.http.HttpServlet implements javax.servlet.Servlet {
   static final long serialVersionUID = 1L;
    public ServletHelloWorld() {
        super();
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    }
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    }
}

好我们加点东西上去看看

package sakrua;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

PrintWriter out = response.getWriter();
out.println("servlet Example by sakrua ");
out.println("
servlet is here
");
out.println("");

    }
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    }
    public void destroy() {
        System.out.println("It is destroy");
        super.destroy();
    }
    public void init() throws ServletException {
        System.out.println("It is started");
        super.init();
    }
}

右键选择

在ie看到

Ok !

下面我们具体说一下

Servlet是一个接口，位于 javax.servlet.Servlet，它规定了每个Servlet所必须实现的方法。实际应用时我们需要从 javax.servlet.GenericServlet 和 javax.servlet.http.HttpServlet 两个抽象类继承出自己的Servlet类，并实现所需的功能。这几个类的关系如下（绿色斜体字为抽象类）：

上图中，Servlet依赖于ServletRequest和ServletResponse接口，这两个接口负责为Servlet接受和发送信息。 HttpServlet也类似。

Servlet接口

javax.servlet.Servlet接口包含以下的方法：

init()

void init(ServletConfig config) throws ServletException

init方法用于初始化，在Servlet启动时调用。

service()

void service(ServletRequest req, ServiceResponse res) throws ServletException, IOException

Servlet通过这个方法，从req获得客户端请求，处理并生成结果，再通过res发送给客户端。

destroy()

void destroy()

Servlet销毁时执行的方法。

getServletInfo()

String getServletInfo()

将Servlet的信息通过字符串返回。

getServletConfig()

ServletConfig getServletConfig()

获取包含Servlet各种信息的ServletConfig对象。

当某个Servlet第一次被请求时，服务器（Servlet容器）会生成该Servlet并调用它的init()方法，再调用其service()方法处理请求。处理结束后该Servlet会常驻于容器中，下一个请求则不再重新生成Servlet，而是直接调用常驻的Servlet对象的service()方法。服务器停止时，会调用该Servlet的destroy()方法。

因此，在Servlet的一个生命周期中，init()和destroy()仅会被调用一次，而service()则会被调用多次。

―――

好我们又看看这样

package sakrua;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class ServletHelloWorld extends javax.servlet.http.HttpServlet implements javax.servlet.Servlet {
   static final long serialVersionUID = 1L;
    public ServletHelloWorld() {
        super();
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        PrintWriter out = response.getWriter();
        out.println("servlet Example by sakrua ");
        out.println("

这就是Servlet 呵呵！

");
        out.println("");
    }
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    }
    public void destroy() {
        System.out.println("It is destroy");
        super.destroy();
    }
    public void init() throws ServletException {
        System.out.println("It is started");
        super.init();
    }
}

看看控制台，所有都ok（close 后才会看到 Is is Destroy）

再看看ie，乱码了！晕

―――

GenericServlet抽象类

javax.servlet.GenericServlet为我们实现了Servlet接口的大部分方法，除了service()方法之外。因此，我们在制作自己的Servlet时，只需要继承GenericServlet并重载service()方法即可。

HttpServlet类

HttpServlet继承了GenericServlet，不过它也是一个抽象类，不能直接使用，只能继承它。

HttpServlet中常用的方法有两个：

doGet

void doGet(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException

当浏览器用GET方式访问时，该方法被调用。

doPost

void doPost(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException

当浏览器用POST方式访问时，该方法被调用。

这两个函数内部的处理方法基本上与上一节介绍的GenericServlet.service()函数相同。

另外其他的HTTP请求也都有相应的方法：

HTTP请求类别

HttpServlet的方法

GET

doGet()

POST

doPost()

HEAD

doHead()

PUT

doPut()

DELETE

doDelete()

HttpServletRequest

doGet()和doPost()函数的两个参数为 HttpServletRequest和HttpServletResponse对象。

HttpServletRequest接口表示浏览器请求，你可以通过这个类获取浏览器发送到服务器的任何信息。

getParameter

String getParameter(String name)

获取指定变量名name所对应的参数值。该方法实际上为父接口 javax.servlet.ServletRequest的方法。如果是GET请求则获取查询字符串后的参数，POST请求则获取

表单中的参数。类似于PHP的$_GET和$_POST数组。

getParameterValues

String[] getParameterValues(String name)

这个方法与getParameter()类似。当你要获取这类会返回多个值的表单属性时，就应当用这个方法。

getMethod

String getMethod()

返回字符串"GET"或"POST"。

getRequestURI

String getRequestURI()

获取请求的URI（不包括查询字符串）。相当于PHP的$_SERVER['REQUEST_URI']。

getServletPath

String getServletPath()

获取Servlet的路径。相当于PHP的$_SERVER['PHP_SELF']。

getPathInfo

String getPathInfo()

获取PathInfo。相当于PHP的$_SERVER['PATH_INFO']。

setCharacterEncoding

void setCharacterEncoding(String new)

设置请求的编码。需要处理汉字时务必要通过该方法设置正确的字符编码，否则将无法正确读取浏览器发过来的文字。

还有好多有用的方法大家可以自己去参考接口文档。

HttpServletResponse

HttpServletResponse接口则用于控制服务器发送给客户端的内容，相当于PHP的echo、header等函数。

setContentType

void setContentType(String type)

设置返回值的类型。通常的HTML内容可设置为"text/html; charset=UTF-8"等，而动态生成的图片则可以设置为"image/gif"等。输出汉字之前，务必要通过该方法指定输出的字符编码。相当于在PHP中写 header("Content-Type: image/gif")。

ServletOutputStream

ServletOutputStream getOutputStream() throws IOException

向客户端发送二进制数据时，需要通过此方法获取输出流。

getWriter

PrintWriter getWriter() throws IOException

向客户端发送文本数据时，需要通过此方法获取输出流。

看到这里应该知道为什么乱码了吧

加上这两句

response.setCharacterEncoding("GBK");

response.setContentType("text/html; charset=GBK");

几乎所有的Web开发语言都支持Session功能，Servlet也不例外。 Servlet/JSP中的Session功能是通过作用域(scope)这个概念来实现的。

作用域分为四种，分别为：

page

在当前页面有效(仅用于JSP中)

request

在当前请求中有效

session

在当前会话中有效

application

在所有应用程序中有效

好，servlet 讲完了，为什么要讲这个呢，我们在以后才会体会到

会到Struts 中，现在，struts 有两个版本 struts 1.x 和struts 2.x , 2 .x 是webwork 的化身,我们现在讲的是1.x .现在来一个struts 的hello world

新建一个同样的工程(如果用myeclipse 有点不一样)

把struts 的这些包copy到lib目录中

下面是step by step

1、修改web.xml文件

http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    Struts_HelloWorld by sakrua


        action
        org.apache.struts.action.ActionServlet

            config
            /WEB-INF/struts-config.xml

        2

        action
        *.do



        index.html
        index.htm
        index.jsp
        default.html
        default.htm
        default.jsp

看不了没，跟servlet 是不是有点相似昵，以后我们会看到更加清楚（struts 的本质，你可以自己想想）

看到这里我们要有一个struts-config.xml文件, Now 我们来写一个

"-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
"http://struts.apache.org/dtds/struts-config_1_3.dtd">

好，我们来看看这个XML文件，我们发现有和现在我们先不理what is this

我们看到type中都有一个类，我们先来完成这个类

从ActionForm 类中继成

package org.helloWorld.struts.form;

import javax.servlet.http.HttpServletRequest;

import org.apache.struts.action.ActionErrors;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionMapping;

/**
* struts helloworld 的action form
* @author sakrua
* email :winds8@gmail.com msn:wind_s8@hotmail.com
* 2007年11月5日
*/
public class HelloWorldForm extends ActionForm {

private static final long serialVersionUID = -3372095237053639793L;

    //一个javabean 从ActionForm继成
    //用户名
    private String userName;
    //想说的话
    private String worldToSay;
/*
    //validate
    public ActionErrors validate(ActionMapping mapping,
            HttpServletRequest request) {
        ActionErrors errors = new ActionErrors();
        //暂时我们不理这个，以后再说
        if(userName.equals("")){
        }
        if(worldToSay.equals("")){
        }
        return super.validate(mapping, request);
    }
*/
    //下面为set get function
    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getWorldToSay() {
        return worldToSay;
    }

    public void setWorldToSay(String worldToSay) {
        this.worldToSay = worldToSay;
    }
}

下面是action

package org.helloWorld.struts.action;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.helloWorld.struts.form.HelloWorldForm;
/**
* struts helloworld 的action form
* @author sakrua
* email :winds8@gmail.com msn:wind_s8@hotmail.com
* 2007年11月5日
*/
public class HelloWorldAction extends Action {

    private static final String FAIL ="fail";
    private static final String SUCCESS ="success";
    //action中所有的请求都会由这个函数处理
    public ActionForward execute(ActionMapping mapping, ActionForm form,
            HttpServletRequest request, HttpServletResponse response)
            throws Exception {
        //从actionForm 中取数据
        HelloWorldForm helloWorldForm =(HelloWorldForm)form;
        String userName = helloWorldForm.getUserName();
        String worldToSay = helloWorldForm.getWorldToSay();
        //如果没有协作输入转到错误页面
        if(userName.equals("")||worldToSay.equals("")){
            return mapping.findForward(FAIL);
        }
        //转到成功页面
        return mapping.findForward(SUCCESS);
    }

}

还有两个jsp

Index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>

<%@ taglib uri="http://struts.apache.org/tags-bean" prefix="bean" %>
<%@ taglib uri="http://struts.apache.org/tags-html" prefix="html" %>

http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
http://www.w3.org/1999/xhtml">

Welcome　you to use this demo

请输入你的用户名：

请输入你想说的话：

Fail.jsp

Success.jsp

好写完了

打开ie输入http://localhost:8080/Struts_HelloWorld/

正常运行中

在这个过程中我们做了什么呢，我们已经完成了我们的第一个struts 程序（废话）

具体做了什么　

To be continued

风の使者 2007-11-08 22:39 发表评论