IDE: Eclipse PDT all in one.

http://www.yesky.com/418/1743418_5.shtml

http://java.chinaitlab.com/line/10270.html

http://fanqiang.chinaunix.net/program/java/2005-07-04/3363.shtml

http://www.21tx.com/dev/2002/02/22/10107.html

http://www.ddvip.com/program/java/index2/79.htm

http://www.ddvip.com/program/java/index2/78.htm

http://www.21tx.com/dev/2005/04/07/14818.html

http://www.jspcn.net/htmlnews/11049310422031206.html

http://www.matrix.org.cn/resource/article/0/132.html

Java 语言本身提供了执行外部程序的机制，那就是java.lang.Runtime。改类自Java诞生就已经从在，这个可以从见JDK帮助文档的Since得到。随着Java的发展，该类也多次修订。http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Runtime.html

改类提供了6个重载的方法（截至目前1.5版本），我们把它拷过来，用作参考：

Process exec(String command)
Executes the specified string command in a separate process.

Process exec(String[] cmdarray)
Executes the specified command and arguments in a separate process.

Process exec(String[] cmdarray, String[] envp)
Executes the specified command and arguments in a separate process with the specified environment.

Process exec(String[] cmdarray, String[] envp, File dir)
Executes the specified command and arguments in a separate process with the specified environment and working directory.

Process exec(String command, String[] envp)
Executes the specified string command in a separate process with the specified environment.

Process exec(String command, String[] envp, File dir)
Executes the specified string command in a separate process with the specified environment and working directory

按照文档上说，这行exec，就会产生一个与操作系统相关的process，Java用Process与之相联系，就是在Process里面有个这个实际的Process的引用。类Process的说明如下：

The ProcessBuilder.start() and Runtime.exec methods create a native process and return an instance of a subclass of Process that can be used to control the process and obtain information about it.

就是说执行了exec，剩下的(输入，输出，等待结束，结束返回值等等）就交给Process具体的实现类来处理：

The class Process provides methods for performing input from the process, performing output to the process, waiting for the process to complete, checking the exit status of the process, and destroying (killing) the process.

网络上有很多介绍的文章，但是如果你看了还是不是很明白的话，其实最重要的还是回到JDK的帮助文档里来，在类Process的文档剩下的部分写的很明白：

The methods that create processes may not work well for special processes on certain native platforms, such as native windowing processes, daemon processes, Win16/DOS processes on Microsoft Windows, or shell scripts. The created subprocess does not have its own terminal or console. All its standard io (i.e. stdin, stdout, stderr) operations will be redirected to the parent process through three streams (getOutputStream(), getInputStream(), getErrorStream()). The parent process uses these streams to feed input to and get output from the subprocess. Because some native platforms only provide limited buffer size for standard input and output streams, failure to promptly write the input stream or read the output stream of the subprocess may cause the subprocess to block, and even deadlock.

The subprocess is not killed when there are no more references to the Process object, but rather the subprocess continues executing asynchronously.

There is no requirement that a process represented by a Process object execute asynchronously or concurrently with respect to the Java process that owns the Process object.

简单的说，所有的标准IO操作都会转给父进程，父进程需要用那三种流给子进程。更糟的是标准输入输出流的缓冲啊，就是buffer，有些操作系统给的是有限的（废话），那么不能及时写输入和读输出给子进程就或许导致子进程被block或者甚至死锁！

明白了上边的几点，我们来看一段例程，就比较清楚了：

直接使用参考文献1中的例程：

public class BadExecJavac
{
public static void main(String args[])
{
try
{
Runtime rt = Runtime.getRuntime();
Process proc = rt.exec(”javac”);
int exitVal = proc.exitValue();
System.out.println(”Process exitValue: ” + exitVal);
}
catch (Throwable t)
{
t.printStackTrace();
}
}
}

执行结果如下：

java.lang.IllegalThreadStateException: process has not exited
at java.lang.ProcessImpl.exitValue(Native Method)
at com.test.tools.test.book.Test.main(Test.java:17)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:585)
at com.intellij.rt.execution.application.AppMain.main(AppMain.java:90)

什么原因呢？ 查查文档，原来是说子进程还未结束，如果call exitValue（）的话，就会报错。

老方法，查查文档，Process有个waitFor() 方法：

waitFor

public abstract int waitFor()
                     throws InterruptedException

causes the current thread to wait, if necessary, until the process represented by this Process object has terminated. This method returns immediately if the subprocess has already terminated. If the subprocess has not yet terminated, the calling thread will be blocked until the subprocess exits.

Returns:

the exit value of the process. By convention, 0 indicates normal termination.

Throws:

InterruptedException - if the current thread is interrupted by another thread while it is waiting, then the wait is ended and an InterruptedException is thrown.

好，我们立即改进我们的程序，使用waitFor():

public class Test

{

public static void main(String args[])

{

try

{

Runtime rt = Runtime.getRuntime();

Process proc = rt.exec(”javac”);

int exitVal = proc.waitFor();

System.out.println(”Process exitValue: ” + exitVal);

}

catch (Throwable t)

{

t.printStackTrace();

}

}

}

编译，运行。。。结果。。。结果。。。好像死在那里了#￥@%@@

好惨。。。立刻反省一下哪里错了？原来前文有提：我们没有处理输入，输出流×可能会×导致死锁！ Javac执行如上的话，会把结果输入到stderr流中去的，结果父进程没有处理(所有的外部流都导给父进程，见文档），子进程等父进程处理，父进程等子进程结束（waitFor())，典型的死锁情节。下面，我们的程序需要加上流的处理的部分！

import java.io.BufferedReader;

import java.io.InputStream;

import java.io.InputStreamReader;

public class Test

{

public static void main(String args[])

{

try

{

Runtime rt = Runtime.getRuntime();

Process proc = rt.exec(”javac”);
//prepare to receive input err stream directed to This Process to drain.

InputStream stderr = proc.getErrorStream(); 得到错误流

InputStreamReader isr = new InputStreamReader(stderr);

BufferedReader br = new BufferedReader(isr);

String line = null;

System.out.println(”<ERROR>”);

while ((line = br.readLine()) != null)

{

System.out.println(line);

}

System.out.println(”</ERROR>”);

int exitVal = proc.waitFor();

System.out.println(”Process exitValue: ” + exitVal);

}

catch (Throwable t)

{

t.printStackTrace();

}

}

}

运行结果如下：

<ERROR>

用法：javac <选项> <源文件>

其中，可能的选项包括：

-g                         生成所有调试信息

-g:none                    不生成任何调试信息

-g:{lines,vars,source}     只生成某些调试信息

-nowarn                    不生成任何警告

-verbose                   输出有关编译器正在执行的操作的消息

-deprecation               输出使用已过时的 API 的源位置

-classpath <路径>            指定查找用户类文件的位置

-cp <路径>                   指定查找用户类文件的位置

-sourcepath <路径>           指定查找输入源文件的位置

-bootclasspath <路径>        覆盖引导类文件的位置

-extdirs <目录>              覆盖安装的扩展目录的位置

-endorseddirs <目录>         覆盖签名的标准路径的位置

-d <目录>                    指定存放生成的类文件的位置

-encoding <编码>             指定源文件使用的字符编码

-source <版本>               提供与指定版本的源兼容性

-target <版本>               生成特定 VM 版本的类文件

-version                   版本信息

-help                      输出标准选项的提要

-X                         输出非标准选项的提要

-J<标志>                     直接将 <标志> 传递给运行时系统

</ERROR>

Process exitValue: 2

Process finished with exit code 0

因为我在IDE里运行的，所以你会看到退出码是0，就是这个java类运行是正常。但是对于javac在例程中运行code是2.不同系统不同意义，这里代表文件没有找到。一般来说，0代表正常，非0都代表错误。

这段程序对这个例子来说足够了，但是缺乏灵活和完美！最要命的是这个程序还没有处理标准输入和输出流。

在开始完美化之前，先说说一个常见的错误。或许你已经迫不及待的编写和运行如下程序，结果发现是有问题的：

public class Test

{

public static void main(String args[])

{

try

{

Runtime rt = Runtime.getRuntime();

     Process proc = rt.exec(”dir”);

InputStream stdin = proc.getInputStream();

InputStreamReader isr = new InputStreamReader(stdin);

BufferedReader br = new BufferedReader(isr);

String line = null;

System.out.println(”<OUTPUT>”);

while ((line = br.readLine()) != null)

{

System.out.println(line);

}

System.out.println(”</OUTPUT>”);

int exitVal = proc.waitFor();

System.out.println(”Process exitValue: ” + exitVal);

}

catch (Throwable t)

{

t.printStackTrace();

}

}

}

为什么不行呢？这是因为dir这个命令需要windows 命令解释器，而不是一个单独存在的命令！也就是说该程序无法找到dir.

现在就让我们开始振奋人心的编程吧！采用一个专门的类处理外部程序需要输出的流，对于我们来说就是输入流。采用线程执行，所以可以异步的处理多个流。

/**

*  gobbler

1. 雄火鸡

2. 狼吞虎咽的人

*/

class StreamGobbler extends Thread

{

InputStream is;

String type;

StreamGobbler(InputStream is, String type)

{

this.is = is;

this.type = type;

}

public void run()

{

try

{

InputStreamReader isr = new InputStreamReader(is);

BufferedReader br = new BufferedReader(isr);

String line = null;

while ((line = br.readLine()) != null)

{

System.out.println(type + “>” + line);

}

}

catch (IOException ioe)

{

ioe.printStackTrace();

}

}

}

class GoodWindowsExec

{

public static void main(String args[])

{

if (args.length < 1)

{

System.out.println(”USAGE: java GoodWindowsExec <cmd>”);

System.exit(1);

}

try

{

String osName = System.getProperty(”os.name”);

String[] cmd = new String[3];

if (osName.equals(”Windows NT”))

{

cmd[0] = “cmd.exe”;

cmd[1] = “/C”;

cmd[2] = args[0];

}

else if (osName.equals(”Windows 95″))

{

cmd[0] = “command.com”;

cmd[1] = “/C”;

cmd[2] = args[0];

}

Runtime rt = Runtime.getRuntime();

System.out.println(”Execing ” + cmd[0] + ” ” + cmd[1]

+ ” ” + cmd[2]);

Process proc = rt.exec(cmd);

// any error message?

StreamGobbler errorGobbler = new

                    StreamGobbler(proc.getErrorStream(), “ERROR”);

            // any output?

StreamGobbler outputGobbler = new

                    StreamGobbler(proc.getInputStream(), “OUTPUT”);

            // kick them off

errorGobbler.start();

            outputGobbler.start();

// 还是惹不起那些进程，我等。

int exitVal = proc.waitFor();

System.out.println(”ExitValue: ” + exitVal);

}

catch (Throwable t)

{

t.printStackTrace();

}

}

}

用这个方式执行：

列目录，java GoodWindowsExec “dir *.java” 。

打开word文档，java GoodWindowsExec “yourdoc.doc”。其他就不赘述了。

另外，要记住，exec不是个命令解释器，它的作用只是运行命令。千万不要认为exec() method 好像一个shell interpreter。如果你那么认为，就会犯下面的错误：

class BadWinRedirect

{

public static void main(String args[])

{

try

{

Runtime rt = Runtime.getRuntime();

Process proc = rt.exec(”java jecho ‘Hello World’ > test.txt”);

// any error message?

StreamGobbler errorGobbler = new

StreamGobbler(proc.getErrorStream(), “ERROR”);

// any output?

StreamGobbler outputGobbler = new

StreamGobbler(proc.getInputStream(), “OUTPUT”);

// kick them off

errorGobbler.start();

outputGobbler.start();

// any error???

int exitVal = proc.waitFor();

System.out.println(”ExitValue: ” + exitVal);

}

catch (Throwable t)

{

t.printStackTrace();

}

}

}

该程序本意是想执行jecho ‘Hello World‘,然后把执行结果存入test.txt。Sorry，错了。你必须用编程的方法来实现。还记得我们前面说过子进程的输出流么，把子进程的输出流===》得到，然后存入test.txt就可以实现了。

有点晕？呵呵。我们里一下思路。该例程运行程序（java jecho ‘Hello World’）,产生个子进程，子进程产生输出流。子进程如前所述没有地方释放，需要父进程排泄。所以，对父进程来说，就是得到proc.getInputStream(), 就是把子进程要输出的东西得到。

这样还需要改进一下我们（吃流者）这个类。SteamBobbler.:) 如下：

import java.io.BufferedReader;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.PrintWriter;

class StreamGobbler extends Thread

{

InputStream is;

String type;

OutputStream os;

StreamGobbler(InputStream is, String type)

{

this(is, type, null);

}

StreamGobbler(InputStream is, String type, OutputStream redirect)

{

this.is = is;

this.type = type;

this.os = redirect;

}

public void run()

{

try

{

       PrintWriter pw = null;

if (os != null)

            {

                pw = new PrintWriter(os);

            }

InputStreamReader isr = new InputStreamReader(is);

BufferedReader br = new BufferedReader(isr);

String line = null;

while ((line = br.readLine()) != null)

{

if (pw != null)

{

          pw.println(line);

}

System.out.println(type + “>” + line);

}

if (pw != null)

{

              pw.flush();

}

}

catch (IOException ioe)

{

ioe.printStackTrace();

}

}

}

class GoodWinRedirect

{

public static void main(String args[])

{

if (args.length < 1)

{

System.out.println(”USAGE java GoodWinRedirect <outputfile>”);

System.exit(1);

}

try

{

FileOutputStream fos = new FileOutputStream(args[0]);

Runtime rt = Runtime.getRuntime();

Process proc = rt.exec(”java jecho ‘Hello World’”);
// any error message?

StreamGobbler errorGobbler = new

StreamGobbler(proc.getErrorStream(), “ERROR”);

// any output?

StreamGobbler outputGobbler = new

StreamGobbler(proc.getInputStream(), “OUTPUT”, fos);

// kick them off

errorGobbler.start();

outputGobbler.start();

// any error???

int exitVal = proc.waitFor();

System.out.println(”ExitValue: ” + exitVal);

fos.flush();

fos.close();

}

catch (Throwable t)

{

t.printStackTrace();

}

}

}

OK，大功告成，基本上成功。

小结如下：

1. You cannot obtain an exit status from an external process until it has exited
2. You must immediately handle the input, output, and error streams from your spawned external process
3. You must use Runtime.exec() to execute programs
4. You cannot use Runtime.exec() like a command line

本文完。下期谈谈如何使用目录，环境变量等高级话题。

参考文档：

1. http://www.javaworld.com/javaworld/jw-12-2000/jw-1229-traps.html

1. good working attitude
2. willing do stuff even feel tired
3. have good sense of taking pressure
4. refractor ability that we strongly need

1. Demonstrate that you ARE ABLE TO work well with your peer managers.
2. When questions comes, try to get them solved with a reasonable way.
3. Don’t quarrel which doesn’t solve any problems and will lead you to a worse situation.
4. Being a manager, you have the right to decide the next step as you are the one who take responsibility.
5. Listening to others’ advice doesn’t mean you have to take’ em. Take only if they are right.

Team Management:

1. Think as a Team.Then make decision on key stuff. Leave things to others to decide.

Trust Relationship Build Up

1. Know what the most important stuff to the individual
2. Over sharing sometimes

Manage Up!

1. Know what the are good at and leverage it.
2. push to meet with you even they don’t want to. ‘cos they are nice so they don’t want to feel bad if they don’t meet with you.

This post is password protected. To view it please enter your password below:

Password:

bsuite是一款wordpress统计插件，它的前身是bstat，简单好用的来访者统计插件。
它的功能如下：

1. 跟踪网页点击次数。
2. 跟踪搜索引挚关键字。
3. 输出点击率最高的文章。
4. 输出最近的评论。
5. 输出最多的搜索关键字。
6. 输出整个网站或单篇文章的访问量脉冲图
7. 高亮搜索单词。
8. 在文章底部列出有联系的相关文章。
9. 与bsuite_speedcache结合一体。
10. 列出文章tag。

请到这儿点击下载，这儿是安装方法。

题目大致是这样的：

   第一部分选择题：有几道网络相关的题目，巨简单，比如第一题是TCP、RIP、IP、FTP中哪个协议是传输层的……。有一道linux的chown使用题目。其他的全是数据结构的题目！什么链，表，码的，不知所云~~~唉，我可以没有学过数据结构的人呐！真残忍！这一部分迅速猜完！

    第二部分简答题：

    1、在linux中如何编译C程序，使之成为可执行文件？如何调试？

答案：1)检查程序中.h文件所在的目录，将其加入系统PATH中；

         2)执行C编译：#gcc [源文件名] -o [目标文件名]

            执行C++编译：#g++ [源文件名] -o [目标文件名]

         3)改变目标文件为可执行文件：#chmod +x [目标文件名]

         4)如需将多个可执行文件连续执行，可生成批处理文件：

             #vi [批处理文件名]

             可执行文件1

             可执行文件2

             ………

             最后将该批处理文件属性该位可执行。

    调试：在编译时使用-g参数，就可以使用gdb进行调试。

    2、写出内存分配和释放的函数，并指出区别。

答案：

      C语言的标准内存分配函数：malloc，calloc，realloc，free等。
      malloc与calloc的区别为1块与n块的区别：
        malloc调用形式为(类型*)malloc(size)：在内存的动态存储区中分配一块长度为“size”字节的连续区域，返回该区域的首地址。
       calloc调用形式为(类型*)calloc(n，size)：在内存的动态存储区中分配n块长度为“size”字节的连续区域，返回首地址。
       realloc调用形式为(类型*)realloc(*ptr，size)：将ptr内存大小增大到size。
       free的调用形式为free(void*ptr)：释放ptr所指向的一块内存空间。
    C++中为new/delete函数。

    3、写出socket函数，并指出其功能。

       socket():建立socket通信描述符；
       bind()：将套接字和机器上的一定的端口关联；
      connect()：连接到远程主机；
      listen()：使套接字做好连接的准备，规定等待服务请求队列的长度；
      accept()：接受连接，一旦有客户端发出连接，accept返回客户地址信息和一个新的sock；
   有了这个新的sock，双方就可以开始收发数据：
      send()和recv()：用于流式套接字或者数据套接字的通讯；
      sendto()和recvfrom()：用于无连接的数据报套接字；
      close()：关闭套接字；
      shutdown()：选择性的关闭套接字，可以只允许某一方向的通讯关闭；
      getpeername()：返回流式套接字时对端peer信息；
      gethostname()：返回程序所运行的机器的主机名字；
      gethostbyname()：返回本机IP；

   第三部分编程题：

    1、从文件中读取字符串数据，反序显示并大小写转换。

    2、给定26字母表以及对应的密码表，编程实现加密及解密功能。

  第四部分思考题(正是传说中的字典纠错题)：

     用户在输入英文单词时经常出错，现对其进行就错。给定一个正确的英文词典，考虑纠错实现。1)指出思路。2)流程、算法难易程度及可能的改进策略。

一道算法题目答案

int Replace(Stringtype &S,Stringtype T,Stringtype V);//将串S中所有子串T替换为V,并返回置换次数
{
for(n=0,i=1;i〈=Strlen(S)-Strlen(T)+1;i++) //注意i的取值范围
if(!StrCompare(SubString(S,i,Strlen(T)),T)) //找到了与T匹配的子串
{ //分别把T的前面和后面部分保存为head和tail
StrAssign(head,SubString(S,1,i-1));
StrAssign(tail,SubString(S,i+Strlen(T),Strlen(S)-i-Strlen(T)+1));
StrAssign(S,Concat(head,V));
StrAssign(S,Concat(S,tail)); //把head,V,tail连接为新串
i+=Strlen(V); //当前指针跳到插入串以后
n++;
}//if
return n;
}//Replace
分析:i+=Strlen(V);这一句是必需的,也是容易忽略的.如省掉这一句,则在某些情况下,会引起不希望的后果,虽然在大多数情况下没有影响.请思考:设S=’place’, T=’ace’, V=’face’,则省掉i+=Strlen(V);运行时会出现什么结果? （无限递归face）

百度2005年的笔试题

1.实现 void delete_char(char * str, char ch);

  把str中所有的ch删掉

2.把字符串S中所有A子串换成B,这个没给函数原型

3.搜索引擎的日志要记录所有查询串,有一千万条查询,不重复的不超过三百万

  要统计最热门的10条查询串. 内存<1G. 字符串长 0-255

  (1) 主要解决思路 //具体用词和原题不大一样

  (2) 算法及其复杂度分析

4.有字典,设计一个英文拼写纠正算法 (1) 思想 (2) 算法及复杂度 (3) 改进

5. { aaa, bb, ccc, dd }, { bbb, ff }, { gg } 等一些字符串的集合

  要求把交集不为空的集合并起来,如上例会得到 { aaa, bb, ccc, dd, ff }, {gg}

  (1) 思想 (2) 算法及复杂度 (3) 改进

All modern search engines attempt to detect and correct spelling errors in users’ search queries. Google, for example, was one of the first to offer such a facility, and today we barely notice when we are asked “Did you mean x?” after a slip on the keyboard. This article shows you one way of adding a “did you mean” suggestion facility to your own search applications using the Lucene Spell Checker, an extension written by Nicolas Maisonneuve and David Spencer.

Techniques of Spell Checking

Automatic spell checking has a long history. One important early paper was F. Damerau’s A Technique for Computer Detection and Correction of Spelling Errors, published in 1964, which introduced the idea of minimum edit distance. Briefly, the concept of edit distance quantifies the idea of one string being “close” to another, by counting the number of character edit operations (such as insertions, deletions and substitutions) that are needed to transform one string into the other. Using this metric, the best suggestions for a misspelling are those with the minimum edit distance.

Another approach is the similarity key technique, in which words are transformed into some sort of key so that similarly spelled and, hopefully, misspelled words have the same key. To correct a misspelling simply involves creating the key for the misspelling and looking up dictionary words with the same key for a list of suggestions. Soundex is the best-known similarity key, and is often used for phonetic applications.

A combination of minimum edit distance and similarity keys (metaphone) is at the heart of the successful strategy used by Aspell, the leading open source spell checker. However, it is a third approach that underlies the implementation of the “did you mean” technique described in this article: letter n-grams.

A letter n-gram is a sequence of n letters of a word. For instance, the word “lucene” can be divided into four 3-grams, also known as trigrams: “luc”, “uce”, “cen”, and “ene.”. Why is it useful to break words up like this? The intuition is that misspellings typically only affect a few of the constituent n-grams, so we can recognize the intended word just by looking through correctly spelled words for those that share a high proportion of n-grams with the misspelled word. There are various ways of computing this similarity measure, but one powerful way is to treat it as a classic search engine problem with an inverted index of n-grams into words. This is precisely the approach taken by Lucene Spell Checker. Let’s see how to use it.

A Simple Search Application

We’ll first build a very simple search interface that does not include the “did you mean” facility. It defines a single method that takes a search query string and returns a search result.

package org.tiling.didyoumean;

import java.io.IOException;

import org.apache.lucene.queryParser.ParseException;

public interface SearchEngine {
    public SearchResult search(String queryString) throws IOException, ParseException;
}
  

The search result is a SearchResult object, which is a JavaBean that exposes a list of hits (actually just the top hits, for simplicity) and a few other properties. I have omitted the constructor and getters in the listing here as they are boilerplate code. (The full source code is available in the accompanying download–see the “References” section at the end of the article.)

package org.tiling.didyoumean;

import java.util.List;

public class SearchResult {

    private List topHits;
    private int totalHitCount;
    private long searchDuration;
    private String originalQuery;
    private String suggestedQuery;

}
  

Here’s a very simple implementation of SearchEngine built with Lucene. It uses Lucene’s QueryParser to parse the search query string into a Query that is then used to perform the search. The Lucene Hits object is then mapped to an instance of our SearchResult class.

package org.tiling.didyoumean;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.queryParser.ParseException;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.store.Directory;

public class SimpleSearchEngine implements SearchEngine {

    private String defaultField;
    private String nameField;
    private Directory originalIndexDirectory;
    private int maxHits;

    public SimpleSearchEngine(String defaultField, String nameField,
            Directory originalIndexDirectory, int maxHits) {
        this.defaultField = defaultField;
        this.nameField = nameField;
        this.originalIndexDirectory = originalIndexDirectory;
        this.maxHits = maxHits;
    }

    public SearchResult search(String queryString) throws IOException, ParseException {
        long startTime = System.currentTimeMillis();
        IndexSearcher is = null;
        try {
            is = new IndexSearcher(originalIndexDirectory);
            QueryParser queryParser = new QueryParser(defaultField, new StandardAnalyzer());
            queryParser.setOperator(QueryParser.DEFAULT_OPERATOR_AND);
            Query query = queryParser.parse(queryString);
            Hits hits = is.search(query);
            long endTime = System.currentTimeMillis();
            return new SearchResult(extractHits(hits), hits.length(), endTime - startTime, queryString);
        } finally {
            if (is != null) {
                is.close();
            }
        }
    }

    private List extractHits(Hits hits) throws IOException {
        List hitList = new ArrayList();
        for (int i = 0, count = 0; i < hits.length() && count++ < maxHits; i++) {
            hitList.add(hits.doc(i).getField(nameField).stringValue());
        }
        return hitList;
    }
}
  

Note that an IOException may be thrown by Lucene if there is a problem reading the index (typically from disk). The finally clause closes the IndexSearcher, but propagates the exception to indicate the problem to the client, which is the MVC layer, in this case.

With these ingredients it is straightforward to write a user interface that accepts user queries and presents the search results back to the user. I chose Spring’s MVC framework for this. Since this is an article about search and not about Spring, I won’t present any of the code for the user interface here–instead, please refer to the accompanying download.

Figure 1 is a screenshot of the search interface, running against an index of texts by Beatrix Potter from Project Gutenberg.

Figure 1. A simple search application

Adding “Did You Mean” to the Simple Search

Next we’ll extend the search to prompt with “did you mean” suggestions for misspelled search terms in the query. Let’s go through this step by step in the following subsections.

Generating a Spell Index

The first step is to generate an index from the original index that includes the letter n-grams for each word in the original index. I shall refer to this index as the spell index. With the help of the Lucene Spell Checker, this is very easy:

package org.tiling.didyoumean;

import java.io.IOException;

import org.apache.lucene.index.IndexReader;
import org.apache.lucene.search.spell.Dictionary;
import org.apache.lucene.search.spell.LuceneDictionary;
import org.apache.lucene.search.spell.SpellChecker;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;

public class DidYouMeanIndexer {
    private static final String DEFAULT_FIELD = "contents";

    private static final String FIELD_OPTION = "f";
    private static final String ORIGINAL_INDEX_OPTION = "i";
    private static final String SPELL_INDEX_OPTION = "o";

    public void createSpellIndex(String field,
            Directory originalIndexDirectory,
            Directory spellIndexDirectory) throws IOException {

        IndexReader indexReader = null;
        try {
            indexReader = IndexReader.open(originalIndexDirectory);
            Dictionary dictionary = new LuceneDictionary(indexReader, field);
            SpellChecker spellChecker = new SpellChecker(spellIndexDirectory);
            spellChecker.indexDictionnary(dictionary);
        } finally {
            if (indexReader != null) {
                indexReader.close();
            }
        }
    }

}

  

The Dictionary interface specifies a single method:

public Iterator getWordsIterator();

that returns an iterator over the words in the dictionary. Here we use a LuceneDictionary object to read each word in the given field from the original index. We then create a SpellChecker, giving it a new index location to which to write the n-grams as it indexes the dictionary.

To create the spell index, you can instantiate a new DidYouMeanIndexer and invoke the createSpellIndex() method from your code. Alternatively, you can run DidYouMeanIndexer from the command line (the main() method is not shown in the above listing).

The “Did You Mean” Search Engine

Next, let’s turn back to our SearchEngine interface and look at the implementation of DidYouMeanSearchEngine. This implementation looks for query suggestions when the search results have low relevance.

package org.tiling.didyoumean;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.apache.lucene.queryParser.ParseException;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.store.Directory;

public class DidYouMeanSearchEngine implements SearchEngine {

    private String defaultField;
    private String nameField;
    private Directory originalIndexDirectory;
    private int maxHits;
    private int minimumHits;
    private float minimumScore;
    private DidYouMeanParser didYouMeanParser;

    public DidYouMeanSearchEngine(String defaultField, String nameField,
            Directory originalIndexDirectory,
            int maxHits, int minimumHits, float minimumScore,
            DidYouMeanParser didYouMeanParser) {

        this.defaultField = defaultField;
        this.nameField = nameField;
        this.originalIndexDirectory = originalIndexDirectory;
        this.maxHits = maxHits;
        this.minimumHits = minimumHits;
        this.minimumScore = minimumScore;
        this.didYouMeanParser = didYouMeanParser;
    }

    public SearchResult search(String queryString) throws IOException, ParseException {
        long startTime = System.currentTimeMillis();
        IndexSearcher is = null;
        try {
            is = new IndexSearcher(originalIndexDirectory);
            Query query = didYouMeanParser.parse(queryString);
            Hits hits = is.search(query);

            String suggestedQueryString = null;
            if (hits.length() < minimumHits || hits.score(0) < minimumScore) {
                Query didYouMean = didYouMeanParser.suggest(queryString);
                if (didYouMean != null) {
                    suggestedQueryString = didYouMean.toString(defaultField);
                }
            }

            long endTime = System.currentTimeMillis();
            return new SearchResult(extractHits(hits), hits.length(),
                    endTime - startTime, queryString, suggestedQueryString);
        } finally {
            if (is != null) {
                is.close();
            }
        }
    }

    private List extractHits(Hits hits) throws IOException {
        List hitList = new ArrayList();
        for (int i = 0, count = 0; i < hits.length() && count++ < maxHits; i++) {
            hitList.add(hits.doc(i).getField(nameField).stringValue());
        }
        return hitList;
    }

}

  

The “Did You Mean” Parser

The key difference between the DidYouMeanSearchEngine class and the SimpleSearchEngine class is the introduction of the DidYouMeanParser interface. The DidYouMeanParser interface encapsulates a strategy both for parsing query strings and for suggesting spelling corrections for query strings:

package org.tiling.didyoumean;

import org.apache.lucene.queryParser.ParseException;
import org.apache.lucene.search.Query;

public interface DidYouMeanParser {
    public Query parse(String queryString) throws ParseException;
    public Query suggest(String queryString) throws ParseException;
}

  

The DidYouMeanSearchEngine only asks the DidYouMeanParser for a suggested query if the number of hits returned falls below a minimum threshold (the minimumHits property), or if the relevance of the top hit falls below a minimum threshold (the minimumScore property). Of course, you may choose to implement your own criteria for when to make a “did you mean” suggestion, but this rule is simple and effective.

The first implementation of DidYouMeanParser is straightforward:

package org.tiling.didyoumean;

import java.io.IOException;

import org.apache.lucene.index.Term;
import org.apache.lucene.queryParser.ParseException;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.spell.SpellChecker;
import org.apache.lucene.store.Directory;

public class SimpleDidYouMeanParser implements DidYouMeanParser {

    private String defaultField;
    private Directory spellIndexDirectory;

    public SimpleDidYouMeanParser(String defaultField, Directory spellIndexDirectory) {
        this.defaultField = defaultField;
        this.spellIndexDirectory = spellIndexDirectory;
    }

    public Query parse(String queryString) {
        return new TermQuery(new Term(defaultField, queryString));
    }

    public Query suggest(String queryString) throws ParseException {
        try {
            SpellChecker spellChecker = new SpellChecker(spellIndexDirectory);
            if (spellChecker.exist(queryString)) {
                return null;
            }
            String[] similarWords = spellChecker.suggestSimilar(queryString, 1);
            if (similarWords.length == 0) {
                return null;
            }
            return new TermQuery(new Term(defaultField, similarWords[0]));
        } catch (IOException e) {
            throw new ParseException(e.getMessage());
        }
    }

}

  

The parse() method simply constructs a new TermQuery from the query. (This means that SimpleDidYouMeanParser only works with single-word queries, a deficiency we shall remedy later.) The suggest() implementation is more interesting. Just as when we created the spell index earlier, we construct a new SpellChecker with the index location for the spell index. This time, however, we just read from the index. First we check if the query word is in the index–if it is, we assume that it is correctly spelled, and make no suggestion by returning null. If instead the query word is not in the index, then we ask the spell checker for a single suggestion, by invoking the suggestSimilar() method. Of course, it may happen that no words are similar enough to the input, so we return null again. But if a suggestion is found, then it is returned as a new TermQuery.

Whew! Let’s see it in action after everything has been wired up using Spring. Figure 2 is a screenshot for the misspelled query “lettice.”

Figure 2. Suggesting a sensible alternative query

How It Works

There’s a lot going on in the suggestSimilar() method of SpellChecker, so let’s follow it through with an example. Take the correctly spelled word “lettuce,” which appears in the Beatrix Potter texts I’ve used for this article. In the original index, where each Lucene document corresponds to a text, “lettuce” appears in two Lucene documents in the contents field. On the other hand, the spell index contains a whole Lucene document for every distinct word in the original index. Each document has a number of fields, as shown here with the values for the document representing the word “lettuce.”

Field name
Field values

word
lettuce

start3
let

gram3
let ett ttu tuc uce

end3
uce

start4
lett

gram4
lett ettu ttuc tuce

end4
tuce

Notice how both trigrams and 4-grams are indexed. In fact, precisely which n-grams are indexed depends on the size of the word. For very short words, unigrams and bigrams are indexed, whereas for longer words, trigrams and 4-grams are indexed.

The suggestSimilar() method forms a Lucene query to search the spell index for candidate suggestions. For the misspelling “lettice” the query is as follows (split over two lines to make it easier to read):

start3:let^2.0 end3:ice gram3:let gram3:ett gram3:tti gram3:tic gram3:ice
start4:lett^2.0 end4:tice gram4:lett gram4:etti gram4:ttic gram4:tice
  

The start n-grams are given more weight than the other n-grams in the word; here, they are boosted by a factor of two, signified by the ^2.0 notation. Another reason to index the start and end n-grams separately is because they are positional, unlike the other n-grams. For example, the words “eat” and “ate” have the same set of unigrams and bigrams (gram1:e gram1:a gram1:t gram2:ea gram2:at), so they need the start and end fields to distinguish them (start1:e end1:t start2:ea end2:at for “eat,” and start1:a end1:e start2:at end2:te for “ate”).

Using a Lucene index browser, such as the excellent Luke–the Lucene Index Toolbox, we can manually run this query against the spell index. Figure 3 shows what we get.

Figure 3. Browsing the spell index–click image for full-size screenshot

But the top hit is “letting,” not “lettuce,” which the web app presented us with. What’s going on? The answer is that the Lucene Spell Checker ranks suggestions by edit distance, not by search relevance. The string “lettice” differs from “lettuce” by a single substitution, whereas “letting” is two substitutions away.

Supporting Composite Queries

SimpleSearchEngine supports composite queries–that is, queries that are composed of a set of clauses; for example, lettuce parsley, which means “find documents in which both of the words ‘lettuce’ and ‘parsley’ appear.” As noted above, DidYouMeanSearchEngine with SimpleDidYouMeanParser only supports single-word queries, so let’s see how we can fix it to support composite queries.

CompositeDidYouMeanParser is an implementation of DidYouMeanParser for use by DidYouMeanSearchEngine that supports composite queries. Recall that the DidYouMeanParser interface has a parse() method and a suggest() method, both of which take query strings and return Lucene Query objects. The implementation of parse() is simple: it uses Lucene’s QueryParser, which has built-in support for composite queries. The implementation of suggest() is a little more tricky. It relies on the getFieldQuery() extensibility hook provided by QueryParser, so if a term (or a word in a phrase) is misspelled, then it is replaced with the best suggestion. If no terms (or words in a phrase) in the whole query are misspelled, then suggest() returns null.

Figure 4 is a screenshot for the misspelled composite query “lettice parslee.”

Figure 4. Correcting the spelling of multiple query terms

Ensuring High-Quality Suggestions

Having a clever algorithm for detecting and correcting spelling errors is a good start, but you need a good source of correctly spelled words to ensure the suggestions are of a high quality. So far, we have used the terms in the original index as the source of words (by constructing a LuceneDictionary). There is a downside to this approach: the content that was indexed will almost certainly contain spelling errors, so there is a good chance that certain query suggestions will be misspelled.

You might think that using a compiled word list might help. However, even the largest dictionaries fall short in word coverage for proper nouns and newly coined words (e.g., technical phrases), so a correctly spelled query term that is not in the dictionary will be incorrectly marked as a misspelling. The user would then be prompted with a distracting alternative query suggestion. (As a side note, Lucene Spell Checker provides an implementation of Dictionary, PlainTextDictionary, which can read words from a word list such as /usr/dict/words commonly found on Unix systems. Use this to do regular spell checking against a dictionary.)

Lucene Spell Checker provides a mechanism to solve this problem, while still using the original index as the source of words. The suggestSimilar() method of SpellChecker is overloaded to support secondary sorting of the suggested words by document frequency in an index; for example:

spellChecker.suggestSimilar(queryText, 1, originalIndexReader, defaultField, true);
  

This call restricts suggestions to those words that are more popular (true) in the original index than the query term. On the plausible assumption that across the whole set of documents, misspellings are less common than the correctly spelled instances of the word, this modification will improve the quality of suggestions, even in document collections containing misspellings.

Zeitgeist

Large search engines use user queries for the source of suggestions. The logic is: if you don’t understand what a user is asking for, compare it to what other users ask for, as someone else is likely to have searched for something similar.

To implement this strategy, each user query submitted to the system should be indexed in the spell index in order to provide a proper record of query frequencies. (All of the main search engines publish their most popular search terms, which are ultimately derived from such an index.) Then, by using the overloaded suggestSimilar() method introduced in the previous section, suggestions will be ranked firstly by edit distance and secondly by user popularity.

Conclusion

Spell checking users’ search queries is a nice feature, and relatively easy to add to a Lucene-powered search application, as this article has shown. Most of the time, the corrections suggested are good ones, but there is plenty of ongoing research in the information retrieval community on improving spell check algorithms (see “References,” below). I think we will continue to see the fruits of such research in open source libraries like Lucene Spell Checker.

References

• Download the code supporting this article. The distribution includes everything you need to get up and running quickly, including a pre-built index that you can unpack on your filesystem, and a WAR file to drop into your servlet container.
• I used Lucene 1.4.3 and Lucene Spell Checker 1.1 in this article.
• David Spencer, who created Lucene Spell Checker, has an interesting website dedicated to search experiments.
• Aspell and its Java cousin Jazzy are good general-purpose spell checkers.
• I leaned heavily on Thomas Risberg’s thorough “Developing a Spring Framework MVC Application Step-by-Step” for building the Spring Search UI.
• A Technique for Computer Detection and Correction of Spelling Errors (Communications of the ACM, 7(3), 171 - 176; 1964), by Fred J. Damerau, is an early paper on spelling correction.
• Techniques for Automatically Correcting Words in Text (ACM Computing Surveys, 24(4), 377-439; 1992), by Karen Kukich, is the definitive survey article on spelling correction.
• The Art of Computer Programming, Volume 3, Sorting and Searching (Addison-Wesley; 1998), by Donald E. Knuth, contains the definitive description of the Soundex algorithm.
• “Spelling Correction for Search Engine Queries,” by Bruno Martins and Mario J. Silva, solves the same problem as the present article using a set of heuristics to make spelling suggestions.
• Spelling Correction as an Iterative Process that Exploits the Collective Knowledge of Web Users (2004 Proceedings of EMNLP 2004 293-300), by S. Cucerzan and E. Brill, is an interesting paper that talks about how spelling correction can be driven from knowledge acquired by a search engine.
• Unsurprisingly, Google, Yahoo, and Microsoft all have a lot of published information on information retrieval.

Tom White is lead Java developer at Kizoom, a leading U.K. software company in the delivery of personalized travel information.

July 9, 2007 on 9:20 pm | InJava|July9,2007on9:20pm|InJava|

在寫程式時，基本上都一定要為錯誤的輸入作檢查或修正。在写程式时，基本上都一定要为错误的输入作检查或修正。 這是基本可以用來檢查一個程式有沒有偷懶/偷工減料的最簡單方法。这是基本可以用来检查一个程式有没有偷懒/偷工减料的最简单方法。

在上電腦的基本課時，應該一定會提到有關 GIGO(garbagein,garbageout; 垃圾輸入, 無用輸出)。在上电脑的基本课时，应该一定会提到有关GIGO(garbagein,garbageout;垃圾输入,无用输出)。 就是說電腦很苯，當輸入的數據是垃圾，輸出就一定只會是垃圾。就是说电脑很苯，当输入的数据是垃圾，输出就一定只会是垃圾。 電腦會出錯，可是人類更易出錯，而且犯的錯誤更多。电脑会出错，可是人类更易出错，而且犯的错误更多。

最基本的，是能在輸入時即時先作出反應和指出錯誤。最基本的，是能在输入时即时先作出反应和指出错误。 最簡單是檢查數據的型態和空白(第一類)，而一個比較像樣的程式都有數字、時間、日期、大小和特定格式 (如 email 或 UUID) 的 Pattern 檢查(第二類)。最简单是检查数据的型态和空白(第一类)，而一个比较像样的程式都有数字、时间、日期、大小和特定格式(如email或UUID)的Pattern检查(第二类)。 造得仔細一點的程式都有會進一步的檢查，就是數據有效性的檢查；例如年月日的組合是否合理，沒有沒串錯字，重復性，在 database 能不能找到相對應的 ID 之類的(第三類)。造得仔细一点的程式都有会进一步的检查，就是数据有效性的检查；例如年月日的组合是否合理，没有没串错字，重复性，在database能不能找到相对应的ID之类的(第三类)。 而最好的則會著重與人的互動關係，清楚的錯誤說明，能在使用者保持集中力的時間內反應(好像大約三秒)，自動的修正、建議(第四類)。而最好的则会着重与人的互动关系，清楚的错误说明，能在使用者保持集中力的时间内反应(好象大约三秒)，自动的修正、建议(第四类)。

實例实例

第一類:Yahoo 字典第一类:Yahoo字典
雖然它說 “請輸入單字查詢，中英文皆可” ，可是日文,法文,德文也能過。虽然它说“请输入单字查询，中英文皆可”，可是日文,法文,德文也能过。 假如輸入簡体字或日文漢字它也不會了解。假如输入简体字或日文汉字它也不会了解。

第二類: 一般的網頁上常見的 “E-mail this page” 表格(我一直很好奇誰會用)。第二类:一般的网页上常见的“E-mailthispage”表格(我一直很好奇谁会用)。 例如這頁的 footer。例如这页的footer。
它會要求你依一定的格式輸入 email，可是在都不會知道這個 email 是否正確的。它会要求你依一定的格式输入email，可是在都不会知道这个email是否正确的。

第三類: 現時 forum 的 Signup form。第三类:现时forum的Signupform。
它會以寄出 validation code 的方式檢查你輸入的 email。它会以寄出validationcode的方式检查你输入的email。

第四類: Google Suggest / Gmail第四类:GoogleSuggest/Gmail
能在在未按下 sutmit 前給建議，修正，甚至 auto-complete。能在在未按下sutmit前给建议，修正，甚至auto-complete。

以上例子都是 web-application 的原因只是誰也看得到。以上例子都是web-application的原因只是谁也看得到。 事實上 client application 的例子更多。事实上clientapplication的例子更多。
如: Notepad vs UltraEdit vs Microsoft Word vs Eclipse IDE.如:NotepadvsUltraEditvsMicrosoftWordvsEclipseIDE.

好像越說越遠了。好像越说越远了。 回到正題，其中最麻煩，最難實作的是自動化的修正建議。回到正题，其中最麻烦，最难实作的是自动化的修正建议。 因為它的目的不做到 GIGO，這不是和上文所說的電腦很苯相反嗎？因为它的目的不做到GIGO，这不是和上文所说的电脑很苯相反吗？ 沒有矛盾，它是建基在數據當中正確的部份。没有矛盾，它是建基在数据当中正确的部份。

再回到主題，英文串字修正是以沒串錯的部份基礎。再回到主题，英文串字修正是以没串错的部份基础。 (從語言角度上著手也可以，不過這是人類善長的工作，不在本文內容)(从语言角度上着手也可以，不过这是人类善长的工作，不在本文内容)
英文是由字母組合而成，而它們的組合次序和方式，則可以提示出正確的建議。英文是由字母组合而成，而它们的组合次序和方式，则可以提示出正确的建议。

用實例來說或會比較易明白： 例如 Monstor (Monster 的誤寫)。用实例来说或会比较易明白：例如Monstor(Monster的误写)。 以 n-Gram 方式拆解的話，就可以得到 mon, ons, nst, sto, tor。以n-Gram方式拆解的话，就可以得到mon,ons,nst,sto,tor。 如果和 Monster 比較(mon, mon, nst, ste, ter)，其中　3/5 * 3/5 都是對的(因為是互相比較, 所以是兩組)。如果和Monster比较(mon,mon,nst,ste,ter)，其中3/5*3/5都是对的(因为是互相比较,所以是两组)。 而如果和 “monsters inc” 比較，則只有 3/5 * 3/8。而如果和“monstersinc”比较，则只有3/5*3/8。 而拿來和 apple 比較，則完全不付合。而拿来和apple比较，则完全不付合。 只要事先為字並建立 index，用這方法可以快速得到幾個相近的詞語。只要事先为字并建立index，用这方法可以快速得到几个相近的词语。

一般，英文只要有 3-gram 和 4-gram 就可以有不錯的結果。一般，英文只要有3-gram和4-gram就可以有不错的结果。 當然啦，這等零件老早就有寫了出來。当然啦，这等零件老早就有写了出来。 如果你是用 Lucene 1.4 的話，花一點心思也可以自己寫出來，而如果用 Lucene 2.0，則已經有現成的 library 可用。如果你是用Lucene1.4的话，花一点心思也可以自己写出来，而如果用Lucene2.0，则已经有现成的library可用。

參考:  SpellChecker - Lucene-java Wiki参考:SpellChecker-Lucene-javaWiki
參考:  Lucene 2.0org.apache.lucene.search.spell参考:Lucene2.0org.apache.lucene.search.spell

就算不用 Lucene，自已利用 php+mysql 也可以寫得到類似的功能，只要依著以上的方式建立 index table 和設計出一句 inner join SQL 就可以。就算不用Lucene，自已利用php+mysql也可以写得到类似的功能，只要依着以上的方式建立indextable和设计出一句innerjoinSQL就可以。

9 July 20079July2007
DennisDennis

import java.net.MalformedURLException;
import java.util.Hashtable;
import java.util.Vector;

import org.apache.xmlrpc.XmlRpc;
import org.apache.xmlrpc.XmlRpcClient;
import org.apache.xmlrpc.XmlRpcException;

public class Test2 {
    public static void main(String[] args) {
        try {
            XmlRpc.setDriver(”org.apache.xerces.parsers.SAXParser”);
            XmlRpcClient xmlrpc = new XmlRpcClient(
                    “http://网址/xmlrpc.php”);
            Vector params = new Vector();
            //params.addElement(”1″);
            params.addElement(”776″);
            params.add(”用户名”);
            params.add(”密码”);

            Vector mp = (Vector)xmlrpc.execute(”mt.getRecentPostTitles”,
                    params);
                System.out.println(mp.get(0));
                System.out.println(mp.get(1));
        } catch (MalformedURLException e) {
            System.out.println(e.toString());
        } catch (XmlRpcException e) {
            System.out.println(e.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

   前些天无意中发现了XML-RPC（不过笑我才发现啊），总想找个机会摆弄摆弄。毕业论文基本上弄完了，所以决定今天把它弄明白。
XML-RPC的最大用处，我首先想到的是浏览器在不刷新页面的情况下与服务器通信，请求数据。下面我就说一下我用XML-RPC是怎么实现的。

第一步：选择XML-RPC实现。
XML-RPC的一个很大优势就是 它是一个标准，并且各种开发环境下都有实现（酷），这是它能够轻松跨平台的原因。
javascript有3个实现。我看了一下最好的应该是jsolait（JavaScript o Lait）的实现了。因为他不仅仅是一个xml-rpc的实现，除此之外还有很多javascript库,详细内容请看这里（http://jsolait.net/）。
java的实现就更多了，我当然毫不犹豫地选择apache的。详细内容看这里（http://ws.apache.org/xmlrpc/）

第二步：建立服务。
用java建立xml-rpc有两种方式，一种是单独开个端口，一种是用servlet。我们客户端是用javascript，那么服务端用servlet是再好不过的了。
如何使用apache的xml-rpc，请详细看apache的资料。（大哥你不会连servlet也不会建吧，那你还是不要往下看了）。
代码如下：
这是一个sayHello的服务类：

public class HelloService {

public String sayHello(String name){
return “Hello: ”+name+” !”;
 }

}

下面是一个Math服务类：

public class MathService {
public double add(Vector v){
double a = Double.parseDouble((String)v.get(0));
double b = Double.parseDouble((String)v.get(1));
return a+b;
 }

public double mult(Vector v){
double a = Double.parseDouble((String)v.get(0));
double b = Double.parseDouble((String)v.get(1));
return a*b;
 }
}

接着是Servlet啦，作为RPC Server用的，这段代码比较经典，很多资料上都有。

public class RpcServer extends HttpServlet {
protected void doPost(HttpServletRequest request,
   HttpServletResponse response) throws ServletException, IOException {
  XmlRpcServer xmlrpc = new XmlRpcServer();
  xmlrpc.addHandler(”HelloService”, new HelloService());
  xmlrpc.addHandler(”MathService”,new MathService());
byte[] result = xmlrpc.execute(request.getInputStream());
  response.setContentType(”text/xml”);
  response.setContentLength(result.length);
  OutputStream out = response.getOutputStream();
out.write(result);
out.flush();
 }
}

主要是这三句：
XmlRpcServer xmlrpc = new XmlRpcServer();
xmlrpc.addHandler(”HelloService”, new HelloService());
xmlrpc.addHandler(”MathService”,new MathService());
一定要记牢Handler的名字，就是第一个参数，因为客户端就靠他来表示要调用的方法呢。

行了现在可以在web.xml中写入配置了：

<servlet>
<servlet-name>RpcServer</servlet-name>
<servlet-class>org.mstar.rpc.RpcServer</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>RpcServer</servlet-name>
<url-pattern>/RpcServer</url-pattern>
</servlet-mapping>

至此，服务端的工作已经完成，启动应用服务器就行了。

下面是javacript的实现，这也是难点（其实不难理解，只是没有中文材料）。
把jsolait的库下来以后解压缩，得到一些js文件，具体我就不说了。

建立一个html文件：

<html>
<head>
<title>XML-RPC</title>
<script type=”text/javascript” src=”./js/init.js”></script>
<script type=”text/javascript” src=”./js/lib/urllib.js”></script>
<script type=”text/javascript” src=”./js/lib/xml.js”></script>
<script type=”text/javascript” src=”./js/lib/xmlrpc.js”></script>
<script type=”text/javascript” src=”./js/hello.js”></script>
</head>
a:<input type=”text” id=”a” /><br>
b:<input type=”text” id=”b” /><br>
<input type=”button” id=”do1″ value=”a+b” onclick=”add()”/>
<input type=”button” id=”do2″ value=”say” onclick=”hello()”/>
<input type=”text” id=”result” />
</html>

注意到前面那一堆javascript的引用吗？就这么写吧。可别把hello.js当成solait的东西啦（看名字也知道啦），你是找不到的。这是我们自己写的：
hello.js

hello = function(){
var xmlrpc=null;
try{
var xmlrpc = importModule(”xmlrpc”);
 }catch(e){
     reportException(e);
throw “importing of xmlrpc module failed.”;
 }
var addr = “http://localhost:8080/Rpc/RpcServer”;
var methods = [”HelloService.sayHello”];
var rslt;

try{
var service = new xmlrpc.ServiceProxy(addr, methods);
        rslt = service.HelloService.sayHello(”MTY”);
    }catch(e){
var em;
if(e.toTraceString){
            em = e.toTraceString();
        }else{
            em = e.message;
        }
        rslt = “Error trace: \n\n” + em;
    }
 document.getElementById(”result”).value=rslt;
}
add = function(){
var xmlrpc=null;
var a = document.getElementById(”a”).value;
var b = document.getElementById(”b”).value;
var params = new Array();
 params[0] = a;
 params[1] = b;
try{
var xmlrpc = importModule(”xmlrpc”);
 }catch(e){
     reportException(e);
throw “importing of xmlrpc module failed.”;
 }
var addr = “http://localhost:8080/Rpc/RpcServer”;
var methods = [”HelloService.sayHello”,”MathService.add”];
var rslt;

try{
var service = new xmlrpc.ServiceProxy(addr, methods);
        rslt = service.MathService.add(params);
    }catch(e){
var em;
if(e.toTraceString){
            em = e.toTraceString();
        }else{
            em = e.message;
        }
        rslt = “Error trace: \n\n” + em;
    }
 document.getElementById(”result”).value=rslt;
}

这个js文件中有两个函数，一个负责从sayhello，一个负责加法运算。
这里需要一些解释的地方：
1、
 var xmlrpc=null;
 try{
     var xmlrpc = importModule(”xmlrpc”);
 }catch(e){
     reportException(e);
     throw “importing of xmlrpc module failed.”;
 }
这里是把xmlrpc模块引进来,你也就这么写吧，我也不知道为什么。
2、
 var addr = “http://localhost:8080/Rpc/RpcServer“;
 var methods = [”HelloService.sayHello”];
定义服务地址和要用的方法名。规则大概你也能看懂：Handler名.方法名。这里的Handler名就是你在xmlrpcServer中注册名，就是我上面让你记住的那个。方法名就是那个类自己的方法名。注意，methods是一个数组，所以可以写多个方法，如第二个例子。var methods = [”HelloService.sayHello”,”MathService.add”];
3、
    try{
        var service = new xmlrpc.ServiceProxy(addr, methods);
        rslt = service.HelloService.sayHello(”MTY”);
    }catch(e){
        var em;
        if(e.toTraceString){
            em = e.toTraceString();
        }else{
            em = e.message;
        }
        rslt = “Error trace: \n\n” + em;
    }
通过new xmlrpc.ServiceProxy(addr, methods);得到服务代理。
然后调用服务的方法就行了，方法就是代理.Handler名.方法名（参数）。好像参数只能有一个，在第二个例子中我开始有两个参数a,b会发生错误。怎么办？没办法，在javascript用Array传参数，在java用Vector接参数（为什么用Vector，因为xml-rpc规范中的 Array，apache使用Vector实现的，为什么javascript不用Vector，因为js没有Vector，且js的的Array是可变长的）。当然这就需要很多java端类型转换工作，js是弱类型的就不用转换了。