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 发表评论

struts标签收集

船长 — Thu, 06 Jul 2006 09:10:00 GMT

Struts提供了五个标签库，即：HTML、Bean、Logic、Template和Nested。

标签库	说明
HTML 标签	用来创建能够和Struts 框架和其他相应的HTML 标签交互的HTML 输入表单
Bean 标签	在访问JavaBeans 及其属性，以及定义一个新的bean 时使用
Logic 标签	管理条件产生的输出和对象集产生的循环
Template 标签	随着Tiles框架包的出现，此标记已开始减少使用
Nested 标签	增强对其他的Struts 标签的嵌套使用的能力

标签的公共特征

使用固定属性名称的Struts 标签：

属性	说明
id	命名自定义标签创建时的脚本变量名。
name	指出关键字值，在该关键字下可以找到一个存在的bean 。如果给出了scope属性，则仅仅在scope中查找。否则，根据标准的顺序在各种scope中查找：(page, request, session, or application)。
property	指出bean 中的某个属性，可以在其中检索值。如果没有标明，则使用对象本身的值。
scope	定义了Bean在哪个范围(page, request, session, or application)中被查找。如果没有标明按顺序查找。脚本变量(见id)将在相同的范围中创建。

Struts 标签也支持嵌套引用，例如：

Property="foo.bar.baz"

这相当于进行下面的调用：
getFoo().getBar().getBaz()；

或者做为setter：
getFoo().getBar().setBaz(value)；

虽然Struts 标签的设计原意是为了避免使用scriptlet，scriptlet的表达式还能够提供给所有的Struts 标签使用。但请确保使用完整的表达式:

错误：
/index.jsp>'>

正确：
'> // 表达式必须提供整个属性值

Html 标签库

标签
它有两个属性：locale和xhtml，两者都不是必需的。

此行代码解析后：

说明：生成的结果取决于Struts应用程序所位于的服务器的locale。如果你将应用程序部署到一个不同locale的服务器，你不需要改变代码，Locale会自动调整。
标签：表示所包含页面的绝对位置。这个标签只有内嵌在head标签中才有效。

此行代码解析后：
标签
最重要的属性page：图象文件的路径，前面必须带有一个斜线。
其它属性：heignt、width、alt。
标签
Click demo

此行代码解析后：
Click demo
标签：通过一个简单的标签，你就可以在一个JSP页面上显示完全自定义的错误信息。功能超强大！！
说明：这个标签在Request对象的属性集合中查找reserved key。如果它找到一个reserved key，它就假设这个key是一个String、或是一个String数组
      （它包含在模块的MessageResources中查找的message keys）、或是类型为org.apache.struts.action.ActionErrors的一个对象。
         如果在应用程序资源中存在相应的信息，那么就可以用下面这些可选的message keys：
        · errors.header  or errors.prefix：相应的信息在错误信息的单独列表前显示。
        · errors.footer or errors.suffix：相应的信息在错误信息的单独列表后显示。

标签系列
使用标签时必须遵循一些规则：

标签中必须包含一个action属性，它是这个标签中唯一必需的属性。如果不具备该属性则JSP页面会抛出一个异常。之后你必须给这个action属性指定一个有效值。一个有效值是指应用程序的Struts配置文件中元素里的任何一个子元素的访问路径。而且相应的元素中必须有一个name属性，它的值是form bean的名称。

如果你有上述一个标签，那么你的Struts配置文件的元素中必须有一个如下显示为粗体的元素：

           type=\"com.javapro.struts.LoginAction\"
      name=\"loginForm\"
      scope=\"request\"
      input=\"/login.jsp\">


    .
    .
    .
// 这就是说一个form标签是和form bean相关联的。

任何包含在中用来接收用户输入的标签（、、、、<radio>、<checkbox>、<select>）必须在相关的form bean中有一个指定的属性值。比如，如果你有一个属性值被指定为“username”的<text>标签，那么相关的form bean中也必须有一个名为“username”的属性。输入<text>标签中的值会被用于生成form bean的userName属性。</div></li></ol><div> <form>标签还有一些不是必须但很有用的“次要”属性。 比如，你可以用focus属性来生成JavaScript，它会“定焦”（focus）到该form所包含的一个元素上。使用focus属性时你需要给它指定元素的名称。 </div><div><table style="WIDTH: 664px; HEIGHT: 397px" bordercolor="#000000" cellspacing="1" cellpadding="1" bgcolor="#ffffcc" border="1"><tbody><tr><td> <body> <html:form action=\"/login\" focus=\"password\"> User Name: <html:text property=\"userName\"/> Password: <html:text property=\"password\"/> <html:submit/> </html:form> </body> 代码解析后： <body> <form name=\"loginForm\" method=\"post\" action=\"/myStrutsApp/login.do\"> User Name: <input type=\"text\" name=\"userName\" value=\"\"> Password: <input type=\"text\" name=\"password\" value=\"\"> <input type=\"submit\" value=\"Submit\"> </form> <script language=\"JavaScript\" type=\"text/javascript\">  </script> </body></td></tr></tbody></table></div>有没有看到这个标签库是如何建立JavaScript来定焦到password元素上的? 这也是该库让人着迷的地方之一。你不用担心如何在客户端进行编程，它会帮你自动生成。 还可以看到，<form>标签中method属性的缺省值是POST。 <text>标签、<hidden>标签、<textarea>标签、<radio>标签、<checkbox>标签、<submit>标签、<reset>标签： 都有一个property属性，最后会被转换成HTML中的name属性，当然还有name和value属性。 <password>标签 <div><table style="WIDTH: 664px; HEIGHT: 24px" bordercolor="#000000" cellspacing="1" cellpadding="1" bgcolor="#ffffcc" border="1"><tbody><tr><td> <html:password property=\"password\" redisplay=\"false\"/></td></tr></tbody></table></div>该标签中的一个很重要的属性是"redisplay"，它用于重新显示以前输入到这个区域中的值。该属性的缺省值为true。然而，为了使password不能被重新显示，你或许希望将该属性的值设为false。 <select>标签和<option>标签： <div><table style="WIDTH: 663px; HEIGHT: 24px" bordercolor="#000000" cellspacing="1" cellpadding="1" bgcolor="#ffffcc" border="1"><tbody><tr><td> <html:select property=\"color\" size=\"3\"> <html:option value=\"r\">red</html:option> <html:option value= \"g\">green</html:option> <html:option value= \"b\">blue</html:option> </html:select></td></tr></tbody></table></div></li></ol>遗补：1.)<html:link>标签<blockquote dir="ltr" style="MARGIN-RIGHT: 0px">forward属性：链接到一个global forward上；action属性：链接到一个action mapping上； href属性：这个链接会转发给控制器，由控制器做决定；page属性：一个相对的链接。 用page属性链接到action上： <table style="WIDTH: 663px; HEIGHT: 56px" bordercolor="#000000" cellspacing="1" cellpadding="1" bgcolor="#ffffcc" border="1"><tbody><tr><td> <html:link page="/html-link.do"> Linking with the page attribute. </html:link></td></tr></tbody></table> 注意，上面的代码中你不必指定web的关联。相反的，如果你使用href属性，你就必须像下面所示指出web的关联(这里的关联就是struts-exercise)： <table style="WIDTH: 664px; HEIGHT: 56px" bordercolor="#000000" cellspacing="1" cellpadding="1" bgcolor="#ffffcc" border="1"><tbody><tr><td> <html:link href="/struts-exercise-taglib/html-link.do"> Using Href </html:link></td></tr></tbody></table> 很明显，当你在相同的web应用程序中做链接是，它比page属性更加好。你也能用href在不同的服务器上创建链接： <table style="WIDTH: 663px; HEIGHT: 56px" bordercolor="#000000" cellspacing="1" cellpadding="1" bgcolor="#ffffcc" border="1"><tbody><tr><td> <html:link href="<a href="http://otherserver/strutsTut/html-link.do">http://otherserver/strutsTut/html-link.do</a>"> Using Href </html:link></td></tr></tbody></table> 另一种链接到html-link.do的方法是用action属性： <table style="WIDTH: 662px; HEIGHT: 56px" bordercolor="#000000" cellspacing="1" cellpadding="1" bgcolor="#ffffcc" border="1"><tbody><tr><td> <html:link action="/html-link"> Using Action attribute </html:link></td></tr></tbody></table> 你也可以以硬编码的方式使用参数： <table style="WIDTH: 663px; HEIGHT: 56px" bordercolor="#000000" cellspacing="1" cellpadding="1" bgcolor="#ffffcc" border="1"><tbody><tr><td> <html:link page="/htmllink.do?doubleProp=3.3&longProp=32"> Double and long via hard coded changes </html:link></td></tr></tbody></table> 或者使用paramId, paramName, and paramProperty属性： <table style="WIDTH: 660px; HEIGHT: 72px" bordercolor="#000000" cellspacing="1" cellpadding="1" bgcolor="#ffffcc" border="1"><tbody><tr><td> <html:link page="/html-link.do" paramId="booleanProperty" paramName="testbean" paramProperty="nested.booleanProperty"> Boolean via paramId, paramName, and paramValue </html:link></td></tr></tbody></table> 解析后的代码： <table style="WIDTH: 661px; HEIGHT: 56px" bordercolor="#000000" cellspacing="1" cellpadding="1" bgcolor="#ffffcc" border="1"><tbody><tr><td> <a href="/struts-exercise-taglib/html-link.do?booleanProperty=false"> Boolean via paramId, paramName, and paramValue </a></td></tr></tbody></table> 另外，还能使用带name属性的Map来实现传递多个参数： <table style="WIDTH: 662px; HEIGHT: 200px" bordercolor="#000000" cellspacing="1" cellpadding="1" bgcolor="#ffffcc" border="1"><tbody><tr><td> <% java.util.HashMap newValues = new java.util.HashMap(); newValues.put("floatProperty", new Float(444.0)); newValues.put("intProperty", new Integer(555)); newValues.put("stringArray", new String[] { "Value 1", "Value 2", "Value 3" }); pageContext.setAttribute("newValues", newValues); %> ... <html:link action="/html-link" name="newValues"> Float, int, and stringArray via name (Map) </html:link></td></tr></tbody></table> 你也能够链接到Map类型的action上，上面的代码解析后的结果： <table bordercolor="#000000" cellspacing="1" cellpadding="1" bgcolor="#ffffcc" border="1"><tbody><tr><td> <html:messages property="property2" message="true" id="msg" header="messages.header" footer="messages.footer"> <tr><td><%= pageContext.getAttribute("msg") %></td></tr> </html:messages></td></tr></tbody></table>2.) select和option标签 <html:select> 的属性：property－与ActionForm中的某个属性对应；size－显示option的数目；multiple－默认为fales，表示不能多选，当设定为true时，property对应的ActionForm的属性必须为数组。 <html:select property="name" size=6 multiple="true"> <html:option>的属性：key、local、bundle－指定Resource Bundle中的内容。 例如 <html:option value="color1">Orange</html:option> <html:option value="color1" bundle="htmlselect.Colors" key="htmlselect.red"/> 它和配置文件中的<message-resources>元素的key属性匹配 --> <message-resource parmeter="HtmlSelectColors" key="htmlselect.Colors"/> <message-resource>中配置的资源文件为HtmlSelectColors.properties，相关内容为 htmlselect.red=RED <html:options>标签，提供了一组<option>元素，在<html:select>元素中可以包含多个<html:options>元素。非常灵活，可以取得集合或数组中的值。 例1 <html:options collection="coll" property="value" labelProperty="label" /> 这指在coll的集合中存放了options，value指实际能被提交的值，label是显示给用户的值。 例2 <html:options property="value" labelProperty="label" /> collection属性不被指定时，将使用表单相关的form bean，form bean中value属性存放option value，label属性值显示给用户。 例3 <html:options name="valueBean" property="values" labelName="labelsBean" labelProperty="labels" /> 这个意思是value值存放在名为valueBean的bean的vlaues属性中，它是一个collection；label值也是同样的意思。 <html:optionsCollection>标签，和<html:options>的用法很相似。 例如 <html:select property="custId"><html:optionsCollection property="customers" label="name" value="custId" /></html:select> 这个标签和org.apache.structs.util.LabelValueBean结合的很好，如果把label和value都放到这个对象中，可以很简单的这样应用： <html:select property="custId"><html:optionsCollection property="customers" /></html:select> </blockquote> <div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/buaacaptain/" target="_blank">船长</a> 2006-07-06 17:10 <a href="http://www.blogjava.net/buaacaptain/archive/2006/07/06/56984.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div> </article> <article> <h1>转:OC4J 10g 10.1.3 数据源中的连接高速缓存</h1> 船长 — Sat, 24 Jun 2006 12:24:00 GMT 在部署 J2EE 应用程序中最耗时的操作之一就要数建立到数据库的连接了。应用程序服务器通常提供连接高速缓存或者连接池以尽量减小这一任务所带来的开销。（尽管术语“连接高速缓存”和“连接池”在 JDBC 中有不同的含义，这里我们将借鉴这些术语。） 在 Oracle Application Server Containers for J2EE 10g (OC4J) 9.0.4 中，根据数据源的类型采用了不同的连接高速缓存机制。然而，OC4J 10g 10.1.3 在数据源中引入了几项关键改进，其中之一就是新的连接高速缓存机制。它是所有 Oracle 数据源的统一连接高速缓存机制，并提供集成的真正应用集群 (RAC) 故障切换支持。该机制利用了 Oracle 数据库 10g 的新 JDBC 连接高速缓存特性。（注意：OC4J 10g 10.0.3 最近改版为 10.1.3，而且下一个公开发行版将反映这一变化。这里对 10.1.3 版的所有引用对当前可用的 10.0.3 版也适用。） 这篇技术说明提供了对这一新特性的详细描述，并阐明了它在应用程序中的用法。 OC4J 10g 10.1.3 数据源：概要 OC4J 10g 10.1.3 已经简化了数据源分类：现在只有两种类型的数据源：受管理的数据源和原生数据源。 受管理的数据源是由 OC4J 管理的数据源。具体来讲，受管理的数据源就是一个 OC4J 提供的 java.sql.DataSource 实现，充当 JDBC 驱动程序或数据源的绕接器。J2EE 组件通过 JNDI 访问受管理的数据源，而还不知晓该数据源竟是一个绕接器。OC4J 为受管理的数据源提供关键的系统基础架构，如全局事务管理、连接高速缓存、通过 JMX 的动态配置以及错误处理。 原生数据源还实现了 java.sql.DataSource 接口，这些数据源由 JDBC 驱动程序供应商如 Oracle 和 DataDirect 提供。原生数据源根本不用 OC4J 绕接。 下表归纳了受管理的和原生数据源之间的主要差异： 受管理的数据源原生数据源 从数据源检索到的连接可以参与全局事务是 否 数据源利用 OC4J 的连接池和语句高速缓存是否 从通过一个 OC4J 连接代理绕接的数据源返回的连接是否 连接高速缓存 连接高速缓存（通常在中间层实现）允许在不同的应用程序间共享一个数据库连接。中间层维护着一个预先分配的物理数据库连接池，应用程序可以使用这些连接来与数据库服务器交互。当应用程序请求数据库连接时，中间层首先查看连接池中是否有符合该请求的可用连接；如果有，则中间层就返回其中的一个连接。 当请求连接而连接高速缓存中没有空闲的池连接实例时，则会创建新的池连接实例。 “空闲”的池连接实例是指该实例当前没有与其相关的逻辑连接实例；换言之，就是指该池连接实例的物理连接没有使用。 当应用程序关闭此连接时，中间层就会把此连接送回到池中，从而避免在发生连接请求执行打开新数据库连接这样耗费大量资源的任务。 高速缓存中的池连接都有一些连接特性或属性（数据库名、服务器名、端口号等等）。大多数连接高速缓存都包括一个连接池，其中包含用于同一数据库和同一用户名的一个或多个连接。 OC4J 10g 10.1.3 数据源中的连接高速缓存 OC4J 10g 10.1.3 数据源中的高速缓存利用了 Oracle 数据库 10g JDBC 提供的所有新高速缓存特性 — 特别是新的隐式连接高速缓存中的特性。 在 Oracle 数据库 10g 之前，将 Oracle JDBC 的连接高速缓存接口命名为 OracleConnectionCache，而将其实现命名为 OracleConnectionCacheImpl。此高速缓存只为指定用户名提供到特定数据库的物理连接池的支持。在 Oracle 10g JDBC 中，不建议使用 OracleConnectionCache 接口和 OracleConnectionCacheImpl 类，从而向一个更强健的以性能为导向的体系结构转变。设计了新的体系结构，这样就可以将连接高速缓存透明地集成到数据源中。 隐式连接高速缓存是数据源的一个新的符合 JDBC 3.0 的连接高速缓存实现。它通过提供对高速缓存的透明访问，不再需要应用程序开发人员编写自己的高速缓存实现。它还支持多用户，并能基于用户定义的属性请求连接。 隐式连接高速缓存影响着物理和逻辑连接的概念。它使用标准 OracleDataSource API 来获得连接，并在底层应用程序启用高速缓存后处理连接缓存中的所有连接。物理连接是由数据库返回的实际连接，而逻辑连接可以看作是高速缓存用于处理物理连接的句柄。 隐式连接高速缓存还提供一个新类 — OracleConnectionCacheManager，这样应用程序就可以使用其丰富的管理 API 组来有效地创建、管理和维护连接高速缓存。应用程序可以通过单个 OracleConnectionCacheManager 实例或者通过与高速缓存相关联的 OracleDataSource 来管理它们的高速缓存。这些 API 广泛应用于 OC4J 10g 10.1.3 中。 还为用户提供了一个回调机制来定义高速缓存行为和确定通过用户定义的连接属性检索到的确切连接。 新的连接高速缓存机制还包括集成的为 Oracle 数据库提供的 RAC 故障切换支持。它通过监听数据库生成的 UP/DOWN RAC 事件实现了与数据库自身同步的快速、高效的连接高速缓存中连接的连接故障切换。事件发布/订阅机制由 Oracle 通知服务 (ONS) 提供。此类支持只用于 RAC 数据库，这是由于 RAC 数据库支持所需故障切换事件的生成。 与 OC4J 10g 10.1.3 数据源中的新连接高速缓存相关的一些好处包括： 驱动程序独立 连接高速缓存的透明访问 每个缓存可以有多个用户和多个口令 符合 JDBC 3.0 标准 连接回收与陈旧连接的刷新 基于属性搜索连接 启用多个缓存的数据源 连接高速缓存回调机制 集成的对 RAC 快速连接故障切换的支持。 应用程序可以轻松地利用 OC4J 10g 10.1.3 数据源中的新连接高速缓存功能。该应用程序只需配置数据源和其连接高速缓存，从该高速缓存获得一个连接，使用该连接实现一些业务逻辑，并在使用后把该连接返回该高速缓存。应用程序还可以使用 OracleConnectionCacheManager 重新初始化一些连接属性。基本上说，应用程序仍将像通常那样使用数据源，如数据源设置和查找。此外，应用程序将配置它们要使用的连接高速缓存。对于大部分应用程序，这一目标是通过对受管理的数据源及原生数据源的简单配置属性更改而声明性实现的。对于由 Oracle 10g JDBC 提供的原生数据源，这也可以通过调用特定的连接高速缓存管理 API 以编程方式实现。同样值得注意的是，这些 API 就是 OC4J 在提供其自己的连接高速缓存时使用的 API。 以声明的方式配置连接高速缓存 在 OC4J 10g 10.1.3 中，指定连接高速缓存属性相对简单一些。对于大多数应用程序来说，此种指定是在 data-sources.xml 配置文件中声明式完成的。 受管理的数据源 对于受管理的数据源，配置连接高速缓存可以分两个步骤完成： 使用 <connection-pool> XML 元素在 data-sources.xml 中添加一个连接高速缓存，指定其所需属性的详细信息。 在同一文件中的每个 <managed-data-source> XML 元素中使用“connection-pool-name”属性，指定这个受管理的数据源用于汇聚其连接的连接高速缓存的名称。 第 2 步相对简单，因此我们集中看第 1 步。<connection-pool> 元素具有以下属性（每个属性都是可选的，除非标记为“必要”）： 属性名称说明默认值 name (Required) The name of the connection pool; must be unique 无 min-connections 连接池将维护的最小连接数 0 max-connections 在任何给定时间能够打开的连接的最大数量。值为 0 或小于 0（表示没有最高限制）。 0 initial-limit 在初次创建或重新初始化高速缓存时设置连接高速缓存的大小。当将该属性设置为大于 0 的值，则可以预先创建许多连接并可随时使用。这个属性通常用于在将缓存设为其最优大小时减少“加速”时间。 0 used-connection-wait-timeout 等待客户端释放使用的连接所需的时间（秒）。该属性只适用于已从数据源获得了最大数量的连接且这些连接都在使用的情形。在这种情况下，当一个客户端尝试从连接池中借一个连接而所有连接都在使用中时，连接池将等待将一个连接释放回池中。 60 inactivity-timeout 将一个未使用的连接从连接池中移除前其不活动的时间（秒） 60 login-timeout 此数据源在尝试连接到一个数据库时将等待的时间的最大值（秒）。值为零说明使用默认的系统超时（如果有的话，否则不会超时）。 0 connection-retry-interval 在重试一个失败的连接尝试前等待的间隔（秒），与“max-connnect-attempts”一起使用 1 max-connect-attempts 重试进行一个连接的次数，与“connection-retry-interval”一起使用 3 validate-connection 表明从连接池借用一个连接时是否根据数据库对其进行验证。值为“true”表明从连接池借用一个连接时，执行由“validate-connection-statement”声明的语句来验证此连接是否有效；值为“false”表明从连接池借用连接时不会执行任何语句。与“validate-connection-statement”一起使用。 false validate-connection-statement 从连接池借用连接时执行的 SQL 语句。与“validate-connection”一起使用。 无 num-cached-statements 应该为每个连接缓存的最大语句数。任何大于 0 的值自动为数据源启用语句缓存。 0 time-to-live-timeout 一个使用的连接保持活动的最长时间（秒）。当这个超时时，所使用的连接会无条件地关闭，取消相关语句句柄，并将此连接返回连接池。值为 –1 表示这个特性没有启用。 -1 abandoned-connection-timeout 只适用于 Oracle 数据库。abandoned-connection-timeout 与 inactivity-timeout 类似，但是前者用在逻辑连接上。在设置了该属性时，JDBC 监视这个逻辑连接（由用户从高速缓存借来的连接）上的 SQL 数据库活动。例如，当在此连接上调用 stmt.execute() 时，会注册一个检测信号 (heart beat) 以表示这个连接是活动的。只监视导致数据库执行调用的地方的检测信号以降低监视成本。如果一个连接不活动时间已达到某一指定值，则将底层的 PooledConnection 回收并返回缓存以重新使用。默认值为 -1，即这个特性未生效。 -1 disable-server-connection-pooling 确定是否禁用应用服务器的连接池。之所以提供这个属性是因为一些 JDBC 驱动程序本身就提供了连接池。如果 JDBC 驱动程序是 Oracle 且驱动程序正在使用隐式连接高速缓存，则忽略这个属性。 false property-check-interval 只适用于 Oracle 数据库。高速缓存后台程序线程执行超时限制的时间间隔（秒）。 900 lower-threshold-limit 只适用于 Oracle 数据库。连接池上较低的阈值限制。默认为 max-connections 的 20%。 20% 除了上面的属性，每个 <connection-pool> 元素都必须包含一个 <connection-factory> 元素，该元素定义用于为连接池创建连接的连接工厂 (connection factory)。它有如下属性（每个属性都是可选的，除非标记为“必要”）： 属性名称说明默认值 factory-class （必要）定义连接工厂 (connection-factory) 实现的全路径类。它必须是 java.sql.Driver、javax.sql.DataSource、javax.sql.ConnectionPoolDataSource 或 javax.sql.XADataSource 的一个实现。 无 url （必要）用来连接底层数据库的 url 无 user 用来连接数据库的默认用户 无 password 用来连接数据库的默认口令 无 login-timeout 尝试连接数据库时等待的最长时间（秒）。值为零表示此超时使用默认的系统超时（如果有的话），否则不会超时。 0 现在我们来看一些具体的例子： 使用 XADataSource 连接工厂的受管理数据源 <managed-data-source jndi-name="jdbc/ManagedXADS" description="Managed DataSource" connection-pool-name="myConnectionPool" name="ManagedXADS"/> <connection-pool name="myConnectionPool" min-connections="10" max-connections="30" inactivity-timeout="30" <connection-factory factory-class="oracle.jdbc.xa.client.OracleXADataSource" user="scott" password="tiger" url="jdbc:oracle:thin:@localhost:1521:oracle"/> <property name="nativeXA" value="true"/> </connection-factory> <!- <connection-pool> ? 使用 DataSource 连接工厂的受管理数据源 <managed-data-source jndi-name="jdbc/ManagedDS" description="Managed DataSource"> connection-pool-name="myConnectionPool" name="ManagedDS"/> <connection-pool name="myConnectionPool" min-connections="10" max-connections="30" inactivity-timeout="30" <connection-factory factory-class="oracle.jdbc.pool.OracleDataSource" user="scott" password="tiger" url="jdbc:oracle:thin:@localhost:1521:oracle"/> <property name="loginTimeout" value="30"/> </connection-factory> <!- <connection-pool> ? 原生数据源 对于原生 Oracle 数据源，配置连接高速缓存主要是以编程的方式完成。（更多详细信息参见接下来的部分。）连接缓存的声明式配置也可分两个步骤完成： 将“oracle.jdbc.pool.OracleDataSource”用作 data-sources.xml 中每个 <native-data-source> XML 元素的“data-source-class”属性的值。这就是在 Oracle 10g JDBC 驱动程序中进行隐式连接高速缓存时的数据源实现。 在 <native-data-source> 内的 <property> 元素中指定任何缓存特有的属性来控制连接高速缓存的行为。 对于第 2 步，下列属性名称可用于 <property> 元素的指定： 名称类型说明 connectionCacheName String 高速缓存的名称；一旦创建则无法更改。 connectionCachingEnabled Boolean 是否启用隐式连接高速缓存 fastConnectionFailoverEnabled Boolean 是否启用 RAC 快速连接故障切换 下面是一个具体的例子： <native-data-source name="nativeDataSource" jndi-name="jdbc/nativeDS" description="Native DataSource" data-source-class="oracle.jdbc.pool.OracleDataSource" user="scott" password="tiger" url="jdbc:oracle:thin:@localhost:1521:oracle"> <property name="connectionCacheName" value="ICC1"/> <property name="connectionCachingEnabled" value="true"/> <property name="fastConnectionFailoverEnabled" value="false"/> </native-data-source> 以编程方式配置连接高速缓存 受管理的数据源 在使用受管理的数据源时，连接高速缓存是通过数据源配置文件以声明的方式指定的。这在“以声明的方式配置连接高速缓存”中有详细说明。 原生数据源 对于 Oracle 10g JDBC 提供的原生数据源，应用程序有附加的选项来以编程方式配置连接高速缓存。由于高速缓存是 OC4J 10g 10.1.3 统一的 Oracle 数据源，从而使它并不比声明式方法难。有了这个选项，应用程序又有了两种利用连接高速缓存的方法：(1) 依赖于 OracleDataSource 中的隐式连接高速缓存行为，并在数据源上设置连接高速缓存属性；(2) 直接使用连接高速缓存管理器 OracleConnectionCacheManager API。 对于 (1)，OracleDataSource 类为连接高速缓存属性提供下列 setter() 和 getter() 方法： String getConnectionCacheName() void setConnectionCacheName(String cacheName) java.util.Properties getConnectionCacheProperties() void setConnectionCacheProperties(java.util.Properties cp) 这里的每个连接高速缓存属性对应“以声明的方式配置连接高速缓存”中的受管理数据源情况下的一个配置属性 — 尽管真正的属性名称可能略有不同。 资源 OC4J 10g 10.0.3 开发人员预览版 2 OC4J 10g (10.0.3) 开发人员预览版 2 已通过了 J2EE 1.4 兼容性组合测试，正式兼容 J2EE 1.4。仅用于测试与开发！ Oracle 10g JDBC 驱动程序 在 Oracle 10g JDBC 中，JDBC Thin、OCI 和服务器端内部驱动程序已经彻底重新调整了结构以提高性能。包括 JDBC 3.0 和 J2EE 1.3 标准特性支持。 Oracle 10g JDBC 示例代码 Oracle 10g JDBC 示例演示 JDBC 3.0 规范中引入的各种新特性的使用。 Oracle 数据库 10g JDBC 开发人员指南与参考 Oracle 数据库 10g JDBC 开发人员指南与参考专门为基于 JDBC 的应用程序和小程序的开发人员而准备。 保持连接：使用隐式连接高速缓存进行透明的高速缓存访问作者：Kuassi Mensah 对于 (2)，OracleConnectionManager 提供了应用程序可用于管理可用连接高速缓存的 API。以下是其中的一些 API。（关于 (1) 和 (2) 的更多详细信息，请参考 Oracle 数据库 10g JDBC 开发人员指南与参考。） static OracleConnectionCacheManager getCacheManagerInstance() void createCache(String cacheName, javax.sql.DataSource ds, Properties cacheProperties) String createCache(javax.sql.DataSource ds, Properties cacheProperties) void removeCache(String cacheName, int mode) void refreshCache(String cacheName, int mode) java.util.properties getCacheProperties(String cacheName) 下面的 configureDataSource 方法显示了与高速缓存相关联的 OracleDataSource 的一般设置。它用主机名称、用户名称、密码等的相应值配置 Datasource。它还加载一些存储在 Connection.properties 文件中的连接属性： private void configDataSource(OracleDataSource ods) { ...... /* Load the properties file to get the connection properties * from the Connection.properties file */ Properties prop = this.loadParams("Connection"); ods.setDriverType("thin"); ods.setHostName("localhost"); ods.setNetworkProtocol("tcp"); ods.setPortNumber (1521); ods.setUser("scott"); ods.setPassword("tiger"); ods.setServiceName("oracle"); ods.setConnectionProperties(prop); ...... } 下面的代码演示上面的方法 (1)。方法 initializeConnectionCacheDataSrc 启用连接高速缓存，并且设置了高速缓存的名称，该名称唯一地标识该连接高速缓存。然后它在 OracleDataSource 上设置一些连接高速缓存属性，这些属性将被传递给高速缓存。 private void configCachingInDataSource(OracleDataSource ods) throws SQLException { ...... ods.setConnectionCachingEnabled(true); // Enable caching ods.setConnectionCacheName(CACHE_NAME); // Set the cache name Properties cacheProperties = new Properties(); cacheProperties.setProperty("MinLimit", "1"); // Set Min Limit for the Cache cacheProperties.setProperty("MaxLimit", "15"); // Set Max Limit for the Cache cacheProperties.setProperty("InitialLimit", "10"); // Set the Initial Limit ods.setConnectionCacheProperties(cacheProperties); } 下面的代码演示上面的方法 (2)：如何使用 OracleConnectionCacheManager 创建一个连接高速缓存。 createCache 方法用于创建高速缓存，同时用于接收 OracleDataSource 高速缓存名称和高速缓存 Properties 对象。请注意，连接高速缓存属性是在创建连接高速缓存时设置的： private void initializeConnectionCache() throws Exception { .............. OracleDataSource ods = new OracleDataSource(); this.configureDataSource(ods); ods.setConnectionCachingEnabled(true); // Enable caching // Initialize the Connection Cache OracleConnectionCacheManager connMgr = OracleConnectionCacheManager.getConnectionCacheManagerInstance(); /* This object holds the properties of a cache and is passed to the * ConnectionCacheManager while creating the cache. */ Properties cacheProperties = new Properties(); cacheProperties.setProperty("MinLimit", "1"); // Set Min Limit for the Cache cacheProperties.setProperty("MaxLimit", "15"); // Set Max Limit for the Cache cacheProperties.setProperty("InitialLimit", "10"); // Set the Initial Limit /* Create the cache by passing the cache name, data source and the * cache properties */ connMgr.createCache(CACHE_NAME, ods, properties); 总结 数据库连接高速缓存是 Oracle 应用服务器一个功能强大的部分。有了 Oracle 数据库 10g 简化的数据源配置和集成的连接高速缓存管理，OC4J 10g 10.1.3 为构建分布式 J2EE 应用程序提供了一个可伸缩的平台。 <div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/buaacaptain/" target="_blank">船长</a> 2006-06-24 20:24 <a href="http://www.blogjava.net/buaacaptain/archive/2006/06/24/54935.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div> </article> <article> <h1>OC4J 10g (9.0.4) FAQ</h1> 船长 — Sat, 24 Jun 2006 12:12:00 GMT 摘要: 转自:http://www.blogjava.net/rosen/archive/2005/08/12/9894.html当今 J2EE 服务器市场可谓百花齐放啊，本文主要介绍 OC4J （ Oracle Application Server Containers for J2EE ）的特性和配置方式，... <a href='http://www.blogjava.net/buaacaptain/archive/2006/06/24/54934.html'>阅读全文</a> <div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/buaacaptain/" target="_blank">船长</a> 2006-06-24 20:12 <a href="http://www.blogjava.net/buaacaptain/archive/2006/06/24/54934.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div> </article> <article> <h1>用JDOM遍历xml文档</h1> 船长 — Tue, 20 Jun 2006 07:18:00 GMT Element类的getContent()方法返回一个List对象，它包括了一个元素的所有内容：注释、属性、处理指令、文本和子元素。利用它我们可以遍历XML文档。下面的程序来自《java语言与xml教程》 import org.jdom.*; import org.jdom.input.SAXBuilder; import java.io.IOException; import java.util.*; public class TreePrinter{ public static void process(Element element){ inspect(element); List content=element.getContent();//取元素的所有内容 Iterator iterator=content.iterator(); while(iterator.hasNext()){ Object o=iterator.next(); if(o instanceof Element){//如果是子元素 Element child=(Element)o; process(child);//递归调用 }else if(o instanceof Comment){//如果是说明 Comment c=(Comment)o; //System.out.println(c.getText()); // System.out.println(); } } public static void inspect(Element element){ if(!element.isRootElement()){ System.out.println(); } String qualifiedName=element.getQualifiedName(); System.out.println(qualifiedName+":"+element.getText()); Namespace namespace=element.getNamespace(); if(namespace!=Namespace.NO_NAMESPACE){ String localName=element.getName(); String uri=element.getNamespaceURI(); String prefix=element.getNamespacePrefix(); System.out.println(" Local name: "+localName); System.out.println(" Namespace URI: "+uri); if(!"".equals(prefix)){ System.out.println(" Namespace prefix: "+prefix); } } List attributes=element.getAttributes(); if(!attributes.isEmpty()){ Iterator iterator=attributes.iterator(); while(iterator.hasNext()){ Attribute attribute=(Attribute)iterator.next(); String name=attribute.getName(); String value=attribute.getValue(); Namespace attributeNamespace=attribute.getNamespace(); if(attributeNamespace==Namespace.NO_NAMESPACE){ System.out.println(" "+name+ "=\""+value+ "\""); }else{ String prefix=attributeNamespace.getPrefix(); System.out.println(" "+prefix+":"+name+"=\""+value+"\""); } } } List namespaces=element.getAdditionalNamespaces(); if(!namespaces.isEmpty()){ Iterator iterator=namespaces.iterator(); while(iterator.hasNext()){ Namespace additional=(Namespace)iterator.next(); String uri=additional.getURI(); String prefix=additional.getPrefix(); System.out.println(" xmlns:"+prefix+"=\""+uri+"\""); } } } public static void main(String[] args){ if(args.length<=0){ System.out.println("Usage: java TreePrinter URL"); return; } String url=args[0]; try{ SAXBuilder parser=new SAXBuilder(); Document document=parser.build(url); process(document.getRootElement()); }catch(JDOMException e){ System.out.println(url+" is not well-formed."); }catch(IOException e){ System.out.println("Due to an IOException,the parser could not encode "+url); } } } 运行结果： C:\java>java TreePrinter sample.xml HD: xmlns:dd="http://www.zzjava.hnzz.net" xmlns:ss="http://www.hnzz.net" disk: name="C" capacity:8G directories:200 files:1580 disk: name="D" capacity:10G directories:500 files:3000 用的xml文件是： <?xml version="1.0" encoding="UTF-8"?> <HD xmlns:dd="http://www.zzjava.hnzz.net" xmlns:ss="http://www.hnzz.net" > <disk name="C"> <capacity>8G</capacity> <directories>200</directories> <files>1580</files> </disk> <disk name="D"> <capacity>10G  </capacity> <directories>500</directories> <files>3000</files> </disk> </HD> <a href="http://blog.iyi.cn/start/2005/01/javaxml.html">http://blog.iyi.cn/start/2005/01/javaxml.html</a> <a href="http://toney.cnblogs.com/archive/2004/11/20/66178.aspx">http://toney.cnblogs.com/archive/2004/11/20/66178.aspx</a> <div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/buaacaptain/" target="_blank">船长</a> 2006-06-20 15:18 <a href="http://www.blogjava.net/buaacaptain/archive/2006/06/20/53993.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div> </article> <article> <h1>有关blob字段操作</h1> 船长 — Sun, 18 Jun 2006 07:07:00 GMT Hibernate 与 SQL Server BLOB<?xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" /?><o:p></o:p> BLOB 数据在 SQL Server 数据库中主要由 IMAGE 类型体现，最大容量为 2GB 。其存储方式不同于普通的数据类型，对于普通类型的数据系统直接在用户定义的字段上存储数据值，而对于 IMAGE 类型数据，系统开辟新的存储页面来存放这些数据，表中 IMAGE 类型数据字段存放的仅是一个 16 字节的指针，该指针指向存放该条记录的 IMAGE 数据的页面。如果 你对 Hibernate 还不熟息，请看 <a href="http://blog.csdn.net/rosen/archive/2004/11/12/179646.aspx"> 这里 </a> 。 <o:p> </o:p> <o:p> </o:p> 新建名为 “BLOB_TEST” 的表，字段分别是 INT 类型的 “ID” 和 IMAGE 类型的 “MYBLOB” 。从文件系统读取 “sample.jpg” 并转换成字节数组再放进 BlobTest 对象实例。 写入程序如下： <o:p> </o:p> <o:p> </o:p> <o:p> <table style="WIDTH: 526px; HEIGHT: 742px" height="742" cellspacing="0" cellpadding="0" width="526" border="1"> <tbody> <tr> <td> import java.io.*; import net.sf.hibernate.*; import net.sf.hibernate.cfg.*; import bo.*; public class Tester { public void DoTest() { InputStream in = null; BlobTest blobTest = null; Configuration cfg = null; SessionFactory sessions = null; Session session = null; Transaction tx = null; try { //begin InputStream in = new FileInputStream("d:/sample.jpg"); byte[] b = new byte[in.available()]; in.read(b); in.close(); //begin BlobTest blobTest = new BlobTest(); blobTest.setMyblob(b); //begin Hibernate Session cfg = new Configuration().configure(); sessions = cfg.buildSessionFactory(); session = sessions.openSession(); tx = session.beginTransaction(); session.save(blobTest); tx.commit(); } catch (Exception e) { e.printStackTrace(); } finally { try { session.close(); } catch (Exception e1) { e1.printStackTrace(); } } } } </td> </tr> </tbody> </table> </o:p> 取出 程序如下： <o:p> </o:p> <o:p> </o:p> <o:p> <table style="WIDTH: 526px; HEIGHT: 100px" height="100" cellspacing="0" cellpadding="0" width="526" border="1"> <tbody> <tr> <td> import java.io.*; import net.sf.hibernate.*; import net.sf.hibernate.cfg.*; import bo.*; public class Tester { public void DoTest() { OutputStream out = null; BlobTest blobTest = null; Configuration cfg = null; SessionFactory sessions = null; Session session = null; try { //begin Hibernate Session cfg = new Configuration().configure(); sessions = cfg.buildSessionFactory(); session = sessions.openSession(); //begin BlobTest blobTest = new BlobTest(); blobTest = (BlobTest) session.load(BlobTest.class, new Integer(23)); //begin OutputStream out = new FileOutputStream("d:/sample.jpg"); out.write(blobTest.getMyblob()); out.flush(); out.close(); } catch (Exception e) { e.printStackTrace(); } finally { try { session.close(); } catch (Exception e1) { e1.printStackTrace(); } } } } </td> </tr> </tbody> </table> </o:p> Hibernate 与 MySQL BLOB<o:p></o:p> MySQL 中的 BLOB 数据由四种类型体现，分别是 TINYBLOB 其容量为 256 字节、 BLOB 其容量为 64KB 、 MEDIUMBLOB 其容量为 16MB 、 LONGBLOB 其容量为 4GB 。 <o:p> </o:p> <o:p> </o:p> 新建名为 “BLOB_TEST” 的表，字段分别是 INTEGER 类型的 “ID” 和 MEDIUMBLOB 类型的 “MYBLOB” 。从文件系统读取 “sample.jpg” 并转换成字节数组再放进 BlobTest 对象实例。 写入、 取出 程序和上面的 SQL Server 一样。 <o:p> </o:p> <o:p> </o:p> Hibernate 与 Oracle BLOB<o:p></o:p> 为了不使用 “for update” 锁住数据库，遂打算让 Oracle LONG RAW 类型保存大对象，最大容量 2GB 。经过测试后发现，直接写 JDBC 代码可以保存，但 Hibernate 只能保存 4K 大小内容，换成 Hibernate 3.0 beta3 也未能成功。偶然的机会在邮件列表上发现这是 JDBC Driver 的问题，换成 Oracle 10g 的驱动后问题解决。 <o:p> </o:p> <o:p> </o:p> 新建名为 “BLOB_TEST” 的表，字段分别是 NUMBER 类型的 “ID” 和 LONG RAW 类型的 “MYBLOB” 。从文件系统读取 “sample.jpg” 并转换成字节数组再放进 BlobTest 对象实例。 写入、 取出 程序和 SQL Server 一样。 <o:p> </o:p> <o:p> </o:p> 如果你一定要用 Oracle BLOB 类型，接着往下看： <o:p> </o:p> Hibernate 处理 Oracle BLOB 类型较特殊 ， 从文件系统读取 “sample.jpg” 放进 BlobTest 对象实例的是 java.sql.Blob 类型，而不是字节数组。 <o:p> </o:p> <o:p> </o:p> <o:p> <table style="WIDTH: 525px; HEIGHT: 100px" height="100" cellspacing="0" cellpadding="0" width="525" border="1"> <tbody> <tr> <td> import java.io.*; import net.sf.hibernate.*; import net.sf.hibernate.cfg.*; import oracle.sql.*; import bo.*; public class Tester { public void DoTest() { BLOB blob = null; InputStream in = null; OutputStream out = null; BlobTest blobTest = null; Configuration cfg = null; SessionFactory sessions = null; Session session = null; Transaction tx = null; try { //begin InputStream in = new FileInputStream("d:/sample.jpg"); byte[] b = new byte[in.available()]; in.read(b); in.close(); //begin BlobTest blobTest = new BlobTest(); blobTest.setMyblob(BLOB.empty_lob()); //begin Hibernate Session cfg = new Configuration().configure(); sessions = cfg.buildSessionFactory(); session = sessions.openSession(); tx = session.beginTransaction(); session.save(blobTest); session.flush(); session.refresh(blobTest, LockMode.UPGRADE); blob = (BLOB) blobTest.getMyblob(); out = blob.getBinaryOutputStream(); out.write(b); out.close(); session.flush(); tx.commit(); } catch (Exception e) { e.printStackTrace(); } finally { try { session.close(); } catch (Exception e1) { e1.printStackTrace(); } } } } </td> </tr> </tbody> </table> </o:p> 取出 程序和其他两种数据库操作几乎一样。 <o:p> </o:p> <o:p> </o:p> iBATIS SQL Maps 与 SQL Server BLOB<o:p></o:p> 建表过程和 Hibernate 操作 SQL Server 一样，如果 你对 iBATIS SQL Maps 还不熟息，请看 <a href="http://blog.csdn.net/rosen/archive/2005/01/09/246433.aspx"> 这里 </a> 。 <o:p> </o:p> <o:p> </o:p> 映射文件如下： <o:p> </o:p> <o:p> </o:p> <o:p> <table style="WIDTH: 526px; HEIGHT: 100px" height="100" cellspacing="0" cellpadding="0" width="526" border="1"> <tbody> <tr> <td> <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE sqlMap PUBLIC "-//iBATIS.com//DTD SQL Map 2.0//EN" " <a href="http://www.ibatis.com/dtd/sql-map-2.dtd"> http://www.ibatis.com/dtd/sql-map-2.dtd </a> "> <sqlMap> <insert id="insertBlob" parameterClass="bo.BlobTest"> <![CDATA[ insert into blob_test (myblob) values (#myblob#) ]]> <selectKey resultClass="java.lang.Integer" keyProperty="id"> <![CDATA[ SELECT @@IDENTITY AS ID ]]> </selectKey> </insert> <resultMap id="get-blob-result" class="bo.BlobTest"> <result property="id" column="id"/> <result property="myblob" column="myblob"/> </resultMap> <select id="getBlob" resultMap="get-blob-result" parameterClass="bo.BlobTest"> <![CDATA[ select * from blob_test where id=#id# ]]> </select> </sqlMap> </td> </tr> </tbody> </table> </o:p> 写入程序如下： <o:p> </o:p> <o:p> </o:p> <o:p> <table style="WIDTH: 526px; HEIGHT: 726px" height="726" cellspacing="0" cellpadding="0" width="526" border="1"> <tbody> <tr> <td> import java.io.*; import com.ibatis.sqlmap.client.*; import com.ibatis.common.resources.*; import bo.*; public class Tester { public void DoTest() { byte[] b=null; Reader reader = null; InputStream in = null; BlobTest blobTest = null; SqlMapClient sqlMap = null; String resource = "SqlMapConfig.xml"; try { //begin InputStream in = new FileInputStream("d:/sample.jpg"); b = new byte[in.available()]; in.read(b); in.close(); //begin BlobTest blobTest = new BlobTest(); blobTest.setMyblob(b); //begin SqlMapClient reader = Resources.getResourceAsReader(resource); sqlMap = SqlMapClientBuilder.buildSqlMapClient(reader); sqlMap.startTransaction(); sqlMap.insert("insertBlob", blobTest); sqlMap.commitTransaction(); } catch (Exception e) { e.printStackTrace(); } finally { try { sqlMap.endTransaction(); } catch (Exception e1) { e1.printStackTrace(); } } } } </td> </tr> </tbody> </table> </o:p> 取出 程序如下： <o:p> </o:p> <o:p> <table style="WIDTH: 524px; HEIGHT: 100px" height="100" cellspacing="0" cellpadding="0" width="524" border="1"><tbody><tr><td>import java.io.*;import com.ibatis.sqlmap.client.*; import com.ibatis.common.resources.*;import bo.*;public class Tester { public void DoTest() { Reader reader = null; OutputStream out = null; BlobTest blobTest = null; SqlMapClient sqlMap = null; String resource = "SqlMapConfig.xml"; try { //begin BlobTest blobTest = new BlobTest(); blobTest.setId(new Integer(21)); //begin SqlMapClient reader = Resources.getResourceAsReader(resource); sqlMap = SqlMapClientBuilder.buildSqlMapClient(reader); blobTest = (BlobTest) sqlMap.queryForObject("getBlob", blobTest); //begin OutputStream out = new FileOutputStream("d:/sample.jpg"); out.write(blobTest.getMyblob()); out.close(); } catch (Exception e) { e.printStackTrace(); } finally { try { sqlMap.endTransaction(); } catch (Exception e1) { e1.printStackTrace(); } } } }</td></tr></tbody></table></o:p> <o:p> </o:p> iBATIS SQL Maps 与 MySQL BLOB<o:p></o:p> 这个主题很简单，需要注意映射文件 insert 元素主键生成方式， 写入、 取出 程序和上面的 SQL Server 一样 ： <o:p> </o:p> <o:p> <table style="WIDTH: 526px; HEIGHT: 100px" height="100" cellspacing="0" cellpadding="0" width="526" border="1"> <tbody> <tr> <td> <insert id="insertBlob" parameterClass="bo.BlobTest"> <![CDATA[ insert into blob_test (myblob) values (#myblob#) ]]> <selectKey resultClass="java.lang.Integer" keyProperty="id"> <![CDATA[ select last_insert_id(); ]]> </selectKey> </insert> </td> </tr> </tbody> </table> </o:p> iBATIS SQL Maps 与 Oracle BLOB<o:p></o:p> 使用 Oracle LONG RAW 类型， 注意映射文件 insert 元素主键生成方式， 写入、 取出 程序和上面的 SQL Server 一样 ： <o:p> </o:p> <o:p> </o:p> <o:p> <table style="WIDTH: 525px; HEIGHT: 100px" height="100" cellspacing="0" cellpadding="0" width="525" border="1"> <tbody> <tr> <td> <insert id="insertBlob" parameterClass="bo.BlobTest"> <selectKey resultClass="int" keyProperty="id"> <![CDATA[ select hibernate_sequence.nextval from dual ]]> </selectKey> <![CDATA[ insert into blob_test (id,myblob) values (#id#,#myblob#) ]]> </insert> </td> </tr> </tbody> </table> </o:p> 如果你一定要用 Oracle BLOB 类型，接着往下看： <o:p> </o:p> 在 iBATIS 2.0.9 以前，处理 Oracle BLOB 类型相当麻烦，要自己实现 TypeHandlerCallback 接口。 iBATIS 2.0.9 的出现使一切都简单了，写入、 取出 程序和上面的 SQL Server 一样。 <a href="http://java.ccidnet.com/art/297/20051117/374459_1.html">http://java.ccidnet.com/art/297/20051117/374459_1.html</a> <div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/buaacaptain/" target="_blank">船长</a> 2006-06-18 15:07 <a href="http://www.blogjava.net/buaacaptain/archive/2006/06/18/53600.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div> </article> <article> <h1>hibernate分页</h1> 船长 — Mon, 05 Jun 2006 09:44:00 GMT 别的请参考：<a href="http://www.java3z.com/cwbwebhome/article/article2a/2101.jsp?id=365">http://www.java3z.com/cwbwebhome/article/article2a/2101.jsp?id=365</a> <a href="http://blogger.org.cn/blog/more.asp?name=jjs_love&id=12738">http://blogger.org.cn/blog/more.asp?name=jjs_love&id=12738</a> <a href="http://willsu.cnblogs.com/archive/2006/03/26/172459.html">http://willsu.cnblogs.com/archive/2006/03/26/172459.html</a> 一、准备工作 主要是搭建Hibernate+Struts的环境，我是mysql+Tomcat 5.0+Hibernate2.1+Struts1.2.4,包括建目录和复制jar文件到相关目录,还有在mysql中创建数据库HibernateTest和表sysuser，请下载我的目录结构参考。 下面文件createTable.txt用来创建表sysuser create table sysuser( userid varchar(32) not null, username varchar(20) not null unique, userpasword varchar(20) not null, lastlogin DATETIME, primary key(userid) ) 二、Hibernate的配置文件hibernate.cfg.xml，主要是数据库的设定，这里用mysql。 <?xml version=Ƈ.0' encoding='big5'?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN" "http://hibernate.sourceforge.net/hibernate-configuration-2.0.dtd"> <hibernate-configuration> <session-factory>  <property name="show_sql">true</property>  <property name="dialect">net.sf.hibernate.dialect.MySQLDialect</property>  <property name="connection.driver_class">com.mysql.jdbc.Driver</property>  <property name="connection.url">jdbc:mysql://localhost/HibernateTest</property>  <property name="connection.username">root</property>  <property name="connection.password"></property>  <mapping resource="com/huangdong/dbwebdemo/dao/SysUser.hbm.xml"/> </session-factory> </hibernate-configuration> 二、Struts的配置文件struts-config.xml,有表单定义，动作映射和资源文件，插件定义。 <?xml version="1.0" encoding="iso-8859-1"?> <!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.2//EN" "http://struts.apache.org/dtds/struts-config_1_2.dtd"> <struts-config> <form-beans> <form-bean name="sysuserForm" type="com.huangdong.dbwebdemo.form.SysuserForm"/> </form-beans> <action-mappings> <action name="sysuserForm" path="/sysuser" type="com.huangdong.dbwebdemo.action.AddAction" scope="request" validate="true" input="/sysuser/editsysuser.jsp"> <forward name="add" path="/sysuser/add.jsp" /> </action> <action path="/list" type="com.huangdong.dbwebdemo.action.ListAction" scope="request" input="/sysuser/index.jsp"> <forward name="list" path="/sysuser/list.jsp" /> </action> <action path="/edit" type="com.huangdong.dbwebdemo.action.EditAction" scope="request" input="/sysuser/editsysuser1.jsp"> <forward name="edit" path="/sysuser/editsysuser1.jsp" /> <forward name="err1" path="/sysuser/err1.jsp" /> </action> <action path="/del" type="com.huangdong.dbwebdemo.action.DelAction" scope="request" input="/sysuser/del.jsp"> <forward name="del" path="/sysuser/delok.jsp" /> <forward name="err" path="/sysuser/err.jsp" /> </action> <action name="sysuserForm" path="/update" type="com.huangdong.dbwebdemo.action.UpdateAction" scope="request" input="/sysuser/editsysuser1.jsp"> <forward name="updateok" path="/sysuser/updateok.jsp" /> </action> </action-mappings> <message-resources parameter="resources.application"/> <plug-in className="com.huangdong.dbwebdemo.InitHibernatePlugin" /> <plug-in className="org.apache.struts.validator.ValidatorPlugIn"> <set-property property="pathnames" value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml"/> </plug-in> </struts-config> 这里加了两个插件，其一利用Plugin的方式将Hibernate与Struts结合起来，其二进行服务器端验证。插件将在Web应用启动时初始化。 在InitHibernatePlugin.java的init()方法中将SessionFactory的实例bind到JNDI目录树的一个节点上，以便在所有要使用SessionFactory的地方通过JNDI lookup出sessionFactory的实例得到具体的session进行数据库操作。 InitHibernatePlugin.java（部分） /* * 插件初始化方法 */ public void init(ActionServlet servlet, ModuleConfig config) throws ServletException { try { // 获取SessionFactory的实例 this.sessionFactory = new Configuration().configure().buildSessionFactory(); } catch (HibernateException ex) { throw new RuntimeException( "Exception building SessionFactory: " + ex.getMessage(), ex); } try { // 取得容器上下文 ctx = new InitialContext(); // 将sessionFactory bind到JND树中 ctx.bind("HibernateSessionFactory", this.sessionFactory); } catch (NamingException ex) { throw new RuntimeException( "Exception binding SessionFactory to JNDI: " + ex.getMessage(), ex); } } 二、国际化资源文件 我们为站点准备一个国际化的资源文件，这个资源文件将是站点用户所使用的语言来决定的，如果Struts不能找到相对应的语言资源文件，就会使用默认的资源文件。这里我们先会建立一个txt文件，将所有的中文信息写入，再通过一个批处理或是shell脚本将该txt转化成为Struts所使用的资源文件。 这里我们给出genres.bat的内容： native2ascii -encoding GBK d:\java\res_zh.txt >d:\java\application_zh_CN.properties 请使用你的文件的路径来代替这里的路径。下面是res_zh.txt: # Resources for parameter 'ApplicationResources' # Project P/WebDlog title.register=用户注册 prompt.login=用户名 prompt.password=口令 # Errors errors.footer= errors.header=<h3>验证错误</h3>你必须更正下列错误: errors.ioException=I/O exception rendering error messages: {0} error.database.missing=<li>User database is missing, cannot validate logon credentials</li> errors.required={0} 是必填项. errors.minlength={0} 不能少于 {1} 个字符. errors.maxlength={0} 不能大于 {2} 个字符. errors.invalid={0} 是无效的. errors.byte={0} must be an byte. errors.short={0} must be an short. errors.integer={0} must be an integer. errors.long={0} must be an long. errors.float={0} must be an float. errors.double={0} must be an double. errors.date={0} is not a date. errors.range={0} is not in the range {1} through {2}. errors.creditcard={0} is not a valid credit card number. errors.email={0} is an invalid e-mail address. 三、设置站点所使用的语言 我们使用一个Servlet的Filter来设置站点所使用的语言。(略，请参看原文） 四、session获取工具类 另外为了配置Plugin的使用，我们使用工具类DBUtil类来获取Session，以下为它的代码： package com.huangdong.dbwebdemo; import javax.naming.Context; import javax.naming.InitialContext; import javax.naming.NamingException; import net.sf.hibernate.HibernateException; import net.sf.hibernate.Session; import net.sf.hibernate.SessionFactory; /** * @author HD */ public class DBUtil { private static SessionFactory sessionFactory = null; public static final ThreadLocal session = new ThreadLocal(); public static Session currentSession() throws HibernateException { if (sessionFactory == null) { // 如果sessionFactory实例为null则从JNDI中获取 if (getSystemSessionFactory() == false) { throw new HibernateException("Exception geting SessionFactory from JNDI "); } } Session s = (Session) session.get(); if (s == null) { s = sessionFactory.openSession(); session.set(s); } return s; } public static void closeSession() throws HibernateException { Session s = (Session) session.get(); session.set(null); if (s != null) s.close(); } private static boolean getSystemSessionFactory() { try { //从JNDI中取得SessionFactory的实例，如果出错返回false Context inttex = new InitialContext(); sessionFactory = (SessionFactory) inttex.lookup("HibernateSessionFactory"); } catch (NamingException e) { return false; } return true; } } 五、持久层的数据表示及设置数据表实体化映射 我们的增、删、改、查使用sysuser表，以下是其对应的SysUser类的源代码： package com.huangdong.dbwebdemo.dao; import java.io.Serializable; import java.text.SimpleDateFormat; import org.apache.commons.lang.builder.EqualsBuilder; import org.apache.commons.lang.builder.HashCodeBuilder; import org.apache.commons.lang.builder.ToStringBuilder; /** @author Hibernate CodeGenerator */ public class SysUser implements Serializable { /** identifier field */ private String userid; /** persistent field */ private String username; /** persistent field */ private String userpasword; /** nullable persistent field */ private java.util.Calendar lastlogin; /** full constructor */ public SysUser( java.lang.String username, java.lang.String userpasword, java.util.Calendar lastlogin) { this.username = username; this.userpasword = userpasword; this.lastlogin = lastlogin; } /** default constructor */ public SysUser() { } /** minimal constructor */ public SysUser(java.lang.String username, java.lang.String userpasword) { this.username = username; this.userpasword = userpasword; } public java.lang.String getUserid() { return this.userid; } public void setUserid(java.lang.String userid) { this.userid = userid; } public java.lang.String getUsername() { return this.username; } public void setUsername(java.lang.String username) { this.username = username; } public java.lang.String getUserpasword() { return this.userpasword; } public void setUserpasword(java.lang.String userpasword) { this.userpasword = userpasword; } public java.util.Calendar getLastlogin() { return this.lastlogin; } public String getLastloginstr() { SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); return df.format(this.lastlogin); } public void setLastlogin(java.util.Calendar lastlogin) { this.lastlogin = lastlogin; } public String toString() { return new ToStringBuilder(this) .append("userid", getUserid()) .toString(); } public boolean equals(Object other) { if (!(other instanceof SysUser)) return false; SysUser castOther = (SysUser) other; return new EqualsBuilder() .append(this.getUserid(), castOther.getUserid()) .isEquals(); } public int hashCode() { return new HashCodeBuilder().append(getUserid()).toHashCode(); } } 还有映射的xml文件： <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 2.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd"> <hibernate-mapping> <class name="com.huangdong.demo.dao.SysUser" table="SYSUSER"> <id column="userid" length="32" name="userid" type="string"> <generator class="uuid.hex"/> </id> <property column="username" length="20" name="username" not-null="true" type="string" unique="true"/> <property column="userpasword" length="20" name="userpasword" not-null="true" type="string"/> <property column="lastlogin" length="7" name="lastlogin" type="calendar"/> </class> </hibernate-mapping> 六、建立Struts的Action和Action FormBean 有AddAction.java，UpdateAction.java，SysuserForm.java等，请下载源码查看。 七、将VO与PO关联 VO与PO的关系 VO即业务层的数据表示，而PO即持久层的数据表示,在这个例子里就是SysUser.java类。VO会在View和业务处理时大量使用，也就是说，所有没有入库前的数据都会存储于一个个的VO中。而PO则是数据库在Java中的持久数据结构。 有许多人喜欢将Struts的VO与Hibernate的PO合并起来，我不同意，原因很多，最重要的有以下几点： 1、VO有自己的数据属性，同时因框架的不同可能会有自己的结构和方法，在Struts中我喜欢用FormBean来做VO，它就是扩展ActionForm的一个类 2、VO中还会有大量的业务操作方法，如校验、自动生成等方法 3、PO中会包含数据集之间的关系，如数据库中的关系也会体现在PO中的一对一、多对多、一对多等，而在VO中不一定关注这样的细节 总之，我更喜欢使用一个或多个关联的类将业务逻辑中的VO与PO对映起来，实现VO到PO的转换，以及PO中VO的取出。 九、VO与PO操作的抽像类 所有VO到PO的操作基本上都会是持久层数据的存入或更改（删除）。这样的操作一定会涉及到数据库的事务操作。另一方面，PO到VO的数据取出涉及到的则是数据集合的缓冲、分页、过涉等技巧。所以我们为这两种情况声明两个抽像类： AbsBaseMap类主要完成VO到PO的数据操作： package com.huangdong.dbwebdemo.db; import net.sf.hibernate.HibernateException; import net.sf.hibernate.Session; import net.sf.hibernate.Transaction; import com.huangdong.dbwebdemo.DBUtil; /** * 系统VO与PO的操作映射器抽像类，完成数据库事务和连接的初始化以及数据库事务的提交及数据库连接的关闭 * @author HD */ public abstract class AbsBaseMap { // 数据库连接session private Session session; // 数据库事务处理器 private Transaction transaction; /** * 初始化数据库连接事务 * @return 初始化完成的数据库连接 * @throws HibernateException */ public Session beginTransaction() throws HibernateException { session = DBUtil.currentSession(); transaction = session.beginTransaction(); return session; } /** * 完成一个数据库事务 * @param commit 是否提交事务，true时提交，false时向数据库发起回滚（rollback） * @throws HibernateException */ public void endTransaction(boolean commit) throws HibernateException { if (commit) { transaction.commit(); } else { transaction.rollback(); } DBUtil.closeSession(); } } AbsQueryMap类则主要提供了有关持久层数据的查询的抽像方法： package com.huangdong.dbwebdemo.db; /** * 系统VO与PO的查询映射抽像类，加入查询的分页相关设置 * @author HD */ public class AbsQueryMap { /** * 数据库连接session **/ Session session; // 分页为20 int pagesize = 20; // 当前页数 int pageno = 1; /** * @return 分页行数大小（默认为20） */ public int getPagesize() { return pagesize; } /** * @param i 设置分页行数大小 */ public void setPagesize(int i) { pagesize = i; } /** * @return 返回当前页号，初始值为1 */ public int getPageno() { return pageno; } /** * @param i 设置当前页号 */ public void setPageno(int i) { pageno = i; } /** * 设置查询分页 */ public void setQueryPage(Query query) { // 设置分页起始记录号 query.setFirstResult((this.pageno - 1) * this.pagesize); // 设置页内数据量 query.setMaxResults(this.pagesize); } /** * 打开当前的数据库连接 * @return * @throws HibernateException */ public void initSession() throws HibernateException { this.session = DBUtil.currentSession(); } /** * 关闭当前的数据库连接 * @throws HibernateException */ public void closeSession() throws HibernateException { DBUtil.closeSession(); } } 以后，我们所有的数据库更新操作都会继承AbsBaseMap类，而数据库查询操作会继承AbsQueryMap类。 十、数据库增、删、改操作映射 一旦有了上节所提供的AbsBaseMap抽像类和Hibernate所提供的功能，我们只需要了解一点点Java的知识就可以完成复杂的数据库更新功能了。 首先在com.huangdong.dbwebdemo.db包中新建一个类名为SysUserMap并扩展AbsBaseMap类： package com.huangdong.dbwebdemo.db; import com.huangdong.dbwebdemo.form.SysuserForm; public class SysUserMap extends AbsBaseMap { } 先来实现一个增加的方法，在VO层，我们使用的数据类为SysuserForm，所以增加方法的参数一定是SysuserForm： public void createSysUser(SysuserForm sysuerForm) throws HibernateException { // 使用sysuerForm的相关属性新建sysuser实例 SysUser sysuser = new SysUser( sysuerForm.getUsername(), sysuerForm.getUserpasword(), Calendar.getInstance()); // 启动事务 Session session = this.beginTransaction(); try { // 新增这个实例到数据库中 session.save(sysuser); // commit this.endTransaction(true); } catch (HibernateException e) { // rollback this.endTransaction(false); throw e; } } 这个方法已经非常的简单了，书写者完全可以不用理会数据库相关的内容了。 其它代码请下载。 十二、数据库简单查询 数据库的查询相对复杂一些了，我们从简单做起，先不使用任何条件，查询数据库中所有的记录。在com.huangdong.dbwebdemo.db中新建SysUserQueryMap类，它扩展AbsQueryMap抽像类： package com.huangdong.dbwebdemo.db; import java.util.Iterator; import net.sf.hibernate.HibernateException; import net.sf.hibernate.Query; /** * @author HD */ public class SysUserQueryMap extends AbsQueryMap { public SysUserQueryMap() throws HibernateException { this.initSession(); } public Iterator findAllSysUser() throws HibernateException { // 查询语句 String querystr = "from SysUser"; // 创建查询 Query query = this.session.createQuery(querystr); // 设置分页 this.setQueryPage(query); // 返回查询出的结果集 return query.iterate(); } } 这里我们已经写好一个查询所有的用户的方法，它的第一句： String querystr = "from SysUser"; 这里的查询语句使用了Hibernate的HQL语法，别的我们先不用管，这里SysUser是区分大小写的，我们之前定义了SysUser数据库映射类，这里必须完全一样，这样Hibernate就会从数据库中取出所有SysUser类的实例。 接下来我们还需要一个方法能够按照用户的id返回其所对应的用户。 /** * 查询出一个UserID的用户实例 * @param UserID 用户的UserID * @return 用户实例，如果数据库无相应记录返回null * @throws HibernateException */ public SysuserForm getSysuserByID(String UserID) throws HibernateException { SysuserForm sysuerform = null; try { sysuerform = new SysuserForm( (SysUser) this.session.load(SysUser.class, UserID)); } catch (HibernateException e) { throw e; } return sysuerform; } 有了这个方法，我们才能对指定用户进行查询，或者对他已有的信息进行修改。 十一、创建第一个View 新建JSP页面 我们先为增加记录建立一个JSP页面editsysuser.jsp，它提供了增加记录的View。 <%@ page contentType="text/html;charset=UTF-8" %> <%@ taglib uri="/tags/struts-bean" prefix="bean" %> <%@ taglib uri="/tags/struts-html" prefix="html" %> <%@ taglib uri="/tags/struts-logic" prefix="logic" %> <html:html> <head> <title><bean:message key="title.register"/></title> <html:base /> </head> <body> OK!!! <logic:messagesPresent> <bean:message key="errors.header"/> <ul> <html:messages id="error"> <li><bean:write name="error"/></li> </html:messages> </ul><hr /> </logic:messagesPresent> <html:form action="/sysuser.do?action=add" method="post" focus="username" onsubmit="return validateSysuserForm(this);"> <table border="0"> <tr> <td> <bean:message key="prompt.login"/> </td> <td> <html:text property="username" size="16" maxlength="20"/> </td> </tr> <tr> <td> <bean:message key="prompt.password"/> </td> <td> <html:password property="userpasword" /> </td> </tr> <tr> <td> <html:submit> <bean:message key="title.register"/> </html:submit> </td> </tr> </table> </html:form> <html:javascript formName="sysuserForm"/> </body> </html:html> 十二、客户端验证和服务器端验证 editsysuser.jsp中的表单属性中有一个onsubmit="return validateSysuserForm(this);"与页面最后的<html:javascript formName="sysuserForm"/>一起构成表单客户端验证。所有javaScript验证代码Struts自动生成。 表单服务器端验证由struts-config.xml中的插件 <plug-in className="org.apache.struts.validator.ValidatorPlugIn"> <set-property property="pathnames" value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml"/> </plug-in> 及资源文件构成。 十三、将业务逻辑关联起来 <div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/buaacaptain/" target="_blank">船长</a> 2006-06-05 17:44 <a href="http://www.blogjava.net/buaacaptain/archive/2006/06/05/50553.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div> </article> <article> <h1>转：关于XML树型菜单的权限管理问题</h1> 船长 — Tue, 30 May 2006 02:58:00 GMT 问：比如我定义了一个数据岛： <xml id=menuXML> <?xml version="1.0" encoding="GB2312"?> <DSTreeRoot text="根节点" open="true" href="http://" treeId="123"> <DSTree text="技术论坛" open="false" treeId=""> <DSTree text="5DMedia" open="false" href="http://" target="box" treeId="12"> <DSTree text="网页编码" href="http://" target="box" treeId="4353" /> <DSTree text="手绘" href="http://" target="box" treeId="543543" /> <DSTree text="灌水" href="http://" target="box" treeId="543543" /> </DSTree> <DSTree text="BlueIdea" open="false" href="http://" target="box" treeId="213"> <DSTree text="DreamWeaver & JS" href="http://" target="box" treeId="4353" /> <DSTree text="FlashActionScript" href="http://" target="box" treeId="543543" /> </DSTree> <DSTree text="CSDN" open="false" href="http://" target="box" treeId="432"> <DSTree text="JS" href="http://" target="box" treeId="4353" /> <DSTree text="XML" href="http://" target="box" treeId="543543" /> </DSTree> </DSTree> <DSTree text="资源站点" open="false" treeId=""> <DSTree text="素材屋" href="http://" target="box" treeId="12" /> <DSTree text="桌面城市" open="false" href="http://" target="box" treeId="213"> <DSTree text="壁纸" href="http://" target="box" treeId="4353" /> <DSTree text="字体" href="http://" target="box" treeId="543543" /> </DSTree> <DSTree text="MSDN" open="false" href="http://" target="box" treeId="432"> <DSTree text="DHTML" href="http://" target="box" treeId="4353" /> <DSTree text="HTC" href="http://" target="box" treeId="543543" /> <DSTree text="XML" href="" target="box" treeId="2312" /> </DSTree> </DSTree> </DSTreeRoot> </xml> 现在我想写程序来控制这个数据岛的权限，应该要怎么做呀？ 答： 用XSL解析? 根据新增属性给相应权限 建表： 角色：role_id,role_name 角色对应节点：role_id,tree_id 工号对应角色：staff_id,role_id 树形表：tree_id,ptree_id,url,title 然后每次树形节点展开通过和本人登录的session("staff_id")关联，查询所有具备权限的子节点。展开只显示子节点。 子节点连接的URL为了防止未授权打开，可以加入判断：判断referer_url是否是来自树形节点的页面。如果不是就不让访问。 <div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/buaacaptain/" target="_blank">船长</a> 2006-05-30 10:58 <a href="http://www.blogjava.net/buaacaptain/archive/2006/05/30/48909.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div> </article> <article> <h1>关于xml数据岛的问题</h1> 船长 — Tue, 30 May 2006 02:53:00 GMT <table style="TABLE-LAYOUT: fixed" cellspacing="8" cellpadding="0" width="100%" border="0"> <tbody> <tr> <td valign="top">差点误人子弟了，汗……， <table cellspacing="0" cellpadding="2" align="right" bgcolor="#b5cfad"><tbody></tbody></table><XML ID="xmlData" SRC="xmlData.xml"></XML> 这句话超级误导人，注意，src应该引用绝对路径。例如<xml id=menuXML src="d:\tree\menuXML.xml"> 在 Microsoft Internet Explorer5.0 里，你可以利用XML元素来创建数据岛，数据岛就是被HTML页面引用或包含的XML数据，XML数据可以包含在HTML文件内，也可以包含在某外部文件内。 　　利用XML元素可以让我们免除了编写脚本的麻烦，如果用户由于安全的考虑禁止执行脚本的话，标记将不能正常工作，那时因为，要初始化XML，必须编写脚本。 行内XML 行内XML包含在标记<XML>和</XML>之间，例如： 程序代码： <table style="BORDER-RIGHT: #999999 1px dotted; BORDER-TOP: #999999 1px dotted; BORDER-LEFT: #999999 1px dotted; BORDER-BOTTOM: #999999 1px dotted" cellspacing="0" cellpadding="0" width="100%" border="0"><tbody><tr bgcolor="#d2eeff"><td width="5"> </td><td> 引用: <XML ID="xmlData"> <?xml version="1.0" ?> <trees> <tree> <name>小龙女</name> <height unit="cm">180</height> </tree> <tree> <name>大侠杨过</name> <height unit="cm">178</height> </tree> </trees> </XML> </td></tr></tbody></table> 引用XML文件 　　使用<XML>标记的SRC属性来引用外部的XML文件，SRC属性可以引用本地的文件，也可以指定一个URL，URL指向外部的服务器，数据可以从数个不同的服务器综合在一起。下面例子的SRC属性引用到本地的XML文件。 程序代码： <XML ID="xmlData" SRC="xmlData.xml"></XML> 其中的文件xmlData.xml里含有XML数据。 下面的例子引用一个远程服务器上的XML文件： 程序代码： <XML ID="xmlData" SRC="http://lucky.myrice.com/exam/xmlData.xml";></XML> 从数据岛读取数据 　　从数据岛读取数据是利用<XML>元素的ID属性来完成的。通过能够接收数据的HTML标记（把数据绑定到该HTML），我们可以进行格式化或显示数据岛里的数据。下面的例子显示元素为<meeting>里各XML子元素的内容： HTML代码： <table style="BORDER-RIGHT: #999999 1px dotted; BORDER-TOP: #999999 1px dotted; BORDER-LEFT: #999999 1px dotted; BORDER-BOTTOM: #999999 1px dotted" cellspacing="0" cellpadding="0" width="100%" border="0"><tbody><tr bgcolor="#d2eeff"><td width="5"> </td><td> 引用: <HTML><HEAD><TITLE></TITLE></HEAD> <BODY> <XML ID="xmlMeetings"> <?xml version="1.0" ?> <meetings> <meeting> <date>1/1/99</date> <time>9:00</time> <location>104号房间</location> </meeting> <meeting> <date>2/1/99</date> <time>13:00</time> <location>34号房间</location> </meeting> <meeting> <date>3/1/99</date> <time>14:30</time> <location>20号房间</location> </meeting> </meetings> </XML> <table datasrc="#xmlMeetings"> <tr> <td><div datafld="date"></div></td> <td><div datafld="time"></div></td> <td><div datafld="location"></div></td> </tr> </table> </BODY> </HTML> </td></tr></tbody></table> 标记<table>利用DATASRC属性引用行内XML，DATASRC属性实际上是通过在要处理的XML元素的ID属性的前面加上#来实现的。由于TD元素不能绑定数据，因此，必须找一个能够绑定数据的元素，在上面的例子里，我们用DIV元素的DADAFLD属性来绑定到要显示的XML元素，例如：DATAFLD="date"就把XML元素里<date>里的值绑定到了DIV。 　　当XML元素被浏览器读入后，对每对<meeting></meeting>标记创建了不同的行。 　　创建ＸＭＬ应用的步骤： 1. 创建一个新的 XML 文档 2. 把下面的代码拷贝粘贴到你的 XML 文档里。 程序代码： <table style="BORDER-RIGHT: #999999 1px dotted; BORDER-TOP: #999999 1px dotted; BORDER-LEFT: #999999 1px dotted; BORDER-BOTTOM: #999999 1px dotted" cellspacing="0" cellpadding="0" width="100%" border="0"><tbody><tr bgcolor="#d2eeff"><td width="5"> </td><td> 引用: <?xml version="1.0" encoding="gb2312" ?> <世界国家介绍> <国家信息> <国家名称>中国</国家名称> <人口>12亿</人口> <首都>北京</首都> <货币>人民币￥</货币> </国家信息> <国家信息> <国家名称>美国</国家名称> <人口>12万</人口> <首都>华盛顿</首都> <货币>美圆$</货币> </国家信息> <国家信息> <国家名称>德国</国家名称> <人口>900万</人口> <首都>柏林</首都> <货币>马克</货币> </国家信息> </世界国家介绍> </td></tr></tbody></table> 3. 世界国家介绍里可以添加任意多的条目. 4.利用数据岛访问XML里的数据。 要在你的HTML文档里应用XML文档，把XML数据岛加入到页面里 　　程序代码： <xml src="xml_application.xml" id="xmlapp" async="false"> </xml> 以上代码的作用：把XML文件"Xml_application.xml"调入所谓的"xmlapp"的数据岛里. async="false" 属性的作用：确保任何HTML处理[解析]之前调入XML数据。 5.绑定XML文件到HTML页面。 绑定XML数据到表格(HTML),在表格数据里，添加数据源属性，并把数据项添加到属性里的数据域: 程序代码： <table style="BORDER-RIGHT: #999999 1px dotted; BORDER-TOP: #999999 1px dotted; BORDER-LEFT: #999999 1px dotted; BORDER-BOTTOM: #999999 1px dotted" cellspacing="0" cellpadding="0" width="100%" border="0"><tbody><tr bgcolor="#d2eeff"><td width="5"> </td><td> 引用: <table datasrc="#xmlapp" width="100%" border="1"> <thead> <th>国家信息</th> <th>人口</th> <th>首都</th> <th>货币</th> </thead> <tr align="left"> <td></td> <td></td> <td></td> <td></td> </tr> </table> </td></tr></tbody></table> 6.绑定XML数据到没有表格的HTML： 要显示XML数据，table 并不是必须的，你可以事业SPAN DIV等，利用 Datasource 和DataField 属性绑定数据。 程序代码： <table style="BORDER-RIGHT: #999999 1px dotted; BORDER-TOP: #999999 1px dotted; BORDER-LEFT: #999999 1px dotted; BORDER-BOTTOM: #999999 1px dotted" cellspacing="0" cellpadding="0" width="100%" border="0"><tbody><tr bgcolor="#d2eeff"><td width="5"> </td><td> 引用: 国家信息: Artist: Year: </td></tr></tbody></table></td> </tr> </tbody> </table> <table class="log_addon_info_box" cellspacing="1" cellpadding="4" width="100%" border="0"> <tbody> <tr> <td style="FONT-SIZE: 10px">By [<a href="http://www.2solo.net/blog/usermdb.asp?un=frank" target="_blank">frank</a>] at 13:55:41 | Comments [0]| <a href="http://www.2solo.net/blog/showTB.asp?log_id=313" target="_blank">TrackBack </a>[0] | 306 views 更多精彩的： <a href="http://www.xml.org.cn/dispbbs.asp?boardID=17&ID=29975">http://www.xml.org.cn/dispbbs.asp?boardID=17&ID=29975</a> <a href="http://java.ccidnet.com/art/3737/20060309/456579_1.html">http://java.ccidnet.com/art/3737/20060309/456579_1.html</a> <a href="http://www.kehui.net/index.php?op=article&file=read&aid=46088">http://www.kehui.net/index.php?op=article&file=read&aid=46088</a></td> </tr> </tbody> </table> <div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/buaacaptain/" target="_blank">船长</a> 2006-05-30 10:53 <a href="http://www.blogjava.net/buaacaptain/archive/2006/05/30/48907.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div> </article> <article> <h1>XML中DTD校验</h1> 船长 — Tue, 23 May 2006 16:45:00 GMT 我们知道校验XML文件的方式有XSD 和XDR两种方式，这两种方式是利用XML Schema来实现的，现在我们介绍另外的一种校验：DTD。 DTD(Document type definition) 校验是使用W3C中有效性约束来实现的。DTD使用一种正式的文法来描述相适应的XML文档的结构和语法。完成一个DTD校验，是利用XmlValidatingReader类。XmlValidatingReader类将DTD定义在DOCTYPE中。这个DOCTYPE定义的可以包括在线的DTD或是指向一个DTD文件。 在什么情况下使用DTD校验呢？使用DTD校验，可以使一个用户组中独立的不同的用户使用共同的DTD来交换数据。比如，你可以使用共同的DTD校验你所接受到的XML数据是不是有效，你也可以用DTD来校验你自己的数据。 下面我们用一个例子来说明DTD是如何使用的。 首先写一个HeadCount.dtd: <!ELEMENT HeadCount (Name)*>//ELEMENT说明元素是HeadCount <!ELEMENT Name (Name)*> //ELEMENT说明元素是Name <!ATTLIST Name First CDATA #REQUIRED>//ATTLIST说明元素Name后面是属性First <!ATTLIST Name Last CDATA #REQUIRED>//ATTLIST说明元素Name后面还有一个是属性Last <!ATTLIST Name Relation (self | spouse | child) "self"> <!ENTITY MyFirst "Jeff"> <!ENTITY MyLast "Smith"> 具体的DTD规范可以参考W3C规范。 还有一个待校验的XML文件HeadCount.xml： <!DOCTYPE HeadCount SYSTEM "HeadCount.dtd"> <HeadCount> <Name First="Waldo" Last="Pepper"> <Name First="Salt" Last="Pepper" Relation="spouse"/> <Name First="Red" Last="Pepper" Relation="child"/> </Name> <Name First="&MyFirst;" Last="&MyLast;"> <Name First="Sharon" Last="&MyLast;" Relation="spouse"/> <Name First="Morgan" Last="&MyLast;" Relation="child"/> <Name First="Shelby" Last="&MyLast;" Relation="child"/> </Name> </HeadCount> 现在我们写一个cs文件来实现校验： testDtd.cs using System; using System.IO; using System.Xml; using System.Xml.Schema; class testDtd { public static void Main() { XmlTextReader tr = new XmlTextReader("HeadCount.xml"); XmlValidatingReader vr = new XmlValidatingReader(tr); vr.ValidationType = ValidationType.DTD; vr.ValidationEventHandler += new ValidationEventHandler (ValidationHandler); while(vr.Read()); Console.WriteLine("Validation finished"); } public static void ValidationHandler(object sender, ValidationEventArgs args) { Console.WriteLine("***Validation error"); Console.WriteLine("\tSeverity:{0}", args.Severity); Console.WriteLine("\tMessage :{0}", args.Message); } } 运行这个程序，可以发现校验正确。 但如果我们把它改下呢? 我们将HeadCount.dtd改成： <!ELEMENT HeadCount1 (Name)*> <!ELEMENT Name (Name)*> <!ATTLIST Name First CDATA #REQUIRED> <!ATTLIST Name Last CDATA #REQUIRED> <!ATTLIST Name Relation (self | spouse | child) "self"> <!ENTITY MyFirst "Jeff"> <!ENTITY MyLast "Smith"> 既将第一个元素改成HeadCount1,再运行这个程序，结果如下： ***Validation error Severity:Error Message :The 'HeadCount' element is not declared. An error occurred at file:///F:/writer/validReader/testDtd/HeadCount.xml, (2, 2). Validation finished 可以发现HeadCount.xml文件中第一个元素不是所期待的HeadCount1,所以报错。 恢复HeadCount.dtd文件，将HeadCount.xml改一下： <!DOCTYPE HeadCount SYSTEM "HeadCount.dtd"> <HeadCount> <Name First1="Waldo" Last1="Pepper"> <Name First="Salt" Last="Pepper" Relation="spouse"/> <Name First="Red" Last="Pepper" Relation="child"/> </Name> <Name First1="&MyFirst;" Last1="&MyLast;"> <Name First="Sharon" Last="&MyLast;" Relation="spouse"/> <Name First="Morgan" Last="&MyLast;" Relation="child"/> <Name First="Shelby" Last="&MyLast;" Relation="child"/> </Name> </HeadCount> 既将First改成First1，Last改成Last1，再运行这个程序，结果如下： ***Validation error Severity:Error Message :The 'HeadCount' element is not declared. An error occurred at file:///F:/writer/validReader/testDtd/HeadCount.xml, (2, 2). Validation finished F:\writer\validReader\testDtd>testDtd ***Validation error Severity:Error Message :The 'First1' attribute is not declared. An error occurred at f ile:///F:/writer/validReader/testDtd/HeadCount.xml, (3, 9). ***Validation error Severity:Error Message :The 'Last1' attribute is not declared. An error occurred at fi le:///F:/writer/validReader/testDtd/HeadCount.xml, (3, 24). ***Validation error Severity:Error Message :The required attribute 'Last' is missing. An error occurred at file:///F:/writer/validReader/testDtd/HeadCount.xml, (3, 4). ***Validation error Severity:Error Message :The 'First1' attribute is not declared. An error occurred at f ile:///F:/writer/validReader/testDtd/HeadCount.xml, (7, 9). ***Validation error Severity:Error Message :The 'Last1' attribute is not declared. An error occurred at fi le:///F:/writer/validReader/testDtd/HeadCount.xml, (7, 28). ***Validation error Severity:Error Message :The required attribute 'Last' is missing. An error occurred at file:///F:/writer/validReader/testDtd/HeadCount.xml, (7, 4). Validation finished 通过报出来的错误信息，我们可以得知，First1和Last1属性在DTD文件中没有定义，所以出错。 通过以上的测试，可以得知DTD校验的一些简单的规律，它同Xml Schema校验相辅相成，共同构成了XML 校验，保证XML数据的正确性，是XML成为数据承载和传输的有效而可靠的载体。 XML 问题 #9 SQL 查询中的 DTD 和 XML 文档 <div>本专栏讨论了可以不依赖 RDBMS 生成可移植 XML 结果集的公众域 sql2dtd 和 sql2xml 实用程序。从关系数据库中抽取数据的 SQL 查询可以提供非常实用且特殊的文档类型信息，用于以 XML 表示查询结果。 前一“XML 话题”专栏讨论了各种数据模型的一些基本理论和它们的优势。得出的一个结论就是 RDBMS 已被普遍接受（有充分的理由），并且在这种环境中，最好将 XML 看作是在各种 DBMS 之间传送数据的一种方法，而不是替代 DBMS 的事物。虽然 XPath 和 XSLT 可用于某些特定的“数据查询”，但它们的应用远不及 RDBMS 和（尤其是）SQL 的应用广泛和普遍。不过，由于篇幅限制，我将在以后的专栏中讨论 XPath 和 XSLT 的具体性能（和限制）。 一些近期的 RDBMS（至少包括 DB2、Oracle，可能还有其它一些 RDBMS）都附带了用于导出 XML 的内置（或者至少可选的）工具。不过，在本专栏中讨论的工具都具有普遍性；特别是，由这些工具生成的 DTD 对于对不同 RDBMS 执行的相同查询都是完全相同的。我希望这对实现数据透明性的目标会有所帮助。过于简化 对于将关系数据库数据转换成 XML，您能想像到的最明显的方式通常也不是什么好的想法。即，它简单到 -- 无论从概念上还是从实践上 -- 将 RDBMS 的所有内容逐个表地转储到相应的 XML 文档中。例如，LIBRARY 数据库（继续上一专栏中那个简单示例）有一个称作 BOOKPRICE 的表，其内容如下：SELECT * FROM BOOKPRICE; +------------+-------+ | ISBN | Price | +------------+-------+ | 2994927282 | 34.99 | | 3920202049 | 47.50 | +------------+-------+ 我可以直接将它转换成如下文档 BOOKPRICE.xml：清单 1. BOOKPRICE.xml 文档<?xml version="1.0"?> <SQL> <row> <ISBN>2994927282</ISBN> <Price>34.99</Price> </row> <row> <ISBN>3920202049</ISBN> <Price>47.50</Price> </row> </SQL> 为数据库中的每个表创建了类似的 XML 文档后，您就拥有了整个数据库的快照。适当简化 上面勾画的方法有两个基本问题。第一个问题是 XML 转储的效率非常低。您已经知道，XML 是一种非常冗长的格式，大型数据库的 XML 转储会生成更大的 XML 文档集合。而且，一些主要 DBMS 已经提供了简洁而有效的文本文件或压缩记录样式的转储。上面所勾画的 XML 对这些简单格式不但没有提供任何额外功能，反而显著地增加了传送文件的大小。第二个问题比第一个更有趣。在某种意义上，“DASD 很廉价”，带宽也变得越来越廉价（"DASD" 是 IBM 对“硬盘”的旧称；这个措词在设计上很陈腐）。因此单单效率不一定就是最重要的因素。更为重要的是，您几乎不会想要将数据库的全部内容与伙伴/部门/用户等进行交流。有时候，一些内容是专用的；而几乎任何时候，大多数内容与特定用户并没有任何关系。将有用的 SQL 查询结果转储到 XML 中比将原始表转储到 XML 更有意义。而为了将 XML 事务或馈送所需的确切语法分析和处理的预期规律化，将 DTD 与这些有用的查询进行关联仍然会比较好。这两种有趣的操作恰好是公众域 Python 实用程序 sql2dtd 和 sql2xml 能够实现的。假设 A 和 B 各自有其自身的内部数据存储器策略（例如，在不同的 RDBMS 中）。各自维护所有种类的相关信息，这些信息与 A 和 B 之间的交互没有关系，但它们又都具有一些希望共享的信息。假设，遵循这样的路线，A 需要与 B 循环地就特定种类的数据集进行通信。A 和 B 可以做的一件事是同意 A 将定期向 B 发送一组 XML 文档，每个文档都符合事先一致认可的 DTD。一个传输中的特定数据将随时间而有所不同，但有效性规则已事先指定。只要 A 和 B 知道它们之间的协议，就可以执行它们的编程。生成 DTD 开发 A 和 B 之间的这种通信的一个方法是开发与 A 和 B 特定需要相匹配的 DTD（或模式）。然后，A 需要开发定制代码来将数据从 A 的当前 RDBMS 导出到符合一致的 DTD 中；B 需要开发定制代码来导入相同的数据（到结构不同的数据库中）。最后，通信通道被打开。不过通常存在一种更快速的方法 -- 往往利用现有导出／导入过程的一种方法。“标准查询语言 (SQL)”是一种能够确切表达 RDBMS 数据库中您所感兴趣的数据的极其简洁的方法。尝试将例如 XPath 或 XSLT 这样的 XML 原始技术合并到关系模型上可能不太自然，尽管它们必定可以在 XML 的基本分层模型中表达查询功能。许多组织已经开发出为实现已知任务的、经过了彻底测试的几组 SQL 语句。事实上，RDBMS 往往提供了用于优化已存储查询的方法。虽然肯定有一些为数据交换而设计的丰富的 DTD 比较有意义的情况，但在许多或者大多数情况下，在 SQL 查询中隐式地使用结构信息作为 SQL 数据传输的（自动）基础是种很好的解决方案。虽然 SQL 查询可以以复杂的方法来组合表数据，但所有 SQL 查询的结果都是相当简单的“行与列”的排列。在查询输出中，列的数量是固定的，每行填入了每个固定列的值。（即，除了数量上没有改变以外，无论是值的类型还是列名在 SQL 结果中均无改变 -- 即使它们可能在 XML 文档中有所改变）。XML 表示元素复杂嵌套模式的潜力在表示 SQL 结果中并没有得到深层的体现。虽然如此，SQL 查询的一些重要方面可以而且也应该在简单的行／列位置以外以 XML DTD 表示。要表示 SQL 查询中的哪些内容？ 我认为在 A 和 B 之间预期的数据交换中，应该区分出两方面。一方面，是 A 数据的内部组织 -- 例如，其标准化和取消标准化优化。B 没有，也不需要考虑 A 的内在方面。另一方面，存在描述实际发送内容的元数据。当然，区分这些方面不一定很容易。在编写 sql2dtd（和帮助规划 Scott Hathaway 的 sql2xml）时，我做了一些决定，确定了哪些属于数据传输的部分，哪些位于发送方设置的内部（不需要以 DTD 表示）。清单 2 所显示的样本 XML（带有作为内部集的 DTD）输出有助于说明这些决定（该输出完全从作为属性包含的 SQL 查询生成；当然，是在对合适的数据库运行时）：清单 2. 带有作为内部集的 DTD 的样本 XML 输出<?xml version="1.0"?> <!DOCTYPE SQL [ <!ELEMENT SQL (row)*> <!ATTLIST SQL GROUP_BY NMTOKEN #FIXED "AuthID" query CDATA #FIXED "SELECT AuthID AS SSN,COUNT(GroupID) FROM AUTHGROUP GROUP BY AuthID ORDER BY AuthID" > <!ELEMENT row (SSN, column2)> <!ATTLIST row num ID #IMPLIED> <!ELEMENT SSN (#PCDATA)> <!ELEMENT column2 (#PCDATA)> <!ATTLIST column2 CALC CDATA #FIXED "COUNT(GroupID)"> ]><SQL> <row num="1"> <SSN>111-22-3333</SSN> <column2>1</column2> </row> <row num="2"> <SSN>333-22-4444</SSN> <column2>2</column2> </row> <row num="3"> <SSN>666-44-5555</SSN> <column2>1</column2> </row> </SQL> 这个简单的 XML 文档实际上可以包含比人们最初时所注意到的更多的元数据。当然，通过将 SQL 本身作为根节点的一个属性包含在内，人们可以重新构造 SQL 中固有的任何事物。但这样做需要对 SQL 重新进行语法分析，sql2dtd 已在文档中表示过它，因此通常这没有必要。CALC 属性的规范包含这样一个事实，即 XML 包含了计算过的元素。因为计算过的表达式可能很长，并且可能包含对于 XML 标记来说非法的字符，所以计算过的列仅由它们的位置命名。不过，加入元素内容的特定计算是作为标记的一个属性包含在内的。为了避免在 XML 主体中重复属性，它在 DTD 中指定为 #FIXED。如果使用计算过的列，计算往往反映使用 "GROUP BY" 修饰符对列所进行的分组。所有这样的分组都在根元素的 GROUP_BY 属性中列出。而且，如果使用了 "ORDER BY" 子句，每个 <row> 标记就会带有指定输出数据序列的 num 属性。不过，如果结果集是无序的，则不使用 num 属性。让我们考虑一下在 DTD 中有什么东西没有表示，就会发现它实际上确实属于 A 的内部数据表示，而不属于发送的消息。除了嵌入的原始 SQL 查询以外，没有保留用于查询数据的一个或多个表的表示（"FROM" 子句）。特殊的表组织只不过不是 B 需要感兴趣的一些事物。事实上，A 可以在有适当传输协议之后彻底地修改其数据库设计；但只要通过一些手段抽取相同的字段（列），B 就不需要担心这一点。尤其是，因为 "AS" 子句覆盖了实际的表的列名，所以有可能继续发送在 A 数据库中不再拥有任何直接文字意义的 XML 元素。在 sql2dtd 设计中最重要的一点是忽略了 "WHERE" 和 "HAVING" 子句（以及 JOIN、DISTINCT 和 ALL 修饰符）。和表名一样，将数据从 A 的那些表中取出所必需的特定联接和过滤器不是 B 应该担心的问题。如果 A 碰巧需要将一些表联接在一起以获得一些数据，那只是 A 的一个标准化策略。B 可以使用也可以不使用任何类似的策略（对于不同的数据子集），两种方法都不用担心 A 的操作。出于相关但稍微不同的理由忽略过滤器（主要使用 "WHERE" 子句或 "DISTINCT" 修饰符）。不管出于何种商业原因，如果 A 只需要告之 B 那些其 whatzit 大于 25 的 woozles，从 B 的角度来说，它只是属于 woozles 的性质。即，A 可能对 B 不关心的 woozles 的一个子类感兴趣；但是 A 需要通过使用过滤器来获得感兴趣的内容（与不拥有它们，或将它们放在另一个表中相反）这一特定事实并不是 B 需要担心的。从这一方面来说，sub-select 只是另一种过滤器。结束 我还没有介绍 sql2dtd 和 sql2xml 的任何特定用法。这里不需要做太多解释，因为它们自己已在内部详细说明了。一般情况下， sql2dtd 可以从 SQL 查询生成 DTD，但它本身并不查询任何数据库。sql2xml 通过 ODBC 执行查询，并可以利用 sql2dtd 来获得 DTD（它也可以生成 DTD 较少的 XML文档）。这些工具只对 A 和 B 之间预期大约一半过程有所帮助。A 和 B 可以快速地使用这些工具达到 DTD，A 可以同样快速地生成符合这些 DTD 的输出 XML 文档。但 B 最终仍需要执行语法分析、存储和处理这些接收到的文档所涉及的所有工作。以后的专栏将更详细地讨论 B 的任务。 简单的DTD例子描述和分析 　下面举一个带有内部DTD的XML文档的例子： 　　＜?xml version="1.0" encoding="GB2312" ?＞ 　　＜!DOCTYPE 家庭 [ 　　　＜!ELEMENT 家庭 (人+,家电*)＞ 　　　＜!ELEMENT人 EMPTY＞ 　　　＜!ELEMENT 家电 EMPTY＞ 　　　＜!ATTLIST 人 　　　　名字 CDATA #REQUIRED 　　　　性别 (男|女) #REQUIRED 　　　　年龄 CDATA #REQUIRED 　　　　爱好 CDATA #IMPLIED 　　　＞ 　　　＜!ATTLIST 家电 　　　　　名称 CDATA #REQUIRED 　　　　　数量 CDATA #REQUIRED 　　　　　说明 CDATA #IMPLIED 　　　　＞ 　　]＞ 　　<家庭> 　　<人> 　　<名字>郭大路 　　<性别>男 　　<年龄>25 　　 　　<人> 　　<名字>李寻欢 　　<性别>男 　　<年龄>38 　　<爱好>作个教育家和伟人 　　 　　<家电> 　　<名称>彩电 　　<数量>3 　　 　　 　　这个文档从第二行开始进行文档类型声明，包含了文档元素（家庭）的名称。根据定义，我们发现该元素可以包含一个或者多个人（由这个+号决定的），可以包含零个或多个家电（由这个*符号决定），然后定义了人这个元素的需要的属性，其中名字、性别和年龄是必须的，而爱好可以填有也可以不填。家电的名字和数量属性必须有，但说明可以写也可以不写。 　　如果采用外部DTD的话，就需要有两个文档，第一个文档就是关于DTD的文档，第二个文档就是遵守DTD格式的内容文档。实际上我们可以建立无穷多个遵守该DTD格式的文档。举一个例子来说，我们在构造关系数据库中的表的时候，我们需要定义好表的结构（也就是表包含的字段集合），然后我们就可以往这个表中放入记录，记录的个数从理论上讲可以是无穷多个的。这里关于表的结构就类似于DTD文档。记录类似于遵守DTD格式的内容文档。外部DTD的好处是：它可以方便高效地被多个XML文件所共享。你只要写一个DTD文件，就可以被多个XML文件所引用。事实上，当许多组织需要统一它们的数据交换格式时，它们就是通过外部DTD来完成的。这样做不仅简化了输入工作，还保证当你需要对DTD做出改动时，不用一一去改每个引用了它的XML文件，只要改一个公用的DTD文件就足够了。不过需要注意，如果DTD的改动不是"向后兼容"的，这时原先根据该DTD编写的那些XML文件可能就会出问题了。 　　现在我们就尝试建立一个DTD文档，不妨命名为Home.dtd。其代码如下： 　　＜?xml version="1.0" encoding="GB2312" ?＞ 　　＜!ELEMENT 家庭 (人+,家电*)＞ 　　＜!ELEMENT人 EMPTY＞ 　　＜!ELEMENT 家电 EMPTY＞ 　　＜!ATTLIST 人 　　　　名字 CDATA #REQUIRED 　　　　性别 (男|女) #REQUIRED 　　　　年龄 CDATA #REQUIRED 　　　　爱好 CDATA #IMPLIED 　　　＞ 　　＜!ATTLIST 家电 　　　名称 CDATA #REQUIRED 　　　数量 CDATA #REQUIRED 　　　说明 CDATA #IMPLIED 　　＞ 　　然后，我们可以建立一个遵守该DTD格式的内容文档，不妨设为HomeInstance.xml。其代码如下： 　　＜?xml version="1.0" encoding="GB2312" ?＞ 　　＜!DOCTYPE 家庭 SYSTEM "Home.dtd"＞ 　　<家庭> 　　<人> 　　<名字>郭大路 　　<性别>男 　　<年龄>25 　　 　　<人> 　　<名字>李寻欢 　　<性别>男 　　<年龄>38 　　<爱好>作个教育家和伟人 　　 　　<家电> 　　<名称>彩电 　　<数量>3 　　 　　 　　把这两个文档放到同一个目录下，然后可以用XML浏览器对HomeInstance.xml进行浏览，结果应该和使用内部DTD的结果一样。 　　众所周知，在设计MIS应用程序的时候，重要的是要进行E-R图设计，然后建立关系数据库，建立数据库的关键就是要定义好表的格式，并使它的范式尽可能的高。对应的，建立基于XML应用的关键就是要定义好DTD，然后所有的内容就按照DTD格式进行编写。DTD实际上表现了一个层次的关系，你也可以把它理解成一棵树的结构。树中的节点实际上就是一个个元素（ELEMENT），一个元素可以包含其他的元素。比如上面的例子中家庭这个元素包含了人和家电这两个元素。一个元素可以包含属性（ATTLIST）也可以没有任何属性。比如上面的例子中，家庭这个元素就没有任何属性，而人和家电都有自己的属性。 　　际上如果大家学过编译系统的话，都知道对编程语言进行语法定义的工具：巴科斯-诺尔范式。它是用来对语言的语法进行定义的工具。实际上DTD就是起到了类似的作用。</div> <div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/buaacaptain/" target="_blank">船长</a> 2006-05-24 00:45 <a href="http://www.blogjava.net/buaacaptain/archive/2006/05/24/47737.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div> </article> <article> <h1>B/S系统权限控制的一种简单方法</h1> 船长 — Tue, 23 May 2006 10:18:00 GMT 看了网上一些关于权限控制的帖子，越看越迷糊，什么用AOP(Aspect Oriented Programming,面向方面编程)，用容器，RBAC(基于角色的访问控制方法),SSO,Jive的Proxy模式等等等等，且又是role又是group，真是头都大了，先写个简单的实现方法，以后再研究高深的。 此方法不依赖容器框架，适用于小系统(主要JSP页面要少于100,因为是硬编码到JSP)，适用于要精确控制页面field的情况较多的系统。(插句话：要分清权限控制与业务逻辑，业务逻辑就是情况由系统运行时的某些条件决定，如学生管理系统中，某一学生进入系统，只能看自己的记录，因为可看的记录是由学号来决定的，所以这是业务逻辑，而又如学生不能看老师的记录，这是有学生的身份来决定的，所以这是权限控制。)好了，进入正题！ 建表： user(user信息： userID userPassword 等) role(role描述：roleID roleDesc) permission(permission描述：permissionID permissionDesc) user-role(user role对应关系表：userID roleID) role-permission(role permission对应关系表：roleID permissionID) user-permission(user permission对应关系表：userID permissionID) 重要申明：1 此处role没有继承关系,只是permission的集合2 user-permission表只是为了方便，其数据是根据user-role role-permission两表得来，只有在user-role role-permission两表有更新的时候更新此表，并不能单独赋予user某个permission,只能赋予user一个或多个role。3 permission的分配，这是一个难点，很多比较复杂的权限控制系统也是因为这个才发展出来，此处把它尽量想简单，不考虑业务逻辑，以页面为视角，分两层，首先是需要控制的jsp页面，然后是需要控制的页面field(包括link,text,textbox,button等等)，field这一层还有privilege之分(R和W，即可读和可写)基本思路：进入JSP页面时，检查用户信息，查到用户有此permission就包含此代码，如果没有此permission就不包含此代码，此功能由Tag来完成(不会写Tag？不要紧，抄！)。看代码吧！1 建表(如上) 2 建两个class(bean) (UserProfile是用户基本信息 UserPermission是permission ) UserProfile.java: package com.××.××.××; import java.util.Collection;public class UserProfile { private String userId; private String userType; private String companyNo; private String companyName; private String companyType; private Collection userPermissions; public String getUserId() { return userId; } public void setUserId(String userId) { this.userId = userId; } public String getUserType() { return userType; } public void setUserType(String userType) { this.userType = userType; } public String getCompanyNo() { return companyNo; } public void setCompanyNo(String companyNo) { this.companyNo = companyNo; } public String getCompanyName() { return companyName; } public void setCompanyName(String companyName) { this.companyName = companyName; } public String getCompanyType() { return companyType; } public void setCompanyType(String companyType) { this.companyType = companyType; } public Collection getUserPermissions() { return userPermissions; } public void setUserPermissions(Collection userPermissions) { this.userPermissions = userPermissions; } }UserPermission.java: package com.××.××.××;public class UserPermission { private int permissionId; private String privilege; public int getPermissionId() { return permissionId; } public void setPermissionId(int permissionId) { this.permissionId = permissionId; } public String getPrivilege() { return privilege; } public void setPrivilege(String privilege) { this.privilege = privilege; } } 3 加两个Tag(Page与Field)： SecurityTagForPage.java： package com.**.**.taglib; import java.util.*;public class SecurityTagForPage extends TagSupport { private int permissionID; public int doEndTag() throws JspException { HttpSession session = pageContext.getSession();//登陆时把该user的userProfile放到session里 UserProfile userProfile = (UserProfile)session.getAttribute("userProfile"); Collection collection= userProfile.getUserPermissions(); Iterator it = collection.iterator() ; while(it.hasNext()) { UserPermission userPermission = (UserPermission)it.next(); if ((permissionID == userPermission.getPermissionId())) { return EVAL_PAGE; } } return SKIP_PAGE; }public int getPermissionID() { return permissionID; } public void setPermissionID(int permissionID) { this.permissionID = permissionID; } } SecurityTagForField： public class SecurityTagForField extends TagSupport { private int permissionID; private String privilege;public int doStartTag() throws JspException { HttpSession session = pageContext.getSession(); UserProfile userProfile = (UserProfile)session.getAttribute("userProfile");Collection collection= userProfile.getUserPermissions(); Iterator it = collection.iterator() ; while(it.hasNext()) { UserPermission userPermission = (UserPermission)it.next(); if (privilege ==null) { if ( (permissionID == userPermission.getPermissionId())) { return EVAL_BODY_INCLUDE; } } else { if ((permissionID == userPermission.getPermissionId()) &&(privilege.equals(userPermission.getPrivilege()))) { return EVAL_BODY_INCLUDE; } } } return SKIP_BODY; } public int getPermissionID() { return permissionID; } public void setPermissionID(int permissionID) { this.permissionID = permissionID; } public String getPrivilege() { return privilege; } public void setPrivilege(String privilege) { this.privilege = privilege; } } 4 在web-inf目录下建个securityTag.tld文件，内容如下：(改一下class的目录) <?xml version="1.0" encoding="ISO-8859-1"?> <!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN" "http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd">  <taglib> <tlibversion>1.0</tlibversion> <jspversion>1.1</jspversion> <shortname>security</shortname> <uri/> <info> access control! </info> <tag> <name>securityForField</name> <tagclass>com.companyname.prjname.taglib.SecurityTagForField</tagclass> <attribute> <name>permissionID</name> <required>true</required> </attribute> <attribute> <name>privilege</name> </attribute></tag> <tag> <name>securityForPage</name> <tagclass>com.companyname.prjname.taglib.SecurityTagForPage</tagclass> <attribute> <name>permissionID</name> <required>true</required> </attribute></tag> </taglib> 5 修改需要控制的jsp在jsp页面这样写： <%@ taglib uri="/WEB-INF/securityTag.tld" prefix="security" %> <%@ page import="com.hp.elog2.util.Util" %> <security:securityForPage permissionID="36" /> ....... <security:securityForField permissionID="46" privilege="R"> <td><html:text name="formBean" property="property1" readonly="true" /></td> </security:securityForField> <security:securityForField permissionID="46" privilege="W"> <td><html:text name="formBean" property="property1" /></td> </security:securityForField> ...... 这样就大功告成了，建议在所有jsp页面完成后再做权限控制这一块(添加Tag)，主要都是些Copy＋C和Copy＋V的工作。此方法最大的问题就是hardcode太多，但结构简单，思路清晰，适用范围广。 <div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/buaacaptain/" target="_blank">船长</a> 2006-05-23 18:18 <a href="http://www.blogjava.net/buaacaptain/archive/2006/05/23/47696.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div> </article> <article> <h1>有关xml的相关资料收集</h1> 船长 — Tue, 23 May 2006 10:06:00 GMT XML DTD是目前使用最广泛的一种XML 模式，XML Schema则已经成为W3C的正式推荐标准，并有替代XML DTD的趋势。那么，从技术角度看，XML Schema与XML DTD有那些区别，XML Schema又有那些优势呢？ 引言 XML DTD(XML的文档类型定义)是近几年来XML技术领域所使用的最广泛的一种模式。但是，由于XML DTD并不能完全满足XML自动化处理的要求，例如不能很好实现应用程序不同模块间的相互协调，缺乏对文档结构、属性、数据类型等约束的足够描述等等，所以W3C于2001年5月正式推荐XML Schema为XML 的标准模式。显然，W3C希望以XML Schema来作为XML模式描述语言的主流，并逐渐代替XML DTD。那么XML Schema与XML DTD相比到底有哪些优势呢，XML DTD是否真的会在XML的模式描述领域中逐渐消失呢？ XML模式与XML格式 XML模式是指用来描述XML结构、约束等因素的语言，例如XML Schema、XML DTD、XDR，SOX等等。XML格式则是XML文档本身所具有的格式。本文以XML Schema来代表W3C所推荐的XML Schema模式标准，而以"XML模式"来代表所有的XML模式描述语言。从模式的描述语言来说，XML Schema和XML DTD都属于语法模式。与概念模式不同，语法模式在对同一事物描述时，可以采用不同的语法，例如在对关系模式描述时，无论是使用XML Schema还是XML DTD，都既可以用元素也可以用属性来描述关系模式的列。模式必须以某种格式来表示，XML Schema的格式与XML DTD的格式有着非常明显的区别，XML Schema事实上也是XML的一种应用，也就是说XML Schema的格式与XML的格式是完全相同的，而作为SGML DTD的一个子集，XML DTD具有着与XML格式完全不同的格式。这种区别会给XML Schema的使用带来许多好处： XML用户在使用XML Schema的时候，不需要为了理解XML Schema而重新学习，节省了时间； 由于XML Schema本身也是一种XML，所以许多的XML编辑工具、API 开发包、XML语法分析器可以直接的应用到XML Schema，而不需要修改。 作为XML的一个应用，XML Schema理所当然的继承了XML的自描述性和可扩展性，这使得XML Schema 更具有可读性和灵活性。 由于格式完全与XML一样，XML Schema除了可以像XML一样处理外，也可以同它所描述的XML文档以同样的方式存储在一起，方便管理。 XML Schema与XML格式的一致性，使得以XML为数据交换的应用系统之间，也可以方便的进行模式交换。 XML有非常高的合法性要求，XML DTD对XML的描述，往往也被用作验证XML合法性的一个基础，但是XML DTD本身的合法性却缺少较好的验证机制，必需独立处理。XML Schema则不同，它与XML有着同样的合法性验证机制。 数据类型或许，对于许多开发人员来讲，XML Schema与XML DTD相比的一个最显著的特征，就是其对数据类型的支持了。这完全是因为XML DTD提供的数据类型只有CDATA 、Enumerated、NMTOKEN 、NMTOKENS等十种内置（built-in）数据类型。这样少的数据类型通常无法满足文档的可理解性和数据交换的需要。XML Schema则不同，它内置了三十七种数据类型，如long，int，short，double等常用的数据类型，并通过将数据类型表示为由value space、lexical space和facet三部分组成的三元组而获得更大的灵活性。但是， XML Schema数据类型的真正灵活性来自于其对用户自定义类型的支持。XML Schema提供两种方式来实现数据类型的定义。1)简单类型定义（simpleType），即在XML Schema内置的数据类型基础上或其它由XML Schema内置的数据类型继承或定义所得到的简单的数据类型（simpleType）基础上，通过restriction，list 或者 union方式定义新的数据类型。例如： 源码1 restriction方式的定义 <simpleType name='Sku'> <restriction base='string'> <pattern value='\d{3}-[A-Z]{2}'/> </restriction> </simpleType> 源码2 list方式的定义 <simpleType name='listOfDouble'> <list itemType='double'/> </simpleType> 源码3 union方式的定义 <xsd:attribute name="size"> <xsd:simpleType> <xsd:union> <xsd:simpleType> <xsd:restriction base="xsd:positiveInteger"> <xsd:minInclusive value="1"/> <xsd:maxInclusive value="12"/> </xsd:restriction> </xsd:simpleType> <xsd:simpleType> <xsd:restriction base="xsd:string"> <xsd:enumeration value="month"/> </xsd:restriction> </xsd:simpleType> </xsd:union> </xsd:simpleType> </xsd:attribute> 2) 复合类型定义（complexType），该方法提供了一种功能强大的复杂数据类型定义机制，可以实现包括结构描述在内的复杂的数据类型。下面是一个以complexType定义实现关系模式中表结构的例子，设有表T_C_Type（Psign，Count），其中Psign为CHAR数据类型，Count为NUMBER数据类型。则有：源码4 complexType定义  <complexType name="T_C_Type"> <sequence minOccurs="0" maxOccurs="unbounded"> <element name="Psign"> <complexType> <simpleContent> <restriction base="string"> <attribute name="value" type="string"/> </restriction> </simpleContent> </complexType> </element> <element name="Count" minOccurs="0"> <complexType> <complexContent> <restriction base="anyType"> <attribute name="value" type="int" use="optional"/> </restriction> </complexContent> </complexType> </element> </sequence> </complexType> 不仅如此，XML Schema还允许元素的内容取空值，这一点可以扩大XML Schema对数据情况的描述范围，而XML DTD则无能为力。例如：源码5 XML Schema 元素取空值的定义 <element name='test' nullable='true'/> 元素顺序的支持 XML DTD与XML Schema 都支持对子元素节点顺序的描述，但XML DTD没有提供对于无序情况的描述，也就是如果以XML DTD来描述元素的无顺序出现情况，它必须采用穷举元素各种可能出现的排列顺序的方式来实现，这种方法不仅繁琐，有时甚至是不现实的。例如对于table的a，b子元素，如果希望它们以任意的顺序出现，用XML DTD来描述：源码6 a，b子元素任意顺序出现的XML DTD定义 <?xml version="1.0" encoding="UTF-8"?> <!ELEMENT ENTER_NAME_OF_ROOT_ELEMENT_HERE EMPTY> <!ELEMENT table ((a,b)|(b,a))> <!ELEMENT a (#PCDATA)> <!ELEMENT b (#PCDATA)> XML Schema提供了<all>标记来描述这种情况：源码7 a，b子元素任意顺序出现的XML Schema定义 <xsd:element name="a" type="xsd:string"/> <xsd:element name="b" type="xsd:string"/> <xsd:element name="table"> <xsd:complexType> <xsd:all> <xsd:element ref="a"/> <xsd:element ref="b"/> </xsd:all> </xsd:complexType> </xsd:element> 可见，用XML Schema来实现子元素的无序描述要简单的多。命名空间 在XML中引入命名空间的目的是为了能够在一个XML文档中使用其它XML文档中的一些具有通用性的定义（通常是一些元素或数据类型等的定义），并保证不产生语义上的冲突。XML DTD并不能支持这一特性，这进一步限制了XML DTD的适用范围。而XML Schema则很好的满足了这一点。并且， XML Schema还提供了include 和 import两种引用命名空间的方法。下面的例子中XML Schema文档引用了其它两个XML Schema的定义，通过使用import实现了混合使用不同命名空间的目的。例子中还定义了不同命名空间中元素之间的keyref约束。源码8 XML Schema对命名空间的使用 schema targetNamespace="<a class="contentlink" href="http://202.117.84.144"/" target="_blank">http://202.117.84.144"</a> xmlns:xs="<a class="contentlink" href="http://202.117.84.144"/" target="_blank">http://202.117.84.144"</a> xmlns="<a class="contentlink" href="http://www.w3.org/2001/XMLSchema"" target="_blank">http://www.w3.org/2001/XMLSchema"</a> xmlns:a="<a class="contentlink" href="http://202.117.84.228/middlewareSqlServer2000sqlservertest20211784228"" target="_blank">http://202.117.84.228/middlewareSqlServer2000sqlservertest20211784228"</a> xmlns:b="<a class="contentlink" href="http://202.117.84.228/middlewareOracle805ioracletest20211784144"" target="_blank">http://202.117.84.228/middlewareOracle805ioracletest20211784144"</a> elementFormDefault="qualified"> <import namespace="<a class="contentlink" href="http://202.117.84.228/middlewareSqlServer2000sqlservertest20211784228"" target="_blank">http://202.117.84.228/middlewareSqlServer2000sqlservertest20211784228"</a> schemaLocation="F:\xml schema\middlewareSqlServer2000sqlservertest20211784228.xsd"/> <import namespace="<a class="contentlink" href="http://202.117.84.228/middlewareOracle805ioracletest20211784144"" target="_blank">http://202.117.84.228/middlewareOracle805ioracletest20211784144"</a> schemaLocation="F:\xml schema\middlewareOrcal805ioracletest20211784144.xsd"/> <annotation> <documentation xml:lang="cn"> schema for Middleware Copyright 2001 Zhou Jingtao. All rights reserved. </documentation> </annotation> <element name="CombineDatabase"> <complexType> <sequence> <element name="CombinGlobeSchema"> <complexType> <sequence> <element ref="a:H-Database"/> <element ref="b:H-Database"/> </sequence> </complexType> <keyref name="SqlServerTest_T_C_Psign" refer="b:gz_jgxx_ID_pk"> <selector xpath="a:H-Database/a:SqlServerTest/a:T_C/a:Count"/> <field xpath="@value"/> </keyref> </element> </sequence> </complexType> </element> </schema> 对于API的支持 在掌握和使用XML技术时，DOM和SAX可能是技术人员最常使用到的XML API。DOM和SAX只对XML实例文档有效，虽然可以通过它们实现以XML DTD来验证XML文档,但是DOM和SAX却没有提供解析XML DTD文档内容的功能，也就是说我们无法通过DOM或SAX来得到DTD中元素、属性的声明和约束的描述。但是在基于XML+DTD的数据交换过程中，一些应用程序需要得到DTD本身的描述内容和结构，以方便对XML文档中数据的处理，例如在使用关系数据库存储XML 文档的过程中就涉及到如何将XML DTD映射为关系模式描述的问题。为了实现对XML DTD的解读，研究人员必须为XML DTD开发新的接口或者专用工具，带来了很大的不便。由于XML Schema本身就是一个XML 文档，所以我们可以通过使用DOM、SAX或JDOM等XML API很容易的解析XML Schema，这就实现了XML文档与其描述模式处理方式的一致性，利于数据的传输和交换。更加清晰的属性出现情况的限制、以及缺省值和枚举 XML DTD以关键字#IMPlIED、#FIXED和#REQUIRED来指定属性是否出现，并支持属性缺省值的定义。XML Schema则提供了更明确的标记来实现清晰易懂的表示。XML Schema废弃了XML DTD的#IMPlIED，不再支持属性的隐含状态，而要求必须给出明确的状态，并以prohibited来表示属性的禁用。对于缺省值的表达则更为直观，用default来直接给出。源码9 XML DTD 、XML Schema对属性出现情况的限制 <!ATTLIST TestDTD testAr1 CDATA #IMPLIED> <!ATTLIST TestDTD testAr2 CDATA #REQUIRED> <!ATTLIST TestDTD testAr3 CDATA #FIXED "3"> <!ATTLIST TestDTD testAr4 CDATA "3"><xsd:attribute name="TestAr1" type="xsd:string" use="optional" default="3"/> <xsd:attribute name="TestAr2" type="xsd:string" use="prohibited"/> <xsd:attribute name="TestAr3" type="xsd:string" use="required" fixed="3"/> 对于XML Schema在枚举方面的改进，请参见参考资料中"XML 问题 #7 W3C XML Schema 与文档类型定义 (DTD) 比较"一文（文献9）。注释 XML DTD和XML Schema都支持<!-注释内容-->这样的注释方法，但是XML Schema提供了更灵活和有用的注释方式：documentation和appinfo。它们提供了面向读者和应用的注释。源码10 XML Schema的注释 <xsd:annotation> <xsd:documentation>面向用户和应用的注释</xsd:documentation> <xsd:appinfo> //这是一段C语言代码。 #include stdio.h void main() { int i,j; i =1; j=i+1; } </xsd:appinfo> 对数据库的支持 目前如何将关系数据表示为XML数据和如何实现基于关系数据库的XML数据存储、查询和更新已经成为了研究的热点。Deutsh，Florescu[5]，Kossman[5]，Shanmugasundaram[6,7]和D W Lee[8]等人都在XML与关系数据的相互转化问题方面作了较深入的研究。然而由于XML Schema成为正式推荐标准的时间较晚，加之XML DTD语法相对简单，所以现在大部分的研究和应用都是基于XML DTD展开的。但是，XML DTD在对关系数据的描述方面明显存在着不足，例如XML DTD有限的数据类型根本无法完成对关系数据数据类型的一一映射，也无法实现大部分的数据规则的描述。XML Schema提供了更多的内建数据类型，并支持用户对数据类型的扩展，基本上满足了关系模式在数据描述上的需要，这一点可以作为XML Schema比XML DTD更适合描述关系数据的一个主要的原因。 一个结论 通过比较，可以看出，XML Schema比XML DTD具有更强的表现力，能够更好的满足不同领域应用的需求。那么，是不是可以说XML DTD会很快被XML Schema替代并最终消失呢。从作者的观点来看，XML Schema虽然在大多数的应用领域都有替代XML DTD的趋势，但是XML DTD仍然有它的适用范围，并不可能被XML Schema完全替代： XML DTD是作为XML 标准的一部分发布的，W3C似乎并没有准备将其从XML标准中废除掉，对于XML DTD的支持还将持续。 目前大多数的面向XML应用，都对XML DTD做了很好的支持，XML DTD的工具也相对较为成熟，一般情况下，这些应用和工具并不会选择以XML Schema替换XML DTD的方式对其升级，更多的选择应该是二者都支持。当然，对于那些对数据交换或者描述能力要求较高、XML DTD已不能满足功能需求的应用来说，以XML Schema来代替XML DTD已经成为一种必然趋势。 当前大多数与XML 模式相关的算法研究都是基于XML DTD展开的，作为一种研究的延续，并不会放弃XML DTD的研究成果，但是，针对XML Schema的研究将会成为一个新的热点。 在一些相对要求简单的处理环境中，XML DTD仍然会占有它的一席之地。 同其他技术的发展一样，由于新标准的出现，XML DTD的作用会逐渐减弱，但正如层次数据库在今天仍然在使用一样，对XML Schema是否会完全替代XML DTD做一个结论似乎为时过早。 所以，作为一种强有力的标准，XML Schema作为XML模式的主流已经成为一种趋势；但作为一种最简单的XML模式，XML DTD也还将会在一段时间内发挥它应有的作用。 <div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/buaacaptain/" target="_blank">船长</a> 2006-05-23 18:06 <a href="http://www.blogjava.net/buaacaptain/archive/2006/05/23/47694.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div> </article> <article> <h1>Jbuilder9.0+JBOSS-3.2+MS Server2000的配置方法</h1> 船长 — Mon, 22 May 2006 10:42:00 GMT 选择自 <a id="ArticleTitle1_ArticleTitle1_AuthorLink" href="http://dev.csdn.net/user/AbnerChai">AbnerChai</a> 的 Blog ，因为我要用到CMP，所以增加了JBOSS下使用MS Server的配置方法。 网络上对Jbuilder9.0+JBOSS-3.2开发环境的配置说明的参考还很少，我在这里整理了一个，这是我在配置这个开发环境时的一个手记。 下面是详细步骤： 1、安装Jbuilder9.0到D:\Jbuilder9目录 2、安装MySQL4.0.18到C:\mySQL目录 3、安装MS SQL Server2k 到C:\Program Files\下 安装JDK.14，下载后直接安装到C:\j2sdk1.4.1_01目录下，然后在系统环境变量中设置：JAVA_HOME= C:\j2sdk1.4.1_01即可。 4、安装JBOSS3.2.1_tomcat-4.1.24到C:\JBOSS目录下。 注意：JBOSS的安装很简单，将下载后的文件解开放入C:\JBOSS下即可，然后在系统环境变量中设置：JBOSS_HOME=C:\JBOSS即可。 5、下载并安装mySql JDBC Driver和MS SQLServer JDBC Driver。下载后的文件史分别是： mysql-connector-jdbc-3.0.10-stable.zip和SQLServer2KJDBCsetup.exe。 安装方法如下：将mysql-connector-jdbc-3.0.10-stable.zip解开，将其中的mysql-connector-jdbc-3.0.10-stable目录下的mysql-connector-java-3.0.10-stable-bin.jar文件持拷入JBOSS安装目录C:\JBOSS下的c:\jboss\server\default\lib目录下。 执行SQLServer2KJDBCsetup.exe安装到C:\Program Files\Microsoft SQL Server 2000 Driver for JDBC目录下，并将其下lib目录（即C:\Program Files\Microsoft SQL Server 2000 Driver for JDBC\lib）目录下的msbase.jar、mssqlserver.jar和msutil.jar三个文件拷入JBOSS安装目录C:\JBOSS下的c:\jboss\server\default\lib目录下。 同时，最后启动MS SQL Server2k服务器并用查询分析器连接到上面，执行： C:\Program Files\Microsoft SQL Server 2000 Driver for JDBC\SQLServer JTA目录下的： instjdbc.sql脚本。 6、配置JBOSS的数据库连接池，使它能正确连接到MySQL和SQL Server上。方法如下： 进入JBOSS安装目录C:\JBOSS下，进入其下的C:\JBOSS\server\default\deploy目录中，用记事本新建两个文件mssql-ds.xml和mysql-ds.xml，内容如下： 1、 mysql-ds.xml <?xml version="1.0" encoding="UTF-8"?> <datasources> <local-tx-datasource> <jndi-name>MySql</jndi-name> <connection-url>jdbc:mysql://10.0.0.18:3306/test</connection-url> <driver-class>org.gjt.mm.mysql.Driver</driver-class> <user-name>root</user-name> <password></password> </local-tx-datasource> </datasources> 2、 mssql-ds.xml <?xml version="1.0" encoding="UTF-8"?> <datasources> <local-tx-datasource> <jndi-name>MSSQL</jndi-name><connection-url>jdbc:microsoft:sqlserver://10.0.0.18:1433;DatabaseName=test</connection-url> <driver-class>com.microsoft.jdbc.sqlserver.SQLServerDriver</driver-class> <user-name>sa</user-name> <password></password> </local-tx-datasource> </datasources> 3、配置CMP数据类型映射 配置JBoss使用MS SQL Server连接池作为缺省的数据源，你可以选择下列方法之一: 在你的应用程序的META-INF目录下创建jaws.xml文件或重载standardjaws.xml中如下所示的缺省设置 示例 jaws.xml(MS SQL Server CMP数据类型映射) <?xml version="1.0" encoding="UTF-8"?> <jaws> <datasource>java:/MSSQLDS</datasource> <type-mapping>MS SQLSERVER</type-mapping> <default-entity> <remove-table>false</remove-table> </default-entity> <type-mappings> <type-mapping> <name>MS SQLSERVER</name>  </type-mapping> </type-mappings> </jaws> 改变%JBOSS_HOME%/conf目录下的standardjaws.xml文件中的缺省设置 要改变缺省的数据源和数据类型映射，请对standardjaws.xml文件作如下修改 <?xml version="1.0" encoding="UTF-8"?> <jaws> <datasource>java:/MSSQLDS</datasource> <type-mapping>MS SQLSERVER</type-mapping> *注: 除了MS SQLSERVER 2000，其它版本都使用MS SQLSERVER。如果你使用的是SQL Server2000, 将 上面的MS SQLSERVER改为MS SQLSERVER2000。 然后需要设置standardjaws.xml 或 jaws.xml文件的<datasource>和<type-mapping>元素： <jaws> <datasource>java:/MSSQLDS</datasource> <type-mapping>MS SQLSERVER</type-mapping> </jaws> 　　同样也需要把standardjbosscmp-jdbc.xml 或 jbosscmp-jdbc.xml文件的<datasource> 和 <datasource-mapping>元素设置为下面这样： <jbosscmp-jdbc> <defaults> <datasource>java:/MSSQLDS</datasource> <datasource-mapping>MS SQLSERVER</datasource-mapping> </defaults> </jbosscmp-jdbc> 　　最后再修改login-config.xml文件来使用MS SQLSERVER： <application-policy name = "MsSqlDbRealm"> <authentication> <login-module code = "org.jboss.resource.security.ConfiguredIdentityLoginModule" flag = "required"> <module-option name ="principal">sa</module-option> <module-option name ="userName">sa</module-option> <module-option name ="password">kjt</module-option> <module-option name ="managedConnectionFactoryName"> jboss.jca:service=LocalTxCM,name=MSSQLDS </module-option> </login-module> </authentication> </application-policy> 　修改了mssql-ds.xml, standardjaws.xml, standardjbosscmp-jdbc.xml,和login-config.xml 文件就可以在Jboss上使用MS SQLSERVER了。 7、下载JBossOpenTool-2.6alpha.zip，用于连接JBOSS和Jbuildrer9.0，下载后，将其解开，将解开后产生的JBossOpenTool.jar文件放入Jbuilder9.0安装目录下的?/span> <div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/buaacaptain/" target="_blank">船长</a> 2006-05-22 18:42 <a href="http://www.blogjava.net/buaacaptain/archive/2006/05/22/47518.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div> </article> <article> <h1>JBOSS4默认端口号修改以及数据源配置</h1> 船长 — Mon, 22 May 2006 06:11:00 GMT 下载后JBOSS4默认的端口号和tomcat一致，均为8080，如果我们要将其修改为8000，可以这样操作： 打开D:\JBOSS\server\default\deploy\jbossweb-tomcat55.sar下的server.xml文件  <Connector port="8000" address="${jboss.bind.address}" maxThreads="250" strategy="ms" maxHttpHeaderSize="8192" emptySessionPath="true" enableLookups="false" redirectPort="8443" acceptCount="100" connectionTimeout="20000" disableUploadTimeout="true"/> 将8080改为8000即可。 有关数据源的配置： Oracle数据库的配置Oracle以它的运行稳定和可靠成为了一个非常受欢迎的企业级数据库。要在Jboss 上配置使用Oracle的话我们要做的第一件事就是把Oracle的JDBC驱动程序复制到ClassPath下。我们把这个JDBC驱动程序复制到server/default/lib目录下。为了使用Oracle的事务处理数据源我们还要把/docs/examples/jca/oracle-xa-ds.xml复制到/server/default/deploy目录下。如果使用的事非事务处理的数据源，就把/docs/examples/jca/oracle-ds.xml文件复制到/server/default/deploy目录下。 下一步，我们需要修改oracle-de.xml配置文件。其中的标签和标签的设置如下： Oracle OCI Type 2 Driver Class: oracle.jdbc.driver.OracleDriver URL: jdbc:oracle:oci8:@<database> Oracle OCI Thin Type 4 Driver Class: oracle.jdbc.driver.OracleDriver URL: jdbc:oracle:thin:@<host>:<port>:<database> Oracle OCI XA Type 2 Driver Class: oracle.jdbc.xa.client.OracleXADataSource URL: jdbc:oracle:thin:@<host>:<port>:<database> Oracle OCI Type 2 Driver Class: oracle.jdbc.driver.OracleDriver URL: jdbc:oracle:oci8:@<database> 在Connection URL中是安装Oracle的计算机主机名，是oracle数据库的端口，是数据库名称。下一步，我们将修改standardjaws.xml 或jaws.xml配置文件，并把和元素这只为下面这样： <jaws> <datasource>java:/OracleDS</datasource> <type-mapping>Oracle8</type-mapping> </jaws> 下一步，再修改standardjbosscmp-jdbc.xml 或 jbosscmp-jdbc.xml配置文件，设置和元素使用Oracle。 <jbosscmp-jdbc> <defaults> <datasource>java:/OracleDS</datasource> <datasource-mapping>Oracle8</datasource-mapping> </defaults> </jbosscmp-jdbc> 最后我们需要修改login-config.xml文件来使用Oracle，下面是login-config.xml文件的元素： <application-policy name = "OracleDbRealm"> <authentication> <login-module code = "org.jboss.resource.security.ConfiguredIdentityLoginModule" flag = "required"> <module-option name = "principal">sa</module-option> <module-option name = "userName">sa</module-option> <module-option name = "password"></module-option> <module-option name ="managedConnectionFactoryName"> jboss.jca:service=LocalTxCM,name=OracleDS </module-option> </login-module> </authentication> </application-policy> 修改了oracle-ds.xml, standardjaws.xml, standardjbosscmp-jdbc.xml,和login-config.xml 文件之后就可以再Jboss4中使用Oracle了。 MS SQL数据库配置 本文提供一个详细而易懂的指导，让你快速掌握使用Microsoft SQL Server关系数据库管理系统(RDBMS)和JBoss J2EE 应用 服务器套件来开发，发布和运行企业Java应用程序的基本知识。　　JBoss是一个业界领先的开放源码的符合标准的J2EE应用服务器套件的名称。该套件包括JBossServer EJB v1.1 Container 和server, JBossMQ JMS 1.0 implemetation, JBossNS JNDI implemetation,JBossCMP advanced O/R mapper和JDBC data object storage implemetation以及JAAS-based JBossSX security frameeork。所有的JBoss应用程序都是100%纯java应用程序。　　Microsoft SQL Server是一个健壮的高性能的和高安全的关系数据库平台。它是一个运行在Windows 95,98,Me,Nt和2000平台上的Windows应用程序。它也有Windows CE平台下的版本，但我想你不会将该版本和JBoss一起使用吧?　　将高性能的开放源码100%Java J2EE应用服务器的JBoss套件和高超新能的Microsoft SQL Server RDBMS组合起来，可以给你提供一个Windows平台下的J2EE开发和发布环境，相比其它Windows平台下的J2EE应用套间和RDBMS方案，该组合性能优异，高回报(ROI),极大减少产品上市时间(RTTM)。　　首先，你需要从JBoss网站获取一份JBoss软件。所有JBoss的产品信息以及如何获取JBoss软件的指导可以在JBoss FAQ或在JBoss 站点找到。本文的余下部分包含下列内容: 1. 安装MS SQL Server的JDBC驱动程序 2. 配置JBoss使用JDBC驱动程序 3. 为CMP指定MS SQL Server数据类型 4. 问题解答 　　需要注意的是JBoss应用服务器套件和MS SQL Server都在蓬勃发展。它们的版本都在发行，修订，增添新的特性。这意味着本文的某些信息对于你的JBoss或MS SQL Server过时了。如果你使用最新的JBoss CVS版本或开发版或MS SQL Server beta版时更容易出现这种情况。安装JDBC驱动程序　　在你能够与JBoss(或所有其它Java应用程序)一起使用Microsoft SQL Server之前，你必须取得并安装JDBC驱动程序。现将一些现有的Microsoft SQL Server JDBC驱动程序列在下面。 --------------------------------------------------------------------------------------------------------------- 驱动程序提供者 JDBC 类型 Availability 版本 --------------------------------------------------------------------------------------------------------------- FreeTDS http://www.freetds.org/ Type 4 免费/开放源码 --------------------------------------------------------------------------------------------------------------- Merant DataDirect http://www.merant.com/ Type 4 商业 Connect JDBC --------------------------------------------------------------------------------------------------------------- i-net Opta JDBC http://www.inetsoftware.de/ Type 4 商业 4.10修订版 --------------------------------------------------------------------------------------------------------------- WebLogic JDriver for Weblogic Type 4 商业 MS SQL Server --------------------------------------------------------------------------------------------------------------- Atinav aveConnect http://www.atinav.com/ Type 4 商业 JDBC --------------------------------------------------------------------------------------------------------------- Sun JDBC- ODBC Bridge http://java.sun.com Type 4 免费 --------------------------------------------------------------------------------------------------------------- 注 * Sun JDBC-ODBC桥驱动程序和FreeTDS JDBC驱动程序(至少目前2001年4月的版本)不推荐使用于正式的J2EE开发和发布 安装Sun JDBC-ODBC桥驱动程序　　Sun JDBC-ODBC桥驱动程序在Java 2 SDK安装过程中自动安装。安装包为sun.jdbc.odbc。对于所有使用JDBC-ODBC桥的应用程序该包都必须在CLASSPATH中。在本教程中假设Sun JDBC-ODBC桥已经正确的安装在你的系统中。为了使用Sun JDBC-ODBC桥你需要创建一个ODBC数据源来引用MS SQL Server数据库。本教程中假设已经创建了名为 jboss_odbc 指向某个MS SQLServer数据库的数据源。安装FreeTDS驱动程序 从http://www.freetds.org下载FreeTDS, 你应该得到了名为freetds_jdbc.snapshot.jar的文件，然后复制到%JBOSS_HOME%/lib/ext 目录下。安装Merant DataDirect Connect JDBC驱动程序 有两种方法，你可以选择下列方法之一： 1. 运行Merant安装程序，然后将base.jar, util.jar和sqlserver.jar文件添加到CLASSPATH中。这些文件位于%MERANT_HOME/lib 目录下。 2. 将base.jar, uitl.jar和sqlserver.jar文件从%MERANT_HOME%/lib目录复制到%JBOSS_HOME%/lib/ext目录，推荐采用这种方法。 安装i-net OPTA 2000JDBCdriver 你可以采用下列方法之一： 1. 运行JBoss时将Opta2000.jar文件加入ClASSPATH。 2. 将文件Opta2000.jar复制到%/JBOSS_HOME%/lib/ext目录。这是推荐的方法。配置JBoss使用JDBC驱动程序 关于配置JBoss使用你的JDBC驱动程序的指导取决于你使用的JBoss版本，请选择适合你的版本的方法。 配置JBoss 2.4遵照配置JBoss2.1和2.2的指导，但是将org.opentools.minerva.jdbc.xa.wrapper.XADataSourceImpl 替换为org.jboss.pool.jdbc.xa.wrapper.XADataSourceImpl。配置JBoss2.1和2.2 告诉JBoss新的JDBC驱动程序 在安装好MS SQL Server JDBC驱动程序后，你需要告诉JBoss你要使用该驱动程序。将该驱动程序添加 到JBoss启动时加载的JDBC清单中。该清单存放在jboss.jcml文件中。该文件可在 %JBOSS_HOME%/conf/<config-name>中找到。对于标准的JBoss发行版本，<config-name>是default而 JBoss-Jetty版本则是jetty。该入口应该是一行用逗号分隔开的JDBC驱动程序名列表。打开文件，找到以下面的mbean标记开始的入口: <mbean code="org.jboss.jdbc.JdbcProvider" name="DefaultDomain:service=JdbcProvider"> 驱动程序列表放在名为Drivers的<attribute>子标记中。按如下所示将你的JDBC驱动程序添加到列表 中。$ 添加Sun JDBC-ODBC桥驱动程序 <mbean code="org.jboss.jdbc.JdbcProvider" name="DefaultDomain:service=JdbcProvider"> <attribute name="Drivers"> org.hsql.jdbcDriver,org.enhydra.instantdb.jdbc.idbDriver,sun.jdbc.odbc.JdbcOdbcDriver </attribute> </mbean> $ 添加FreeTDS驱动程序 <mbean code="org.jboss.jdbc.JdbcProvider" name="DefaultDomain:service=JdbcProvider"> <attribute name="Drivers"> org.hsql.jdbcDriver,org.enhydra.instantdb.jdbc.idbDriver,com.internetcds.jdbc.tds.Driver </attribute> </mbean> $ 添加Merant DataDirect Connect JDBC驱动程序 <mbean code="org.jboss.jdbc.JdbcProvider" name="DefaultDomain:service=JdbcProvider"> <attribute name="Drivers"> org.hsql.jdbcDriver,org.enhydra.instantdb.jdbc.idbDriver,com.merant.datadirect.jdbc.sqlserver.SQLServerDriver </attribute> </mbean> $ 添加i-net OPTA 2000 JDBC驱动程序 <mbean code="org.jboss.jdbc.JdbcProvider" name="DefaultDomain:service=JdbcProvider"> <attribute name="Drivers"> org.hsql.jdbcDriver,org.enhydra.instantdb.jdbc.idbDriver,com.inet.tds.TdsDriver </attribute> </mbean> $ 添加WebLogic jDriver for Microsoft SQL Server <mbean code="org.jboss.jdbc.JdbcProvider" name="DefaultDomain:service=JdbcProvider"> <attribute name="Drivers"> org.hsql.jdbcDriver,org.enhydra.instantdb.jdbc.idbDriver,weblogic.jdbc.mssqlserver4.Driver </attribute> </mbean> 创建DB连接池 到目前为止，你已经告诉JBoss你的驱动程序。现在建立一个你的EJBBean能够连接的连接池。在本教程中，你将创建 一个名为SQLServerPool的连接池。要创建连接池，先在jboss.jcml文件中定位已下列行开始的mbean入口： <mbean code="org.jboss.jdbc.XADataSourceLoader" name="DefaultDomain:service=XADataSource,name=DefaultDS"> 在你刚在定位的mbean项下面加入如下所给的mbean项。注意这些必须加在结束标记</mbean>后面！！！ $ Sun JDBC-ODBC桥驱动程序连接池声明 <mbean code="org.jboss.jdbc.XADataSourceLoader" name="DefaultDomain:service=XADataSource,name=SQLServerPool"> <attribute name="DataSourceClass">org.opentools.minerva.jdbc.xa.wrapper.XADataSourceImpl</attribute> <attribute name="PoolName">SQLServerPool</attribute> <attribute name="URL">jdbc:odbc:jboss_odbc</attribute> <attribute name="JDBCUser">dbusername</attribute> <attribute name="Password">dbpassword</attribute> etc... </mbean> $ Merant DataDirect Connect JDBC驱动程序连接池声明 <mbean code="org.jboss.jdbc.XADataSourceLoader" name="DefaultDomain:service=XADataSource,name=SQLServerPool"> <attribute name="DataSourceClass">org.opentools.minerva.jdbc.xa.wrapper.XADataSourceImpl</attribute> <attribute name="PoolName">SQLServerPool</attribute> <attribute name="URL">jdbc:sqlserver://servername:1433</attribute> <attribute name="Properties">DatabaseName=DatabaseName</attribute> <attribute name="JDBCUser">dbusername</attribute> <attribute name="Password">dbpassword</attribute> etc... </mbean> $ i-net OPTA 2000 JDBC驱动程序连接池声明(采用INET数据源) <mbean code="org.jboss.jdbc.XADataSourceLoader" name="DefaultDomain:service=XADataSource,name=SQLServerPool"> <attribute name="DataSourceClass">com.inet.tds.XDataSource</attribute> <attribute name="PoolName">SQLServerPool</attribute> <attribute name="Properties">host=ServerName; database=DatabaseName</attribute> <attribute name="JDBCUser">dbusername</attribute> <attribute name="Password">dbpassword</attribute> etc... </mbean> $ i-net OPTA 2000 JDBC驱动程序连接池声明(采用JBoss数据源) <mbean code="org.jboss.jdbc.XADataSourceLoader" name="DefaultDomain:service=XADataSource,name=SQLServerPool"> <attribute name="DataSourceClass">org.opentools.minerva.jdbc.xa.wrapper.XADataSourceImpl</attribute> <attribute name="PoolName">SQLServerPool</attribute> <attribute name="URL">jdbc:inetdae7:HostName</attribute> <attribute name="JDBCUser">dbusername</attribute> <attribute name="Password">dbpassword</attribute> etc... </mbean> $ WebLogic jDriver for Microsoft SQL Server连接池声明 <mbean code="org.jboss.jdbc.XADataSourceLoader" name="DefaultDomain:service=XADataSource,name=SQLServerPool"> <attribute name="DataSourceClass">org.opentools.minerva.jdbc.xa.wrapper.XADataSourceImpl</attribute> <attribute name="PoolName">SQLServerPool</attribute> <attribute name="URL">jdbc:weblogic:mssqlserver4:DatabaseName@ServerName:1433</attribute> <attribute name="Properties">user=dbusername; password=dbpassword</attribute> etc... </mbean> 检验DB连接池 启动JBoss确保JDBC驱动程序找到并且创建了连接池，如果成功加载JDBC驱动程序将有如下所示的输出 [Transaction manager] Initializing [Transaction manager] Loaded JDBC-driver:org.hsql.jdbcDriver [Transaction manager] Loaded JDBC-driver:org.enhydra.instantdb.jdbc.idbDriver [Transaction manager] Loaded JDBC-driver:sun.jdbc.odbc.JdbcOdbcDriver [Transaction manager] Loaded JDBC-driver:com.merant.datadirect.jdbc.sqlserver.SQLServerDriver [Transaction manager] Loaded JDBC-driver:com.inet.tds.TdsDriver [Transaction manager] Loaded JDBC-driver:weblogic.jdbc.mssqlserver4.Driver [Transaction manager] Initialized 稍等片刻...连接池的输出 [SQLServerPool] Starting [SQLServerPool] XA Connection pool SQLServerPool bound to java:/SQLServerPool [SQLServerPool] Started 配置CMP数据类型映射 配置JBoss使用MS SQL Server连接池作为缺省的数据源，你可以选择下列方法之一: $ 在你的应用程序的META-INF目录下创建jaws.xml文件重载standardjaws.xml中如下所示的缺省设置 示例 jaws.xml(MS SQL Server CMP数据类型映射) <?xml version="1.0" encoding="UTF-8"?> <jaws> <datasource>java:/SQLServerPool</datasource> <type-mapping>MS SQLSERVER</type-mapping> <default-entity> <remove-table>false</remove-table> </default-entity> <type-mappings> <type-mapping> <name>MS SQLSERVER</name></type-mapping> </type-mappings> </jaws> $ 改变%JBOSS_HOME%/conf目录下的standardjaws.xml文件中的缺省设置 要改变缺省的数据源和数据类型映射，请对standardjaws.xml文件作如下修改 <?xml version="1.0" encoding="UTF-8"?> <jaws> <datasource>java:/SQLServerPool</datasource> <type-mapping>MS SQLSERVER</type-mapping> *注: 除了MS SQLSERVER 2000，其它版本都使用MS SQLSERVER。如果你使用的是SQL Server2000, 将 上面的MS SQLSERVER改为MS SQLSERVER2000。疑难解答 JDBC未装载错误 在启动时显示如下错误: [JDBC] Could not load driver:sun.jdbc.odbc.JdbcOdbcDrivers 这种错误可能在下列情况出现: 1. jboss.jcml配置文件中的JDBC驱动名称拼写错误。在如上的例子中应该是 sun.jdbc.odbc.JdbcOdbcDriver 2. JDBC驱动程序没有正确的安装 - 它的类文件或.jar文件不在CLASSPATH中。 在启动连接池时JBoss悬停 当JBoss启动时，一系列的信息显示在控制台上。关于连接池的最后信息应该如下所示： [Hypersonic] Press [Ctrl]+[C] to abort [InstantDB] Started [DefaultDS] Starting [DefaultDS] XA Connection pool DefaultDS bound to java:/DefaultDS [DefaultDS] Started [SQLServerPool] Starting [SQLServerPool] XA Connection pool SQLServerPool bound to java:/SQLServerPool 　　首先检查JDBC驱动程序是否正确加载。如果没有正确加载请察看前面的"JDBC未装载错误"部分。如果驱动 正确加载，该错误意味着JBoss不能和你的数据库服务器通讯。该错误可能在以下情形出现: 1. 用于连接数据库的参数拼写错误或遗漏。请检查是否正确的指定了该连接池的主机名，数据库，用户 名，用户口令等。 MySQL数据库配置 MySQL是一个开放源代码的数据库，有很多开源项目和小型的社团都在使用它。要在Jboss4中使用MySQL的话首先要把MySQL的JDBC驱动放到CLASSPATH中。同样，把它复制到/server/default/lib目录下，再把/docs/examples/jca/mysql-ds.xml复制到/server/default/deploy目录下。修改mysql-ds.xml文件，设置为 com.mysql.jdbc.Driver再把设置为 jdbc:mysql:///，其中是数据库主机名是数据库名。 然后需要设置standardjaws.xml 或 jaws.xml文件的和元素： <jaws> <datasource>java:/MySqlDS</datasource> <type-mapping>mySql</type-mapping> </jaws> 同样也需要把standardjbosscmp-jdbc.xml 或 jbosscmp-jdbc.xml文件的和元素设置为下面这样： <jbosscmp-jdbc> <defaults> <datasource>java:/MySqlDS</datasource> <datasource-mapping>mySql</datasource-mapping> </defaults> </jbosscmp-jdbc> 最后再修改login-config.xml文件来使用MySQL： <application-policy name = "MySqlDbRealm"> <authentication> <login-module code = "org.jboss.resource.security.ConfiguredIdentityLoginModule" flag = "required"> <module-option name ="principal">sa</module-option> <module-option name ="userName">sa</module-option> <module-option name ="password"></module-option> <module-option name ="managedConnectionFactoryName"> jboss.jca:service=LocalTxCM,name=MySqlDS </module-option> </login-module> </authentication> </application-policy> 修改了mysql-ds.xml, standardjaws.xml, standardjbosscmp-jdbc.xml,和login-config.xml 文件就可以在Jboss上使用MySQL了。 SysBase数据库配置 Sybase Adaptive Server Enterprises(ASE)是Sysbase公司的数据库服务器。ASE可以在Unix和linux平台上使用。同样我们要把它的数据库驱动放到CLASSPATH中，把它复制到/server/default/lib目录下，然后把/docs/examples/jca/sybase-ds.xml 复制到/server/default/deploy目录下。修改sybase-ds.xml文件把设置为 com.sybase.jdbc2.jdbc.SybDriver再把设置为 jdbc:sybase:Tds::/，其中分别为主机名、端口名和数据库名。同样需要修改standardjaws.xml 或 jaws.xml 文件的和元素： <jaws> <datasource>java:/SybaseDS</datasource> <type-mapping>Sybase</type-mapping> </jaws> 再修改standardjbosscmp-jdbc.xml 或 jbosscmp-jdbc.xml 文件的和元素： <jbosscmp-jdbc> <defaults> <datasource>java:/SybaseDS</datasource> <datasource-mapping>Sybase</datasource-mapping> </defaults> </jbosscmp-jdbc> 最后修改login-config.xml 文件来使用Sysbase数据库.设置元素： <application-policy name = "SybaseDbRealm"> <authentication> <login-module code = "org.jboss.resource.security.ConfiguredIdentityLoginModule" flag = "required"> <module-option name ="principal">sa</module-option> <module-option name = "userName">sa</module-option> <module-option name = "password"></module-option> <module-option name = "managedConnectionFactoryName"> jboss.jca:service=LocalTxCM,name=SybaseDS </module-option> </login-module> </authentication> </application-policy> 修改了sybase-ds.xml, standardjaws.xml, standardjbosscmp-jdbc.xml, 和login-config.xml文件后就可以在JBOSS中使用Sysbase了。 DB2数据库配置IBM的DB2是一个完善、使用方便的数据库服务器，它可以在Linux，UNIX和Windows平台上使用。在JBOSS4上使用DB2只要把db2java.zip复制到/server/default/lib目录下。然后复制/docs/examples/jca/db2-ds.xml到/server/default/deploy目录下，然后修改元素位 COM.ibm.db2.jdbc.app.DB2Driver ，元素为 jdbc:db2:其中的元素代表数据库服务名。 <jaws> <datasource>java:/DB2DS</datasource> <type-mapping>DB2</type-mapping> </jaws> 下面是相应的 standardjbosscmp-jdbc.xml (或 jbosscmp-jdbc.xml)文件: <jbosscmp-jdbc> <defaults> <datasource>java:/DB2DS</datasource> <datasource-mapping>DB2</datasource-mapping> </defaults> </jbosscmp-jdbc> 最后在login-config.xml文件中加上下面的内容： <application-policy name = "DB2DbRealm"> <authentication> <login-module code = "org.jboss.resource.security.ConfiguredIdentityLoginModule" flag = "required"> <module-option name = "principal">sa</module-option> <module-option name = "userName">sa</module-option> <module-option name = "password"></module-option> <module-option name ="managedConnectionFactoryName"> jboss.jca:service=LocalTxCM,name=DB2DS </module-option> </login-module> </authentication> </application-policy> 完成上面的配置就可以在Jboss上使用DB2了 Informix 数据库配置IBM的Infoxmix数据库服务器用于作为数据仓库、分析和报告。在Jboss4上使用Informix数据库，首先要把它相应的数据库JDBC驱动复制到/server/default/lib目录下，然后，把/docs/examples/jca/informix-ds.xml 复制到 /server/default/deploy目录下，如果你使用的是事务的(XA)JDBC就复制那个/docs/examples/jca/informix-xa-ds.xml文件。 下一步要作的就是修改这个informix-ds.xml文件，把元素设置为：com.informix.jdbc.IfxDriver把元素设置为 jdbc:informix-sqli://::informixserver=， 其中，,,分别代表数据库主机名、数据库端口和数据库服务名。然后修改standardjaws.xml 或 jaws.xml文件的和元素： <post> <jaws> <datasource>java:/InformixDS</datasource> <type-mapping>InformixDB</type-mapping> </jaws> 把standardjbosscmp-jdbc.xml 或 jbosscmp-jdbc.xml文件中的和元素设置为下面这样： <jbosscmp-jdbc> <defaults> <datasource>java:/InformixDS</datasource> <datasource-mapping>InformixDB</datasource-mapping> </defaults> </jbosscmp-jdbc> 最后在login-config.xml文件中加入元素： <application-policy name = "InformixDbRealm"> <authentication> <login-module code = "org.jboss.resource.security.ConfiguredIdentityLoginModule" flag = "required"> <module-option name = "principal">sa</module-option> <module-option name = "userName">sa</module-option> <module-option name = "password"></module-option> <module-option name ="managedConnectionFactoryName"> jboss.jca:service=LocalTxCM,name=InformixDS </module-option> </login-module> </authentication> </application-policy> 这样，你就可以在Jboss4中使用Informix数据库了。 结论Jboss4默认情况下使用的是Hypersonic数据库，但如你所见我们只要简单的修改几个配置文件就可以使用市面上流行的其他数据库了。 <div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/buaacaptain/" target="_blank">船长</a> 2006-05-22 14:11 <a href="http://www.blogjava.net/buaacaptain/archive/2006/05/22/47454.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div> </article> </main></body></html>