BlogJava-永远的船长-随笔分类-J2EE

一步一步教你远程调用EJB

船长 — Sat, 09 Sep 2006 05:48:00 GMT

前期准备：弄清楚weblogic（或jboss）、tomcat、JBluder（或eclipse＋MyEclipse）的使用方法，能写一个简单的基于struts框架的web工程，然后准备两台联网的电脑（局域网也可以），如果没有条件，也可以在同一台电脑上分别安装两个web服务器（例如：weblogic和tomcat）来代替，本文将采用后一种方法，采用weblogic作EJB容器，tomcat作web容器，用struts工程来调用EJB

准备好了吗？让我们开始下一步

第一步：写一个简单的EJB。写EJB最好用的还是JBuilder，毕竟够傻瓜化。当然作为专业人士，eclipse搭配MyEclipse是最佳选择，不过作为初学者，建议采用JBuilder。以下是本文测试所用到的EJB。

remote接口：

package testhello;

import javax.ejb.EJBObject;

public interface SayHello extends EJBObject {
public String sayHello(String name) throws java.rmi.RemoteException;
}

home接口：

package testhello;

import javax.ejb.EJBHome;
import javax.ejb.CreateException;
import java.rmi.RemoteException;

public interface SayHelloHome extends EJBHome {
public SayHello create() throws CreateException, RemoteException;
}

bean类：

package testhello;

import javax.ejb.SessionBean;
import javax.ejb.SessionContext;
import javax.ejb.CreateException;

public class SayHelloBean implements SessionBean {
    SessionContext sessionContext;
    public void ejbCreate() throws CreateException {
    }

public void ejbRemove() {
}

public void ejbActivate() {
}

public void ejbPassivate() {
}

    public void setSessionContext(SessionContext sessionContext) {
        this.sessionContext = sessionContext;
    }

    public String sayHello(String name) {
        return "Hello "+name;
    }
}

如果你是采用上面两种工具来写的话，配置文件就不必考虑了

第二步：利用JBuilder或eclipse将这个EJB工程编译并打包，会得到一个jar(如果你的工程名叫testhello，那么这个jar文件就是testhello.jar)文件。如果你的EJB容器（weblogic或JBoss）是在本机上，那么在JBuilder或eclipse中就可以直接鼠标右击EJB工程，来部署EJB。如果需要部署到远程服务器上，只需要通过EJB容器的控制台将testhello.jar上传到远程端，然后在EJB Modler里面按提示部署好EJB。最后，别忘了在JNDI Tree里面察看你的EJB工程的JNDI名，本例的JNDI名叫SayHello

第三步：将remote接口和home接口打包成jar文件，copy到你要远程调用EJB的struts工程下的lib目录（例如：helloapp ->WEB-INF ->lib）

第四步：将weblogic的weblogic.jar（在weblogic的安装目录－>weblogic81－>server－>lib文件夹中）copy到tomcat安装目录下的－>shared－>lib文件夹中，其实这里我们需要用到的只是weblogic.jar里的几个class文件而已，不过对于初学者而言，先不必去深究到底只需要那几个class。

第五步：编写一个简单的struts工程（其实这些都可以用工具生成），一下是调用EJB的HelloAction的源代码(特别要注意的是，记得要将之前第三步生成的jar包导入编辑器中，否则下面的代码编译通不过。如果你不知道导入jar包，就把那个jar包多copy一份到你的jdk安装目录 -> jre-> lib-> ext文件夹下)

package logging.actions;
import logging.Constants;

import java.util.*;
import javax.servlet.ServletException;
import javax.servlet.RequestDispatcher;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.rmi.PortableRemoteObject;

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.apache.struts.action.ActionMessage;
import org.apache.struts.action.ActionMessages;
import org.apache.struts.util.MessageResources;
import org.apache.struts.validator.DynaValidatorForm;

public final class HelloAction extends Action{

public ActionForward execute(ActionMapping mapping,
         ActionForm form,
         HttpServletRequest request,
         HttpServletResponse response)
throws Exception{

InitialContext ctx=this.getInitialContext();

//查找JNDI名为SayHello的EJB组件
Object obj=ctx.lookup("SayHello");

//获得远程EJB组件的home接口的引用
testhello.SayHelloHome home=(testhello.SayHelloHome)PortableRemoteObject.narrow(obj,testhello.SayHelloHome.class);

  //获得远程EJB组件的remote接口的引用
       testhello.SayHello hello=home.create();

       String name="飘然随风";
       String sayString=hello.sayHello(name);

       request.setAttribute("userName",name);
       request.setAttribute("passWord",sayString);
       request.removeAttribute(mapping.getAttribute());

  return mapping.findForward("loginSuccess");
}

/*以下方法是作用是：通过传递环境属性选择JNDI驱动和服务器的网络位置，
并连接到连接到JNDI树。
这是采用weblogic做EJB容器时，远程调用EJB的固定初始化模式，初学者可以死记下来
*/
private InitialContext getInitialContext() throws Exception {
  //EJB容器的地址
    String url = "t3://image:7001";
    String user = null;
    String password = null;
    Properties properties;

        properties = new Properties();
        properties.put(Context.INITIAL_CONTEXT_FACTORY,
                       "weblogic.jndi.WLInitialContextFactory");
        properties.put(Context.PROVIDER_URL, url);
        if (user != null) {
            properties.put(Context.SECURITY_PRINCIPAL, user);
            properties.put(Context.SECURITY_CREDENTIALS,
                           password == null ? "" : password);
        }
        return new javax.naming.InitialContext(properties);
}
}

第六步：如果你严格按照上面的步骤做了，那么剩下的就是同时启动weblogic和tomcat来测试了。

船长 2006-09-09 13:48 发表评论

深入 Lucene 索引机制

船长 — Tue, 01 Aug 2006 15:12:00 GMT

Lucene 是一个基于 Java 的全文检索工具包，你可以利用它来为你的应用程序加入索引和检索功能。Lucene 目前是著名的 Apache Jakarta 家族中的一个开源项目，下面我们即将学习 Lucene 的索引机制以及它的索引文件的结构。

在这篇文章中，我们首先演示如何使用 Lucene 来索引文档，接着讨论如何提高索引的性能。最后我们来分析 Lucene 的索引文件结构。需要记住的是，Lucene 不是一个完整的应用程序，而是一个信息检索包，它方便你为你的应用程序添加索引和搜索功能。

架构概览

图一显示了 Lucene 的索引机制的架构。Lucene 使用各种解析器对各种不同类型的文档进行解析。比如对于 HTML 文档，HTML 解析器会做一些预处理的工作，比如过滤文档中的 HTML 标签等等。HTML 解析器的输出的是文本内容，接着 Lucene 的分词器(Analyzer)从文本内容中提取出索引项以及相关信息，比如索引项的出现频率。接着 Lucene 的分词器把这些信息写到索引文件中。

图一：Lucene 索引机制架构

回页首

用Lucene索引文档

接下来我将一步一步的来演示如何利用 Lucene 为你的文档创建索引。只要你能将要索引的文件转化成文本格式，Lucene 就能为你的文档建立索引。比如，如果你想为 HTML 文档或者 PDF 文档建立索引，那么首先你就需要从这些文档中提取出文本信息，然后把文本信息交给 Lucene 建立索引。我们接下来的例子用来演示如何利用 Lucene 为后缀名为 txt 的文件建立索引。

1．准备文本文件

首先把一些以 txt 为后缀名的文本文件放到一个目录中，比如在 Windows 平台上，你可以放到 C:\\files_to_index 下面。

2．创建索引

清单1是为我们所准备的文档创建索引的代码。

清单1：用 Lucene 索引你的文档


												package lucene.index;

import java.io.File;
import java.io.FileReader;
import java.io.Reader;
import java.util.Date;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexWriter;

/**
 * This class demonstrates the process of creating an index with Lucene 
 * for text files in a directory.
 */
public class TextFileIndexer {
 public static void main(String[] args) throws Exception{
   //fileDir is the directory that contains the text files to be indexed
   File   fileDir  = new File("C:\\files_to_index ");

   //indexDir is the directory that hosts Lucene's index files
   File   indexDir = new File("C:\\luceneIndex");
   Analyzer luceneAnalyzer = new StandardAnalyzer();
   IndexWriter indexWriter = new IndexWriter(indexDir,luceneAnalyzer,true);
   File[] textFiles  = fileDir.listFiles();
   long startTime = new Date().getTime();

   //Add documents to the index
   for(int i = 0; i < textFiles.length; i++){
     if(textFiles[i].isFile() >> textFiles[i].getName().endsWith(".txt")){
       System.out.println("File " + textFiles[i].getCanonicalPath() 
              + " is being indexed");
       Reader textReader = new FileReader(textFiles[i]);
       Document document = new Document();
       document.add(Field.Text("content",textReader));
       document.add(Field.Text("path",textFiles[i].getPath()));
       indexWriter.addDocument(document);
     }
   }

   indexWriter.optimize();
   indexWriter.close();
   long endTime = new Date().getTime();

   System.out.println("It took " + (endTime - startTime) 
              + " milliseconds to create an index for the files in the directory "
              + fileDir.getPath());
  }
}

正如清单1所示，你可以利用 Lucene 非常方便的为文档创建索引。接下来我们分析一下清单1中的比较关键的代码，我们先从下面的一条语句开始看起。


												Analyzer luceneAnalyzer = new StandardAnalyzer();

这条语句创建了类 StandardAnalyzer 的一个实例，这个类是用来从文本中提取出索引项的。它只是抽象类 Analyzer 的其中一个实现。Analyzer 也有一些其它的子类，比如 SimpleAnalyzer 等。

我们接着看另外一条语句：


												IndexWriter indexWriter = new IndexWriter(indexDir,luceneAnalyzer,true);

这条语句创建了类 IndexWriter 的一个实例，该类也是 Lucene 索引机制里面的一个关键类。这个类能创建一个新的索引或者打开一个已存在的索引并为该所引添加文档。我们注意到该类的构造函数接受三个参数，第一个参数指定了存储索引文件的路径。第二个参数指定了在索引过程中使用什么样的分词器。最后一个参数是个布尔变量，如果值为真，那么就表示要创建一个新的索引，如果值为假，就表示打开一个已经存在的索引。

接下来的代码演示了如何添加一个文档到索引文件中。


												Document document = new Document();
document.add(Field.Text("content",textReader));
document.add(Field.Text("path",textFiles[i].getPath()));
indexWriter.addDocument(document);

首先第一行创建了类 Document 的一个实例，它由一个或者多个的域(Field)组成。你可以把这个类想象成代表了一个实际的文档，比如一个 HTML 页面，一个 PDF 文档，或者一个文本文件。而类 Document 中的域一般就是实际文档的一些属性。比如对于一个 HTML 页面，它的域可能包括标题，内容，URL 等。我们可以用不同类型的 Field 来控制文档的哪些内容应该索引，哪些内容应该存储。如果想获取更多的关于 Lucene 的域的信息，可以参考 Lucene 的帮助文档。代码的第二行和第三行为文档添加了两个域，每个域包含两个属性，分别是域的名字和域的内容。在我们的例子中两个域的名字分别是"content"和"path"。分别存储了我们需要索引的文本文件的内容和路径。最后一行把准备好的文档添加到了索引当中。

当我们把文档添加到索引中后，不要忘记关闭索引，这样才保证 Lucene 把添加的文档写回到硬盘上。下面的一句代码演示了如何关闭索引。


												indexWriter.close();

利用清单1中的代码，你就可以成功的将文本文档添加到索引中去。接下来我们看看对索引进行的另外一种重要的操作，从索引中删除文档。

回页首

从索引中删除文档

类IndexReader负责从一个已经存在的索引中删除文档，如清单2所示。

清单2：从索引中删除文档


												File   indexDir = new File("C:\\luceneIndex");
IndexReader ir = IndexReader.open(indexDir);
ir.delete(1);
ir.delete(new Term("path","C:\\file_to_index\lucene.txt"));
ir.close();

在清单2中，第二行用静态方法 IndexReader.open(indexDir) 初始化了类 IndexReader 的一个实例，这个方法的参数指定了索引的存储路径。类 IndexReader 提供了两种方法去删除一个文档，如程序中的第三行和第四行所示。第三行利用文档的编号来删除文档。每个文档都有一个系统自动生成的编号。第四行删除了路径为"C:\\file_to_index\lucene.txt"的文档。你可以通过指定文件路径来方便的删除一个文档。值得注意的是虽然利用上述代码删除文档使得该文档不能被检索到，但是并没有物理上删除该文档。Lucene 只是通过一个后缀名为 .delete 的文件来标记哪些文档已经被删除。既然没有物理上删除，我们可以方便的把这些标记为删除的文档恢复过来，如清单 3 所示，首先打开一个索引，然后调用方法 ir.undeleteAll() 来完成恢复工作。

清单3：恢复已删除文档


												File   indexDir = new File("C:\\luceneIndex");
IndexReader ir = IndexReader.open(indexDir);
ir.undeleteAll();
ir.close();

你现在也许想知道如何物理上删除索引中的文档，方法也非常简单。清单 4 演示了这个过程。

清单4：如何物理上删除文档


												File   indexDir = new File("C:\\luceneIndex");
Analyzer luceneAnalyzer = new StandardAnalyzer();
IndexWriter indexWriter = new IndexWriter(indexDir,luceneAnalyzer,false);
indexWriter.optimize();
indexWriter.close();

在清单 4 中，第三行创建了类 IndexWriter 的一个实例，并且打开了一个已经存在的索引。第 4 行对索引进行清理，清理过程中将把所有标记为删除的文档物理删除。

Lucene 没有直接提供方法对文档进行更新，如果你需要更新一个文档，那么你首先需要把这个文档从索引中删除，然后把新版本的文档加入到索引中去。

回页首

提高索引性能

利用 Lucene，在创建索引的工程中你可以充分利用机器的硬件资源来提高索引的效率。当你需要索引大量的文件时，你会注意到索引过程的瓶颈是在往磁盘上写索引文件的过程中。为了解决这个问题, Lucene 在内存中持有一块缓冲区。但我们如何控制 Lucene 的缓冲区呢？幸运的是，Lucene 的类 IndexWriter 提供了三个参数用来调整缓冲区的大小以及往磁盘上写索引文件的频率。

1．合并因子（mergeFactor）

这个参数决定了在 Lucene 的一个索引块中可以存放多少文档以及把磁盘上的索引块合并成一个大的索引块的频率。比如，如果合并因子的值是 10，那么当内存中的文档数达到 10 的时候所有的文档都必须写到磁盘上的一个新的索引块中。并且，如果磁盘上的索引块的隔数达到 10 的话，这 10 个索引块会被合并成一个新的索引块。这个参数的默认值是 10，如果需要索引的文档数非常多的话这个值将是非常不合适的。对批处理的索引来讲，为这个参数赋一个比较大的值会得到比较好的索引效果。

2．最小合并文档数

这个参数也会影响索引的性能。它决定了内存中的文档数至少达到多少才能将它们写回磁盘。这个参数的默认值是10，如果你有足够的内存，那么将这个值尽量设的比较大一些将会显著的提高索引性能。

3．最大合并文档数

这个参数决定了一个索引块中的最大的文档数。它的默认值是 Integer.MAX_VALUE，将这个参数设置为比较大的值可以提高索引效率和检索速度，由于该参数的默认值是整型的最大值，所以我们一般不需要改动这个参数。

清单 5 列出了这个三个参数用法，清单 5 和清单 1 非常相似，除了清单 5 中会设置刚才提到的三个参数。

清单5：提高索引性能


												/**
 * This class demonstrates how to improve the indexing performance 
 * by adjusting the parameters provided by IndexWriter.
 */
public class AdvancedTextFileIndexer  {
  public static void main(String[] args) throws Exception{
    //fileDir is the directory that contains the text files to be indexed
    File   fileDir  = new File("C:\\files_to_index");

    //indexDir is the directory that hosts Lucene's index files
    File   indexDir = new File("C:\\luceneIndex");
    Analyzer luceneAnalyzer = new StandardAnalyzer();
    File[] textFiles  = fileDir.listFiles();
    long startTime = new Date().getTime();

    int mergeFactor = 10;
    int minMergeDocs = 10;
    int maxMergeDocs = Integer.MAX_VALUE;
    IndexWriter indexWriter = new IndexWriter(indexDir,luceneAnalyzer,true);        
    indexWriter.mergeFactor = mergeFactor;
    indexWriter.minMergeDocs = minMergeDocs;
    indexWriter.maxMergeDocs = maxMergeDocs;

    //Add documents to the index
    for(int i = 0; i < textFiles.length; i++){
      if(textFiles[i].isFile() >> textFiles[i].getName().endsWith(".txt")){
        Reader textReader = new FileReader(textFiles[i]);
        Document document = new Document();
        document.add(Field.Text("content",textReader));
        document.add(Field.Keyword("path",textFiles[i].getPath()));
        indexWriter.addDocument(document);
      }
    }

    indexWriter.optimize();
    indexWriter.close();
    long endTime = new Date().getTime();

    System.out.println("MergeFactor: " + indexWriter.mergeFactor);
    System.out.println("MinMergeDocs: " + indexWriter.minMergeDocs);
    System.out.println("MaxMergeDocs: " + indexWriter.maxMergeDocs);
    System.out.println("Document number: " + textFiles.length);
    System.out.println("Time consumed: " + (endTime - startTime) + " milliseconds");
  }
}

通过这个例子，我们注意到在调整缓冲区的大小以及写磁盘的频率上面 Lucene 给我们提供了非常大的灵活性。现在我们来看一下代码中的关键语句。如下的代码首先创建了类 IndexWriter 的一个实例，然后对它的三个参数进行赋值。


												int mergeFactor = 10;
int minMergeDocs = 10;
int maxMergeDocs = Integer.MAX_VALUE;
IndexWriter indexWriter = new IndexWriter(indexDir,luceneAnalyzer,true);        
indexWriter.mergeFactor = mergeFactor;
indexWriter.minMergeDocs = minMergeDocs;
indexWriter.maxMergeDocs = maxMergeDocs;

下面我们来看一下这三个参数取不同的值对索引时间的影响，注意参数值的不同和索引之间的关系。我们为这个实验准备了 10000 个测试文档。表 1 显示了测试结果。

表1：测试结果

通过表 1，你可以清楚地看到三个参数对索引时间的影响。在实践中，你会经常的改变合并因子和最小合并文档数的值来提高索引性能。只要你有足够大的内存，你可以为合并因子和最小合并文档数这两个参数赋尽量大的值以提高索引效率，另外我们一般无需更改最大合并文档数这个参数的值，因为系统已经默认将它设置成了最大。

回页首

Lucene 索引文件结构分析

在分析 Lucene 的索引文件结构之前，我们先要理解反向索引（Inverted index）这个概念，反向索引是一种以索引项为中心来组织文档的方式，每个索引项指向一个文档序列，这个序列中的文档都包含该索引项。相反，在正向索引中，文档占据了中心的位置，每个文档指向了一个它所包含的索引项的序列。你可以利用反向索引轻松的找到那些文档包含了特定的索引项。Lucene正是使用了反向索引作为其基本的索引结构。

回页首

索引文件的逻辑视图

在Lucene 中有索引块的概念，每个索引块包含了一定数目的文档。我们能够对单独的索引块进行检索。图 2 显示了 Lucene 索引结构的逻辑视图。索引块的个数由索引的文档的总数以及每个索引块所能包含的最大文档数来决定。

图2：索引文件的逻辑视图

回页首

Lucene 中的关键索引文件

下面的部分将会分析Lucene中的主要的索引文件，可能分析有些索引文件的时候没有包含文件的所有的字段，但不会影响到对索引文件的理解。

1．索引块文件

这个文件包含了索引中的索引块信息，这个文件包含了每个索引块的名字以及大小等信息。表 2 显示了这个文件的结构信息。

表2：索引块文件结构

2．域信息文件

我们知道，索引中的文档由一个或者多个域组成，这个文件包含了每个索引块中的域的信息。表 3 显示了这个文件的结构。

表3：域信息文件结构

3．索引项信息文件

这是索引文件里面最核心的一个文件，它存储了所有的索引项的值以及相关信息，并且以索引项来排序。表 4 显示了这个文件的结构。

表4：索引项信息文件结构

4．频率文件

这个文件包含了包含索引项的文档的列表，以及索引项在每个文档中出现的频率信息。如果Lucene在索引项信息文件中发现有索引项和搜索词相匹配。那么 Lucene 就会在频率文件中找有哪些文件包含了该索引项。表5显示了这个文件的一个大致的结构，并没有包含这个文件的所有字段。

表5：频率文件的结构

5．位置文件

这个文件包含了索引项在每个文档中出现的位置信息，你可以利用这些信息来参与对索引结果的排序。表 6 显示了这个文件的结构

表6：位置文件的结构

到目前为止我们介绍了 Lucene 中的主要的索引文件结构，希望能对你理解 Lucene 的物理的存储结构有所帮助。

回页首

总结

目前已经有非常多的知名的组织正在使用 Lucene，比如，Lucene 为 Eclipse 的帮助系统，麻省理工学院的 OpenCourseWare 提供了搜索功能。通过阅读这篇文章，希望你能对 Lucene 的索引机制有所了解，并且你会发现利用 Lucene 创建索引是非常简单的事情。

船长 2006-08-01 23:12 发表评论

string和stringbuffer

船长 — Thu, 13 Jul 2006 09:47:00 GMT

String和StringBuffer之概览
　　非可变对象一旦创建之后就不能再被改变，可变对象则可以在创建之后被改变。String对象是非可变对象，StringBuffer对象则是可变对象。为获得更佳的性能你需要根据实际情况小心谨慎地选择到底使用这两者中的某一个。下面的话题会作详细的阐述。（注意：这个章节假设读者已经具备Java的String和StringBuffer的相关基础知识。）

创建字符串的较佳途径
你可以按照以下方式创建字符串对象：
1. String s1 = "hello";
    String s2 = "hello";
2. String s3 = new String("hello");
    String s4 = new String("hello");

上面哪种方式会带来更好的性能呢？下面的代码片断用来测量二者之间的区别。

StringTest1.java
package com.performance.string;
/** This class shows the time taken for creation of
*  String literals and String objects.
*/
public class StringTest1 {
public static void main(String[] args){
    // create String literals
    long startTime = System.currentTimeMillis();
    for(int i=0;i<50000;i++){
    String s1 = "hello";
    String s2 = "hello";
    }
    long endTime = System.currentTimeMillis();
    System.out.println("Time taken for creation of String literals : "
                  + (endTime - startTime) + " milli seconds" );
    // create String objects using 'new' keyword
    long startTime1 = System.currentTimeMillis();
    for(int i=0;i<50000;i++){
    String s3 = new String("hello");
    String s4 = new String("hello");
    }
    long endTime1 = System.currentTimeMillis();
    System.out.println("Time taken for creation of String objects : "
                  + (endTime1 - startTime1)+" milli seconds");
    }
}
这段代码的输出：
Time taken for creation of String literals : 0 milli seconds
Time taken for creation of String objects : 170 milli seconds

JVM是怎样处理字符串的呢？
　　Java虚拟机会维护一个内部的滞留字符串对象的列表（唯一字符串的池）来避免在堆内存中产生重复的String对象。当JVM从class文件里加载字符串字面量并执行的时候，它会先检查一下当前的字符串是否已经存在于滞留字符串列表，如果已经存在，那就不会再创建一个新的String对象而是将引用指向已经存在的String对象，JVM会在内部为字符串字面量作这种检查，但并不会为通过new关键字创建的String对象作这种检查。当然你可以明确地使用String.intern()方法强制JVM为通过 new关键字创建的String对象作这样的检查。这样可以强制JVM检查内部列表而使用已有的String对象。
　　所以结论是，JVM会内在地为字符串字面量维护一些唯一的String对象，程序员不需要为字符串字面量而发愁，但是可能会被一些通过 new关键字创建的String对象而困扰，不过他们可以使用intern()方法来避免在堆内存上创建重复的String对象来改善Java的运行性能。下一小节会向大家展示更多的信息。

下图展示了未使用intern()方法来创建字符串的情况。

string_creating_without_intern() method
　　你可以自己使用==操作符和String.equals()方法来编码测试上面提到的区别。==操作符会返回true如果一些引用指向一个相同的对象但不会判断String对象的内容是否相同；String.equals()方法会返回true如果被操作的String对象的内容相同。对于上面的代码会有s1==s2，因为s1和s2两个引用指向同一个对象，对于上面的代码，s3.equals(s4)会返回true因为两个对象的内容都一样为”hello”。你可以从上图看出这种机制。在这里有三个独立的包含了相同的内容（”hello”）的对象，实际上我们不需要这么三个独立的对象—— 因为要运行它们的话既浪费时间又浪费内存。

　　那么怎样才能确保String对象不会重复呢？下一个话题会涵盖对于内建String机制的兴趣。

滞留字符串的优化作用
　　同一个字符串对象被重复地创建是不必要的，String.intern ()方法可以避免这种情况。下图说明了String.intern()方法是如何工作的，String.intern()方法检查字符串对象的存在性，如果需要的字符串对象已经存在，那么它会将引用指向已经存在的字符串对象而不是重新创建一个。下图描绘了使用了intern()方法的字符串字面量和字符串对象的创建情况。

string_creating_with_intern() method
下面的例程帮助大家了解String.intern()方法的重要性。
StringTest2.java

package com.performance.string;
// This class shows the use of intern() method to improve performance
public class StringTest2 {
public static void main(String[] args){
    // create String references like s1,s2,s3...so on..
    String variables[] = new String[50000];
    for( int i=0;i        variables[i] = "s"+i;
    }
    // create String literals
    long startTime0 = System.currentTimeMillis();
    for(int i=0;i        variables[i] = "hello";
    }
    long endTime0 = System.currentTimeMillis();
    System.out.println("Time taken for creation of String literals : "
                         + (endTime0 - startTime0) + " milli seconds" );
    // create String objects using 'new' keyword
    long startTime1 = System.currentTimeMillis();
    for(int i=0;i        variables[i] = new String("hello");
    }
    long endTime1 = System.currentTimeMillis();
    System.out.println("Time taken for creation of String objects with 'new' key word : "
                        + (endTime1 - startTime1)+" milli seconds");
    // intern String objects with intern() method
    long startTime2 = System.currentTimeMillis();
    for(int i=0;i        variables[i] = new String("hello");
        variables[i] = variables[i].intern();
    }
    long endTime2 = System.currentTimeMillis();
    System.out.println("Time taken for creation of String objects with intern(): "
                        + (endTime2 - startTime2)+" milli seconds");
    }
}
这是上面那段代码的输出结果：
Time taken for creation of String literals : 0 milli seconds
Time taken for creation of String objects with 'new' key word : 160 milli seconds
Time taken for creation of String objects with intern(): 60 milli seconds

连接字符串时候的优化技巧
　　你可以使用+操作符或者String.concat()或者StringBuffer.append()等办法来连接多个字符串，那一种办法具有最佳的性能呢？
　　如何作出选择取决于两种情景，第一种情景是需要连接的字符串是在编译期决定的还是在运行期决定的，第二种情景是你使用的是 StringBuffer还是String。通常程序员会认为StringBuffer.append()方法会优于+操作符或 String.concat()方法，但是在一些特定的情况下这个假想是不成立的。

1) 第一种情景：编译期决定相对于运行期决定
请看下面的StringTest3.java代码和输出结果。

package com.performance.string;
/** This class shows the time taken by string concatenation at compile time and run time.*/
public class StringTest3 {
  public static void main(String[] args){
    //Test the String Concatination
    long startTime = System.currentTimeMillis();
    for(int i=0;i<5000;i++){
    String result = "This is"+ "testing the"+ "difference"+ "between"+
            "String"+ "and"+ "StringBuffer";
    }
    long endTime = System.currentTimeMillis();
    System.out.println("Time taken for string concatenation using + operator : "
         + (endTime - startTime)+ " milli seconds");
    //Test the StringBuffer Concatination
    long startTime1 = System.currentTimeMillis();
    for(int i=0;i<5000;i++){
    StringBuffer result = new StringBuffer();
         result.append("This is");
        result.append("testing the");
        result.append("difference");
        result.append("between");
       result.append("String");
       result.append("and");
       result.append("StringBuffer");
     }
    long endTime1 = System.currentTimeMillis();
    System.out.println("Time taken for String concatenation using StringBuffer : "
           + (endTime1 - startTime1)+ " milli seconds");
  }
}
这是上面的代码的输出结果：
Time taken for String concatenation using + operator : 0 milli seconds
Time taken for String concatenation using StringBuffer : 50 milli seconds
很有趣地，+操作符居然比StringBuffer.append()方法要快，为什么呢？

　　这里编译器的优化起了关键作用，编译器像下面举例的那样简单地在编译期连接多个字符串。它使用编译期决定取代运行期决定，在你使用new关键字来创建String对象的时候也是如此。

编译前：
String result = "This is"+"testing the"+"difference"+"between"+"String"+"and"+"StringBuffer";
编译后：
String result = "This is testing the difference between String and StringBuffer";

这里String对象在编译期就决定了而StringBuffer对象是在运行期决定的。运行期决定需要额外的开销当字符串的值无法预先知道的时候，编译期决定作用于字符串的值可以预先知道的时候，下面是一个例子。

编译前：
public String getString(String str1,String str2) {
    return str1+str2;
}
编译后：
return new StringBuffer().append(str1).append(str2).toString();
运行期决定需要更多的时间来运行。

2) 第二种情景：使用StringBuffer取代String
看看下面的代码你会发现与情景一相反的结果——连接多个字符串的时候StringBuffer要比String快。
StringTest4.java

package com.performance.string;
/** This class shows the time taken by string concatenation
using + operator and StringBuffer  */
public class StringTest4 {
public static void main(String[] args){
    //Test the String Concatenation using + operator
    long startTime = System.currentTimeMillis();
    String result = "hello";
    for(int i=0;i<1500;i++){
        result += "hello";
    }
    long endTime = System.currentTimeMillis();
    System.out.println("Time taken for string concatenation using + operator : "
                  + (endTime - startTime)+ " milli seconds");
    //Test the String Concatenation using StringBuffer
    long startTime1 = System.currentTimeMillis();
    StringBuffer result1 = new StringBuffer("hello");
    for(int i=0;i<1500;i++){
        result1.append("hello");
    }
    long endTime1 = System.currentTimeMillis();
    System.out.println("Time taken for string concatenation using StringBuffer :  "
                  + (endTime1 - startTime1)+ " milli seconds");
    }
}
这是上面的代码的输出结果：
Time taken for string concatenation using + operator : 280 milli seconds
Time taken for String concatenation using StringBuffer : 0 milli seconds
看得出StringBuffer.append()方法要比+操作符要快得多，为什么呢？

　　原因是两者都是在运行期决定字符串对象，但是+操作符使用不同于StringBuffer.append()的规则通过String和StringBuffer来完成字符串连接操作。（译注：什么样的规则呢？）

借助StringBuffer的初始化过程的优化技巧
　　你可以通过StringBuffer的构造函数来设定它的初始化容量，这样可以明显地提升性能。这里提到的构造函数是StringBuffer(int length)，length参数表示当前的StringBuffer能保持的字符数量。你也可以使用ensureCapacity(int minimumcapacity)方法在StringBuffer对象创建之后设置它的容量。首先我们看看StringBuffer的缺省行为，然后再找出一条更好的提升性能的途径。

StringBuffer的缺省行为：
　　StringBuffer在内部维护一个字符数组，当你使用缺省的构造函数来创建StringBuffer对象的时候，因为没有设置初始化字符长度，StringBuffer的容量被初始化为16个字符，也就是说缺省容量就是16个字符。当StringBuffer达到最大容量的时候，它会将自身容量增加到当前的2倍再加2，也就是（2*旧值+2）。
　　如果你使用缺省值，初始化之后接着往里面追加字符，在你追加到第16个字符的时候它会将容量增加到34（2*16+2），当追加到34个字符的时候就会将容量增加到70（2*34+2）。无论何事只要StringBuffer到达它的最大容量它就不得不创建一个新的字符数组然后重新将旧字符和新字符都拷贝一遍——这也太昂贵了点。所以总是给StringBuffer设置一个合理的初始化容量值是错不了的，这样会带来立竿见影的性能增益。
　　我利用两个StringBuffer重新测试了上面的StringTest4.java代码，一个未使用初始化容量值而另一个使用了。这次我追加了50000个’hello’对象没有使用+操作符。区别是我使用StringBuffer(250000)的构造函数来初始化第二个 StringBuffer了。

输出结果如下：
Time taken for String concatenation using StringBuffer with out setting size: 280 milli seconds
Time taken for String concatenation using StringBuffer with setting size: 0 milli seconds
StringBuffer初始化过程的调整的作用由此可见一斑。所以，使用一个合适的容量值来初始化StringBuffer永远都是一个最佳的建议。

关键点
1. 无论何时只要可能的话使用字符串字面量来常见字符串而不是使用new关键字来创建字符串。
2. 无论何时当你要使用new关键字来创建很多内容重复的字符串的话，请使用String.intern()方法。
3. +操作符会为字符串连接提供最佳的性能——当字符串是在编译期决定的时候。
4. 如果字符串在运行期决定，使用一个合适的初期容量值初始化的StringBuffer会为字符串连接提供最佳的性能

http://java.chinaitlab.com/JDK/364481.html

船长 2006-07-13 17:47 发表评论

xml的document和xml字符串间的转换

船长 — Thu, 13 Jul 2006 04:52:00 GMT

XML字符串和XML DOCUMENT的相互转换

在做一般的XML数据交换过程中，我更乐意传递XML字符串，而不是格式化的XML Document。这就涉及到XML字符串和Xml Document的转换问题，说白了这是个很简单的问题，本文就各种XML解析器分别列举如下，以方便自己今后查阅。

一、使用最原始的javax.xml.parsers，标准的jdk api

// 字符串转XML
String xmlStr = \"......\";
StringReader sr = new StringReader(xmlStr);
InputSource is = new InputSource(sr);
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder=factory.newDocumentBuilder();
Document doc = builder.parse(is);

//XML转字符串
TransformerFactory tf = TransformerFactory.newInstance();
Transformer t = tf.newTransformer();
t.setOutputProperty(\"encoding\",\"GB23121\");//解决中文问题，试过用GBK不行
ByteArrayOutputStream bos = new ByteArrayOutputStream();
t.transform(new DOMSource(doc), new StreamResult(bos));
String xmlStr = bos.toString();

这里的XML DOCUMENT为org.w3c.dom.Document

二、使用dom4j后程序变得更简单

// 字符串转XML
String xmlStr = \"......\";
Document document = DocumentHelper.parseText(xmlStr);

// XML转字符串
Document document = ...;
String text = document.asXML();

这里的XML DOCUMENT为org.dom4j.Document

三、使用JDOM

JDOM的处理方式和第一种方法处理非常类似

//字符串转XML
String xmlStr = \".....\";
StringReader sr = new StringReader(xmlStr);
InputSource is = new InputSource(sr);
Document doc = (new SAXBuilder()).build(is);

//XML转字符串
Format format = Format.getPrettyFormat();
format.setEncoding(\"gb2312\");//设置xml文件的字符为gb2312，解决中文问题
XMLOutputter xmlout = new XMLOutputter(format);
ByteArrayOutputStream bo = new ByteArrayOutputStream();
xmlout.output(doc,bo);
String xmlStr = bo.toString();

这里的XML DOCUMENT为org.jdom.Document

四、JAVASCRIPT中的处理

//字符串转XML
var xmlStr = \".....\";
var xmlDoc = new ActiveXObject(\"Microsoft.XMLDOM\");
xmlDoc.async=false;
xmlDoc.loadXML(xmlStr);
//可以处理这个xmlDoc了
var name = xmlDoc.selectSingleNode(\"/person/name\");
alert(name.text);

//XML转字符串
var xmlDoc = ......;
var xmlStr = xmlDoc.xml

这里的XML DOCUMENT为javascript版的XMLDOM

船长 2006-07-13 12:52 发表评论

关于clob字段的一些讨论

船长 — Tue, 11 Jul 2006 03:07:00 GMT

在网上闲逛找到了解决方案：
     现在3.x中对blob和clob增加了org.hibernate.lob.SerializableBlob和org.hibernate.lob.SerializableClob类的封装。

其次如果你将前面的测试程序放到weblogic的容器中通过weblogic的数据源得到连接的话，你会发现oracle.sql.BLOB blob = (oracle.sql.BLOB)person.getImage();和 oracle.sql.CLOB clob = (oracle.sql.CLOB)person.getArticle();这俩行会出错，原因就是weblogic进行了包装。

现在将以上两个问题的综合解决方案用以下代码说明：

            for (int i = 0; i < 10; i++) {
                LargeObject large = new LargeObject();
                large.setId(i + "");
                large.setName("林意炜");

                // 插入一个小数据数据
                large.setImage(Hibernate.createBlob(new byte[1]));
                large.setArticle(Hibernate.createClob(" "));

                session.save(large);
                session.flush();

                // 锁定该记录
                session.refresh(large, LockMode.UPGRADE);

                // 插入图片数据
                String fileName = "E:/AAA/" + i + ".jpg";
                SerializableBlob sb = (SerializableBlob)large.getImage();
                java.sql.Blob wrapBlob = sb.getWrappedBlob();
                // 通过非weblogic容器中数据源获得连接的情况
                if(wrapBlob instanceof oracle.sql.BLOB){
                    oracle.sql.BLOB blob = (oracle.sql.BLOB) wrapBlob;
                    OutputStream out = blob.getBinaryOutputStream();
                    out.write(getData(fileName));
                    out.close();
                }
                // 使用weblogic的Oracle Thin driver类型连接池，驱动类名：oracle.jdbc.OracleDriver
                else if(wrapBlob instanceof weblogic.jdbc.vendor.oracle.OracleThinBlob){
                    OracleThinBlob blob = (OracleThinBlob)wrapBlob;
                    OutputStream out = blob.getBinaryOutputStream();
                    out.write(getData(fileName));
                    out.close();
                }

                // 插入文章数据
                fileName = "E:/AAA/" + i + ".java";
                SerializableClob cb = (SerializableClob)large.getArticle();
                java.sql.Clob wrapClob = cb.getWrappedClob();
                // 通过非weblogic容器中数据源获得连接的情况
                if(wrapClob instanceof oracle.sql.CLOB){
                    oracle.sql.CLOB clob = (oracle.sql.CLOB) wrapClob;
                    Writer writer = clob.getCharacterOutputStream();
                    String article = new String(getData(fileName));
                    writer.write(article);
                    writer.close();
                }
                // 使用weblogic的Oracle Thin driver类型连接池，驱动类名：oracle.jdbc.OracleDriver
                else if(wrapClob instanceof weblogic.jdbc.vendor.oracle.OracleThinClob){
                    OracleThinClob clob = (OracleThinClob)wrapClob;
                    Writer writer = clob.getCharacterOutputStream();
                    String article = new String(getData(fileName));
                    writer.write(article);
                    writer.close();
                }
            }

***************************************************
采用得是ORACLE9i数据库，Jboss或Weblogic。
JDBC采用ORACLE9i自带的Class12.jar
－－－－－－－－－－－－－
数据库结构：

java代码:

CREATE TABLE SNCPARAMETERS 
(
  ID     NUMBER(19)                             NOT NULL, 
  SNCID  NUMBER(19), 
  NAME   VARCHAR2(255), 
  VALUE  CLOB 
)

－－－－－－－－－－－－－－
BO采用xdoclet建立的：

java代码:

publicclass SNCParameters extends BaseObject 
{

    /** 
     * Returns the id. 
     * 
     * @return      long 
     * @hibernate.id 
     *          column = "id" 
     *          type = "long" 
     *          generator-class = "native" 
     *          unsaved-value = "null" 
     */
    publicLong getId()
    {
        return id; 
    }

    /** 
     *    Sets the Id attribute of the SNCParameters object 
     * 
     * @param    id  The new Id value 
     */
    publicvoid setId(Long id)
    {
        this.id = id; 
    }


    /** 
     * Returns the name. 
     * 
     * @return      String 
     * 
     * @hibernate.property 
     *          column = "name" 
     *          type = "string" 
     *          not-null = "true" 
     *          unique = "false" 
     */

    publicString getName()
    {
        return name; 
    }

    /** 
     *    Sets the Name attribute of the SNCParameters object 
     * 
     * @param    name  The new Name value 
     */
    publicvoid setName(String name)
    {
        this.name = name; 
    }

    /** 
     * Returns the sncId. 
     * 
     * @return      Long 
     * 
     * @hibernate.property 
     *          column = "sncId" 
     *          type = "long" 
     *          not-null = "true" 
     *          unique = "false" 
     */

    publicLong getSncId()
    {
        return sncId; 
    }

    /** 
     *    Sets the SncId attribute of the SNCParameters object 
     * 
     * @param    sncId  The new SncId value 
     */
    publicvoid setSncId(Long sncId)
    {
        this.sncId = sncId; 
    }

    /** 
     * Returns the values. 
     * 
     * @return      Clob 
     * 
     * @hibernate.property 
     *          column = "value" 
     *          type = "clob" 
     *          not-null = "true" 
     *          unique = "false" 
     */

    publicClob getValue()
    {
        return value; 
    }

    /** 
     *    Sets the Values attribute of the SNCParameters object 
     * 
     * @param    values  The new Values value 
     */
    publicvoid setValue(Clob value)
    {
        this.value = value; 
    }
    privateLong id; 
    privateLong sncId; 
    privateString name; 
    privateClob value; 
    privateString valueString; 
    publicString getValueString()
    {
        return valueString; 
    }
        publicvoid setValueString(String  valueString)
    {
        this.valueString = valueString; 
    }
}

注：valueString并不映射到数据库的CLOB字段，只是方便需要使用这个BO的人用GET、SET 处理这个巨长的CLOB字段
－－－－－－－－－－－－
xdocLet生成的XML文件：

java代码:

1.0"?> 

PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 2.0//EN" 
    "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

 
    <class
        name="com.idncn.mc.bo.SNCParameters" 
        table="SNCParameters" 
        dynamic-update="false" 
        dynamic-insert="false" 
    > 

                    name="id" 
            column="id" 
            type="long" 
            unsaved-value="null" 
        > 
            class="native"> 
             
         

                    name="name" 
            type="string" 
            update="true" 
            insert="true" 
            column="name" 
            not-null="true" 
            unique="false" 
        /> 

                    name="sncId" 
            type="long" 
            update="true" 
            insert="true" 
            column="sncId" 
            not-null="true" 
            unique="false" 
        /> 

                    name="value" 
            type="clob" 
            update="true" 
            insert="true" 
            column="value" 
            not-null="true" 
            unique="false" 
        /> 
    class> 

 

－－－－－－－－－－－－－－－－－－－－
insert的代码：

java代码:

    publicList batchAddSncParameters(List sncParametersList, Long sncId)throws DbAccessException 
    {
        logger.enterMethod(); 
        List ret = newArrayList(); 
        try
        {
            sess = getSession(); 
            if(sncParametersList != null && sncParametersList.size() > 0)
            {
                for(int i = 0; i < sncParametersList.size(); i++)
                {
                    SNCParameters cp = (SNCParameters) sncParametersList.get(i); 
                    long newId = -1; 
                    if(cp != null)
                    {
                        SNCParameters cpNew = new SNCParameters(); 
                        cpNew.setSncId(sncId); 
                        cpNew.setName(cp.getName()); 
                        cpNew.setValue(Hibernate.createClob(" ")); 
                        newId = ((Long) sess.save(cpNew)).longValue(); 
                        sess.flush(); 

                        sess.refresh(cpNew, LockMode.UPGRADE); 
                        String content = cp.getValueString(); 

                        String appserver = System.getProperty("appserver", "jboss"); 
                        if(!appserver.equalsIgnoreCase("jboss"))
                        {
                            //weblogic
                            OracleThinClob clob = (OracleThinClob) cpNew.getValue(); 
                            java.io.Writer pw = clob.getCharacterOutputStream(); 
                            pw.write(content); 
                            pw.flush(); 
                            pw.close(); 
                        }
                        else
                        {
                            //jboss
                            oracle.sql.CLOB clob = (oracle.sql.CLOB) cpNew.getValue(); 
                            java.io.Writer pw = clob.getCharacterOutputStream(); 
                            pw.write(content); 
                            pw.flush(); 
                            pw.close(); 
                        }
                        ret.add(newLong(newId)); 
                    }
                }
            }
        }
        catch(Exception e)
        {
            logger.error(e); 
            ErrorReason errorReason = new ErrorReason(ErrorReason.INSERT_OBJECT_FAILED_REASON); 
            throw new DbAccessException(DbAccessException.DBA_OPERATE_EXCEPTION, errorReason); 
        }
        finally
        {
            closeSession(sess); 
            logger.exitMethod(); 
        }
        return ret; 
    }

－－－－－－－－－－－－－－－－－
注：Weblogic必须使用weblogic.jdbc.vendor.oracle.OracleThinClob
－－－－－－－－－－－－－－－－－－－－－
读取CLOB字段：

java代码:

    publicList selectSncParametersBySncId(long sncId)throws DbAccessException 
    {
        logger.enterMethod(); 
        List ret = newArrayList(); 
        try
        {
            sess = getSession(); 
            String query = "select cp from cp in class com.idncn.mc.bo.SNCParameters where cp.sncId = ?"; 
            logger.debug("SQL=" + query); 
            List iter = sess.find(query, newLong(sncId), Hibernate.LONG); 
            for(int i = 0; i < iter.size(); i++)
            {
                SNCParameters newCp = new SNCParameters(); 
                SNCParameters cp = (SNCParameters)(iter.get(i)); 
                logger.debug("after fetch:" + cp); 
                newCp.setId(cp.getId()); 
                newCp.setSncId(cp.getSncId()); 
                newCp.setName(cp.getName()); 
                java.sql.Clob clob = cp.getValue(); 
                if(clob != null)
                {
                    logger.debug("b===" + clob.length()); 
                    String b = clob.getSubString(1, (int) clob.length()); 
                    //logger.debug("b==="+b);
                    newCp.setValueString(b); 
                }
                ret.add(newCp); 
            }
        }
        catch(Exception e)
        {
            logger.error(e); 
            ErrorReason errorReason = new ErrorReason(ErrorReason.SELECT_FAILED_REASON); 
            throw new DbAccessException(DbAccessException.DBA_OPERATE_EXCEPTION, errorReason); 
        }
        finally
        {
            closeSession(sess); 
            logger.exitMethod(); 
        }
        return ret; 
    }

－－－－－－－－－－－－－－－
更新这个字段的代码：

java代码:

    publicvoid updateSncParameters(SNCParameters newParam)throws DbAccessException 
    {
        logger.enterMethod(); 
        try
        {
            sess = getSession(); 

            Long id = newParam.getId(); 
            SNCParameters pp = (SNCParameters) sess.load(SNCParameters.class, id, net.sf.hibernate.LockMode.UPGRADE); 

            pp.setSncId(newParam.getSncId()); 
            pp.setName(newParam.getName()); 
            pp.setId(newParam.getId()); 

            String newValue = newParam.getValueString(); 
            logger.debug("Update Length =" + newValue.length()); 

            String appserver = System.getProperty("appserver", "jboss"); 
            logger.debug("appserver: " + appserver); 
            if(!appserver.equalsIgnoreCase("jboss"))
            {
                //weblogic
                OracleThinClob clob = (OracleThinClob) pp.getValue(); 
                if(pp != null)
                {
                    java.io.Writer pw = clob.getCharacterOutputStream(); 
                    pw.write(newValue); 
                    pw.flush(); 
                    pw.close(); 
                }
            }
            else
            {
                //jboss
                oracle.sql.CLOB clob = (oracle.sql.CLOB) pp.getValue(); 
                if(pp != null)
                {
                    java.io.Writer pw = clob.getCharacterOutputStream(); 
                    pw.write(newValue); 
                    pw.flush(); 
                    pw.close(); 
                }
            }
        }
        catch(Exception e)
        {
            logger.error(e); 
            ErrorReason errorReason = new ErrorReason(ErrorReason.UPDATE_OBJECT_FAILED_REASON); 
            throw new DbAccessException(DbAccessException.DBA_OPERATE_EXCEPTION, errorReason); 
        }
        finally
        {
            closeSession(sess); 
            logger.exitMethod(); 
        }
    }

船长 2006-07-11 11:07 发表评论

web中下拉列表的几种实现

船长 — Mon, 10 Jul 2006 05:52:00 GMT

总结一下关于web上使用下拉框的情况

从数据库中获得数据List，将数据放到Request里面
        使用setAttribute（”AList”,AList）
A中有2个属性（String id,String value）

1.        使用JSTL的forEach方式

2.        使用struts的标签

查一下struts的api文档，可以看到select 中选项有3 taglib可以使用。
第一种直接使用把所有选项写在中间。

0-15
 15-20
 20-30
 30 or above

第二种：把选项放在一个Collection中(这里使用List).在实际项目中，更多的是可能数据来源于db,文件等。这种情况用得比较多。


把option放在list中的过程在Action中作处理
//prepare the age selector list.
List ageList =new ArrayList();
ageList.add(new LabelValueBean("0-15","0-15"));
ageList.add(new LabelValueBean("15-20","15-20"));
ageList.add(new LabelValueBean("20-30","20-30"));
ageList.add(new LabelValueBean("30 or above","30 or above"));
request.setAttribute("AList",AList);

这里使用了LabelValueBean，可以不用的，象

只要在AList中填入的bean有value和id属性就可以

第三种，把此list 作为Form 的一个属性.

在Form 中添加AList 的setter和getter. Form中作如下处理。
//the list can be a form property.
f.setAgeList(AList);

1.        从数据库中获得数据，你应该在Action里面取得数据后，将数据放到Request里面
2.        数据取出来后放在一个List或Collection或Map里面，我习惯用List
3.        从List或其它的容器中取数据应该用或
4.         和外层必须用，所以这个属性你必须在FormBean里定义
5.        由于你要用到这些标签，所以你必须定义FormBean
6.
从Action取数据，以List为例

List list = xxxxx;//从数据库中取得下拉列表中的数据
request.setAttribute("list",list);

在页面显示


...



...

补充一点点：

因为数据你要从数据库去取，所以一般在 action 里调用 DAO ，作为 request 的一个属性传到页面上；这时一般用标签

另外，如果数据不从数据库去取，而是代码固定的，则一般把这种放到 ActionForm 里，作为属性在页面上取，这时一般用

船长 2006-07-10 13:52 发表评论