语源科技BlogJava-sakrua`s java 世界

hurt

风の使者 — Wed, 21 Jan 2009 00:45:00 GMT

风の使者 2009-01-21 08:45 发表评论

很久前写的一个javascript 拖动类

风の使者 — Sat, 08 Dec 2007 07:56:00 GMT

在web 2.0 的今天，经常用在web页面中拖动页面中的元素。例如，www.google.com/ig .那当然，我们baidu空间后台的操作也用到了，在word press中也可以看到！下面show一下代码：在后面提供代码的完整下载

说说为什么会用图片，因为是用live writer 发布再到其它的blog的，帖代码不好看，反正提供代码下载！哈哈！

下次改用qqmail 发看看效果

页面测试的部分代码

下面为代码测试页面　http://winds8.googlepages.com/drag.html

风の使者 2007-12-08 15:56 发表评论

有空写了一个javascript 操作cookie的类－用javascript 控制cookie

风の使者 — Sun, 25 Nov 2007 14:31:00 GMT

在web2.0的时代，Ajax技术的应用，我们经常会用到用javascript 用读写cookie,下面先来介绍一下，什么是cookies
味道以怎样的（有点饿了）：
一.什么是Cookies?
你会问，什么是cookies呢? cookie 是浏览器保存在用户计算机上的少量数据。它与特定的WEB页或WEB站点关联起来，自动地在WEB浏览器和WEB服务器之间传递。比如，如果你运行的是Windows操作系统，使用Internet Explorer上网，那么你会发现在你的“Windows”目录下面有一个子目录，叫做“Temporary Internet Files”。如果你有空看看这个目录，就会发现里面有一些文件，文件名称看起来就象电子邮件地址。比如在我机器上的这个目录里，就有“XX@support.microsoft.com”这样的文件。这是一个cookie 文件，这个文件从哪来呢？猜一猜，它来自微软的支持站点。对于管理细小的、不重要的、不想保存在中央数据库里的细节信息，Cookies 是个很不错的方案。（这不是说大家的名字不重要。）比如，目前网站上不断增长的自定义服务，可以为每个用户定制他们要看的内容。如果你设计的就是这样一个站点，那么你怎么来管理这样的信息：一个用户喜欢绿色的菜单条，而另一个喜欢红色的。确实是个累人的问题。不过，这样的信息，可以很安全地记录到cookie，并保存在用户的计算机上，而你自己的数据库空间可以留给更长久更有意义的数据。
二.Cookie的构成
Cookies最初设计时，是为了CGI编程。但是，我们也可以使用Javascript脚本来操纵cookies。
在Javascript脚本里，一个cookie 实际就是一个字符串属性。当你读取cookie的值时，就得到一个字符串，里面当前WEB页使用的所有cookies的名称和值。每个cookie除了name名称和value值这两个属性以外，还有四个属性。这些属性是： expires过期时间、 path路径、 domain域、以及 secure安全。
1.Expires–过期时间
指定cookie的生命期。具体是值是过期日期。如果想让cookie的存在期限超过当前浏览器会话时间，就必须使用这个属性。当过了到期日期时，浏览器就可以删除cookie文件，没有任何影响。
2.Path–路径
指定与cookie关联的WEB页。值可以是一个目录，或者是一个路径。
3.Domain–域
指定关联的WEB服务器或域。值是域名，比如microsoft.com。这是对path路径属性的一个延伸。如果我们想让 catalog.mycompany.com 能够访问shoppingcart.mycompany.com设置的cookies，该怎么办? 我们可以把domain属性设置成“mycompany.com”，并把path属性设置成“/”。FYI：不能把cookies域属性设置成与设置它的服务器的所在域不同的值。
4.Secure–安全
指定cookie的值通过网络如何在用户和WEB服务器之间传递。这个属性的值或者是“secure”，或者为空。缺省情况下，该属性为空，也就是使用不安全的HTTP连接传递数据。如果一个 cookie 标记为secure，那么，它与WEB服务器之间就通过HTTPS或者其它安全协议传递数据。不过，设置了secure属性不代表其他人不能看到你机器本地保存的cookie。换句话说，把cookie设置为secure，只保证cookie与WEB服务器之间的数据传输过程加密，而保存在本地的cookie文件并不加密。如果想让本地cookie也加密，得自己加密数据。
三.操作Cookies
请记住，cookie就是文档的一个字符串属性。要保存cookie，只要建立一个字符串，格式是name=（名称＝值），然后把文档的 document.cookie 设置成与它相等即可。比如，假设想保存表单接收到的用户名，那么代码看起来就象这样：
代码
document.cookie = "username=" + escape(form.username.value);
在这里，使用 escape() 编码函数非常重要，因为cookie值里可能包含分号、逗号或者空格。这就是说，在读取cookie值时，必须使用对应的unescape()函数给值解码。
1.cookie的四个属性
name=[; expires=][; domain=][; path=][; secure]
名称=<值>[; expires=<日期>][; domain=<域>][; path=<路径>][; 安全], 和应当用对应的值替换。
2.应当使用GMT格式
可以使用Javascript脚本语言的日期类Date的.toGMTString() 方法得到这一GMT格式的日期值。
3.方括号代表这项是可选的
比如在 [; secure]两边的方括号代表要想把cookie设置成安全的，就需要把"; secure" 加到cookie字符串值的后面。如果"; secure" 没有加到cookie字符串后面，那么这个cookie就是不安全的。
4.不要把尖括号<> 和方括号[] 加到cookie里
（除非它们是某些值的内容）设置属性时，不限属性，可以用任何顺序设置。
四.Cookies 的隐患
1.Cookies 安全性
因为某些原因Cookies 的名声很不好。许多人利用cookies做一些卑鄙的事情，比如流量分析、点击跟踪。Cookies 也不是非常安全，特别是没有secure属性的cookies。不过，即使你用了安全的cookies，如果你和别人共用计算机，比如在网吧，那么别人就可以窥探计算机硬盘上未加密保存的cookie文件，也就有可能窃取你的敏感信息。所以，如果你是一个WEB开发人员，那么你要认真考虑这些问题。不要滥用cookies。不要把用户可能认为是敏感的数据保存在cookies里。如果把用户的社会保险号、信用卡号等保存在cookie里，等于把这些敏感信息放在窗户纸下，无异于把用户投到极大危险之中。一个好的原则是，如果你不想陌生人了解你的这些信息，那就不要把它们保存在cookies里。
2.cookies还有一些实际的限制
Cookies保留在计算机上，不跟着用户走。如果用户想换计算机，那么新计算机无法得到原来的cookie。甚至用户在同一台计算机上使用不同浏览器，也得不到原来的cookie：Netscape 不能读取Internet Explorer 的cookies。
3.用户不愿意接受cookies
所以不要以为所有的浏览器都能接受你发出的cookies。如果浏览器不接受cookies，你要保证自己的WEB站点不致因此而崩溃或中断。
4.WEB 浏览器能保留的cookies不一定能超过300个
也没有标准规定浏览器什么时候、怎么样作废cookies。所以达到限制时，浏览器能够有效地随机删除cookies。浏览器保留的来自一个WEB服务器上的cookies，不超过20个，每个cookie的数据（包括名称和值），不超过4K字节.
[b]总之，注意保持cookie简单。不要依赖cookies的存在，不要在每个cookie里保存太多信息。不要保存太多的cookes。但是，抛除这些限制，在技巧高超的WEB管理员手里，cookie的概念是一个有用的工具。
好，对上面有了了解后，我们来看看我写的代码：有100行左右，不会好长，但是以前写的，有点记不得了：

这个在firefox ie opera 中测试成功的，大家也可以试试，下面讲一下代码的使用方法

是不是好简单

风の使者 2007-11-25 22:31 发表评论

javascript 面向对象程序设计 Ajax的必由之路（1）

风の使者 — Sun, 25 Nov 2007 14:21:00 GMT

这次我来讲一下javascript的程序设计。
在当今的Web2.0的时代，Ajax已成为的它的代名词.无可否定，javascript 是其中的一个非常重要的内容。

下面为wiki 的说明

AJAX全称为“Asynchronous JavaScript and XML”（异步JavaScript和XML），是一种创建交互式网页应用的网页开发技术。根據Ajax提出者Jesse James Garrett建議^[1]，它：

使用XHTML+CSS来表示信息；
使用JavaScript操作DOM（Document Object Model）进行动态显示及交互；
使用XML和XSLT进行数据交换及相关操作；
使用XMLHttpRequest对象与Web服务器进行异步数据交换；
使用JavaScript将所有的东西绑定在一起。
使用SOAP以XML的格式来传送方法名和方法参数。

类似于DHTML或LAMP，AJAX不是指一种单一的技术，而是有机地利用了一系列相关的技术。事实上，一些基于AJAX的“派生/合成”式（derivative/composite）的技术正在出现，如“AFLAX”。

AJAX的应用使用支持以上技术的Web浏览器作为运行平台。这些浏览器目前包括：Mozilla、Firefox、Internet Explorer、Opera、Konqueror及Mac OS的Safari。

因此学习Ajax首先就要学习javascript,好下面我来讲讲javascript的面向对象的程序设计。

本身，对于javascript 来说，它不支持面向对象的，但我们可以用其它的一些方法来模拟其的实现，下面先看一段小代码

这段小代码定义了一个函数，我们把它放到HTML中可以查看它的运行效果
刚才说javascript 本身是不支持面向对象的，但它给我们流下了function ,下面就用它来构造一个类，请看下面的代码：

在上面的代码中我们定义了一个叫做class1的类，同时我们发现，定义类的方法跟定义函数的方法是一样的，下面来讲一下javascript的一个重要的特性：prototype （是不是很熟啊，我们的prototype.js有一样的名字，现在大家也可以猜到作者为什么要用这个名字了吧。好再看看下面的代码：

跟上面的代码有一样的运行效果。
下面来重点讲一下代码吧
在javascript中，由于没有象java ,c#中的class的定义的关键字，因此我们要定义一个类时，就要用到function这个关键字，在javascript中，其实function也就是一个类（一个只有运行代码的类），但注意的是用typeof 时，函数是返回function的,面类是返回object的
产生一个类的对象，跟java一样是用new 的关键字的。大家再看看上面的代码，可以发现我在定义函数和属性时用了this这个关键字，这样是让代码在其的实验中可以引用，相当于我们的公共的方法和属性，当然用var 定义会产生一个private的属性（其实是由于作用域的问题，这个在后面的问题我再说）
跟java不一样的是prototype 这个是一个非常重要的属性，大家要记好。这个定义的格式也要记好。
下面我们来写一个例子程序。看看自己学会了多少（别以为自己学会了，要学的还有好多，“这个游戏才刚刚开始”－－不知道谁说的）：

下次讲讲Ajax了，当然javascript 还有很多要讲的，会讲Ajax 中提到

风の使者 2007-11-25 22:21 发表评论

跟菜鸟学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 发表评论