1、首先下载apache2.2 下载地址：http://mirrors.sohu.com/apache/httpd-2.2.16.tar.gz

2、然后下载SVN

a) 包：subversion-deps-1.6.12.tar.gz

i. 地址：http://subversion.tigris.org/downloads/subversion-deps-1.6.12.tar.gz

b) susubversion-1.6.12.tar.gz  地址：

i. http://subversion.tigris.org/downloads/subversion-1.6.12.tar.gz 

3、然后解析Apache2，安装

4、tar -zxvf httpd-2.2.16.tar.gz

5、安装Apache

a) ./configure -prefix=/opt/web/apache2 --enable-mods-shared=all --enable-so

b) Make

c) Make install

6、检查APACHE是否安装成功：

启动apache:/opt/web/apache2/bin/apachectl start

7、安装Svn

8、首先解压： tar -zxvf subversion-deps-1.6.12.tar.gz

9、然后解压：tar -zxvf susubversion-1.6.12.tar.gz 

10、安装命令：

a) ./configure --prefix=/opt/web/subversion --with-apxs=/opt/web/apache2/bin/apxs --with-apr=/opt/web/httpd-2.2.16/srclib/apr  --with-apr-util=/opt/web/httpd-2.2.16/srclib/apr-util

11、make  make install

LoadModule caucho_module \
<installdir>/resin-3.1.x/win32/apache-2.0/mod_caucho.dll
ResinConfigServer localhost 6802
<Location /caucho-status>
SetHandler caucho-status
</Location>

1、首先检查一下linux下是有存在一下软件，如果不存在，必须将这些软件安装
rpm -q compat-libstdc++-33 elfutils-libelf elfutils-libelf-devel glibc glibc-common glibc-devel gcc- gcc-c++ libaio-devel libaio libgcc libstdc++ libstdc++-devel make sysstat unixODBC unixODBC-devel
2、以root方式登陆，修改/etc/sysctl.conf，在文件中增加一下参数
kernel.shmall = 2097152
kernel.shmmax = 2147483648
kernel.shmmni = 4096
kernel.sem = 250 32000 100 128
fs.file-max = 65536
net.ipv4.ip_local_port_range =1024 65000
net.core.rmem_default = 4194304
net.core.rmem_max = 4194304
net.core.wmem_default =262144
net.core.wmem_max =262144

然后创建数据库的所有者：
groupadd oinstall
groupadd dba
useradd -g oinstall -G dba Oracle 创建用户Oracle
passwd Oracle（修改Oracle的密码）
修改Oracle用户的限制
cd /etc/security
vi limits.conf
在该文件增加一下内容
Oracle soft nproc 2047
Oracle hard nproc 16384
Oracle soft nofile 1024
Oracle hard nofile 65536
在文件/etc/pam.d/login文件增加一下内容
session required /lib/security/pam_limits.so
session required pam_limits.so
在文件/etc/profile增加一下内容

if [$USER = "Oracle"] ; then
if [ $SHELL = " /bin/ksh" ]; then
ulimit -p 16384
ulimit -n 65535
else
ulimit -u 16384 -n 65536
fi
fi
创建安装目录：
mkdir -p /opt/app/oracle
chown -P Oracle:oinstall /opt/app
chmod -R 755 /opt/app
执行命令，解压安装文件 ：unzip linux_11gR1_database.zip
然后进入解压后的目录，执行
$ ./runInstaller

首先我们看看Directory 的类
public abstract class Directory {
volatile boolean isOpen = true;
/*** 持有一个LockFactory的实例（实现锁定这个目录实例）*/
protected LockFactory lockFactory;
/**返回该目录下的所有文件数组.如果这个目录下没有文件存在，或者存在权限问题不能访问，该方法可能返回Null*/
public abstract String[] list() throws IOException;
/** * 返回指定名称的文件是不是存在 */
public abstract boolean fileExists(String name)
throws IOException;
/**返回指定名称的文件最后修改的时间
public abstract long fileModified(String name) throws IOException;
/**设置指定文件名的文件最后的修改时间为当前时间*/
public abstract void touchFile(String name) throws IOException;

/**删除指定文件。 */
public abstract void deleteFile(String name)throws IOException;
/**返回指定文件的长度。 */
public abstract long fileLength(String name) throws IOException;
/** 在当前目录下使用给定的名称创建一个空的文件。并且返回一个流来写该文件。*/
public abstract IndexOutput createOutput(String name) throws IOException;
/** * Lucene使用该方法确保所有的针对该文件的写操作都会存储到Index。并且阻止machine/OS发生故障 破坏该index。*/
public void sync(String name) throws IOException {}
/**获取已经存在的一个文件的IndexInput流操作该文件。 */
public abstract IndexInput openInput(String name) throws IOException;
/** 返回已经存在的一个文件、并且使用指定大小的缓冲的IndexInput，但是当前目录也可能忽略该缓冲池的大小，
* 当前主要是考虑CompoundFileReader和FSDirectory对于次参数的需求。*/
public IndexInput openInput(String name, int bufferSize) throws IOException {
return openInput(name);
}
/** 创建一个指定名称的锁/
public Lock makeLock(String name) {
return lockFactory.makeLock(name);
}
/**
* 清除指定的锁定（强行解锁和删除）这不仅要求在这个时候当前的锁一定不在使用。 */
public void clearLock(String name) throws IOException {
if (lockFactory != null) {
lockFactory.clearLock(name);
}
}
/** 结束这个store. */
public abstract void close() throws IOException;

/**设置LockFactory，此目录实例应使其锁定执行。每个LockFactory实例只用于一个目录（即，不要共用一个实例在多个目录） */
public void setLockFactory(LockFactory lockFactory) {
this.lockFactory = lockFactory;
lockFactory.setLockPrefix(this.getLockID());
}

/** 获得LockFactory，此目录例实例使用其锁定执行。请注意，这可能是无效的目录执行，提供自己锁执行*/
public LockFactory getLockFactory() {
return this.lockFactory;
}
/**过去锁实例的唯一表示ID的字符串描述*/
public String getLockID() {
return this.toString();
}
/**// 拷贝源目录src下的文件，复制到目的目录dest下面，拷贝完成后关闭源目录src*/
public static void copy(Directory src, Directory dest, boolean closeDirSrc) throws IOException {
final String[] files = src.list();
if (files == null)
throw new IOException("cannot read directory " + src + ": list() returned null");
byte[] buf = new byte[BufferedIndexOutput.BUFFER_SIZE];
for (int i = 0; i < files.length; i++) {
IndexOutput os = null;
IndexInput is = null;
try {
// create file in dest directory
os = dest.createOutput(files[i]);
// read current file
is = src.openInput(files[i]);
// and copy to dest directory
long len = is.length();
long readCount = 0;
while (readCount < len) {
int toRead = readCount + BufferedIndexOutput.BUFFER_SIZE > len ? (int)(len - readCount) : BufferedIndexOutput.BUFFER_SIZE;
is.readBytes(buf, 0, toRead);
os.writeBytes(buf, toRead);
readCount += toRead;
}
} finally {
// graceful cleanup
try {
if (os != null)
os.close();
} finally {
if (is != null)
is.close();
}
}
}
if(closeDirSrc)
src.close();
}

从Directory抽象类的定义，我们可以得到如下几点：
1、管理锁工厂及其锁实例；
2、管理Directory目录实例的基本属性，主要是通过文件名称进行管理；
3、管理与操作该目录相关的一些流对象；
4、管理索引文件的拷贝。

2、我们首先看看IndexWriter的构造函数

public IndexWriter(String path, Analyzer a, boolean create, MaxFieldLength mfl)

public IndexWriter(String path, Analyzer a, boolean create)(废弃，不提倡使用)

public IndexWriter(File path, Analyzer a, boolean create, MaxFieldLength mfl)

public IndexWriter(File path, Analyzer a, boolean create)(废弃，不提倡使用)

public IndexWriter(Directory d, Analyzer a, boolean create, MaxFieldLength mfl)

public IndexWriter(Directory d, Analyzer a, boolean create)(废弃，不提倡使用)

public IndexWriter(String path, Analyzer a, MaxFieldLength mfl)

public IndexWriter(String path, Analyzer a)(废弃，不提倡使用)

public IndexWriter(File path, Analyzer a, MaxFieldLength mfl)

public IndexWriter(File path, Analyzer a)(废弃，不提倡使用)

public IndexWriter(Directory d, Analyzer a, MaxFieldLength mfl)

public IndexWriter(Directory d, Analyzer a)(废弃，不提倡使用)

public IndexWriter(Directory d, boolean autoCommit, Analyzer a)(废弃，不提倡使用)

public IndexWriter(Directory d, boolean autoCommit, Analyzer a, boolean create)（废弃，不提倡使用)

public IndexWriter(Directory d, Analyzer a, IndexDeletionPolicy deletionPolicy, MaxFieldLength mfl)

public IndexWriter(Directory d, boolean autoCommit, Analyzer a, IndexDeletionPolicy deletionPolicy)（废弃，不提倡使用)

public IndexWriter(Directory d, Analyzer a, boolean create, IndexDeletionPolicy deletionPolicy, MaxFieldLength mfl)

public IndexWriter(Directory d, boolean autoCommit, Analyzer a, boolean create, IndexDeletionPolicy deletionPolicy)（废弃，不提倡使用)

细心的读者肯定会发现，废弃的构造函数与提倡使用的构造函数，多了一个MaxFieldLength参数。带有该参数的构造函数都是允许正常使用的。（注释：废弃的构造函数将在Lucene3.0中移除）

仔细查看其构造函数的实现呢，最终都转化成一个私有的构造函数：如图：

/**

* 该构造函数主要是创建一个IndexWrite对象

* d ：指定的存放建立索引文件的索引目录

* a ：Analyzer  分词分析器

* create ：是否要重新写入索引文件，如果为true，则重写索引文件；如果为false，则追加写入索引文件

* closeDir ：一个boolean型变量，表示是否关闭索引目录Directory d，与IndexWriter的一个成员变量相关

* deletionPolicy ：指定删除索引文件使用的策略

* autoCommit ：建立索引文件后，自动提交。

* maxFieldLength ： 表示索引中Field的最大长度。

*/

private void init(Directory d, Analyzer a, final boolean create, boolean closeDir, IndexDeletionPolicy deletionPolicy, boolean autoCommit, int maxFieldLength)

    throws CorruptIndexException, LockObtainFailedException, IOException {

    this.closeDir = closeDir;

    directory = d;

    analyzer = a;

    setMessageID(defaultInfoStream);//这里主要是指定infoStream，是一个PrintStream输出流对象

    this.maxFieldLength = maxFieldLength; //指定Field数据的最大长度

    if (create) {

      // 如果是重新创建索引文件，清除写锁文件write.lock

      directory.clearLock(WRITE_LOCK_NAME);

    }

    Lock writeLock = directory.makeLock(WRITE_LOCK_NAME);

    if (!writeLock.obtain(writeLockTimeout)) // 获取写锁文件

      throw new LockObtainFailedException("Index locked for write: " + writeLock);

    this.writeLock = writeLock;             //保存新的写锁文件

    try {

      if (create) {

        // 如果create为true，表示重写索引文件。重写索引文件之前，要先读取已经存在的索引文件，并且要清除掉历史写入的segment信息

        try {

          segmentInfos.read(directory);

          segmentInfos.clear();

        } catch (IOException e) {

        }

        segmentInfos.commit(directory);  // 向指定的索引存放目录中写入segment信息   

      } else {

        segmentInfos.read(directory); //读取segment信息

        // We assume that this segments_N was previously

        // properly sync'd:

        for(int i=0;i<segmentInfos.size();i++) {

          final SegmentInfo info = segmentInfos.info(i);

          List files = info.files();

          for(int j=0;j<files.size();j++)

            synced.add(files.get(j));

        }

      }

      this.autoCommit = autoCommit; //执行提交写入索引的标志 

      setRollbackSegmentInfos(segmentInfos); //克隆原来的segment状态信息，并且将信息保存到HashSet。

      docWriter = new DocumentsWriter(directory, this); //创建一个DocumentsWriter对象

      docWriter.setInfoStream(infoStream); //设置DocumentsWriter对象的infoStream信息

      docWriter.setMaxFieldLength(maxFieldLength); //设置DocumentsWriter对象的maxFieldLength信息

      //默认的删除策略实现类为KeepOnlyLastCommitDeletionPolicy，它只是保证将最近提交删除的索引文件，提交删除动作 

      // IndexFileDeleter deleter是IndexWriter类的一个私有的成员变量，它在org.apache.lucene.index包里面，主要对删除索引文件进行实现和管理 

      deleter = new IndexFileDeleter(directory,

                                     deletionPolicy == null ? new KeepOnlyLastCommitDeletionPolicy() : deletionPolicy,

                                     segmentInfos, infoStream, docWriter);

      pushMaxBufferedDocs(); //刷新DocsBuffer。

      if (infoStream != null) { //如果infoStream是null

        message("init: create=" + create);

        messageState();

      }

    } catch (IOException e) {

      this.writeLock.release();

      this.writeLock = null;

      throw e;

    }

  } 

  通过IndexWrite的构造函数，以及最终的实现方法的init分发，其主要是实现了根据指定的建立索引的方式(重写、追加写入)，通过create标志位来判断，从而指定一种在操作索引文件的过程中删除索引文件的策略。

在理解lucene的时间，必须熟悉其初始化IndexWrite的原理，才能深入了解该框架在创建索引的核心实现机制。

Filed类源代码解析
    首先Filed内部定义了三个静态类Store、Index、TermVector。
//定一个静态类Store ，主要为了设置Field的存储属性
public static final class Store extends Parameter implements Serializable {
    private Store(String name) {
      super(name);
    }
    //使用压缩的方式来存储Field的值
    public static final Store COMPRESS = new Store("COMPRESS");
    //在索引中存储Field的值
    public static final Store YES = new Store("YES");
    //在索引中不存贮Field的值
    public static final Store NO = new Store("NO");
  }
//定一个静态类Index ，主要为了设置Field的索引属性
public static final class Index extends Parameter implements Serializable {
    private Index(String name) {
      super(name);
 }
 //不对Field进行索引，所以这个Field就不能被检索到(一般来说，建立索引而使它不被检索，这是没有意义的)
 //如果对该Field还设置了Field.Store为Field.Store.YES或Field.Store.COMPRESS，则可以检索
    public static final Index NO = new Index("NO");

    //对Field进行索引，同时还要对其进行分词(由Analyzer来管理如何分词)
    public static final Index ANALYZED = new Index("ANALYZED");
//废弃的属性，使用ANALYZED 来替代
     public static final Index TOKENIZED = ANALYZED;
//对Field进行索引，但是不对该Field使用分词
    public static final Index NOT_ANALYZED = new Index("NOT_ANALYZED");
//废弃的属性，使用NOT_ANALYZED来替代
    public static final Index UN_TOKENIZED = NOT_ANALYZED;
//即不对Field索引，也不对其使用Analyzer来分词
    public static final Index NOT_ANALYZED_NO_NORMS = new  Index("NOT_ANALYZED_NO_NORMS");
//废弃的属性，有NOT_ANALYZED_NO_NORMS来替代
    public static final Index NO_NORMS = NOT_ANALYZED_NO_NORMS;
//对Field属性，使用分词，但是不是使用Analyzer来分词
    public static final Index ANALYZED_NO_NORMS = new Index("ANALYZED_NO_NORMS");
  }
这是一个与词条有关的类。因为在检索的时候需要指定检索关键字，通过为一个Field添加一个TermVector，就可以在检索中把该Field检索到。
public static final class TermVector  extends Parameter implements Serializable {
    private TermVector(String name) {
      super(name);
    }
    //不存储
    public static final TermVector NO = new TermVector("NO");
    //为每个Document都存储一个TermVector
    public static final TermVector YES = new TermVector("YES");
    //存储，并且存在位置信息
    public static final TermVector WITH_POSITIONS = new TermVector("WITH_POSITIONS");
    //存储，并且存贮偏移量信息
    public static final TermVector WITH_OFFSETS = new TermVector("WITH_OFFSETS");
    //存储位置、偏移量等所有信息
    public static final TermVector WITH_POSITIONS_OFFSETS = new TermVector("WITH_POSITIONS_OFFSETS");
  }

构造函数
 public Field(String name, String value, Store store, Index index)  
public Field(String name, String value, Store store, Index index, TermVector termVector)
public Field(String name, Reader reader)
public Field(String name, Reader reader, TermVector termVector)
public Field(String name, TokenStream tokenStream)
public Field(String name, TokenStream tokenStream, TermVector termVector)
 public Field(String name, byte[] value, Store store)
public Field(String name, byte[] value, int offset, int length, Store store)

流程：
首先检查name以及values不能为空以及Nnull。
然后检查是否是存储以及是否分词如果两者都是No，则抛出异常。
然后检查是否存储以及是否向量分词，如果两者都是No'，则抛出异常。
然后将该Filed的名称命令传递过来的名称源代码（this.name = name.intern）
表示获取JVM String常量池的地址
此时根据Store的值，来设置是否存储以及压缩的值
然后根据Index的值，来设置是否索引、是否分词、omitNorms  的值以及置是否是二进制
然后开始根据TermVector 的值，来设置是否存储向量、是否存储偏移量、是否存储位置等信息。


以上信息可能存在分析不正确，请大家给指证，本人英语有不怎么好，

Document是lucene自己定义的一种文件格式，lucene使用docement来代替对应的物理文件或者保存在数据库中的数据。因此Document只能作为数据源在Lucene中的数据存贮的一种文件形式。

Document只是负责收集数据源，因为不同的文件可以构建同一个Document。只要用户将不同的文件创建成Document类型的文件，Lucene就能快速找到查找并且使用他们。

对于一个Document文件，可以同时增加多个Field。Lucene中对于每个数据源是使用Field类来表示的。多个Field组成一个Document，多个Document组成一个索引文件。Document与Field关系如果一所示

此时，我们去看看Document这个类的源代码。Document采用默认不带参数的构造函数，但是我们他在创建的时间，
        产生两个变量：fields和 boost

其中fields是创建了一个arrayList,其主要是保存Field类

Boost主要是设置该doc的优先级

其方法：add（Fieldable field）增加一个field对象

    removeField(String name)  根据name移除一个ield对象（找到一个就返回）

removeFields(String name)  根据name移除所有的field对象

Field getField(String name)  根据名字找到该Field对象。

Fieldable getFieldable(String name)  根据名字找到Fieldable子类（Fieldable是 接口，具体有Filed来实现）

String get(String name) 根据名字，找到给Filed对象中包含的内容

public final byte[] getBinaryValue(String name) 主要查找Doc中包含有二进制field 数据（如果不存在，则返回null）
    public final List getFields() 直接返回该Doc中包含的Field。
    

这个是需要替换的内容<a href=../../08/19/10483.html>下一篇： PHP+MySQL应用中使用XOR运算加密算法</a>

不知道是什么原因，replassall竟然不能替换，是找不到源里的数据，还是其他有问题呢？其他页面都能替换掉，就是有1-2个页面不能替换，郁闷。是不是字符编码的问题？有谁知道吗？请赐教

实现限制输入大、小写英文，数字，浮点小数，日期，中文，部分英文，部分中文等众多功能。直接加入到html代码中即可使用。

<script>
function regInput(obj, reg, inputStr)
{
var docSel = document．selection.createRange()
if (docSel.parentElement().tagName != "INPUT") return false
oSel = docSel.duplicate()
oSel.text = ""
var srcRange = obj.createTextRange()
oSel.setEndPoint("StartToStart", srcRange)
var str = oSel.text + inputStr + srcRange.text.substr(oSel.text.length)
return reg.test(str)
}
</script>

小写英文：<xmp style= "display:inline"> </xmp>
<input onkeypress = "return regInput(this, /^[a-z]*$/, String.fromCharCode(event.keyCode))"
onpaste = "return regInput(this, /^[a-z]*$/, window.clipboardData.getData('Text'))"
ondrop = "return regInput(this, /^[a-z]*$/, event.dataTransfer.getData('Text'))"
style="ime-mode:Disabled"><br>

大写英文：<xmp style= "display:inline"> </xmp>
<input onkeypress = "return regInput(this, /^[A-Z]*$/, String.fromCharCode(event.keyCode))"
onpaste = "return regInput(this, /^[A-Z]*$/, window.clipboardData.getData('Text'))"
ondrop = "return regInput(this, /^[A-Z]*$/, event.dataTransfer.getData('Text'))"
style="ime-mode:Disabled">
<br>

任意数字：<xmp style="display:inline"> </xmp>
<input onkeypress = "return regInput(this, /^[0-9]*$/, String.fromCharCode(event.keyCode))"
onpaste = "return regInput(this, /^[0-9]*$/, window.clipboardData.getData('Text'))"
ondrop = "return regInput(this, /^[0-9]*$/, event.dataTransfer.getData('Text'))"
style="ime-mode:Disabled"><br>

限2位小数：<xmp style="display:inline"> </xmp>
<input onkeypress = "return regInput(this, /^\d*\.?\d{0,2}$/,
String.fromCharCode(event.keyCode))"
onpaste = "return regInput(this, /^\d*\.?\d{0,2}$/,
window.clipboardData.getData('Text'))"
ondrop = "return regInput(this, /^\d*\.?\d{0,2}$/,
event.dataTransfer.getData('Text'))"
style="ime-mode:Disabled">

如: 123.12<br>

日　 期：<xmp style="display:inline"> </xmp>

<input onkeypress = "return regInput(this, /^\d{1,4}
([-\/](\d{1,2}([-\/](\d{1,2})?)?)?)?$/,
String.fromCharCode(event.keyCode))"

onpaste = "return regInput(this, /^\d{1,4}([-\/](\d{1,2}
([-\/](\d{1,2})?)?)?)?$/,
window.clipboardData.getData('Text'))"

ondrop = "return regInput(this, /^\d{1,4}([-\/](\d{1,2}
([-\/](\d{1,2})?)?)?)?$/,
event.dataTransfer.getData('Text'))"

style="ime-mode:Disabled">

如: 2002-9-29<br>

任意中文：<xmp style="display:inline"> </xmp>

<input onkeypress = "return regInput(this, /^$/,
String.fromCharCode(event.keyCode))"

onpaste = "return regInput(this, /^[\u4E00-\u9FA5]*$/,
window.clipboardData.getData('Text'))"

ondrop = "return regInput(this, /^[\u4E00-\u9FA5]*$/,
event.dataTransfer.getData('Text'))"><br>

部分英文：<xmp style="display:inline"> </xmp>
<input onkeypress = "return regInput(this, /^[a-e]*$/,
String.fromCharCode(event.keyCode))"

onpaste = "return regInput(this, /^[a-e]*$/,
window.clipboardData.getData('Text'))"

ondrop = "return regInput(this, /^[a-e]*$/,
event.dataTransfer.getData('Text'))"

style="ime-mode:Disabled">

范围: a,b,c,d,e<br>

部分中文：<xmp style="display:inline"> </xmp>
<script language=javascript>

function checkChinese(oldLength, obj)
{
var oTR = window.document．selection.createRange()
var reg = /[^一二三四五六七八九十]/g
oTR.moveStart("character", -1*(obj.value.length-oldLength))
oTR.text = oTR.text.replace(reg, "")
}
</script>

<input onkeypress="return false" onkeydown=
"setTimeout('checkChinese('+this.value.length+','+this.uniqueID+')',
1)"

onpaste = "return regInput(this, /^[一二三四五六七八九十]*$/,
window.clipboardData.getData('Text'))"

ondrop = "return regInput(this, /^[一二三四五六七八九十]*$/,
event.dataTransfer.getData('Text'))">

范围: 一二三四五六七八九十<br>

2.不能展开右键，不能全选，不能复制的实现

<body oncontextmenu="window.event.returnvalue=false"
onkeypress="window.event.returnvalue=false"
onkeydown="window.event.returnvalue=false"
onkeyup="window.event.returnvalue=false"
ondragstart="window.event.returnvalue=false"
onselectstart="event.returnvalue=false">
...
</body>

3.禁止页面正文内容被选取

<body oncontextmenu="return false" ondragstart="return false"
onselectstart ="return false" onselect="document．selection.empty()"
oncopy="document．selection.empty()" onbeforecopy="return false"onmouseup="document．selection.empty()">

4.避免别人把网页放在框架中

<script language=“javascript”><!--if (self!=top){top.location=self.location;}-->< /script>

5.禁示查看源代码

<frameset>
<frame src="你要保密的文件的URL">
</frameset>

6.关闭输入法

<input style="ime-mode:disabled">

7.禁止图片下载

在这里的最后加入：

oncontextmenu="return false" ondragstart="return false" onselectstart="return
false" scroll="auto"

8.禁止缓存

在HEAD里加入：

<meta http-equiv="Expires" CONTENT="0">
<meta http-equiv="Cache-Control" CONTENT="no-cache">
<meta http-equiv="Pragma" CONTENT="no-cache">

        webService主要是可以解决站点间的数据共享问题，把复杂的业务方法，封装在被调用的站点上面，这样不管是WEB站点和其他的应用程序（当然要能保证上网）都可以访问到暴露的方法。

myeclipse5.1支持xfire支持的非常棒。这里讲解一个简单的例子，
此文章为引用文章，仅做保留，供学习参考使用

点击finish之后，myeclipse自动帮你生成services.xml以及web应用目录结构，其中的services.xml是你导出服务的配置文件，注意在WEB-INF/web.xml文件中配置了xfire自己的

servlet.

2.接下来，现在编写要导出的pojo类，首先是接口：
过程：File>New>Other>MyEclipse>Web Service
选择：Create web service from Java bean，把Create new javabean也勾上

3。在导航页面中，输入

web service name:   HelloWorldTest
java package : services
services Interface : IHelloWorldTest
services impl.class :HelloWorldTestImpl

其他的默认，点finish
最后可以看到Web Services   下面的services.xml的内容如下
<beans xmlns="http://xfire.codehaus.org/config/1.0">
<service>
   <name>HelloWorldTest</name>
   <serviceClass>services.IHelloWorldTest</serviceClass>
   <implementationClass>
    services.HelloWorldTestImpl
   </implementationClass>
   <style>wrapped</style>
   <use>literal</use>
   <scope>application</scope>
</service>
</beans>

4。services包中的文件：

IHelloWorldTest.java
-----------------------------------------------
package services;
//Generated by MyEclipse

public interface IHelloWorldTest {

public String sayHello(String message);

}
----------------------------------------------------------

HelloWorldTestImpl.java
----------------------------------------------------
package services;
//Generated by MyEclipse

public class HelloWorldTestImpl implements IHelloWorldTest {

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

}
------------------------------------------------------------

到此为止webServices编码工作完成，现在开始部署到tomcat这里省略。

部署好后可以测试下：
http://localhost:8080/HelloWorld/services/HelloWorldTest?WSDL

• changefreq:页面内容更新频率。
• lastmod:页面最后修改时间
• loc:页面永久链接地址
• priority:相对于其他页面的优先权
• url:相对于前4个标签的父标签
• urlset:相对于前5个标签的父标签

1. <urlset xmlns="http://www.google.com/schemas/sitemap/0.84">
   这一行定义了此xml文件的命名空间，相当于网页文件中的<html>标签一样的作用。
2. <url>这是具体某一个链接的定义入口，你所希望展示在SiteMap文件中的每一个链接都要用<url>和</url>包含在里面，这是必须的。
3. <loc>http://duduwolf.winzheng.com</loc>用<loc>描述出具体的链接地址，这里需要注意的是链接地址中的一些特殊字符必须转换为XML(HTML)定义的转义字符，如下表：

   字符		转义后的字符
   		HTML字符	字符编码
   and(和)	&	&	&
   单引号	'	'	'
   双引号	"	"	"
   大于号	>	>	>
   小于号	<	&lt;	<

4. <lastmod>2005-06-03T04:20:32-08:00</lastmod><lastmod>是用来指定该链接的最后更新时间，这个很重要。Google的机器人会在索引此链接前先和上次索引记录的最后更新时间进行比较，如果时间一样就会跳过不再索引。所以如果你的链接内容基于上次Google索引时的内容有所改变，应该更新该时间，让Google下次索引时会重新对该链接内容进行分析和提取关键字。这里必须用ISO 8601中指定的时间格式进行描述，格式化的时间格式如下：
   • 年：YYYY(2005)
   • 年和月：YYYY-MM(2005-06)
   • 年月日：YYYY-MM-DD(2005-06-04)
   • 年月日小时分钟：YYYY-MM-DDThh:mmTZD(2005-06-04T10:37+08:00)
   • 年月日小时分钟秒：YYYY-MM-DDThh:mmTZD(2005-06-04T10:37:30+08:00)
   这里需注意的是TZD，TZD指定就是本地时间区域标记，像中国就是+08:00了
5. <changefreq>always</changefreq>用这个标签告诉Google此链接可能会出现的更新频率，比如首页肯定就要用always(经常)，而对于很久前的链接或者不再更新内容的链接就可以用yearly(每年)。这里可以用来描述的单词共这几个："always", "hourly", "daily", "weekly", "monthly", "yearly"，具体含义我就不用解释了吧，光看单词的意思就明白了。
6. <priority>1.0</priority> <priority>是用来指定此链接相对于其他链接的优先权比值，此值定于0.0 - 1.0之间
7. 还有</url>和</urlset>，这两个就是来关闭xml标签的，这和HTML中的</body>和</html>是一个道理
8. 另外需要注意的是，这个xml文件必须是utf-8的编码格式，不管你是手动生成还是通过代码生成，建议最好检查一下xml文件是否是utf-8编码，最简单的方法就是用记事本打开xml然后另存为时选择编码(或转换器)为UTF-8。

import org.apache.commons.dbcp.ConnectionFactory;
import org.apache.commons.dbcp.DriverManagerConnectionFactory;
import org.apache.commons.dbcp.PoolableConnectionFactory;
import org.apache.commons.dbcp.PoolingDriver;
import org.apache.commons.pool.ObjectPool;
import org.apache.commons.pool.impl.GenericObjectPool;
import org.apache.log4j.Logger;

/**
 * @author Administrator
 *
 */
public class DBConnectionFactory {
 /**
  * Logger for this class
  */
 private static final Logger logger = Logger
   .getLogger(DBConnectionFactory.class);

 private static ObjectPool connectionPool=null;
 private static String sqlJdbc = "";
    private static String sqlUser = "";
    private static String sqlPwd = "";
    @SuppressWarnings("unchecked")
 private static Class driverClass=null;

    public static void proDBConnectionFactory(){
     if(sqlJdbc.equals("")){
      sqlJdbc = "jdbc:jtds:sqlserver://27.0.0.1:1433/finance;tds=8.0;lastupdatecount=true";
     }
     if(sqlUser.equals("")){
      sqlUser = "sa";
     }
     if(sqlPwd.equals("")){
      sqlPwd = "11111";
     }
     initDataSource();
    }
     public synchronized static void initDataSource(){
      if(driverClass == null){
       try {
    driverClass = Class.forName("net.sourceforge.jtds.jdbc.Driver");
   } catch (ClassNotFoundException e) {
    logger.error("在注册驱动名称的时间发生错误："+e.getMessage(),e);
   }
      }
      if(connectionPool == null){
       setupDriver(sqlJdbc);
       //printDriverStats();
      }else{
       System.out.print("连接池已经存在");
      }
      try {
            // printDriverStats();
         } catch (Exception e) {
             e.printStackTrace();
         }  
     }
    
     public static Connection getConn(){
      proDBConnectionFactory();
      Connection conn = null;
      try {
             conn = DriverManager.getConnection("jdbc:apache:commons:dbcp:FinanceDBPool");
         } catch(SQLException e) {
             e.printStackTrace();
         }
         return conn;

     }
    
     public static void printDriverStats() throws Exception {
         PoolingDriver driver = (PoolingDriver) DriverManager.getDriver("jdbc:apache:commons:dbcp:");
         ObjectPool connectionPool = driver.getConnectionPool("FinanceDBPool");
         System.out.println("活动的连接: " + connectionPool.getNumActive());
         System.out.println("空闲的连接: " + connectionPool.getNumIdle());
     }

    
     public static void setupDriver(String connectURI){
      try {
   connectionPool = new GenericObjectPool(null);
    ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(connectURI,sqlUser,sqlPwd);
    @SuppressWarnings("unused")
   PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(connectionFactory,connectionPool,null,null,false,true);
    Class.forName("org.apache.commons.dbcp.PoolingDriver");
    PoolingDriver driver = (PoolingDriver) DriverManager.getDriver("jdbc:apache:commons:dbcp:");
    //driver.registerPool("FinanceDBPool",connectionPool);
    driver.registerPool("FinanceDBPool",connectionPool);

  } catch (ClassNotFoundException e) {
   logger.error("注册连接池的时间发生错误:"+e.getMessage(),e);
  } catch (SQLException e) {
   logger.error("注册连接池的时间发生错误:"+e.getMessage(),e);
  }
     }
 

web.xml
<?xml version="1.0" encoding="GB18030"?>
<web-app version="2.4"
 xmlns="http://java.sun.com/xml/ns/j2ee"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
 http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
 <filter>
  <filter-name>webwork</filter-name>
  <filter-class>com.opensymphony.webwork.dispatcher.FilterDispatcher</filter-class>
 </filter>
 <filter-mapping>
  <filter-name>webwork</filter-name>
  <url-pattern>/*</url-pattern>
 </filter-mapping>
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>

xwork.xml
<!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.0//EN"
"http://www.opensymphony.com/xwork/xwork-1.0.dtd">

<xwork>
 <include file="webwork-default.xml"></include>
 <package name="default" extends="webwork-default">
  <action name="helloWorld" class="cn.javaworker.yeming.action.HelloWorld">
   <result name="success">index.jsp</result>
   <result name="input">hello.jsp</result>
  </action>
 </package>
</xwork>

hello.jsp
<%@ taglib prefix="ww" uri="/webwork"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>   
    <title>Enter you name</title>
  </head>
 
  <body>
  <ww:form action="helloWorld">
   <ww:textfield label="please enter user name" name="name"></ww:textfield>
   <input  type="submit"/>
  </ww:form>
   <form action="helloWorld.action">
     please enter you name:<input type="text" name="name" value="<ww:property value="name"/>"/>
    <input type="submit">
   </form>
  </body>
</html>

index.jsp

<%@ taglib prefix="ww" uri="/webwork"%>
<html>
 <head>
  <title>hello page</title>
 </head>
 <body>
  The message generated by my first action is :<ww:property value="message"/>
 </body>
</html>

HelloWorld.java

package cn.javaworker.yeming.action;

import com.opensymphony.xwork.ActionSupport;

/**
* @author $author
*/
@SuppressWarnings("serial")
public class HelloWorld extends ActionSupport{
 
 private String message;
 
 private String name;
 /**
  * @see com.opensymphony.xwork.Action#execute()
  */
 public String execute() throws Exception
 {
  if(name==null||name.equals("")||name.equals("world")){
   addFieldError("name","blank names or names of 'world' are not allowed!");
   return INPUT;
  }
  message ="hello "+name+"!\n";
  message+="this is the time is: "+System.currentTimeMillis();
  return SUCCESS;
 }
 /**
  * @return the name
  */
 public String getName() {
  return name;
 }
 /**
  * @param name the name to set
  */
 public void setName(String name) {
  this.name = name;
 }
 /**
  * @return the message
  */
 public String getMessage() {
  return message;
 }

}

出现这个问题，是因为你没有正确配置 Hibernate internal session context management .

1. StringTokenizer(String str) ：构造一个用来解析str的StringTokenizer对象。java默认的分隔符是“空格”、“制表符(‘\t’)”、“换行符(‘\n’)”、“回车符(‘\r’)”。
2. StringTokenizer(String str, String delim) ：构造一个用来解析str的StringTokenizer对象，并提供一个指定的分隔符。
3. StringTokenizer(String str, String delim, boolean returnDelims) ：构造一个用来解析str的StringTokenizer对象，并提供一个指定的分隔符，同时，指定是否返回分隔符。

1. int countTokens() ：返回nextToken方法被调用的次数。如果采用构造函数1和2，返回的就是分隔符数量(例2)。
2. boolean hasMoreTokens() ：返回是否还有分隔符。
3. boolean hasMoreElements() ：结果同2。
4. String nextToken() ：返回从当前位置到下一个分隔符的字符串。
5. Object nextElement() ：结果同4。
6. String nextToken(String delim) ：与4类似，以指定的分隔符返回结果。

		String s = new String("The Java platform is the ideal platform for network computing");
		StringTokenizer st = new StringTokenizer(s);
		System.out.println( "Token Total: " + st.countTokens() );
		while( st.hasMoreElements() ){
			System.out.println( st.nextToken() );
　　　　　　　　　　　}
结果为：
Token Total: 10
The
Java
platform
is
the
ideal
platform
for
network
computing

		String s = new String("The=Java=platform=is=the=ideal=platform=for=network=computing");
		StringTokenizer st = new StringTokenizer(s,"=",true);
		System.out.println( "Token Total: " + st.countTokens() );
		while( st.hasMoreElements() ){
			System.out.println( st.nextToken() );
		}
结果为：
Token Total: 19
The
=
Java
=
platform
=
is
=
the
=
ideal
=
platform
=
for
=
network
=
computing

StringBuffer() ：构造一个没有任何字符的StringBuffer类。
StringBuffer(int length) ： ：构造一个没有任何字符的StringBuffer类，并且，其长度为length。
StringBuffer(String str) ：以str为初始值构造一个StringBuffer类。

1. StringBuffer append(boolean b)
2. StringBuffer append(char c)
3. StringBuffer append(char[] str)
4. StringBuffer append(char[] str, int offset, int len)
5. StringBuffer append(double d)
6. StringBuffer append(float f)
7. StringBuffer append(int i)
8. StringBuffer append(long l)
9. StringBuffer append(Object obj)
10. StringBuffer append(String str)
11. StringBuffer append(StringBuffer sb)

以上的方法都是向字符串缓冲区“追加”元素，但是，这个“元素”参数可以是布尔量、字符、字符数组、双精度数、浮点数、整型数、长整型数对象类型的字符串、字符串和StringBuffer类等。如果添加的字符超出了字符串缓冲区的长度，Java将自动进行扩充。

		String question = new String("1+1=");
		int answer = 3;
		boolean result = (1+1==3);

		StringBuffer sb = new StringBuffer();
		sb.append(question);
		sb.append(answer);
		sb.append('\t');
		sb.append(result);

		System.out.println(sb);
结果为：
1+1=3   false

12. int capacity() ：返回当前StringBuffer对象（字符串缓冲区）的总空间，而非字符号串的长度。
13. char charAt(int index) ：在当前StringBuffer对象中取索引号为index的字符。第一个字符的索引为“0”
14. StringBuffer delete(int start, int end) ：删除当前StringBuffer对象中以索引号start开始，到end结束的子串。
15. StringBuffer deleteCharAt(int index) ：删除当前StringBuffer对象中索引号为index的字符。
16. void ensureCapacity(int minimumCapacity) ：重新设置字符号串缓冲区的总空间。如果minimumCapacity大于当前的总空间，则新的空间被设置：一种结果是minimumCapacity；另一种结果是{“老空间”乘2加2}。

		StringBuffer sb1 = new StringBuffer(5);
		StringBuffer sb2 = new StringBuffer(5);

		sb1.ensureCapacity(6);
		sb2.ensureCapacity(100);

		System.out.println( "sb1.Capacity: " + sb1.capacity() );
		System.out.println( "sb2.Capacity: " + sb2.capacity() );
结果为：
sb1.Capacity: 12
sb2.Capacity: 100

17. void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) ：从当前StringBuffer对象的索引号srcBegin开始，到srcEnd结束的子串，赋值到字符数组dst中，并且从dst的索引号dstBegin开始。

		StringBuffer sb = new StringBuffer("I love her!");
		char[] i = {'I',' ','l','o','v','e',' ','y','o','u'};

		sb.getChars(7,10,i,7);

		System.out.println( "sb: " + sb );
结果为：sb: I love her!

18. int indexOf(String str) ：返回当前StringBuffer对象中，第一个满足str子串的位置。
19. int indexOf(String str, int fromIndex) ：从当前StringBuffer对象的fromIndex开始查找，返回第一个满足str子串的位置。
20. StringBuffer insert(int offset, boolean b)
21. StringBuffer insert(int offset, char c)
22. StringBuffer insert(int offset, char[] str)
23. StringBuffer insert(int index, char[] str, int offset, int len)
24. StringBuffer insert(int offset, double d)
25. StringBuffer insert(int offset, float f)
26. StringBuffer insert(int offset, int i)
27. StringBuffer insert(int offset, long l)
28. StringBuffer insert(int offset, Object obj)
29. StringBuffer insert(int offset, String str)

以上的方法都是在当前StringBuffer对象中插入一个元素，在索引号offset处插入相应的值。
30. int lastIndexOf(String str) ：返回当前StringBuffer对象中，最后一个满足str子串的位置。
31. int lastIndexOf(String str, int fromIndex) ：从当前StringBuffer对象的fromIndex开始查找，返回最后一个满足str子串的位置。
32. int length() ：返回当前StringBuffer对象（字符缓冲区）中，字符串的长度。注意：此方法与capacity() 不同。
33. StringBuffer replace(int start, int end, String str) ：替换当前StringBuffer对象的字符串。从start开始，到end结束的位置替换成str。
34. StringBuffer reverse() ：将字符串翻转。

		StringBuffer sb = new StringBuffer("0123456789");
		System.out.println( "sb.reverse(): " + sb.reverse() );
结果为：sb.reverse(): 9876543210

35. void setCharAt(int index, char ch) ：设置索引号index的字符为ch。
36. void setLength(int newLength) ：重新设置字符串缓冲区中字符串的长度，如果newLength小于当前的字符串长度，将截去多余的字符。

		StringBuffer sb = new StringBuffer("0123456789");
		sb.setLength(5);
		System.out.println( "sb: " + sb );
结果为：sb: 01234

37. String substring(int start) ：取当前StringBuffer对象中，从start开始到结尾的子串。
38. String substring(int start, int end) ：取当前StringBuffer对象中，从start开始到end的子串。
39. String toString() ：将当前StringBuffer对象转换成String对象。

log4j.rootLogger=INFO, A1,A4

log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.Threshold=ERROR

log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%p [%t] %c{2} (%M:%L) - %m%n

log4j.appender.A4=org.apache.log4j.DailyRollingFileAppender
log4j.appender.A4.file=D:\\Java\\logs\\yeming.log
log4j.appender.A4.Encoding=GBK
log4j.appender.A4.DatePattern='.'yyyy-MM-dd
log4j.appender.A4.layout=org.apache.log4j.PatternLayout
log4j.appender.A4.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n

使用代码：
package com.javawoker.yeming.jiemie.database;
import java.sql.Connection;
import java.sql.SQLException;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.sql.DataSource;
import org.apache.log4j.Logger;
/**
 *@author 叶明 ---guming123416@gmail.com
 *@version $Id: v 1.01 2006/06/38 16:09:14 teodord Exp $
 */
public class Pubconn {
 
 /*
  * 创建私有变量conn为数据库连接对象中Connection
  * 创建私有变量dsye为数据库连接池的DataSource
  */
 
 private Connection conn;
 private DataSource dsye;
 private static Logger log=Logger.getLogger(Pubconn.class);
 /*
  * 创建构造函数Pubconn，在建立class中加载数据源的InitialContext
  */
 public Pubconn()
 {
  try{
   Context initCtx=new InitialContext();
   if(initCtx==null)
   {
    throw new Exception("不能加载文件Context");
   }
   dsye=(javax.sql.DataSource)initCtx.lookup("jdbc/yeming");
  }catch(Exception ex)
  {
   ex.printStackTrace();
   log.error("在加栽数据库连接池时间发生错误"+ex.getMessage());
  }
 }
 /*
  * 从连接池中取出一条连接变量
  *
  */
 public Connection getConn()
 {
  try{
   conn=dsye.getConnection();
  }catch(SQLException ex)
  {
   ex.printStackTrace();
   log.error("获得连接对象CONN时间发生错误"+ex.getMessage());
  }
  return conn;
 }
 /*
  * 关闭数据库连接，释放资源
  */
 public void closeConn(Connection conn)
 {
  try{
   if(conn!=null)
   {
    conn.close();
    conn=null;
   }
  }catch(SQLException ex)
  {
   ex.printStackTrace();
   log.error("关闭CONN时间发生错误"+ex.getMessage());
  }
 }

}

}
然后建立调用页面
代码如下：

<%@ page language="java" import="java.util.*,java.sql.*" pageEncoding="GBK" contentType="text/html charset=gbk"%>
<jsp:useBean id="yeconn" scope="page" class="com.javawoker.yeming.jiemie.database.Pubconn"></jsp:useBean>
<%
Connection conn=yeconn.getConn();
Statement stmt=conn.createStatement();
String sql="select * from combasicinfo";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next())
{
  out.println(rs.getInt(1));
  out.println(rs.getString(2));
}
rs.close();
stmt.close();
yeconn.closeConn(conn);
%>