通过前面的几节，现在看一个实例：apache的日志分析程序。以我本机的apache log为例，如下：
192.168.1.138 - - [03/Feb/2006:01:40:20 +0800] "GET /phpinfo.php HTTP/1.1" 404 295
//分别为 客户端IP、访问日期、请求路径、服务端响应Code、请求文件大小

其正则表达式为：
^([\d.]+) (\S+) (\S+) \[([\w:/]+\s[+\-]\d{4})\] "(.+?)" (\d{3}) (\d+)

想到前面正则中()的作用了么？可以通过group(i)快速的将每组()中类容提取出来。
第一组([\d.]+)：将IP地址匹配出来
第四组([\w:/]+\s[+\-]\d{4})：将时间匹配出来
第五组"(.+?)"：将客户端请求内容匹配出来
第六组(\d{3})：将服务端响应Code匹配出来
第七组(\d+)：将文件大小匹配出来

关于那些正则表达式元字符的语法详见：
http://java.sun.com/j2se/1.4.2/docs/api/java/util/regex/Pattern.html

测试程序：

    public static void main(String[] args) {
        
        String pattern = "^([\\d.]+) (\\S+) (\\S+) \\[([\\w:/]+\\s[+\\-]\\d{4})\\] \"(.+?)\" (\\d{3}) (\\d+)";
        String log = "192.168.1.138 - - [03/Feb/2006:01:40:20 +0800] \"GET /phpinfo.php HTTP/1.1\" 404 295";
        
        System.out.println("pattern: " + pattern);
        System.out.println("log: " + log);
        
        Pattern p = Pattern.compile(pattern);
        Matcher m = p.matcher(log);
        
        if (m.find()) {
            System.out.println("IP Address: " + m.group(1));
            System.out.println("Date&Time: " + m.group(4));
            System.out.println("Request: " + m.group(5));
            System.out.println("Response: " + m.group(6));
            System.out.println("Size: " + m.group(7));
        } else {
            System.out.println("error!");
        }
    }

    /**//* 
    程序输出:
    pattern: ^([\d.]+) (\S+) (\S+) \[([\w:/]+\s[+\-]\d{4})\] "(.+?)" (\d{3}) (\d+)
    log: 192.168.1.138 - - [03/Feb/2006:01:40:20 +0800] "GET /phpinfo.php HTTP/1.1" 404 295
    IP Address: 192.168.1.138
    Date&Time: 03/Feb/2006:01:40:20 +0800
    Request: GET /phpinfo.php HTTP/1.1
    Response: 404
    Size: 295
    */

在4.3中介绍了查找到匹配正则表达式的功能，假如需要替换掉匹配正则表达式的字符串，我们可以自已使用String类的subString()方法，但jdk1.4的正则表达式API中提供了实现此功能的相关方法，如下：

* replaceAll(newString); 替换全部符合正则表达式的子串为newString.

* appendReplacement(StringBuffer, newString); 将字符串中匹配正则的子串之前的字符串先传入到StringBuffer中，然后再加上newString。

* appendTail(StringBuffer); 将字符串中匹配最后一个正则表达式后面的字符串传入到StringBuffer(通常和appendReplacement一起使用).

appendReplacement()和appendTail()看原文没太理解，上面的描述是通过debug看StringBuffer中的变化得来的。：）

看下面的例子：

        // 匹配d开头,接着是a或e最少一次，最多2次，再接着是mon
        // 感觉自已跟唐僧一样，N啰嗦 -__-!!
        String pattern = "d[ae]{1,2}mon";
        String input = "Unix hath demons and deamons in it!";
        System.out.println("Input: " + input);

        Pattern p = Pattern.compile(pattern);
        Matcher m = p.matcher(input);
        // 两个子串符合: demons, deamons.
        System.out.println("ReplaceAll: " + m.replaceAll("deamon"));

        m.reset();

        StringBuffer sb = new StringBuffer();
        System.out.print("Append methods: ");
        // 这个地方用debug跟着走一圈
        // 第一次StringBuffer中为: Unix hath deamons
        // 第二次StringBuffer为: Unix hath deamons and deamons
        while (m.find()) {
            m.appendReplacement(sb, "deamon");
        }
        // 执行完appendTail()中后为: Unix hath deamons and deamons in it!
        m.appendTail(sb);
        System.out.println(sb.toString());

start(), end()  返回字符串中匹配正则表达式的子串的开始位置和结束位置

groupCount()  返回()号匹配的数目，如果有的话。返回0表示没有使用()组，下面将会有介绍

group(int i)  返回正则表达式()匹配的第i组，如果i小于或等于groupCount()则返回相应的()匹配值，如果调用group(0)或group()则返回整个匹配正则表达式的部分

下面这个例子使用group()直接将整个匹配正则表达式的子字符串取出来：

    public static void main(String[] args) {
        // 匹配Q开头，第二个字符不为u，后面接数字1次或多次，后面再.号
        String pattern = "Q[^u]\\d+\\.";
        Pattern p = Pattern.compile(pattern);

        String line = "Order QT300. Now !";

        Matcher m = p.matcher(line);
        if (m.find()) {
            // m.group()须调用相关查找方法成功后才能调用
            System.out.println(pattern + " matches \"" + m.group() + "\" in \""
                    + line + "\"");
        } else {
            System.out.println("NO MATCH");
        }
    }

    // 输出：Q[^u]\d+\. matches "QT300." in "Order QT300. Now !"

    public static void main(String[] args) {
        String pattern = "Q[^u]\\d+\\.";
        Pattern p = Pattern.compile(pattern);

        String line = "Order QT300. Now!";
        Matcher m = p.matcher(line);

        if (m.find()) {
            System.out.println(pattern + " matches \""
                    + line.substring(m.start(), m.end()) + "\" in \"" + line
                    + "\"");
        } else {
            System.out.println("NO MATCH!");
        }
    }

    public static void main(String[] args) {
        
        String line = "Smith, John";
        // 这就是上面所说的()号,如果调用groupCount()的话,将输出2
        // 匹配任何字符0次或多次,然后是","号和空格,再匹配任何字符0次和多次
        // 上面的任何字符不包括换行符
        Pattern p = Pattern.compile("(.*), (.*)");

        Matcher m = p.matcher(line);
        if (m.find()) {
            // 先取上面正则()中匹配的group 2,也就是John
            // 然后再取()中匹配的group 1,也就是Smith
            System.out.println(m.group(2) + ' ' + m.group(1));
        } else {
            System.out.println("NO MATCH!");
        }
    }

    // 输出: John Smith

if (inputString.matches(regexPattern)) {
    // 字符串inputString匹配regexPattern这个模式
}

    public static void main(String[] args) throws PatternSyntaxException {
        String pattern = "^Q[^u]\\d+\\.";
        String input = "Qa777. is the next flight. It is on time.";

        Pattern p = Pattern.compile(pattern);
        boolean found = p.matcher(input).lookingAt();

        System.out.println("'" + pattern + "'"
                + (found ? " matches '" : " doesn't match '") + input + "'");
    }

在程序中使用正则表达式的步骤一般如下：
1. 建立Pattern对象，通过静态方法Pattern.compile();
2. 取得Matcher对象，通过pattern.matcher(CharSequence charSequence);
3. 调用Matcher对象的相关查找方法。

java.lang.CharSequence接口是在JDK1.4版本中被添加进来的，它为不同种类的char序列提供了统一的只读访问。实现的类有String, StringBuffer, java.nio.CharBuffer

Matcher提供几个有不同的查找方法，比String类的matches()方法更灵活，如下：

match() 使用整个字符串与相关模式相比较，和String的matches()差不多

lookingAt() 从字符串开头的地方与相关模式比较

find() 匹配字符串，没有必要从字符串的第一个字符开始，如果前一个操作匹配，而且匹配器没有重置的话，则从不匹配的第一个字符开始。

上面每个方法都返回boolean类型，返回true则意味的匹配，返回false则不匹配。

要检测给定的String是否匹配给定的模式，只须下面这样就可以了：

Matcher m = Pattern.compile(yourPattern).matcher(yourString);

if (m.find()) {
    System.out.println("match");
} else {
    System.out.println("no match");
}

昨天学习了如何模似一个GET请求，地址:http://www.blogjava.net/hexuzhong/archive/2005/12/05/22640.html

今天学习在这个GET请求后加上Query.在实例化一个GetMethod方法后，可以调用setQueryString()方法添加Query.下面演示了这个特性

// recipe11_4.jsp
// 假如这是我们要模似GET并发出Query的jsp文件

<%@ page contentType="text/html; charset=utf-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
    <body>
        Param A: <%=request.getParameter("paramA")%>
        <br>
        Param B: <%=request.getParameter("paramB")%>
    </body>
</html>

// Recipe11_4.java

    String url = "http://127.0.0.1:8080/test/commons/httpclient/recipe11_4.jsp";
    HttpClient client = new HttpClient();
    GetMethod method = new GetMethod(url);
    // 模似GET方法的两个参数.
    // 下面相当于?paramA=param%2520A%2520value&paramB=param%2520B%2520value
    try {
        NameValuePair pairA = new NameValuePair("paramA", URIUtil
                .encodeQuery("param A value"));
        NameValuePair pairB = new NameValuePair("paramB", URIUtil
                .encodeQuery("param B value"));
        NameValuePair[] pair = new NameValuePair[] { pairA, pairB };
        // 将参数设置到url中去
        method.setQueryString(pair);
        // 模似http GET请求
        client.executeMethod(method);
            
        if (method.getStatusCode() == HttpStatus.SC_OK) {
            // 输出服务端响应内容(html)
            System.out.println(method.getResponseBodyAsString());
        }
    } catch (URIException e) {
        e.printStackTrace();
    } catch (HttpException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
    <body>
        Param A: param A value
        <br>
        Param B: param B value
    </body>
</html>

创建一个HttpClient实例,使用它执行GetMethod对象,服务端response能通过InputStream, byte[]或String访问,下面的例子演示了GetMethod的用法,将返回信息通过String访问

    HttpClient client = new HttpClient();
    // 待访问的url,这个程序中将用GetMethod模拟一个客户端访问这个URL
    String url = "http://127.0.0.1:8080/test/commons/httpclient/MyJsp.jsp";
    GetMethod method = new GetMethod(url);
    
    try {
        client.executeMethod(method);
        // 服务端返回成功信息的话,则将服务端返回转换为String并显示
        if (method.getStatusCode() == HttpStatus.SC_OK) {
            String response = method.getResponseBodyAsString();
            System.out.println(response);
        }
    // 如果抛出HttpException则问题可能与HTTP协议有关
    } catch (HttpException e) {
        e.printStackTrace();
    // 如果抛出IOException则问题可能与网络状况有关
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        // 释放网络连接资源
        method.releaseConnection();
        // 不赞成使用的方法,重新使用GetMethod,当调用这个方法的时候,全部的实例变量将重置
        method.recycle();
    }

使用DynaBean,可以在程序运行时运态创建一个bean.(像struts中的ActionFrom有动态创建bean这个功能等)这个创建的bean也能被Commons BeanUtils中的类操作.下面的代码演示这个特性

// 动态创建bean中含有的属性,这个例子中有name和age这两个属性
    DynaProperty[] beanProperties = new DynaProperty[] {
        new DynaProperty("name", String.class),
        new DynaProperty("age", Integer.class),
    };
    
    BasicDynaClass personClass = new BasicDynaClass("person", BasicDynaBean.class, beanProperties);
    
    // 生成这个bean的一个实例
    DynaBean person = personClass.newInstance();
    
    // 设置name属性,age属性的值
    person.set("name", "hxz");
    person.set("age", new Integer(21));

    // 输出
    // hxz
    // 21
    System.out.println(person.get("name"));
    System.out.println(person.get("age"));
    
    // 输出 21
    // Commons BeanUtils包中的类也能操作这个动态生成的bean
    System.out.println(PropertyUtils.getSimpleProperty(person, "name"));

使用PropertyUtils.describe()生成Map实例,其中包含了源bean中所有可读的属性.下面的代码片段演示了这个特性

    Person author = new Person();
    author.setName("Timothy M. O'Brien");
        
    Book book = new Book();
    book.setName("Jakarta Commons Cookbook");
    book.setAuthor(author);
    
    // 取得book中的所有可读属性,返回到map中
    Map bookMap = PropertyUtils.describe(book);
    // Book类中包含一个Author类型的属性
    // 取bookMap中的author bean,并将其所有可读属性返回到authorMap中
    Map authorMap = PropertyUtils.describe(bookMap.get("author"));
    
    // 输出
    // Book Name: Jakarta Commons Cookbook
    // Author Name: Timothy M. O'Brien
    System.out.println("Book Name: " + bookMap.get("name"));
    System.out.println("Author Name: " + authorMap.get("name"));

使用PropertyUtils.copyProperties()拷贝一个bean中的属性到另一个bean中,第一个参数是目标bean,第二个参数是源bean,代码片段见下

    Book srcBook = new Book();
    srcBook.setName("Jakarta Commons Cookbook");
        
    Book destBook = new Book();
        
    PropertyUtils.copyProperties(destBook, srcBook);
        
    // 输出 
    // Jakarta Commons Cookbook
    System.out.println(destBook.getName());

    Person author = new Person();
    author.setName("Timothy M. O'Brien");
        
    Book srcBook = new Book();
    srcBook.setName("Jakarta Commons Cookbook");
    srcBook.setAuthor(author);
        
    Book destBook = new Book();
        
    PropertyUtils.copyProperties(destBook, srcBook);
        
    // 结果输出
    // Author objects identical
    if (srcBook.getAuthor() == destBook.getAuthor()) {
        System.out.println("Author objects identical");
    }

    Map srcMap = new HashMap();
    srcMap.put("name", "Jakarta Commons Cookbook");
        
    Book destBook = new Book();
        
    PropertyUtils.copyProperties(destBook, srcMap);
    // 输出
    // Jakarta Commons Cookbook
    System.out.println(destBook.getName());

使用PropertyUtils.getPropertyType()确定bean属性的类型,这个方法返回 Class 对象使用getter方法表述它的类型,下面的代码片段演示了从Book bean中检索author属性的类型

    // 直接取book的author属性类型
    Book book = new Book();
    Class type = PropertyUtils.getPropertyType(book, "author");
    // author属性类型为 Author
    System.out.println(type.getName());
    // 输出: commons.beanutils.Person

// 演示从嵌套属性中取出其值类型
    Chapter chapter = new Chapter();
    // 下面将出个这个name属性的类型,String
    chapter.setName("Chapter 3 BeanUtils");
        
    List chapters = new ArrayList();
    chapters.add(chapter);
        
    Book book2 = new Book();
    book2.setChapters(chapters);
        
    Class type2 = PropertyUtils.getPropertyType(book2, "chapters[0].name");
    // chapter的name属性类型为String
    System.out.println(type2.getName());
        
    // 输出
    // java.lang.String

    // chapters[0].name 相当于
    // book2.getChapters().get(0).getName();
    PropertyDescriptor pd = PropertyUtils.getPropertyDescriptor(book2, "chapters[0].name");
    Class type3 = pd.getPropertyType();
    Method writeMethod = pd.getWriteMethod();
    Method readMethod = pd.getReadMethod();
    System.out.println("writeMethod: " + writeMethod.getName());
    System.out.println("readMethod: " + readMethod.getName());

    // 输出
    // writeMethod: setName
    // readMethod: getName

使用PropertyUtils.getProperty()访问任何类型的bean属性(嵌套,索引,map等).
下面的代码片段演示了访问简单的属性population,嵌套的map属性cities,索引属性regions

        City richmond = new City();
        richmond.setName("Richmond");
        richmond.setPopulation(new Long(500000));

        Map cities = new HashMap();
        cities.put("richmond", richmond);
        
        Region midAtlantic = new Region();
        midAtlantic.setName("Mid-Atlantic");
        midAtlantic.setCities(cities);
        
        List regions = new ArrayList();
        regions.add(midAtlantic);
        
        Country country = new Country();
        country.setName("United States");
        country.setRegions(regions);
        
        // 检索richmod实例的population属性
        Long population = (Long)PropertyUtils.getProperty(country, "regions[0].cities(richmond).population");
        
        // 输出 50000
        System.out.println(population);

上面的getProperty()片段想当于调用以下方法:
Region region = (Region)country.getRegions().get(0);
City city = region.getCities().get("richmond");
Long population = city.getPopulation();

当调用getProperty()方法时,系统会从你提供的参数中切分"."号,分析并调用合适的方法如:
getSimpleProperty(), getNestedProperty(), getIndexedProperty(), getMappedProperty().
  

使用PropertyUtils.getMappedProperty()/setMappedProperty()提供了从Bean的map类型中取得其值的功能，
下面的代码片段演示了这个功能。

Room dining = new Room();
        dining.setArea(20);
        dining.setCarpeted(true);
        dining.setFurnished(true);

        Room bed = new Room();
        bed.setArea(25);
        bed.setCarpeted(false);
        bed.setFurnished(false);

        Map rooms = new HashMap();

        rooms.put("Dining Room", dining);

        Apartment apartment = new Apartment();
        apartment.setRooms(rooms);
        
        // 为rooms这个map类型添加一个bed对象,map的key为 Bed Room
        PropertyUtils.setMappedProperty(apartment, "rooms", "Bed Room", bed);

        // 检索dining room对象
        // 相当于调用 apartment.getRooms().get("Dining Room");
        Room room = (Room) PropertyUtils.getMappedProperty(apartment,
                "rooms(Dining Room)");
        System.out.println(room.getArea());
        
        // 检索apartment对象中rooms属性的bed room值，通过getMappedProperty()方法的另一种版本
        Room room2 = (Room) PropertyUtils.getMappedProperty(apartment, "rooms",
                "Bed Room");
        System.out.println(room2.getArea());
        
        // 输出
        // 20
        // 25

使用PorpertyUtils.getIndexedProperty()/setIndexedProperty()方法可以检索指定索引的array或list属性。
假如先前的Book类有一个chapters属性，类型为List。下面的代码片段演示了上面的方法的使用

Book book = new Book();
        Chapter chapter1 = new Chapter();
        Chapter chapter2 = new Chapter();
        chapter1.setName("BeanUtils");
        chapter2.setName("xml");
        
        book.getChapters().add(chapter1);
        //先添加chapter1两次，如只添加一次的话，list中只存在一个元素，在设置他时，将出现IndexOutOfBoundsException异常
        book.getChapters().add(chapter1);
        
        //设置chapters中第一个索引元素为 chapter2
        PropertyUtils.setIndexedProperty(book, "chapters[1]", chapter2);
        
        Chapter x = (Chapter)PropertyUtils.getIndexedProperty(book, "chapters[0]");
        Chapter y = (Chapter)PropertyUtils.getIndexedProperty(book, "chapters[1]");
        System.out.println(x.getName());
        // 可以看到，已经成功将 chapter2 设置到 chapters 中去了
        System.out.println(y.getName());
        
        // 输出
        BeanUtils
        xml

使用PropertyUtils.getNestedProperty()检索嵌套的bean属性,使用"."号识别嵌套的bean属性.
例如one.two.three.four的属性有三层,four是three的属性,而three又是two的属性,two又是one的属性.

下面来看一个代码片段,还是围绕Person等类展开

Book book = new Book();
    book.setName("富爸爸，穷爸爸");
    
    Person person = new Person();
    person.setName("Robert T.Kiyosaki");
        
    book.setAuthor(person);
    
    // catch exception
    String authorName = (String)PropertyUtils.getNestedProperty(book, "author.name");
    System.out.println("Article: " + book.getName());
    System.out.println("Author: " + authorName);

author是book类的一个属性, 它是Person类型,有一个name属性.下面是它们的类图


上面的代码片段中我们使用getNestedProperty(book, "author.name")来取得book类的author属性的name的值( 好拗口 :~( )

来一个更深的嵌套代码片段:

Book book = new Book();
    book.setName("富爸爸，穷爸爸");
        
    Person person = new Person();
    person.setName("Robert T.Kiyosaki");

    Address address = new Address();
    address.setCity("N/A");
        
    person.setAddress(address);
    book.setAuthor(person);
    
    String cityName = (String)PropertyUtils.getNestedProperty(book, "author.address.city");
    System.out.println("City: " + cityName);

PropertyUtils.getSimpleProperty()/setSimpleProperty()方法提供了通过名字访问/设置bean的属性,通过提供属性的名字返回它的值.
下面的代码片段演示了使用这个方法检索 Person 类 name 属性.

    Person person = new Person();
    person.setName("Ben");
    try {
        PropertyUtils.setSimpleProperty(person, "age", new Integer(21));
        String name = (String)PropertyUtils.getSimpleProperty(person, "name");
        Integer age = (Integer)PropertyUtils.getSimpleProperty(person, "age");
        System.out.println(name);
        System.out.println(age);
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    }

代码比较简单,值得注意的是那些异常处理,当于属性对应的名字的getter方法不可访问时(比如果private)IllegalAccessException异常产生,当getter方法本身抛出异常时,InvocationTargetException异常产生,当给定的名字属性不存在时,NoSuchMethodException异常产生,比如说Person类不存在getAddress()方法,而你又使用了getSimpleProperty(person, "address");

简单的使用这些方法,还不如来得getXXX()直接,但这种方法将你的代码绑定在编译期,如果想在运行期动态的检索,设置想关的属性,使用BeanUtils类库就比较合适了.比如说在Struts等这些框架中

这里给出另一种解决方法(mysql-4.1.11).低版本的mysql似乎没出现过中文问题(mysql-4.0.17). :)

1.添加一个过滤器,将字符集编码设为UTF-8.
修改web.xml:

 <filter>
  <filter-name>SetCharacterEncoding</filter-name>
  <filter-class>hxz.filter.SetEncodingFilter</filter-class>
  <init-param>
   <param-name>encoding</param-name>
   <param-value>UTF-8</param-value>
  </init-param>
 </filter>
 
 <filter-mapping>
  <filter-name>SetCharacterEncoding</filter-name>
  <url-pattern>/*</url-pattern>
 </filter-mapping>

新建一个过滤器:
package hxz.filter;

import java.io.IOException;

import javax.servlet.*;

public class SetEncodingFilter implements Filter {
 
 // default character encoding
 String defaultEncoding = "UTF-8"; 
 
 public void init(FilterConfig config) throws ServletException {
  String encoding = config.getInitParameter("encoding");
  if (encoding != null) {
   defaultEncoding = encoding;
  }
 }

 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
  request.setCharacterEncoding(defaultEncoding);
  chain.doFilter(request, response);
 }

 public void destroy() {
  defaultEncoding = null;
 }

}

2.修改hibernate配置文件:
<property name="url">
  <value>jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=UTF-8</value>
</property>
注意后面的:useUnicode=true&amp;characterEncoding=UTF-8, 在xml中&要改为;amp;

3.在新版本中mysql建表时,你可以选择一种字符集,将它设为utf-8.
jsp或servlet中把字符集改为UTF-8.

4.trying...

现在就来开始我们的例子吧。首先修改/WEB-INF/web.xml文件,为其添加标签库(在使用中发现，不添加也能成功。但为了保持书上一致，还是添加安全些。hoho~~)将下面代码添加至 </webapp> 上面：

<taglib>
<taglib-uri>/tags/struts-html</taglib-uri>
<taglib-location>/WEB-INF/struts-html.tld</taglib-location>
</taglib>

<taglib>
<taglib-uri>/tags/struts-bean</taglib-uri>
<taglib-location>/WEB-INF/struts-bean.tld</taglib-location>
</taglib>

<taglib>
<taglib-uri>/tags/struts-logic</taglib-uri>
<taglib-location>/WEB-INF/struts-logic.tld</taglib-location>
</taglib>
完成后，打开struts-config.xml文件，点击这个界面左下角的Design进入可视化设计界面。有没有注意右边的Palette :) 点击它，让我们来开始我们的jsp页面设计。我们先建立userLoginSuccess.jsp文件，为啥先建这一个呢？等下就知道了，在myeclipse中可以一次性把我们的Action,ActionForm,Jsp文件一次建好（将三个有关联的文件等下创建）。
点击Palette面版上的创建JSP文件图标,弹出创建JSP文件面板。图4：

在File Name里输入userLoginSuccess.jsp，Template to use选择2] Standard JSP using Struts 1.1,点击Finish完成。 完成后，struts-config.xml文件自动被更新，可视化界在上也出现了刚新建的JSP模块。新建的jsp文件也被打开了。 覆盖所有的<%@ taglib ...... 为我们开始在/WEB-INF/web.xml中定义的： <%@ taglib uri="/tags/struts-html" prefix="html"%> <%@ taglib uri="/tags/struts-bean" prefix="bean"%> <%@ taglib uri="/tags/struts-logic" prefix="logic"%> 然后在<body></body>中添加: Hello <bean:write name="userName" scope="request" /> . 这里将request中的属性userName输出在页面上，所以等下我们在UserLoginAction中，登录成功后要设置一个相关属性。

OK,下面来开始我们最后三个文件的设计吧。在Struts-config.xml的Design模式中，在画版的空白区域点右键，选择New --> New Form, Action and JSP 弹出ActionForm的选项面板，我们按图上输入相关值，图5：

OK，完成。。。下面就部暑项目，测试。。。

像为项目添加Struts框架一样，在项目名上右击，选择MyEclipse --> Add and Remove Project development. 在弹出对话框上，单击add ，在弹出的 New Deployment 对话框上，Server选Tomcat5，点击Finish完成部署，如图13: 在用浏览器上打开：http://127.0.0.1:8080/LoginDemo/userLogin.jsp 输入密码123456,用户名EricHe。显示成功： 如果输错，或不输入，则无反映又回到当前登录页面（因为我们没有设置错误信息）。 55555~~~ 终于写完了。。。。。。。2005-07-06