BlogJava-The blog of Astro Qi-随笔分类-Javahttp://www.blogjava.net/AstroQi/category/32540.htmlI'm Astro Qi. If call me, please send email to closoastroqi@126.comzh-cnThu, 09 Jun 2011 10:01:28 GMTThu, 09 Jun 2011 10:01:28 GMT60对 java.nio.ByteBuffer 的理解http://www.blogjava.net/AstroQi/archive/2011/05/18/350457.htmlAstro.QiAstro.QiWed, 18 May 2011 02:53:00 GMThttp://www.blogjava.net/AstroQi/archive/2011/05/18/350457.htmlhttp://www.blogjava.net/AstroQi/comments/350457.htmlhttp://www.blogjava.net/AstroQi/archive/2011/05/18/350457.html#Feedback0http://www.blogjava.net/AstroQi/comments/commentRss/350457.htmlhttp://www.blogjava.net/AstroQi/services/trackbacks/350457.html

今晚用到 ByteBuffer, 我跟 joy 都是初学 java, 文档里的中文翻译实在是看他母亲不懂, 晕了半天, 作了几个测试, 终于把这个类的用法搞清楚了, 顺便臆想了哈其工作原理.

先列点代码片段:
// ...
//
// 此段代码功能为从 t.txt 里复制所有数据到 out_j.txt:
//
...
1　FileChannel fcin = new FileInputStream( "d:/t.txt" ).getChannel();
2　FileChannel fcout = new FileOutputStream( new File( "d:/out_j.txt" )).getChannel();
3　ByteBuffer buff = ByteBuffer.allocate( 1024 );
4　long t1 = System.currentTimeMillis();
5
6　while( fcin.read( buff ) != -1 )
7　{
8　　　buff.flip();
9　　　fcout.write( buff );
10　　　buff.clear();
11　}
12
13　long t2 = System.currentTimeMillis();
14　long size = fcin.size();
15　javax.swing.JOptionPane.showMessageDialog( null, size + " 字节, 耗时 " + ( t2 - t1 + 1 ) + " ms." );
...

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

SDK 文档里对 ByteBuffer 的说明为:

public abstract class ByteBuffer
extends Buffer
implements Comparable <ByteBuffer>

这说明 ByteBuffer 是继承于 Buffer 的抽象类, 实现了两个接口.

行3 通过 allocate() 分配了一块 1024 字节的缓冲区, 并返回一个 ByteBuffer 对象. (抽象类不能直接 new)
行6 fcin.read() 将数据读入到 buff. 此处的 read() 是 FileChannel 类的一个虚函数.
行8 buff.flip() 这个调用就是开头一直无法理解的部分.

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

SDK 文档里的对 flip() 的说明是:

public final Buffer flip()
反转此缓冲区。首先对当前位置设置限制，然后将该位置设置为零。如果已定义了标记，则丢弃该标记。
当将数据从一个地方传输到另一个地方时，经常将此方法与 compact 方法一起使用。

我最终的理解是: 文档翻译得太差了, 把不应该翻译的内容也译成了中文, 所以反而不容易理解.
关键就在以下 2 处:

当前位置: 这个可以直观地理解为缓冲区中的当前数据指针, 或是 SQL 中的游标, 记为 curPointer.
限制: 这个可以理解成实际操作的缓冲区段的结束标记, 记为 endPointer.
反转: 这个完全是对 flip 这个词不负责的翻译, 如果参照 DirectX 里的 flip() 而译为翻转/翻页, 那就好理解得多, 就像写信/看信, 写/看完一页后, 翻到下一页, 眼睛/笔从页底重新移回页首.
这个翻转背后的操作其实就是 "把 endPointer 定位到 curPointer 处, 并把 curPointer 设为 0".

关于标记, 在这里不涉及. 下一句说到常与 compact 方法一起使用, 是可以想像的, 因为 compact 方法对数据进
行了压缩, 有效数据的真实长度发生了变化, 肯定需要用 flip 重新定位结束标记.

在填充, 压缩等数据操作时, curPointer 估计都是自动更新了位置的, 总是指向最后一个有效数据, 所以每次调
用 flip() 后, endPointer 就指向了有效数据的结尾, 而 curPointer 指向了 0 (缓冲起始处).

举个图例:
(c 和 e 分别代表 curPointer 和 endPointer 两个指针)

* 先是一个空的 ByteBuffer (大小为 10 字节)
-------------------
-------------------
c
e


* 然后填充 5 字节数据
-------------------
0 1 2 3 4
-------------------
e           c
此时, endPointer 尚在 0 处, curPointer 移到了数据结尾.
经测试, 此时若取数据, 将得到 5 个字节, 内容通常为 0 (也有可能是未知), 因为实际上取到的是从 c 处到缓冲区实际结束处的 5 个未初始化的字节.

* 调用一次 flip() 后
-------------------
0 1 2 3 4
-------------------
c           e
此时, endPointer 先被移到 curPointer, 然后 curPointer 移到 0.
通过测试可见, ByteBuffer 取数据时, 是从 curPointer 起, 到 endPointer 止, 若 curPointer > endPointer, 则取到缓冲区结束.


再看上面代码的关键片段, 行 8 处调用 flip() 即有两个作用, 一是将 curPointer 移到 0, 二是将 endPointer 移到有效数据结尾.

此行可由以下两行代替:
buff.limit( buff.position());
buff.position( 0 );

可见对其工作原理的理解, 应该是正确的.

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

总结如下:
1. put 数据时, 不会自动清除缓冲区中现有的数据.
2. 每一次 get 或 put 后, curPointer 都将向缓冲区尾部移动, 移动量=操作的数据量.
3. get/put 均是从 curPointer 起, 到 curPointer + 操作的数据长度止.
4. get/put 操作中, 若 curPointer 超过了 endPointer 或缓冲区总长度, 将抛出 java.nio.BufferUnderflowException 异常.

注: curPointer 和 endPointer 只是为文中方便描述命名的, 实际分别对应到 ByteBuffer.position() 和 ByteBuffer.limit() 两个方法.

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

疑惑:
curPointer 是用 ByteBuffer.position() 取值, 用 ByteBuffer.position( int ) 赋值, 不知道 JDK 为什么要用多态来实现这两个功能, 按我的想法, 设计成 getPosition(), setPosition() 不是要好看好记得多啊.

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

跟 C++ 的简单比较:
C++ 里面没有类似 ByteBuffer 的现成实现, 实现上述类似的文件复制功能, 通常要自己创建管理缓冲区. C++ 里读写文件通常用 FileRead(), FileWrite() 函数, 在读/写的时候, 可以直接指定读/写的数据长度, 相比下显得
直观方便些, 但 JDK 这个 ByteBuffer 的方式, 确实更方便好用.

ByteBuffer 作为继承自 Buffer 的抽象类, 实现了对 Byte 型缓冲的管理, 同时 JDK 里还有对应其他数据类型的
继承自 Buffer 的抽象类, 分别实现对应类型的缓冲管理. 这种设计减少了编程时的工作. 如果在 C++ 中, 调用
读/写函数时, 还需要考虑传入数据的类型, 通常用传入 sizeof(数据类型) 的方式指定, 除了函数调用时增加耗
费外, 灵活性也更差些.

反过来再想, 为什么 C 要用这种方式? 个人认为, 这是 C 标准库的实现方式, 因为在不同 OS 平台上, 对文件和
设备的访问方法在系统层不一定相同, 同时硬件平台(主要是 CPU)上基本数据类型宽度也有可能不同, 标准库通过
sizeof 这个宏在编译时才能确定数据宽度, 所以标准 C 代码通常可以在不同平台上重新编译.

再想 C++ 为什么要用这种方式? 首先, C++ 里沿用 C 标准库的模式是可以理解的, 其次, 也许只是 C++ 标准库
里没有类似的设计, 说不定早就有第三方通过模板实现的了.

个人认为, ByteBuffer 在实现上, 可以算是一种数据结构, 在类设计上, 可以算是一种设计模式了.


Astro.Qi 2011-05-18 10:53 发表评论
]]>字符编码详解及由来(UNICODE,UTF-8,GBK)http://www.blogjava.net/AstroQi/archive/2010/11/18/338412.htmlAstro.QiAstro.QiThu, 18 Nov 2010 09:51:00 GMThttp://www.blogjava.net/AstroQi/archive/2010/11/18/338412.htmlhttp://www.blogjava.net/AstroQi/comments/338412.htmlhttp://www.blogjava.net/AstroQi/archive/2010/11/18/338412.html#Feedback0http://www.blogjava.net/AstroQi/comments/commentRss/338412.htmlhttp://www.blogjava.net/AstroQi/services/trackbacks/338412.html一直对字符的各种编码方式懵懵懂懂，什么ANSI、UNICODE、UTF-8、GB2312、GBK、DBCS、UCS……是不是看的很晕，假如您细细的阅读本文你一定可以清晰的理解他们。
          
    很久很久以前，有一群人，他们决定用8个可以开合的晶体管来组合成不同的状态，以表示世界上的万物。他们看到8个开关状态是好的，于是他们把这称为"字节"。

    再后来，他们又做了一些可以处理这些字节的机器，机器开动了，可以用字节来组合出很多状态，状态开始变来变去。他们看到这样是好的，于是它们就这机器称为"计算机"。
    开始计算机只在美国用。八位的字节一共可以组合出256(2的8次方)种不同的状态。 
    他们把其中的编号从0开始的32种状态分别规定了特殊的用途，一但终端、打印机遇上约定好的这些字节被传过来时，就要做一些约定的动作。遇上00x10, 终端就换行，遇上0x07, 终端就向人们嘟嘟叫，例如遇上0x1b, 打印机就打印反白的字，或者终端就用彩色显示字母。他们看到这样很好，于是就把这些0x20以下的字节状态称为"控制码"。 
    他们又把所有的空格、标点符号、数字、大小写字母分别用连续的字节状态表示，一直编到了第127号，这样计算机就可以用不同字节来存储英语的文字了。大家 看到这样，都感觉很好，于是大家都把这个方案叫做 ANSI 的"Ascii"编码（American Standard Code for Information Interchange，美国信息互换标准代码）。当时世界上所有的计算机都用同样的ASCII方案来保存英文文字。 
          
    后来，就像建造巴比伦塔一样，世界各地的都开始使用计算机，但是很多国家用的不是英文，他们的字母里有许多是ASCII里没有的，为了可以在计算机保存他 们的文字，他们决定采用127号之后的空位来表示这些新的字母、符号，还加入了很多画表格时需要用下到的横线、竖线、交叉等形状，一直把序号编到了最后一 个状态255。从128到255这一页的字符集被称"扩展字符集"。从此之后，贪婪的人类再没有新的状态可以用了，美帝国主义可能没有想到还有第三世界国 家的人们也希望可以用到计算机吧！

    等中国人们得到计算机时，已经没有可以利用的字节状态来表示汉字，况且有6000多个常用汉字需要保存呢。但是这难不倒智慧的中国人民，我们不客气地把那些127号之后的奇异符号们直接取消掉, 
    规定：一个小于127的字符的意义与原来相同，但两个大于127的字符连在一起时，就表示一个汉字，前面的一个字节（他称之为高字节）从0xA1用到 0xF7，后面一个字节（低字节）从0xA1到0xFE，这样我们就可以组合出大约7000多个简体汉字了。在这些编码里，我们还把数学符号、罗马希腊的 字母、日文的假名们都编进去了，连在 ASCII 里本来就有的数字、标点、字母都统统重新编了两个字节长的编码，这就是常说的"全角"字符，而原来在127号以下的那些就叫"半角"字符了。 
      中国人民看到这样很不错，于是就把这种汉字方案叫做 "GB2312"。GB2312 是对 ASCII 的中文扩展。 
      但是中国的汉字太多了，我们很快就就发现有许多人的人名没有办法在这里打出来，特别是某些很会麻烦别人的国家领导人。于是我们不得不继续把 GB2312 没有用到的码位找出来老实不客气地用上。 
      后来还是不够用，于是干脆不再要求低字节一定是127号之后的内码，只要第一个字节是大于127就固定表示这是一个汉字的开始，不管后面跟的是不是扩展字 符集里的内容。结果扩展之后的编码方案被称为 GBK 标准，GBK 包括了 GB2312 的所有内容，同时又增加了近20000个新的汉字（包括繁体字）和符号。 
      后来少数民族也要用电脑了，于是我们再扩展，又加了几千个新的少数民族的字，GBK 扩成了GB18030。从此之后，中华民族的文化就可以在计算机时代中传承了。 
      中国的程序员们看到这一系列汉字编码的标准是好的，于是通称他们叫做 "DBCS"（Double Byte Charecter Set 双字节字符集）。在DBCS系列标准里，最大的特点是两字节长的汉字字符和一字节长的英文字符并存于同一套编码方案里，因此他们写的程序为了支持中文处 理，必须要注意字串里的每一个字节的值，如果这个值是大于127的，那么就认为一个双字节字符集里的字符出现了。那时候凡是受过加持，会编程的计算机僧侣 们都要每天念下面这个咒语数百遍：

      "一个汉字算两个英文字符！一个汉字算两个英文字符……"
          
      因为当时各个国家都像中国这样搞出一套自己的编码标准，结果互相之间谁也不懂谁的编码，谁也不支持别人的编码，连大陆和台湾这样只相隔了150海里，使用 着同一种语言的兄弟地区，也分别采用了不同的 DBCS 编码方案——当时的中国人想让电脑显示汉字，就必须装上一个"汉字系统"，专门用来处理汉字的显示、输入的问题，但是那个台湾的愚昧封建人士写的算命程序 就必须加装另一套支持 BIG5  编码的什么"倚天汉字系统"才可以用，装错了字符系统，显示就会乱了套！这怎么办？而且世界民族之林中还有那些一时用不上电脑的穷苦人民，他们的文字又怎 么办？

      真是计算机的巴比伦塔命题啊！ 
      正在这时，大天使加百列及时出现了——一个叫 ISO（国际标谁化组织）的国际组织决定着手解决这个问题。他们采用的方法很简单：废了所有的地区性编码方案，重新搞一个包括了地球上所有文化、所有字母 和符号的编码！他们打算叫它"Universal Multiple-Octet Coded Character Set"，简称 UCS, 俗称 "UNICODE"。 
      UNICODE 开始制订时，计算机的存储器容量极大地发展了，空间再也不成为问题了。于是 ISO 就直接规定必须用两个字节，也就是16位来统一表示所有的字符，对于ascii里的那些“半角”字符，UNICODE 包持其原编码不变，只是将其长度由原来的8位扩展为16位，而其他文化和语言的字符则全部重新统一编码。由于"半角"英文符号只需要用到低8位，所以其高 8位永远是0，因此这种大气的方案在保存英文文本时会多浪费一倍的空间。

      这时候，从旧社会里走过来的程序员开始发现一个奇怪的现象：他们的strlen函数靠不住了，一个汉字不再是相当于两个字符了，而是一个！是的，从 UNICODE 开始，无论是半角的英文字母，还是全角的汉字，它们都是统一的"一个字符"！同时，也都是统一的"两个字节"，请注意"字符"和"字节"两个术语的不 同，“字节”是一个8位的物理存贮单元，而“字符”则是一个文化相关的符号。在UNICODE 中，一个字符就是两个字节。一个汉字算两个英文字符的时代已经快过去了。 
          
      从前多种字符集存在时，那些做多语言软件的公司遇上过很大麻烦，他们为了在不同的国家销售同一套软件，就不得不在区域化软件时也加持那个双字节字符集咒 语，不仅要处处小心不要搞错，还要把软件中的文字在不同的字符集中转来转去。UNICODE 对于他们来说是一个很好的一揽子解决方案，于是从 Windows NT 开始，MS 趁机把它们的操作系统改了一遍，把所有的核心代码都改成了用 UNICODE 方式工作的版本，从这时开始，WINDOWS 系统终于无需要加装各种本土语言系统，就可以显示全世界上所有文化的字符了。 
    但是，UNICODE 在制订时没有考虑与任何一种现有的编码方案保持兼容，这使得 GBK 与UNICODE 在汉字的内码编排上完全是不一样的，没有一种简单的算术方法可以把文本内容从UNICODE编码和另一种编码进行转换，这种转换必须通过查表来进行。 
    如前所述，UNICODE 是用两个字节来表示为一个字符，他总共可以组合出65535不同的字符，这大概已经可以覆盖世界上所有文化的符号。如果还不够也没有关系，ISO已经准备 了UCS-4方案，说简单了就是四个字节来表示一个字符，这样我们就可以组合出21亿个不同的字符出来（最高位有其他用途），这大概可以用到银河联邦成立 那一天吧！
    UNICODE 来到时，一起到来的还有计算机网络的兴起，UNICODE 如何在网络上传输也是一个必须考虑的问题，于是面向传输的众多 UTF（UCS Transfer Format）标准出现了，顾名思义，UTF8就是每次8个位传输数据，而UTF16就是每次16个位，只不过为了传输时的可靠性，从UNICODE到 UTF时并不是直接的对应，而是要过一些算法和规则来转换。

    受到过网络编程加持的计算机僧侣们都知道，在网络里传递信息时有一个很重要的问题，就是对于数据高低位的解读方式，一些计算机是采用低位先发送的方法，例 如我们PC机采用的 INTEL 架构，而另一些是采用高位先发送的方式，在网络中交换数据时，为了核对双方对于高低位的认识是否是一致的，采用了一种很简便的方法，就是在文本流的开始时 向对方发送一个标志符——如果之后的文本是高位在位，那就发送"FEFF"，反之，则发送"FFFE"。不信你可以用二进制方式打开一个UTF-X格式的 文件，看看开头两个字节是不是这两个字节？
    讲到这里，我们再顺便说说一个很著名的奇怪现象：当你在 windows 的记事本里新建一个文件，输入"联通"两个字之后，保存，关闭，然后再次打开，你会发现这两个字已经消失了，代之的是几个乱码！呵呵，有人说这就是联通之所以拼不过移动的原因。

    其实这是因为GB2312编码与UTF8编码产生了编码冲撞的原因。 
    从网上引来一段从UNICODE到UTF8的转换规则：
                             Unicode           UTF-8
         (0-127)          0000 - 007F     0xxxxxxx

         (128-2047)     0080 - 07FF     110xxxxx 10xxxxxx 

         (2048-65535)  0800 - FFFF     1110xxxx 10xxxxxx 10xxxxxx

    例如"汉"字的Unicode编码是6C49。6C49在0800-FFFF之间，所以要用3字节模板：1110xxxx 10xxxxxx 10xxxxxx。将6C49写成二进制是：0110 1100 0100 1001，将这个比特流按三字节模板的分段方法分为0110 110001 001001，依次代替模板中的x，得到：1110-0110 10-110001 10-001001，即E6 B1 89，这就是其UTF8的编码。 
    而当你新建一个文本文件时，记事本的编码默认是ANSI,如果你在ANSI的编码输入汉字，那么他实际就是GB系列的编码方式，在这种编码下，"联通"的内码是： 
            c1 1100 0001 
            aa 1010 1010 
            cd 1100 1101 
            a8 1010 1000 
          
    注意到了吗？第一二个字节、第三四个字节的起始部分的都是"110"和"10"，正好与UTF8规则里的两字节模板是一致的，于是再次打开记事本时，记事 本就误认为这是一个UTF8编码的文件，让我们把第一个字节的110和第二个字节的10去掉，我们就得到了"00001 101010"，再把各位对齐，补上前导的0，就得到了"0000 0000 0110 1010"，不好意思，这是UNICODE的006A，也就是小写的字母"j"，而之后的两字节用UTF8解码之后是0368，这个字符什么也不是。这就 是只有"联通"两个字的文件没有办法在记事本里正常显示的原因。

    而如果你在"联通"之后多输入几个字，其他的字的编码不见得又恰好是110和10开始的字节，这样再次打开时，记事本就不会坚持这是一个utf8编码的文件，而会用ANSI的方式解读之，这时乱码又不出现了。
          
    好了，终于可以回答NICO的问题了，在数据库里，有n前缀的字串类型就是UNICODE类型，这种类型中，固定用两个字节来表示一个字符，无论这个字符是汉字还是英文字母，或是别的什么。

    如果你要测试"abc汉字"这个串的长度，在没有n前缀的数据类型里，这个字串是7个字符的长度，因为一个汉字相当于两个字符。而在有n前缀的数据类型里，同样的测试串长度的函数将会告诉你是5个字符，因为一个汉字就是一个字符。



Astro.Qi 2010-11-18 17:51 发表评论
]]>SLF4J + logBackhttp://www.blogjava.net/AstroQi/archive/2010/11/17/338255.htmlAstro.QiAstro.QiWed, 17 Nov 2010 06:33:00 GMThttp://www.blogjava.net/AstroQi/archive/2010/11/17/338255.htmlhttp://www.blogjava.net/AstroQi/comments/338255.htmlhttp://www.blogjava.net/AstroQi/archive/2010/11/17/338255.html#Feedback0http://www.blogjava.net/AstroQi/comments/commentRss/338255.htmlhttp://www.blogjava.net/AstroQi/services/trackbacks/338255.html阅读全文

Astro.Qi 2010-11-17 14:33 发表评论
]]>byte[] to inthttp://www.blogjava.net/AstroQi/archive/2010/11/12/337898.htmlAstro.QiAstro.QiFri, 12 Nov 2010 04:09:00 GMThttp://www.blogjava.net/AstroQi/archive/2010/11/12/337898.htmlhttp://www.blogjava.net/AstroQi/comments/337898.htmlhttp://www.blogjava.net/AstroQi/archive/2010/11/12/337898.html#Feedback0http://www.blogjava.net/AstroQi/comments/commentRss/337898.htmlhttp://www.blogjava.net/AstroQi/services/trackbacks/337898.html
public class NumberBytesUtils {

public static void main(String[] args) {
byte[] bytes = new byte[4];
bytes[0] = (byte) 65;
bytes[1] = (byte) 0;
bytes[2] = (byte) 97;
bytes[3] = (byte) 0;
System.out.println("String: " + new String(bytes));
int iv = bytesToInt(bytes);
float fv = bytesToFloat(bytes);
byte[] bs = intToBytes(iv);
byte[] fs = floatToBytes(fv);
System.out.println("Int: " + iv);
System.out.println("Float: " + fv);
System.out.println("------------");
for (int i = 0; i < bs.length; i++) {
System.out.println(bs[i]);
}
System.out.println("============");
for (int i = 0; i < fs.length; i++) {
System.out.println(fs[i]);
}
System.out.println("============");
System.out.println(bytesToFloat(floatToBytes(-0.45367f)));
System.out.println("************");
// System.out.println(0xff);
// System.out.println(0xff00);
// System.out.println(0xff0000);
// System.out.println(0xff000000);
byte[] bytesL = new byte[8];
System.arraycopy(bytes, 0, bytesL, 0, bytes.length);
bytesL[4] = (byte) 0;
bytesL[5] = (byte) 0;
bytesL[6] = (byte) 0;
bytesL[7] = (byte) 0;
long lv = bytesToLong(bytesL);
double dv = bytesToDouble(bytesL);
byte[] bls = longToBytes(lv);
byte[] dls = doubleToBytes(dv);
System.out.println("Long: " + lv);
System.out.println("Double: " + dv);
System.out.println("----");
for (int i = 0; i < bls.length; i++) {
System.out.println(bls[i]);
}
System.out.println("----");
for (int i = 0; i < dls.length; i++) {
System.out.println(dls[i]);
}
System.out.println("****");
System.out.println(bytesToDouble(doubleToBytes(2.345)));
}
/**
* bytes[3] = value >> 24
* bytes[2] = value >> 16
* bytes[1] = value >>  8
* bytes[0] = value >>  0
* @param value
* @return
*/
public static byte[] intToBytes(int value){
int length = 4;
byte[] bytes = new byte[length];
for (int i = length - 1; i >= 0; i--) {
int offset = i * 8; // 24, 16, 8
bytes[i] = (byte) (value >> offset);
}
return bytes;
}
/**
* bytes[7] = value >> 56
* bytes[6] = value >> 48
* bytes[5] = value >> 40
* bytes[4] = value >> 32
* bytes[3] = value >> 24
* bytes[2] = value >> 16
* bytes[1] = value >>  8
* bytes[0] = value >>  0
* @param value
* @return
*/
public static byte[] longToBytes(long value){
int length = 8;
byte[] bytes = new byte[length];
for (int i = length - 1; i >= 0; i--) {
int offset = i * 8; //56, 48, 40, 32, 24, 16, 8
bytes[i] = (byte) (value >> offset);
}
return bytes;
}

/**
* 操作符 << 的优先级比 & 高
* intValue = (bytes[3] & 0xFF) << 24
       | (bytes[2] & 0xFF) << 16
       | (bytes[1] & 0xFF) <<  8
       | (bytes[0] & 0xFF) <<  0
* @param bytes
* @return
*/
public static int bytesToInt (byte[] bytes){
int length = 4;
int intValue = 0;
        for (int i = length - 1; i >= 0; i--) {
         int offset = i * 8; //24, 16, 8
         intValue |= (bytes[i] & 0xFF) << offset;
        }
       return intValue;
}
/**
* 操作符 << 的优先级比 & 高
* longValue = (long)(bytes[7] & 0xFF) << 56
        | (long)(bytes[6] & 0xFF) << 48
        | (long)(bytes[5] & 0xFF) << 40
        | (long)(bytes[4] & 0xFF) << 32
        | (long)(bytes[3] & 0xFF) << 24
        | (long)(bytes[2] & 0xFF) << 16
        | (long)(bytes[1] & 0xFF) <<  8
        | (long)(bytes[0] & 0xFF) <<  0
* @param bytes
* @return
*/
public static long bytesToLong (byte[] bytes){
int length = 8;
long longValue = 0;
        for (int i = length - 1; i >= 0; i--) {
         int offset = i * 8; //56, 48, 40, 32, 24, 16, 8
         longValue |= (long)(bytes[i] & 0xFF) << offset; //一定要先强制转换成long型再移位, 因为0xFF为int型
        }
       return longValue;
}
public static float bytesToFloat(byte[] bytes) {
return Float.intBitsToFloat(bytesToInt(bytes));
}
public static double bytesToDouble(byte[] bytes) {
return Double.longBitsToDouble(bytesToLong(bytes));
}
public static byte[] floatToBytes(float value){
return intToBytes(Float.floatToIntBits(value));
}

public static byte[] doubleToBytes(double value){
return longToBytes(Double.doubleToLongBits(value));
}
}
====================================================================================
/**
public static String bytes2HexString(byte[] b) { 
String ret = ""; 
for (int i = 0; i < b.length; i++) { 
String hex = Integer.toHexString(b[ i ] 0xFF); 
if (hex.length() == 1) {
  hex = '0' + hex; 
  } 
  ret += hex.toUpperCase(); 
  } 
  return ret; 
} 
 
 上面是将byte[]转化十六进制的字符串,注意这里b[ i ] & 0xFF将一个byte和 0xFF进行了与运算,
 然后使用Integer.toHexString取得了十六进制字符串,可以看出 b[ i ] & 0xFF运算后得出的仍然
 是个int,那么为何要和 0xFF进行与运算呢?
 直接 Integer.toHexString(b[ i ]);,将byte强转为int不行吗?答案是不行的. 
 其原因在于: 
 1.byte的大小为8bits而int的大小为32bits 
 2.java的二进制采用的是补码形式 
 
 在这里先温习下计算机基础理论 byte是一个字节保存的，有8个位，即8个0、1。 
 8位的第一个位是符号位， 也就是说
 0000 0001代表的是数字1 
 1000 0000代表的就是-1 
 所以
 正数最大为0111 1111，也就是数字127 
 负数最大为1111 1111，也就是数字-128 
 上面说的是二进制原码，
 但是在java中采用的是补码的形式，而不是原码，
 
 下面介绍下什么是补码 
 1、反码：一个数如果是正，则它的反码与原码相同； 一个数如果是负，则符号位为1，其余各位是对原码取反； 
 2、补码：利用溢出，我们可以将减法变成加法，
  对于十进制数，从9得到5可用减法： 9－4＝5。
  因为4+6＝10，我们可以将6作为4的补数，改写为加法： 9+6＝15（去掉高位1，也就是减10）得到5. 
  对于十六进制数，从c到5可用减法： c－7＝5。
  因为7+9＝16 将9作为7的补数，改写为加法： c+9＝15（去掉高位1，也就是减16）得到5. 
 
 在计算机中，如果我们用1个字节表示一个数，一个字节有8位，超过8位就进1，在内存中情况为（1 0000 0000），进位1被丢弃。
 所以补码是这样运算的：
  ⑴一个数为正，则它的原码、反码、补码相同
  ⑵一个数为负，高符号位为1，其余各位是对原码取反，然后整个数加1，(符号位不变，其余为取反再加1)
  -1的原码为 10000001 
  -1的反码为 11111110 再 + 1 
  -1的补码为 11111111 
  
  0的原码为  00000000 
  0的反码为  11111111 (正零和负零的反码相同) 再 + 1
  0的补码为 100000000（舍掉打头的1，正零和负零的补码相同） 
  
  Integer.toHexString的参数是int，如果不进行&0xff，那么当一个byte转换成int时，
  由于int是32位，而byte只有8位，这时会进行补位，补位补的是1
  例如：补码11111111的十进制数为-1，转换为int时变为11111111 11111111 11111111 11111111
  好多1啊，呵呵！即 0xff ff ff ff ，但是这个数是不对的，
  这种补位就会造成误差。和0xff相与后，高24bits就会被清0了，结果就对了。(任是补码11111111)
*/


Astro.Qi 2010-11-12 12:09 发表评论
]]>Java 中 byte与char、String互转原理http://www.blogjava.net/AstroQi/archive/2010/11/12/337897.htmlAstro.QiAstro.QiFri, 12 Nov 2010 04:08:00 GMThttp://www.blogjava.net/AstroQi/archive/2010/11/12/337897.htmlhttp://www.blogjava.net/AstroQi/comments/337897.htmlhttp://www.blogjava.net/AstroQi/archive/2010/11/12/337897.html#Feedback0http://www.blogjava.net/AstroQi/comments/commentRss/337897.htmlhttp://www.blogjava.net/AstroQi/services/trackbacks/337897.html阅读全文

Astro.Qi 2010-11-12 12:08 发表评论
]]>Java Stack栈和Heap堆的区别http://www.blogjava.net/AstroQi/archive/2009/01/20/252025.htmlAstro.QiAstro.QiTue, 20 Jan 2009 03:59:00 GMThttp://www.blogjava.net/AstroQi/archive/2009/01/20/252025.htmlhttp://www.blogjava.net/AstroQi/comments/252025.htmlhttp://www.blogjava.net/AstroQi/archive/2009/01/20/252025.html#Feedback0http://www.blogjava.net/AstroQi/comments/commentRss/252025.htmlhttp://www.blogjava.net/AstroQi/services/trackbacks/252025.html       堆存储： heapstorage    堆存储分配： heapstorage allocation  堆存储管理： heap storage management
        栈编址： stack addressing   栈变换：stack transformation  栈存储器：stack memory  栈单元： stack cell
 
          接着，总结在Java里面Heap和Stack分别存储数据的不同。
 
             Heap(堆)       Stack(栈)
 JVM中的功能      内存数据区                    内存指令区
 存储数据      对象实例(1)  基本数据类型, 指令代码,常量,对象的引用地址(2)
1. 保存对象实例，实际上是保存对象实例的属性值，属性的类型和对象本身的类型标记等，并不保存对象的方法（方法是指令，保存在stack中）。
  
   对象实例在heap中分配好以后，需要在stack中保存一个4字节的heap内存地址，用来定位该对象实例在heap中的位置，便于找到该对象实例。
 
2. 基本数据类型包括byte、int、char、long、float、double、boolean和short。
    函数方法属于指令.
 
 =======================       
  引用网上广泛流传的“Java堆和栈的区别”里面对堆和栈的介绍；
          "Java 的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、anewarray和multianewarray等指令建 立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分 配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。"
        “栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本 类型的变量（,int, short, long, byte, float, double, boolean, char）和对象句柄。 ”
   
         可见，垃圾回收GC是针对堆Heap的，而栈因为本身是FILO - first in, last out. 先进后出，能够自动释放。 这样就能明白到new创建的，都是放到堆Heap！


Astro.Qi 2009-01-20 11:59 发表评论
]]>Apache James 收发内外网邮件的配置http://www.blogjava.net/AstroQi/archive/2008/08/25/224181.htmlAstro.QiAstro.QiMon, 25 Aug 2008 07:35:00 GMThttp://www.blogjava.net/AstroQi/archive/2008/08/25/224181.htmlhttp://www.blogjava.net/AstroQi/comments/224181.htmlhttp://www.blogjava.net/AstroQi/archive/2008/08/25/224181.html#Feedback2http://www.blogjava.net/AstroQi/comments/commentRss/224181.htmlhttp://www.blogjava.net/AstroQi/services/trackbacks/224181.html阅读全文

Astro.Qi 2008-08-25 15:35 发表评论
]]>Web Services Xfirehttp://www.blogjava.net/AstroQi/archive/2008/07/18/215717.htmlAstro.QiAstro.QiFri, 18 Jul 2008 03:45:00 GMThttp://www.blogjava.net/AstroQi/archive/2008/07/18/215717.htmlhttp://www.blogjava.net/AstroQi/comments/215717.htmlhttp://www.blogjava.net/AstroQi/archive/2008/07/18/215717.html#Feedback0http://www.blogjava.net/AstroQi/comments/commentRss/215717.htmlhttp://www.blogjava.net/AstroQi/services/trackbacks/215717.html

Web Services ---- XFire

轻松将 POJO 发布成 Web 服务

 developerWorks
文档选项
将此页作为电子邮件发送

将此页作为电子邮件发送

未显示需要 JavaScript 的文档选项

样例代码

2007 年 5 月 16 日

Java 社区一直试图将 POJO 的作用发挥到极致，降低 Java 应用实现的难度，最近的尝试是将 EJB3.0 建立在 POJO 之上；另一方面，SOA 是目前 Java 社区炙手可热的名词，非常多的企业都在努力应用和实施 SOA；XFire 为这两方面的需求提供了一种魔术般的解决方式，我们很快能够发现使用 XFire 创建和发布 Web 服务可以直接基于 POJO，将烦人的继承关系和一大堆其他可能的约束丢在一边。

POJO、SOA 概述

被重新审视的 POJO

POJO（Plain Old Java Object，简单 Java 对象）是 Java 社区中最早的成员（回想您学习 Java 时第一个兴奋的时刻，那个简单的 "Hello World！" 例子），也是最简单、最容易实现的方式。

然而现实中 Java 的发展已经远远超越了 POJO 的范围，成为面向对象技术应用中最成功的编程语言，尤其是继承、多态的应用为我们造就了一大批开发框架（如 Struts）和标准（如 EJB），随之而来的就是实现的复杂化，我们必须面对一大堆继承关系的限制。比如说：要开发一个基于 Struts 的应用，我们必须了解 Struts 特定的继承关系如 ActionForm、ValidateActionForm；要开发一个 EJB 应用，我们必须继承 EJBObject、SessionEJB 等。

为了抛开这些限制，降低 Java 应用实现的难度，Java 社区开始重新审视 POJO 的价值，试图将 POJO 的作用发挥到极致，最新的努力是 EJB3.0。Java 社区将 EJB3.0 设计为基于 POJO，而不是为他准备更多的继承关系等限制。

让人爱恨交加的 SOA

SOA 已经成为了目前 Java 社区中炙手可热的名词，几乎所有的软件厂商都在讨论它，为他提供解决方案和产品支持，大部分的企业也已经在企业内部实施或者正在考虑实施 SOA。

然而 SOA 在企业内的实施却不是一项简单的任务，即使抛开新建系统直接基于 SOA 架构实施的因素，要把企业已有系统纳入 SOA 框架也不是一件容易的事情。企业必须在对当前架构深入了解的基础上，对已有系统进行大规模的改造才能满足新的要求。如何经济的从原有技术架构切换到 SOA 架构成为很多企业的难题。


回页首


XFire 概述

XFire 是 codeHaus 组织提供的一个开源框架，它构建了 POJO 和 SOA 之间的桥梁，主要特性就是支持将 POJO 通过非常简单的方式发布成 Web 服务，这种处理方式不仅充分发挥了 POJO 的作用，简化了 Java 应用转化为 Web 服务的步骤和过程，也直接降低了 SOA 的实现难度，为企业转向 SOA 架构提供了一种简单可行的方式。

XFire 目前最新的版本是 1.2.2，目前支持的特性主要包括：

  • 支持将 Web 服务绑定到 POJO、XMLBeans、JAXB1.1、JAXB2.0 和 Castor；
  • 支持基于 HTTP、JMS、XMPP 等多种协议访问 Web 服务；
  • 支持多种 Web 服务业界重要标准如 SOAP、WSDL、Web 服务寻址（WS-Addressing）、Web 服务安全（WS-Security）等；
  • 支持 JSR181，可以通过 JDK5 配置 Web 服务；
  • 高性能的 SOAP 实现；
  • 服务器端、客户端代码辅助生成；
  • 对 Spring、Pico、Plexus 等项目的支持等。




回页首


XFire 安装包

XFire 框架目前的最新版本是 1.2.6，可以访问 xfire.codehaus.org 下载 XFire 框架的安装包，下载时请选择“全部二进制发布包（Binary Distribution in zip package）”，而不仅仅是“XFire jar 文件（Jar of all XFire modules）”。

下载完成后，我们可以将下载的 .zip 文件解压缩到任意的文件夹中（后面的章节中使用 % XFIRE_HOME % 表示 XFire 框架的安装目录），解压缩后形成的文件目录结构如下：

  • api（目录）

    api 目录中是 XFire 框架中所有类（class）对应的 API 文档，为开发者使用 XFire 完成应用开发提供帮助。

  • examples（目录）

    examples 目录中包含了所有随 XFire 二进制包发布的实例，包括这些实例的源代码和相关 Web 应用配置内容。

  • lib（目录）

    lib 目录中包含 XFire 运行所需要的外部支持类包（.jar文件），可以根据不同项目所需的 XFire 特性选择所需要的支持类包。保守的方法是在 Web 项目中包含所有的外部支持类包（.jar文件）。

  • manual（目录）

    manual 目录中包含有 XFire 框架的帮助文档，开发者可以从这些帮助文档中学习更多运用 XFire 框架实现 SOA 的知识和技巧。

  • modules（目录）

    modules 目录中包含了 XFire 框架根据不同特性分别编译的二进制包文件。发布基于 XFire 框架的 Web 项目时，可以选择使用该目录下的所有 .jar 文件，也可以选择 XFire-all-1.2.6.jar 文件。

  • XFire-all-1.2.6.jar

    XFire 框架的二进制包文件，包含了全部的模块（modules）。

  • LICENSE.txt

    LICENSE.txt 文件中包含了 XFire 框架的授权协议。

  • NOTICE.txt
  • README.txt

    这两个文件中包含了 XFire 发布时的一些有用的信息。


回页首


XFire 框架支撑环境

XFire框架是一种基于Servlet技术的SOA应用开发框架，要正常运行基于XFire应用框架开发的企业应用，除了XFire框架本身之外，还需要JDK和Servlet容器的支持。

1．JDK 版本选择、下载和安装

XFire 支持非常多的特性，其中不同的特性对 JDK 版本的要求有所不同，比如如果项目中选择基于 JSR181 标准发布 Web 服务，我们就需要选择 JDK5 或者以上版本，如果仅仅选择将 Web 服务绑定到最简单的 POJO，我们只需要选择 JDK1.4 版本即可。

JDK 各版本均可以在 java.sun.com 网站上下载，如何安装 JDK 请参考 SUN 公司的相关技术文档和 JDK 的帮助文档。

2．Servlet 容器下载和安装

XFire 是一种基于 Servlet 技术的 SOA 应用开发框架，需要 Servlet 容器的支持。XFire 支持在多种 Servlet 容器中运行，包括 Websphere、Weblogic、TOMCAT 等。为了说明的简单，我们选择使用 TOMCAT（版本5.0.30）作为 XFire 的运行容器，所有配置过程和发布步骤的说明也均是针对 TOMCAT，如果读者使用 TOMCAT 之外的其它 Servlet 容器或者选择了 TOMCAT 的其它版本，下面的配置过程和步骤可能需要做出调整，请读者根据实际 Servlet 容器的帮助文档进行相应调整。

TOMCAT 各版本均可以在 tomcat.apache.org 网站上下载，如何正确安装 TOMCAT 服务器请参考 TOMCAT 服务器的帮助文档。

3．xalan

XFire 需要 xalan 项目的支持，然而 1.2.6 版本中并没有带有相应的 jar 文件，因此请访问 xml.apache.org，下载 xalan 项目的二进制包。


回页首


XFire 应用配置

前面的章节中我们下载和安装了 XFire 安装包和所需要的支持环境，现在我们开始学习如何从零开始创建 XFire 应用开发环境。下面的所有配置过程和发布步骤均针对 TOMCAT（版本5.0.30）服务器，如果选择其它的 Servlet 容器，下面的配置过程和步骤可能需要做出调整，请读者根据实际 Servlet 容器的帮助文档进行相应调整。

1、创建 Web 应用目录和基本元素

  1. 在 %TOMCAT_HOME%/webapps 目录下创建新的 Web 应用目录 “XFire”

    [注] 其中的 %TOMCAT_HOME% 指向 TOMCAT 的安装目录。

  2. 在 ”XFire”目录下创建 ”WEB-INF”目录、
  3. 在 ” WEB-INF”目录下创建 ”lib”目录和 ”classes”目录
  4. 在 ” WEB-INF”目录下创建 Web 应用描述文件 ”web.xml”， ”web.xml”文件的内容见 清单 1-1。

清单 1-1 WEB-INF\web.xml
                

                        1、	<?xml version="1.0" encoding="ISO-8859-1"?>

                        2、	<web-app xmlns="http://java.sun.com/xml/ns/j2ee"

                        3、	    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

                        4、	    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee   

                        http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"

                        5、	    version="2.4">

                        6、	

                        7、	    <display-name>XFire实例</display-name>

                        8、	    <description>

                        9、	         基于XFire框架发布Web服务的例子

                        10、	    </description>

                        11、	

                        12、	</web-app>

2、拷贝 XFire 所需的支持类包文件

拷贝 %XFIRE_HOME%/lib 目录下所有文件到 “1、创建 Web 应用目录和基本元素” 中所创建的 ”lib”目录下，将 %XFIRE_HOME%/XFire-all-1.2.6.jar 文件也拷贝到 “1、创建 Web 应用目录和基本元素” 中所创建的 ”lib”目录下。将 xalan 安装包中的所有 jar 文件和所需要的支持 jar 文件拷贝到相同的 ”lib”目录下。

[注] 为了减少拷贝的 jar 文件的数目，开发者可以根据项目的需要选择需要拷贝的 jar 文件，而不是全部拷贝，如何根据需要选择拷贝合适的类包文件请访问 XFire 站点。

3、配置 XFire 框架运行所需的 Servlet

修改 web.xml 文件，在其中增加如下 Servlet 定义内容。

1、	<servlet>

                        2、	    <servlet-name>XFireServlet</servlet-name>

                        3、	    <display-name>XFire Servlet</display-name>

                        4、	    <servlet-class>

                        5、	        org.codehaus.xfire.transport.http.XFireConfigurableServlet

                        6、	    </servlet-class>

                        7、	  </servlet>

                        8、	

                        9、	  <servlet-mapping>

                        10、	    <servlet-name>XFireServlet</servlet-name>

                        11、	    <url-pattern>/servlet/XFireServlet/*</url-pattern>

                        12、	  </servlet-mapping>

                        13、	

                        14、	  <servlet-mapping>

                        15、	    <servlet-name>XFireServlet</servlet-name>

                        16、	    <url-pattern>/services/*</url-pattern>

                        17、	</servlet-mapping>

4、创建 XFire 框架的服务发布文件 services.xml

  1. 在 “1、创建 Web 应用目录和基本元素” 中创建的 classes 目录下新建目录 ”META-INF\xfire”；
  2. 在步骤 a) 中新建的 ”xfire”文件目录下创建新文件 services.xml，文件的默认内容如 清单1-2 。

清单 1-2 WEB-INF\classes\META-INF\xfire\services.xml
                

                        1、	<beans xmlns="http://XFire.codehaus.org/config/1.0">

                        2、	</beans>





回页首


将 POJO 发布成 Web 服务

XFire 框架中，我们有两种方式将 POJO 发布成 Web 服务：

  • 一种方式是直接使用 Web 服务接口和 Web 服务实现类（POJO）来发布；
  • 另一种方式是基于 JSR181 标准和注释技术将被注释的 POJO 发布成 Web 服务；

下面的章节中我们将学习使用第一种方式来完成 POJO 的 Web 服务发布。我们将使用经典的 ”Hello World!”例子来演示将 POJO 发布成 Web 服务所需要的步骤，不过我们不再是简单的访问一个 Java 方法来输出 ”Hello World!”字符串，而是转为在 SOA 环境下实现：Web 服务客户端通过访问服务器端发布成 Web 服务的 POJO 获得返回的 ”Hello World!”字符串后输出到客户端的控制台上。

将 POJO 发布成 Web 服务的基本步骤如下：

  1. 创建 Web 服务接口，声明该 Web 服务对外暴露的接口；
  2. 创建 Web 服务实现类，为 Web 服务接口提供实现；
  3. 修改 XFire 框架的服务发布文件 ---- services.xml，将 POJO 发布成 Web 服务。

下面我们通过创建 ”Hello World!”例子来具体说明如何实现这三个步骤。

1．创建 Web 服务接口 ---- HelloWorldService

要将 POJO 发布成 Web 服务，首先需要创建 Web 服务接口，在接口中声明该 Web 服务需要对外暴露的接口。

我们根据需要创建 Web 服务接口 ” HelloWorldService”，在其中声明一个 ”sayHello”方法，该方法返回 ”String ”类型的内容。” HelloWorldService”接口对应的 Java 文件代码如 清单 1-3。


清单 1-3 WEB-INF\classes\org\vivianj\xfire\pojo\HelloWorldService.java
                

                        1．package org.vivianj.xfire.pojo;

                        2．

                        3． /**

                        4． * HelloWorldService 中声明需要发布成 Web 服务的所有 Java 方法 

                        5． * HelloWorldService 作为Web服务接口

                        6． */

                        7． public interface HelloWorldService {

                        8．	/**

                        9．	     * sayHello 方法声明了 Web 服务对外暴露的接口

                        10．	 * 

                        11．	 * @return 返回给客户端的字符串

                        12．	 */

                        13．	public String sayHello();

                        14．}

2．创建 Web 服务实现类 ”HelloWorldServiceImpl”

创建 Web 服务实现类 ”HelloWorldServiceImpl”，它继承 ”1、创建Web服务接口 ---- HelloWorldService” 中创建的 HelloWorldService 接口，并且为它声明的 ”sayHello”方法提供具体实现： 返回字符串”Hello World!”。 ”HelloWorldServiceImpl”类对应的 Java 文件代码如 清单 1-4。


清单 1-4 WEB-INF\classes\org\vivianj\xfire\pojo\HelloWorldServiceImpl.java
                

                        1．package org.vivianj.xfire.pojo;

                        2．

                        3．/**

                        4． * HelloWorldServiceImpl 中为 Web 服务接口中声明的所有 Java 方法提供具体实现 

                        5． * HelloWorldServiceImpl 作为 Web 服务的实现类

                        6． */

                        7．public class HelloWorldServiceImpl implements HelloWorldService {

                        8．

                        9．	/*

                        10．	 * sayHello 方法为 HelloWorldService 服务接口定义的 sayHello 方法提供具体实现

                        11．	 *  

                        12．	 * @see org.vivianj.XFire.pojo.HelloWorldService#sayHelloToXFire()

                        13．	 */

                        14．	public String sayHello() {

                        15．		return "Hello World!";

                        16．	}

                        17．

                        18．}

3．修改 services.xml，将 POJO 发布成 Web 服务

我们可以在 WEB-INF\classes\META-INF\XFire\services.xml 文件中的 <beans …> 和 </beans> 元素中间加入如下的 xml 内容将上面创建的 HelloWorldService 发布成 Web 服务。

1．<service>

                        2．	<name>HelloWorldService</name>

                        3．	<namespace>http://vivianj.org/HelloWorldService</namespace>

                        4．	<serviceClass>

                        5．		org.vivianj.xfire.pojo.HelloWorldService

                        6．	</serviceClass>

                        7．	<implementationClass>

                        8．		org.vivianj.xfire.pojo.HelloWorldServiceImpl

                        9．	</implementationClass>

                        10．</service>

其中各元素的功能如下：

  • service

    service 标签和它所包含的 xml 内容为发布成 Web 服务的 POJO 提供完整的描述。

  • name

    Web 服务被发布时所采用的唯一名称。

  • namespace

    Web 服务发布时所使用的命名空间。

  • serviceClass

    Web 服务接口类的全名，包括包名和类名。

  • implemetationClass

    Web 服务实现类的全名，包括包名和类名。

更多 service 元素的子元素和它们的用法请参考 XFire 站点。

通过上面的三个步骤，我们已经将新创建的HelloWorldService发布成了Web服务，我们可以使用下面的步骤测试一下创建的Web服务是否能够正常运行：

  1. 编译上面的步骤中创建的 Java 接口和类；
  2. 启动 TOMCAT 服务器。
  3. 等 TOMCAT 服务器完全启动后，打开浏览器，在地址栏中输入 http://localhost:8080/XFire/services/HelloWorldService?wsdl。

其中 HelloWorldServcie 是配置文件中 service\name 元素所定义的内容，”wsdl”参数表示查看该 Web 服务的 WSDL（Web服务描述语言）文件。

如果浏览器中出现如下图所示类似的内容，表示 Web 服务发布成功，我们可以编写客户端访问该 Web 服务从服务器获取返回字符串，本文下载资源中提供的下载文件中包含有可供参考的客户端类 org.vivianj.xfire.pojo.client.HelloWorldServiceClient。


图：浏览器中访问效果

如果浏览器中出现错误提示，请按照上面的步骤和说明检查已经完成的开发、配置过程是否完全正确。


回页首


结束语

本文中作者首先讲解了 XFire 框架的主要特性，XFire 框架的运行环境以及基于 XFire 框架开发 SOA 应用的基本步骤，并且借助于 SOA 环境下的 ”Hello World!”例子，详细的讲解和演示了如何基于 XFire 框架、经过简单的开发、配置步骤就将一个 POJO 类中包含的方法发布成Web服务。从 ”Hello World!”例子实现的过程中，我们可以发现 XFire 框架最大化的发挥了 POJO 的作用，减少了 SOA 实施时对框架本身的依赖，降低了 SOA 实施的难度，企业实施 SOA 时并不需要增加太多的投入就可以实现目标。


回页首


下载

名字 大小 下载方法
xfire.war 6 KB HTTP
关于下载方法的信息


参考资料

学习

获得产品和技术


Astro.Qi 2008-07-18 11:45 发表评论
]]>JDBC ORACLE CLOB (用分页思想解决兆级以上的字符流操作问题)http://www.blogjava.net/AstroQi/archive/2008/07/10/214025.htmlAstro.QiAstro.QiThu, 10 Jul 2008 09:05:00 GMThttp://www.blogjava.net/AstroQi/archive/2008/07/10/214025.htmlhttp://www.blogjava.net/AstroQi/comments/214025.htmlhttp://www.blogjava.net/AstroQi/archive/2008/07/10/214025.html#Feedback1http://www.blogjava.net/AstroQi/comments/commentRss/214025.htmlhttp://www.blogjava.net/AstroQi/services/trackbacks/214025.html import java.io.*;
import java.util.*;
import java.sql.*;
 
public class ClobTest {
 
    private static final String DRIVER = "oracle.jdbc.driver.OracleDriver";
    private static final String URL = "jdbc:oracle:thin:@127.0.0.1:1521:ora10g";
    private static final String USER = "sc";
    private static final String PASSWORD = "sc";
    private static Connection conn = null;
    private static Statement stmt = null;

 
    /**
     * 往数据库中插入一个新的CLOB对象
     */
    public static void save(BO obj) throws Exception {
        /* 一定要设定不自动提交，否则抛出ORA-01002: 读取违反顺序 */
        boolean defaultCommit = conn.getAutoCommit();
        conn.setAutoCommit(false);
 
        try {
            stmt = conn.createStatement();
            /* 插入一个空的CLOB对象 */
            stmt.executeUpdate("INSERT INTO TEST_CLOB VALUES ('1000', EMPTY_CLOB())");//一定要使用Oracle中的EMPTY_CLOB()函数
           
            stmt.close();//记得关掉我哦 :-)
            stmt= null;

            /* 查询此CLOB对象并锁定 */
            //stmt = conn.prepareStatement();//如果是PrepareStatement接口,一定要重新创建该对象,否则抛出ORA-01006: 赋值变量不存在
           
            ResultSet rs = stmt.executeQuery("SELECT CLOBCOL FROM TEST_CLOB WHERE ID='1000' FOR UPDATE");//一定要for update锁定该记录，否则抛出ORA-22920: 未锁定含有 LOB 值的行
            while (rs.next()) {
                /* 取出此CLOB对象 */
                oracle.sql.CLOB clob = (oracle.sql.CLOB)rs.getClob("CLOBCOL");

                /* 向CLOB对象中写入数据 */
                Writer out = clob.getCharacterOutputStream();
                //out.write(new String(obj.getEmail()));//obj.getEmail()返回byte[]类型,但是当obj.getEmail()绝对大时,执行new String(byte[])时,JVM会抛出内存溢出异常

                byte[] emails = obj.getEmail();
                ClobStreamHandler csh = new ClobStreamHandler(emails);
                String[] arrx = csh.pagedClobStream();//要解决内存溢出异常，必须把绝对大的byte[]进行分页
                if (arrx != null){
                    for (int i = 0; i < arrx.length; i++) {
                        out.write(arrx[i]);
                        out.flush();//要解决内存溢出异常,必须一页一页的flush()到数据库
                    }
                }
                else out.write("");
                out.close();
            }
            /* 正式提交 */
            conn.commit();

            /* 恢复原提交状态 */
            conn.setAutoCommit(defaultCommit);
        } catch (Exception ex) {
            /* 出错回滚 */
            conn.rollback();
            throw ex;
        } finally {相关关闭操作}
 
      
    }
 
    /**
     * 修改CLOB对象（是在原CLOB对象基础上进行覆盖式的修改）
     *
     * @param obj - 数据对象
     * @throws java.lang.Exception
     * @roseuid 3EDA04B60367
     */
    public static void modify(BO obj) throws Exception {
        /* 设定不自动提交 */
        boolean defaultCommit = conn.getAutoCommit();
        conn.setAutoCommit(false);
 
        try {
            /* 查询CLOB对象并锁定 */
            ResultSet rs = stmt.executeQuery("SELECT CLOBCOL FROM TEST_CLOB WHERE ID='1000' FOR UPDATE");
            while (rs.next()) {
                /* 获取此CLOB对象 */
                oracle.sql.CLOB clob = (oracle.sql.CLOB)rs.getClob("CLOBCOL");  
                
                /* 进行覆盖式修改 */
                Writer out = clob.getCharacterOutputStream();
                byte[] emails = obj.getEmail();
                ClobStreamHandler csh = new ClobStreamHandler(emails);
                String[] arrx = csh.pagedClobStream();//要解决内存溢出异常，必须把绝对大的byte[]进行分页
                if (arrx != null){
                    for (int i = 0; i < arrx.length; i++) {
                        out.write(arrx[i]);
                        out.flush();//要解决内存溢出异常,必须一页一页的flush()到数据库
                    }
                }
                else out.write("");
                out.close();
            }
            /* 正式提交 */
            conn.commit();

            /* 恢复原提交状态 */
            conn.setAutoCommit(defaultCommit);
        } catch (Exception ex) {
            /* 出错回滚 */
            conn.rollback();
            throw ex;
        } finally {相关关闭操作}
 
        /* 恢复原提交状态 */
        conn.setAutoCommit(defaultCommit);
    }
 
    /**
     * 替换CLOB对象（将原CLOB对象清除，换成一个全新的CLOB对象）
     *
     * @param obj - 数据对象
     * @throws java.lang.Exception
     * @roseuid 3EDA04BF01E1
     */
    public static void replace(BO obj) throws Exception {
        /* 设定不自动提交 */
        boolean defaultCommit = conn.getAutoCommit();
        conn.setAutoCommit(false);
 
        try {
            /* 清空原CLOB对象 */
            stmt.executeUpdate("UPDATE TEST_CLOB SET CLOBCOL=EMPTY_CLOB() WHERE ID='1000'");
            
            /* 查询CLOB对象并锁定 */
            ResultSet rs = stmt.executeQuery("SELECT CLOBCOL FROM TEST_CLOB WHERE ID='1000' FOR UPDATE");
            
            while (rs.next()) {
                /* 获取此CLOB对象 */
                oracle.sql.CLOB clob = (oracle.sql.CLOB)rs.getClob("CLOBCOL");
                /* 更新数据 */
                Writer out = clob.getCharacterOutputStream();
                byte[] emails = item.getEmail();
                ClobStreamHandler csh = new ClobStreamHandler(emails);
                String[] arrx = csh.pagedClobStream();//要解决内存溢出异常，必须把绝对大的byte[]进行分页
                if (arrx != null){
                    for (int i = 0; i < arrx.length; i++) {
                        out.write(arrx[i]);
                        out.flush();//要解决内存溢出异常,必须一页一页的flush()到数据库
                    }
                }
                else out.write("");
                out.close();
            }
            /* 正式提交 */
            conn.commit();

            /* 恢复原提交状态 */
            conn.setAutoCommit(defaultCommit);
        } catch (Exception ex) {
            /* 出错回滚 */
            conn.rollback();
            throw ex;
        } finally {相关关闭操作}
 
       
    }
 
    /**
     * 读取CLOB对象
     */
    public static byte[] read() throws Exception {
        /* 设定不自动提交 */
        boolean defaultCommit = conn.getAutoCommit();
        conn.setAutoCommit(false);
 
        try {
            /* 查询CLOB对象 */
            ResultSet rs = stmt.executeQuery("SELECT * FROM TEST_CLOB WHERE ID='1000'");
            while (rs.next()) {
                /* 获取CLOB对象 */
                oracle.sql.CLOB c= (oracle.sql.CLOB)rs.getClob("CLOBCOL");
               
                if (c != null){
                     try {
                          oracle.jdbc.driver.OracleClobInputStream is = (OracleClobInputStream) c.getAsciiStream();
                          java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream();
                   
                          byte[] by = new byte[1024 * 200];
                          while(is.read(by, 0, by.length) != -1){
                              baos.write(by, 0, by.length);
                              baos.flush();//把数据写入内存
                          }
                   
                          baos.close();
                          is.close();
                          return baos.toByteArray();//不会内存溢出了,呵呵. 原因是把数据写入了内存,而不是JVM的内存管理区域
                     } catch (SQLException e) {
                           //e.printStackTrace();
                     }
                }
                else return new byte[0];
                break;
            }
        } catch (Exception ex) {
            conn.rollback();
            throw ex;
        } finally {相关关闭操作}
 
        /* 恢复原提交状态 */
        conn.setAutoCommit(defaultCommit);
    }
 
    /**
     * 建立测试用表格
     * @throws Exception
     */
    public static void createTables() throws Exception {
        try {
            stmt.executeUpdate("CREATE TABLE TEST_CLOB (ID VARCHAR2(4), CLOBCOL CLOB)");
            stmt.executeUpdate("CREATE TABLE TEST_BLOB (ID VARCHAR2(4), BLOBCOL BLOB)");
        } catch (Exception ex) {
 
        }
    }
 
    public static void main(String[] args) throws Exception {
        /* 装载驱动,建立数据库连接 */
        Class.forName(DRIVER);
        conn = DriverManager.getConnection(URL, USER, PASSWORD);
        stmt = conn.createStatement();
 
        /* 建立测试表格 */
        createTables();
    }
}


    对Clob字符流进行分页的算法：
   
 1 package privy.astroqi.oracle.db.handler;
 2 
 3 /**
 4  * 
 5  * @author Astro Qi
 6  * @since  2008-07-23 00:05
 7  *
 8  */
 9 public class ClobStreamHandler {
10 
11     private static int PAGE_SIZE = 1024 * 200 * 1;
12     
13     private byte[] dataes;
14     
15     private int length;
16     
17     private int pageCount;
18     
19     public ClobStreamHandler(byte[] data){
20         if (data == null){
21             throw new java.lang.IllegalArgumentException("参数byte[]不能为空,否则无法处理接下来的操作.");
22         }
23         
24         dataes = data;
25         length = dataes.length;
26         pageCount = (length % PAGE_SIZE == 0) ? (length / PAGE_SIZE) : (length / PAGE_SIZE) + 1;
27         
28     }
29     
30     public String[] pagedClobStream(){
31         
32         String[] arr = new String[pageCount];
33         
34         for (int i = 1; i <= pageCount; i++) {
35             int sheYuByte = length - (PAGE_SIZE * (i - 1));
36             byte[] b = null;
37             if (sheYuByte > PAGE_SIZE){
38                 b = new byte[PAGE_SIZE];
39             } 
40             else {
41                 b = new byte[sheYuByte];
42             }
43             for (int j = 0; j < b.length; j++){
44                 b[j] = dataes[(i - 1) * PAGE_SIZE + j];
45             }
46             arr[i - 1] = new String(b);
47         }
48         
49         return arr;
50     }
51 }


Astro.Qi 2008-07-10 17:05 发表评论
]]>JavaMail API 简介http://www.blogjava.net/AstroQi/archive/2008/07/01/211873.htmlAstro.QiAstro.QiTue, 01 Jul 2008 05:42:00 GMThttp://www.blogjava.net/AstroQi/archive/2008/07/01/211873.htmlhttp://www.blogjava.net/AstroQi/comments/211873.htmlhttp://www.blogjava.net/AstroQi/archive/2008/07/01/211873.html#Feedback1http://www.blogjava.net/AstroQi/comments/commentRss/211873.htmlhttp://www.blogjava.net/AstroQi/services/trackbacks/211873.html1.介绍:

Java Mail API的开发是SUN为Java开发者提供公用API框架的持续努力的良好例证。提倡公用框架，反对受限于供应商的解决方案，充分预示着一个日益开放的开发环境的建立。
Java Mail API的结构本身证明了它的开发者的基本目标之一--软件开发的工作量应该取决于应用程序本身的复杂程度以及开发者所要求的控制程度。换句话说，Java Mail API尽可能地保持简单。乍看起来，JavaMail API所拥有的类总数以及类之间的关系可能让人误解为要花费漫长的学习时间。实际上，一旦正式开始使用，你就会发现该API不失为在应用程序中加入健壮的邮件/通讯支持的简单工具。

在我们步入JavaMail API之前，先看一下API所涉及的协议。以下便是大家日常所知、所乐于使用的4大信息传输协议：SMTP POP IMAP MIME NNTP。
当然，上面的4个协议，并不是全部，还有NNTP和其它一些协议可用于传输信息，但是由于不常用到，所以本文便不提及了。理解这4个基本的协议有助于我们更好的使用JavaMail API。然而JavaMail API是被设计为与协议无关的，目前我们并不能克服这些协议的束缚。确切的说，如果我们使用的功能并不被我们选择的协议支持，那么JavaMail API并不可能如魔术师一样神奇的赋予我们这种能力。

1．SMTP
简单邮件传输协议定义了递送邮件的机制。在下文中，我们将使用基于Java-Mail的程序与公司或者ISP的SMTP服务器进行通讯。这个SMTP服务器将邮件转发到接收者的SMTP服务器，直至最后被接收者通过POP或者IMAP协议获取。这并不需要SMTP服务器使用支持授权的邮件转发，但是却的确要注意SMTP服务器的正确设置（SMTP服务器的设置与JavaMail API无关）。

2．POP
POP 是一种邮局协议，目前为第3个版本，即众所周知的POP3。POP定义了一种用户如何获得邮件的机制。它规定了每个用户使用一个单独的邮箱。大多数人在使用POP时所熟悉的功能并非都被支持，例如查看邮箱中的新邮件数量。而这个功能是微软的Outlook内建的，那么就说明微软Outlook之类的邮件客户端软件是通过查询最近收到的邮件来计算新邮件的数量来实现前面所说的功能。因此在我们使用JavaMail API时需要注意，当需要获得如前面所讲的新邮件数量之类的信息时，我们不得不自己进行计算。

3．IMAP
IMAP 使用在接收信息的高级协议，目前版本为第4版，所以也被称为IMAP4。需要注意的是在使用IMAP时，邮件服务器必须支持该协议。从这个方面讲，我们并不能完全使用IMAP来替代POP，不能期待IMAP在任何地方都被支持。假如邮件服务器支持IMAP，那么我们的邮件程序将能够具有以下被IMAP所支持的特性：每个用户在服务器上可具有多个目录，这些目录能在多个用户之间共享。
其与POP相比高级之处显而易见，但是在尝试采取IMAP时，我们认识到它并不是十分完美的：由于IMAP需要从其它服务器上接收新信息，将这些信息递送给用户，维护每个用户的多个目录，这都为邮件服务器带来了高负载。并且IMAP与POP的一个不同之处是POP用户在接收邮件时将从邮件服务器上下载邮件，而IMAP允许用户直接访问邮件目录，所以在邮件服务器进行备份作业时，由于每个长期使用此邮件系统的用户所用的邮件目录会占有很大的空间，这将直接导致邮件服务器上磁盘空间暴涨。

4．MIME
MIME 并不是用于传送邮件的协议，它作为多用途邮件的扩展定义了邮件内容的格式：信息格式、附件格式等等。一些RFC标准都涉及了MIME：RFC 822, RFC 2045, RFC 2046, RFC 2047，有兴趣的Matrixer可以阅读一下。而作为JavaMail API的开发者，我们并不需关心这些格式定义，但是这些格式被用在了程序中。

5．NNTP和其它的第三方协议
正因为JavaMail API在设计时考虑到与第三方协议实现提供商之间的分离，故我们可以很容易的添加一些第三方协议。SUN维护着一个第三方协议实现提供商的列表：http://java.sun.com/products/javamail/Third_Party.html，通过此列表我们可以找到所需要的而又不被SUN提供支持的第三方协议：比如NNTP这个新闻组协议和S/MIME这个安全的MIME协议。


2.安装:

安装前要确保你的机子上安装得有标准版的JDK和Web服务器,并且已配置好,有关它们的安装方法,请参考其它文章(网上到处都有).

(1).安装JavaMail API。现在最常用的 JavaMail API 版本是1.3.
要使用 JavaMail 1.3 API，请下载 JavaMail 1.3 实现，解开Javamail-1_3.zip 文件，并将 mail.jar 文件添加到 CLASSPATH 中。除了核心类，随版本 1.3 实现一起提供的还有 SMTP、IMAP4 和 POP3 供应商。

(2).JavaBeans Activation Framework(1.0.2版) 的安装
JavaMail API 的所有版本都需要 JavaBeans Activation Framework 来支持任意数据块的输入及相应处理。功能似乎不多，但目前许多浏览器和邮件工具中都能找到这种基本的 MIME 型支持。下载完框架后，解开 jaf1_0_2.zip 文件，并将 activation.jar 文件添加到 CLASSPATH 中。

注: 如果您使用的JDK是J2EE，就没有什么特定的事非要用基本 JavaMail API来做不可；J2EE 的类就能处理了,因为它本身就包含有JavaMail API和JAF,您只需要确将 j2ee.jar 文件添加到您的CLASSPATH 中并已全部设置好。


3.JavaMail的常用类介绍

(1) javax.mail.Properties类
JavaMail需要Properties来创建一个session对象。它将寻找字符串"mail.smtp.host"，属性值就是发送邮件的主机.

用法:
Properties props = new Properties ();
props.put("mail.smtp.host", "smtp.163.com");//可以换上你的smtp主机名。


(2) javax.mail.Session类
这个Session类代表JavaMail 中的一个邮件session. 每一个基于 JavaMail的应用程序至少有一个session但是可以有任意多的session。 在这个例子中, Session对象需要知道用来处理邮件的SMTP 服务器。

用法:
Session sendMailSession;
sendMailSession = Session.getInstance(props, null);


(3) javax.mail.Transport类
邮件是既可以被发送也可以被受到。JavaMail使用了两个不同的类来完成这两个功能：Transport 和Store. Transport 是用来发送信息的，而Store用来收信。对于这的教程我们只需要用到Transport对象。

用法：
Transport transport;
transport = sendMailSession.getTransport("smtp");

用JavaMail Session对象的getTransport 方法来初始化Transport。传过去的字符串申明了对象所要使用的协议，如"smtp"。这将为我们省了很多时间。因为JavaMail以境内置了很多协议的实现方法。

注意: JavaMail并不是绝对支持每一个协议，目前支持IMAP、 SMTP和 POP3.


(4) javax.mail.MimeMessage类
Message对象将存储我们实际发送的电子邮件信息，Message对象被作为一个MimeMessage对象来创建并且需要知道应当选择哪一个JavaMail session。

用法：
Message newMessage = new MimeMessage(sendMailSession);


(5) javax.mail.InternetAddress类
一旦您创建了 Session 和 Message，并将内容填入消息后，就可以用Address确定信件地址了。和 Message 一样，Address 也是个抽象类。您用的是Javax.mail.internet.InternetAddress 类.

用法:
InternetAddress from=new InternetAddress("xxf@cafe.com");


(6) javax.mail.Store类
Store类实现特定邮件协议上的读、写、监视、查找等操作。通过Javax.mail.Store类可以访问Javax.mail.Folder类。

用法:
Store store=session.getSorte("pop3");//session为一个邮件会话
store.connect(pop3server,username,password);//通过你提供的pop3地址,用户名和密码登录你的邮箱


(7) javax.mail.Folder类
Folder类用于分级组织邮件，并提供照Javax.mail.Message格式访问email的能力。

用法:
Folder folder=store.getFolder("INBOX");
folder.open(Folder.READ_ONLY);


(8) javax.mail.Internet.MimeMultpart
一般保存电子邮件内容的容器是Multipart抽象类,它定义了增加和删除及获得电子邮件不同部分内容的方法.由于Multipart是抽象类,我们必须为它使用一个具体的子类,JavaMail API提供javax.mail.Internet.MimeMultpart类来使用MimeMessage对象.

用法:
MimeMultipart multipart=new MimeMultipart();

注:我们使用MimeMultipart对象的一个方法是addBodyPart(),它在我们的电子邮件内容里添加BodyPart(BodyPart类在下面紧接着要介绍)对象.消息可以有很多部分,一个BodyPart可以代表一个部分.


(9) javax.mail.Internet.MimeBodyPart类

MimeBodyPart是BodyPart具体用于mimeMessage的一个子类.
MimeBodyPart对象代表一个MimeMessage对象内容的一部分.每个MimeBodyPart被认为有两部分:
⊙一个MIME类型
⊙匹配这个类型的内容

用法:
MimeBodyPart mdp=new MimeBodyPart();
String text="Hello JavaMail!";
mdp.setContent(text,"text/plain");//定义MIME类型为text/plain,并设置MimeBodyPart的内容.


(10) javax.activation.DataHandler类(包含在JAF中)
JavaMail API不限制信息只为文本,任何形式的信息都可能作茧自缚MimeMessage的一部分.除了文本信息,作为文件附件包含在电子邮件信息的一部分是很普遍的.JavaMail API通过使用DataHandler对象,提供一个允许我们包含非文本BodyPart对象的简便方法.

用法:
DataHandler dh=new DataHandler(text,type);
mdp.setDatahandler(dh);//mdp是一个MimeBodyPart对象


(11) javax.activation.FileDataSource类(包含在JAF中)
一个FileDataSource对象可以表示本地文件和服务器可以直接访问的资源.一个本地文件可以通过创建一个新的MimeBodyPart对象附在一个mimeMessage对象上.

用法:
MimeMultipart mm=new MimeMultipart();
MimeBodyPart mdp=new MimeBodyPart();
FileDataSource fds=new FileDataSource("c:/exam.txt");
mdp.setDataHandler(new DataHandler(fds)); //设置数据源
mm.addBodyPart(mdp); //为当前消息MimeMultipart对象增加MimeBodyPart


(12) javax.activation.URLDataSource类(包含在JAF中)
远程资源,URL不会指向它们,由一个URLDataSource对象表示.一个远程资源可以通过创建一个新mimeBodyPart对象附在一个mimeMessage对象上(同FileDataSource差不多).

用法:
与FileDataSource唯一不同的是数据源的设置:
URLDataSource uds=new URLDataSource("/JAVA/UploadFiles_6441/200703/20070320105128501.gif");


4.使用JavaMail API

在明确了JavaMail API的核心部分如何工作后，本人将带领大家学习一些使用Java Mail API任务案例。
1．发送邮件
在获得了Session后，建立并填入邮件信息，然后发送它到邮件服务器。这便是使用Java Mail API发送邮件的过程，在发送邮件之前，我们需要设置SMTP服务器：通过设置Properties的mail.smtp.host属性。

String host = ...;
String from = ...;
String to = ...;

// Get system properties
Properties props = System.getProperties();

// Setup mail server
props.put("mail.smtp.host", host);

// Get session
Session session = Session.getDefaultInstance(props, null);

// Define message
MimeMessage message = new MimeMessage(session);
message.setFrom(new InternetAddress(from));
message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
message.setSubject("Hello JavaMail");
message.setText("Welcome to JavaMail");

// Send message
Transport.send(message);
由于建立邮件信息和发送邮件的过程中可能会抛出异常，所以我们需要将上面的代码放入到try-catch结构块中。

2．接收邮件
为了在读取邮件，我们获得了session，并且连接到了邮箱的相应store，打开相应的Folder，然后得到我们想要的邮件，当然别忘记了在结束时关闭连接。

String host = ...;
String username = ...;
String password = ...;

// Create empty properties
Properties props = new Properties();

// Get session
Session session = Session.getDefaultInstance(props, null);

// Get the store
Store store = session.getStore("pop3");
store.connect(host, username, password);

// Get folder
Folder folder = store.getFolder("INBOX");
folder.open(Folder.READ_ONLY);

// Get directory
Message message[] = folder.getMessages();
for (int i=0, n=message.length; i<n; i++) {     
  System.out.println(i + ": " +
  message[i].getFrom()[0] + "\t" + message[i].getSubject());
}

// Close connection
folder.close(false);store.close();

上面的代码所作的是从邮箱中读取每个邮件，并且显示邮件的发信人地址和主题。从技术角度讲，这里存在着一个异常的可能：当发信人地址为空时，getFrom()[0]将抛出异常。

下面的代码片断有效的说明了如何读取邮件内容，在显示每个邮件发信人和主题后，将出现用户提示从而得到用户是否读取该邮件的确认，如果输入YES的话，我们可用Message.writeTo(java.io.OutputStream os)方法将邮件内容输出到控制台上，关于 Message.writeTo()的具体用法请看JavaMail API。

BufferedReader reader = new BufferedReader (new InputStreamReader(System.in));

// Get directory
Message message[] = folder.getMessages();
for (int i=0, n=message.length; i<n; i++) {
  System.out.println(i + ": " + message[i].getFrom()[0] + "\t" + message[i].getSubject());
  System.out.println("Do you want to read message? " + "[YES to read/QUIT to end]"); 
  String line = reader.readLine();
  if ("YES".equals(line)) {
    message[i].writeTo(System.out); 
  } else if ("QUIT".equals(line)) {
    break; 
  }
}

3．删除邮件和标志
设置与message相关的Flags是删除邮件的常用方法。这些Flags表示了一些系统定义和用户定义的不同状态。在Flags类的内部类Flag中预定义了一些标志：
Flags.Flag.ANSWERED
Flags.Flag.DELETED
Flags.Flag.DRAFT
Flags.Flag.FLAGGED
Flags.Flag.RECENT
Flags.Flag.SEEN
Flags.Flag.USER
但需要在使用时注意的：标志存在并非意味着这个标志被所有的邮件服务器所支持。例如，对于删除邮件的操作，POP协议不支持上面的任何一个。所以要确定哪些标志是被支持的??通过访问一个已经打开的Folder对象的getPermanetFlags()方法，它将返回当前被支持的Flags类对象。

删除邮件时，我们可以设置邮件的DELETED标志： 
message.setFlag(Flags.Flag.DELETED, true);

但是首先要采用READ_WRITE的方式打开Folder：
folder.open(Folder.READ_WRITE);

在对邮件进行删除操作后关闭Folder时，需要传递一个true作为对删除邮件的擦除确认。
folder.close(true);

Folder类中另一种用于删除邮件的方法expunge()也同样可删除邮件，但是它并不为sun提供的POP3实现支持，而其它第三方提供的POP3实现支持或者并不支持这种方法。
另外，介绍一种检查某个标志是否被设置的方法：Message.isSet(Flags.Flag flag)方法，其中参数为被检查的标志。

4．邮件认证
我们在前面已经学会了如何使用Authenticator类来代替直接使用用户名和密码这两字符串作为 Session.getDefaultInstance()或者Session.getInstance()方法的参数。在前面的小试牛刀后，现在我们将

了解到全面认识一下邮件认证。
我们在此取代了直接使用邮件服务器主机名、用户名、密码这三个字符串作为连接到POP3 Store的方式，使用存储了邮件服务器主机名信息的属性文件，并在获得Session时传入自定义的Authenticator实例：

// Setup properties
Properties props = System.getProperties();
props.put("mail.pop3.host", host);

// Setup authentication, get session
Authenticator auth = new PopupAuthenticator();
Session session = Session.getDefaultInstance(props, auth);

// Get the storeStore store = session.getStore("pop3");
store.connect();

PopupAuthenticator 类继承了抽象类Authenticator，并且通过重载Authenticator类的getPasswordAuthentication()方法返回PasswordAuthentication类对象。而getPasswordAuthentication()方法的参数param是以逗号分割的用户名、密码组成的字符串。

import javax.mail.*;
import java.util.*;
public class PopupAuthenticator extends Authenticator { 
public PasswordAuthentication getPasswordAuthentication(String param) {
    String username, password;   
    StringTokenizer st = new StringTokenizer(param, ",");
    username = st.nextToken();
    password = st.nextToken();
    return new PasswordAuthentication(username, password);
  }
}

5．回复邮件
回复邮件的方法很简单：使用Message类的reply()方法，通过配置回复邮件的收件人地址和主题（如果没有提供主题的话，系统将默认将“Re：”作为邮件的主体），这里不需要设置任何的邮件内容，只要复制发信人或者reply-to到新的收件人。而reply()方法中的boolean参数表示是否将邮件回复给发送者（参数值为false），或是恢复给所有人（参数值为true）。
补充一下，reply-to地址需要在发信时使用setReplyTo()方法设置。

MimeMessage reply = (MimeMessage)message.reply(false);
reply.setFrom(new InternetAddress("president@whitehouse.gov"));
reply.setText("Thanks");
Transport.send(reply);

6．转发邮件
转发邮件的过程不如前面的回复邮件那样简单，它将建立一个转发邮件，这并非一个方法就能做到。
每个邮件是由多个部分组成，每个部分称为一个邮件体部分，是一个BodyPart类对象，对于MIME类型邮件来讲就是MimeBodyPart类对象。这些邮件体包含在成为Multipart的容器中对于MIME类型邮件来讲就是MimeMultiPart类对象。在转发邮件时，我们建立一个文字邮件体部分和一个被转发的文字邮件体部分，然后将这两个邮件体放到一个Multipart中。说明一下，复制一个邮件内容到另一个邮件的方法是仅复制它的 DataHandler（数据处理者）即可。这是由JavaBeans Activation Framework定义的一个类，它提供了对邮件内容的操作命令的访问、管理了邮件内容操作，是不同的数据源和数据格式之间的一致性接口。

// Create the message to forward
Message forward = new MimeMessage(session);

// Fill in headerforward.setSubject("Fwd: " + message.getSubject());
forward.setFrom(new InternetAddress(from));
forward.addRecipient(Message.RecipientType.TO,   new InternetAddress(to));

// Create your new message part
BodyPart messageBodyPart = new MimeBodyPart();
messageBodyPart.setText(  "Here you go with the original message:\n\n");

// Create a multi-part to combine the parts
Multipart multipart = new MimeMultipart();
multipart.addBodyPart(messageBodyPart);

// Create and fill part for the forwarded contentmessage
BodyPart = new MimeBodyPart();
messageBodyPart.setDataHandler(message.getDataHandler());

// Add part to multi part
multipart.addBodyPart(messageBodyPart);

// Associate multi-part with message
forward.setContent(multipart);

// Send message
Transport.send(forward);

7．使用附件
附件作为与邮件相关的资源经常以文本、表格、图片等格式出现，如流行的邮件客户端一样，我们可以用JavaMail API从邮件中获取附件或是发送带有附件的邮件。

A．发送带有附件的邮件
发送带有附件的邮件的过程有些类似转发邮件，我们需要建立一个完整邮件的各个邮件体部分，在第一个部分（即我们的邮件内容文字）后，增加一个具有DataHandler的附件而不是在转发邮件时那样复制第一个部分的DataHandler。

如果我们将文件作为附件发送，那么要建立FileDataSource类型的对象作为附件数据源；如果从URL读取数据作为附件发送，那么将要建立URLDataSource类型的对象作为附件数据源。

然后将这个数据源（FileDataSource或是URLDataSource）对象作为DataHandler类构造方法的参数传入，从而建立一个DataHandler对象作为数据源的DataHandler。

接着将这个DataHandler设置为邮件体部分的DataHandler。这样就完成了邮件体与附件之间的关联工作，下面的工作就是BodyPart的setFileName()方法设置附件名为原文件名。

最后将两个邮件体放入到Multipart中，设置邮件内容为这个容器Multipart，发送邮件。

// Define message
Message message = new MimeMessage(session);
message.setFrom(new InternetAddress(from));
message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
message.setSubject("Hello JavaMail Attachment");

// Create the message part BodyPart message
BodyPart = new MimeBodyPart();

// Fill the message
messageBodyPart.setText("Pardon Ideas");
Multipart multipart = new MimeMultipart();
multipart.addBodyPart(messageBodyPart);

// Part two is attachment
messageBodyPart = new MimeBodyPart();
DataSource source = new FileDataSource(filename);
messageBodyPart.setDataHandler(new DataHandler(source));
messageBodyPart.setFileName(filename);
multipart.addBodyPart(messageBodyPart);

// Put parts in message
message.setContent(multipart);

// Send the message
Transport.send(message);

如果我们使用servlet实现发送带有附件的邮件，则必须上传附件给servlet，这时需要注意提交页面form中对编码类型的设置应为multipart/form-data。

<FORM ENCTYPE="multipart/form-data" method="post" action="/myservlet">
   <INPUT TYPE="file" NAME="thefile">
  <INPUT TYPE="submit" VALUE="Upload">
</FORM>

B．读取邮件中的附件
读取邮件中的附件的过程要比发送它的过程复杂一点。因为带有附件的邮件是多部分组成的，我们必须处理每一个部分获得邮件的内容和附件。
但是如何辨别邮件信息内容和附件呢？Sun在Part类（BodyPart类实现的接口类）中提供了getDisposition()方法让开发者获得邮件体部分的部署类型，当该部分是附件时，其返回之将是Part.ATTACHMENT。但附件也可以没有部署类型的方式存在或者部署类型为 Part.INLINE，无论部署类型为Part.ATTACHMENT还是Part.INLINE，我们都能把该邮件体部分导出保存。

Multipart mp = (Multipart)message.getContent();
for (int i=0, n=multipart.getCount(); i<n; i++) {
  Part part = multipart.getBodyPart(i));
  String disposition = part.getDisposition();
  if ((disposition != null) &&
       ((disposition.equals(Part.ATTACHMENT) ||
        (disposition.equals(Part.INLINE))) {
    saveFile(part.getFileName(), part.getInputStream());
  }
}

下列代码中使用了saveFile方法是自定义的方法，它根据附件的文件名建立一个文件，如果本地磁盘上存在名为附件的文件，那么将在文件名后增加数字表示区别。然后从邮件体中读取数据写入到本地文件中（代码省略）。

// from saveFile()
File file = new File(filename);
for (int i=0; file.exists(); i++) {
  file = new File(filename+i);
}

以上是邮件体部分被正确设置的简单例子，如果邮件体部分的部署类型为null，那么我们通过获得邮件体部分的MIME类型来判断其类型作相应的处理，代码结构框架如下：

if (disposition == null) {
  // Check if plain 
  MimeBodyPart mbp = (MimeBodyPart)part;
  if (mbp.isMimeType("text/plain")) {
    // Handle plain
  } else {
    // Special non-attachment cases here of
    // image/gif, text/html
    ...
  }
  ...
}

8．处理HTML邮件
前面的例子中发送的邮件都是以文本为内容的（除了附件），下面将介绍如何接收和发送基于HTML的邮件。
A．发送HTML邮件
假如我们需要发送一个HTML文件作为邮件内容，并使邮件客户端在读取邮件时获取相关的图片或者文字的话，只要设置邮件内容为html代码，并设置内容类型为text/html即可：

String htmlText = "<H1>Hello</H1>" + "<img src=\"http://www.jguru.com/images/logo.gif\">";
message.setContent(htmlText, "text/html"));

请注意：这里的图片并不是在邮件中内嵌的，而是在URL中定义的。邮件接收者只有在线时才能看到。
在接收邮件时，如果我们使用JavaMail API接收邮件的话是无法实现以HTML方式显示邮件内容的。因为JavaMail API邮件内容视为二进制流。所以要显示HTML内容的邮件，我们必须使用JEditorPane或者第三方HTML展现组件。

以下代码显示了如何使用JEditorPane显示邮件内容：
if (message.getContentType().equals("text/html")) {
  String content = (String)message.getContent();
  JFrame frame = new JFrame();
  JEditorPane text = new JEditorPane("text/html", content);
  text.setEditable(false);
  JScrollPane pane = new JScrollPane(text);
  frame.getContentPane().add(pane);
  frame.setSize(300, 300);
  frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  frame.show();
}

B．在邮件中包含图片
如果我们在邮件中使用HTML作为内容，那么最好将HTML中使用的图片作为邮件的一部分，这样无论是否在线都会正确的显示HTML中的图片。处理方法就是将HTML中用到的图片作为邮件附件并使用特殊的cid URL作为图片的引用，这个cid就是对图片附件的Content-ID头的引用。
处理内嵌图片就像向邮件中添加附件一样，不同之处在于我们必须通过设置图片附件所在的邮件体部分的header中Content-ID为一个随机字符串，并在HTML中img的src标记中设置为该字符串。这样就完成了图片附件与HTML的关联。

String file = ...;
// Create the message
Message message = new MimeMessage(session);

// Fill its headers
message.setSubject("Embedded Image");
message.setFrom(new InternetAddress(from));
message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));

// Create your new message part
BodyPart messageBodyPart = new MimeBodyPart();
String htmlText = "<H1>Hello</H1>" + "<img src=\"cid:memememe\">";
messageBodyPart.setContent(htmlText, "text/html");

// Create a related multi-part to combine the parts
MimeMultipart multipart = new MimeMultipart("related");
multipart.addBodyPart(messageBodyPart);

// Create part for the image
messageBodyPart = new MimeBodyPart();

// Fetch the image and associate to part
DataSource fds = new FileDataSource(file);
messageBodyPart.setDataHandler(new DataHandler(fds));
messageBodyPart.setHeader("Content-ID","<memememe>");

// Add part to multi-part
multipart.addBodyPart(messageBodyPart);

// Associate multi-part with
messagemessage.setContent(multipart);

9．在邮件中搜索短语
JavaMail API提供了过滤器机制，它被用来建立搜索短语。这个短语由javax.mail.search包中的SearchTerm抽象类来定义，在定义后我们便可以使用Folder的Search()方法在Folder中查找邮件：
SearchTerm st = ...;Message[] msgs = folder.search(st);
下面有22个不同的类（继承了SearchTerm类）供我们使用：
AND       terms (class AndTerm)
OR        terms (class OrTerm)
NOT       terms (class NotTerm)
SENT DATE terms (class SentDateTerm)
CONTENT   terms (class BodyTerm)
HEADER    terms (FromTerm / FromStringTerm,
                 RecipientTerm / RecipientStringTerm, SubjectTerm, etc.)
使用这些类定义的断语集合，我们可以构造一个逻辑表达式，并在Folder中进行搜索。下面是一个实例：在Folder中搜索邮件主题含有“ADV”字符串或者发信人地址为friend@public.com的邮件。

SearchTerm st = new OrTerm(new SubjectTerm("ADV:"), new FromStringTerm("friend@public.com"));
Message[] msgs = folder.search(st);


Astro.Qi 2008-07-01 13:42 发表评论
]]>Apache James 用户信息的数据库存储和密码问题http://www.blogjava.net/AstroQi/archive/2008/06/26/210784.htmlAstro.QiAstro.QiThu, 26 Jun 2008 03:55:00 GMThttp://www.blogjava.net/AstroQi/archive/2008/06/26/210784.htmlhttp://www.blogjava.net/AstroQi/comments/210784.htmlhttp://www.blogjava.net/AstroQi/archive/2008/06/26/210784.html#Feedback0http://www.blogjava.net/AstroQi/comments/commentRss/210784.htmlhttp://www.blogjava.net/AstroQi/services/trackbacks/210784.html
一、James简介

Apache James（Java Apache Mail Enterprise Server）是Apache组织的子项目之一，完全采用纯Java技术开发，实现了SMTP、POP3与NNTP等多种邮件相关协议。

James也是一个邮件应用平台，可以通过Mailet扩充其功能，如Mail2SMS、Mail2Fax等。James提供了比较完善的配置方案，尤其是关于邮件内容存储和用户信息存储部分，可以选择在文件、数据库或其他介质中保存。

James性能稳定、可配置性强，还是开源项目，所有源代码不存在版权问题，因此，James在项目中的应用日益广泛，现在常用版本为2.1，但最新版本2.3已经推出，在本文中，我们将仍以James2.1作为介绍蓝本。

二、一个假设的项目

假设我要以James为邮件服务器，开发一套基于Web的邮件系统，就像263.net，163.net一样，要求实现在线注册、在线收发邮件等功能。

默认情况下，James的用户信息存储在文本中，虽然加了密，但由于文本存档不足，不便于查询及相应处理，幸好James提供了多种用户信息存储方案，如数据库存储，LDAP存储等。

这里我们将以数据库存储为例，讲解用户信息的管理，数据库采用MySQL。当然你也可以采用LDAP，比如免费的OpenLDAP，功能非常强大。

三、用户信息的数据库存储

James邮件用户的用户信息默认保存在apps\james\var\users目录下，通过修改配置文件apps\james\SAR-INF\config.xml，可以把用户信息保存到数据库中，配置方法如下：

第一步：在MySQL中新建一个数据库mail，用户名root，密码为空；

第二步：打开config.xml，找到<users-store>这一项，此面默认的内容为：

<repository name="LocalUsers" class="org.apache.james.userrepository.UsersFileRepository">
         <destination URL="file://var/users/"/>
</repository>

需要修改为：

<repository name="LocalUsers" class="org.apache.james.userrepository.JamesUsersJdbcRepository" destinationURL="db://maildb/users">
        <sqlFile>file://conf/sqlResources.xml</sqlFile>
      </repository>

通过修改，我们就把用户信息的存储介质从file改成了db，<sqlFile>是指明了在db中的数据表结构及相关数据库信息。

第三步：仍然是config.xml，找到<data-sources>项，默认内容为空，把此项内容修改为：

<data-source name="maildb" class="org.apache.james.util.mordred.JdbcDataSource">
                           <driver>org.gjt.mm.mysql.Driver</driver>
                            <dburl>jdbc:mysql://127.0.0.1/mail</dburl>
                            <user>root</user>
                            <password></password>
                            <max>20</max>
</data-source>

<driver>是指MySQL的JDBC驱动，<dburl>指数据库的访问路径，IP后的mail即MySQL中新建数据库名，接下来是用户名、密码及最大连接数。

至此，数据库配置完成，启动James，若正常无误，请通过telnet添加一个新用户，比如adduser holen 123456，然后检查MySQL中的mail数据库，下面将有一个表users，这是James根据james_home\apps\james\conf的内容创建的。

通过以上配置，James的用户信息就可以保存在数据库中了。

四、密码问题

当你通过telnet添加新用户时，比如adduser holen 123456，你可以查看数据库中的记录，第一个字段是holen，第二字段是密码，但密码并非123456，而一串“乱码 ”（zhwQUMTwdMqWfm/h0biB51Gf）——这是加密码后的密码内容，再看后面的字段是“SHA”，显然用的是SHA加密方式。

通过telnet方式添加新用户，用户密码将自动加密，然后插入数据库中。但通过telnet方式进行用户管理有着诸多不便，尽管你可以借助James的一个RMI工具包，提高效率，但仍然没有本质改变，当需要用作商业用途时，你更不能要求你的客户熟记那一堆命令符。

一般我们可以做一个Web前端，通过网页形式，添加修改用户，界面友好，傻瓜化使用，如263或163一样。若这样做，我们就需要直接操作数据库， 添加用户记录或修改删除用户记录了。但别忘了，James默认对用户密码是加密的，既然我们要直接操作数据库，那么我们只有两个选择：要么我们研究其密码 机制，添加记录时，我们对新增用户的密码进行同样加密，要么我们去掉James的加密机制，使其明码保存。

幸好，这两种选择都是可行的。我们从Apache网站下载James的源码包，下载后的文件为james-2.1-src.zip，接近8M，通过分析源码，我们发现，与用户密码相关的文件是DefaultUser.java，部分源码如下：

package org.apache.james.userrepository;
……
/**
     * Method to verify passwords.
     *
     * @param pass the String that is claimed to be the password for this user
     * @return true if the hash of pass with the current algorithm matches
     * the stored hash.
     */
    public boolean verifyPassword(String pass) {
        try {
            String hashGuess = DigestUtil.digestString(pass, algorithm);
            return hashedPassword.equals(hashGuess);
        } catch (NoSuchAlgorithmException nsae) {
        throw new RuntimeException("Security error: " + nsae);
    }
    }

    /**
     * Sets new password from String. No checks made on guessability of
     * password.
     *
     * @param newPass the String that is the new password.
     * @return true if newPass successfuly hashed
     */
    public boolean setPassword(String newPass) {
        try {
            hashedPassword = DigestUtil.digestString(newPass, algorithm);
            return true;
        } catch (NoSuchAlgorithmException nsae) {
            throw new RuntimeException("Security error: " + nsae);
        }
}
……

第一个方法verifyPassword()是用来做密码认证，传入的参数是明文密码，通过DigestUtil.digestString()方 法，转换成密文密码，然后与数据库中密码作比较，返回比较结果。请注意这里的DigestUtil.digestString()方法，在后面还在提到。

第二个方法setPassword()是用于密码转换的，把明文转成密文，用的同样是DigestUtil.digestString()方法。

谈到这里，相信你应该知道怎么在自己的程序中进行密码转换和密码认证了吧！其实并不是要你自己去写一个SHA的加密算法，既然James已经提供了此功能，你调用便是了。

还有一种情况，开发者需要在数据库中必须用明文保存密码，这样就不必在自己写的程序中进行密码转换了，而且当多个应用系统采用统一用户模型时，最好 只有一个用户实例。要实现这个需求，就只能修改James源代码了，把verifyPassword()方法和setPassword()改成：

public boolean verifyPassword(String pass) {      
            return hashedPassword.equals(pass);      
}  
public boolean setPassword(String newPass) {     
            hashedPassword = newPass;
            return true;      
}

其实就是把转换过程去掉，保存和认证就都采用明文进行了。

你要是觉得SHA方式不妥，也可以挂接别的加密方式，同样是修改这两个方法。

注意，当你修改了James的源码后，你需要用Ant重新build James项目，build后将在james-2.1-src\dist\james-2.1\apps下面找到新生成的james.sar文件。把该文 件覆盖James原来james.sar，并删除与james.sar同级的james目录，重启动james即可。建议保留原来的 config.xml，免得又配一次。

通过以上探讨，我们明白了如何通过Web方式进行用户注册和用户登记等。需要说明一点是，James自动生成的users表中只有7个字段，而且都 是系统需要使用的。一般注册时需要输入的信息项比较多，这时建议开发者自己再建一个新表USERINFO，用username把两个表关联起来，不建议修 改users表的内容（如果想试试，请参考james_home\apps\james\conf）。

五、基于James的邮件系统开发方案简述


James运行在Win2000上，客户端采用Web界面（仿263风格）、Foxmail或OutLook Express，该系统主要面向1000人以下的中小企业。

基于James的邮件开发，主要包括两个方面：一是邮件系统的后台管理，另一个是客户端应用系统。

后台管理的功能主要包括用户的添加、删除、修改、用户使用空间指配、邮件备份等。

Web客户端功能包括收件箱、发邮件、发件箱、草稿箱、回收站、地址本、自定义文件夹、配置等。

用户信息存储在MySQL数据库中，邮件内容默认存储在文档中。

系统采用Struts架构，运行环境为Apache1.3+Tomcat4.1，数据库连接池采用Tomcat自带的DBCP。

系统开发预计需60人天完成，开发人员需要掌握Struts和JavaMail。

压力测试超过50个并发。

六、参考资料

James 2.1 Documentation



Astro.Qi 2008-06-26 11:55 发表评论
]]>Apache james 使用入门http://www.blogjava.net/AstroQi/archive/2008/06/26/210781.htmlAstro.QiAstro.QiThu, 26 Jun 2008 03:52:00 GMThttp://www.blogjava.net/AstroQi/archive/2008/06/26/210781.htmlhttp://www.blogjava.net/AstroQi/comments/210781.htmlhttp://www.blogjava.net/AstroQi/archive/2008/06/26/210781.html#Feedback0http://www.blogjava.net/AstroQi/comments/commentRss/210781.htmlhttp://www.blogjava.net/AstroQi/services/trackbacks/210781.html
一、简介

Apache James（Java Apache Mail Enterprise Server）是Apache组织的子项目之一，完全采用纯Java技术开发，实现了SMTP、POP3与NNTP等多种邮件相关协议。

James也是一个邮件应用平台，可以通过Mailet扩充其功能，如Mail2SMS、Mail2Fax等。James提供了比较完善的配置方案，尤其是关于邮件内容存储和用户信息存储部分，可以选择在文件、数据库或其他介质中保存。

James性能稳定、可配置性强，还是开源项目，所有源代码不存在版权问题，因此，James在项目中的应用日益广泛，现在常用版本为2.1，但最新版本2.3已经推出，在本文中，我们将仍以James2.1作为介绍蓝本。

二、安装与配置

James的安装配置过程非常简单。

第一步：安装JDK

请使用JDK1.3以上版本（推荐使用JDK1.4），假设安装在c:\jdk1.3。

第二步：下载James，并解压

可以到Apache网站上下载James2.1，下载将得到一个压缩文件james-2.1.zip，大小为4.45M，将此包解压到c:\james。

第三步：直接运行或需要配置JAVA_HOME

这时，可以尝试直接双击c:\james\bin\run.bat，若启动无误，将提示如下：

Using PHOENIX_HOME: C:\james
Using PHOENIX_TMPDIR: C:\james\temp
Using JAVA_HOME:

Phoenix 4.0.1

James 2.1
Remote Manager Service started plain:4555
POP3 Service started plain:110
SMTP Service started plain:25
NNTP Service Disabled
Fetch POP Disabled

也有可能启动不了，并报JAVA_HOME找不到，这时，需要指定JAVA_HOME，比较简单的方法是在c:\james\bin\run.bat中指定JAVA_HOME，修改后的run.bat如下：

……
rem
rem Determine if JAVA_HOME is set and if so then use it
rem
set JAVA_HOME= c:\jdk1.3
if not "%JAVA_HOME%"=="" goto found_java
……

修改完后再运行run.bat，应该就可以正常启动了，若还有什么问题，请参见本文的FAQ部分。

三、项目应用

1、 项目需求

某单位，有16个职能处室，共78台电脑（操作系统为Win98/2000/xp），其中有1台为专用服务器（Win2000），已连成局域网。为使单位内部的信息交流，尤其是文件交互更加便捷，单位决定在局域网内部架设一套E-mail系统。

2、 解决方案

在专用服务器上安装James2.1，客户端使用操作系统自带的Outlook Express。

3、 服务器端配置

首先找出专用服务器的名字，假设叫unitname。

然后打开文件c:\james\apps\james\SAR-INF\config.xml。

在config.xml文件中，找到 Postmaster@localhost，把此项改为 Postmaster@unitname，同理，找到localhost，把此项改为unitname。其实，改这两项就是把默认的localhost改为机器名，这样做是为了让其它机器也能访问邮件系统，当然，前提是在局域网上没有与服务器重名的机器。

4、 客户端配置

假设有一个账号，用户名为holen，密码为123456，如何在Outlook中配置呢？

首先，根据用户名，可以得出该用户邮箱地址为holen@unitname ，然后在输入POP3和SMTP服务器时，直接使用服务器机器名unitname即可。

5、 帐号管理

James的账号管理是通过telnet完成的，登录命令为：

telnet unitname 4555

其中unitname也可以换成IP，4555是端口号。登录时需要用户名和密码，初始的用户名和密码均为root。若登录成功，提示如下：

JAMES Remote Administration Tool 2.1
Please enter your login and password
Login id:
Password:
Welcome root. HELP for a list of commands

需要注意的是，所有敲入的命令都不显示在屏幕上。

输入help，将出现命令的帮助，信息如下：

JAMES Remote Administration Tool 2.1
Please enter your login and password
Login id:
Password:
Welcome root. HELP for a list of commands
Currently implemented commands:
help display this help
listusers display existing accounts
countusers display the number of existing accounts
adduser [username] [password] add a new user
verify [username] verify if specified user exist
deluser [username] delete existing user
setpassword [username] [password] sets a users password
setalias [alias] [user] locally forwards all email for alias t
o user
unsetalias [alias] unsets an alias
setforwarding [username] [emailaddress] forwards a users email to another email
address
unsetforwarding [username] removes a forward
user [repositoryname] change to another user repository
shutdown kills the current JVM (convenient when J
ames is run as a daemon)
quit close connection

常用的命令有listusers、countusers、adduser、deluser、setpassword等。

其中添加用户为adduser，例如：adduser holen 123456。

通过这个后台管理界面，管理员就可以实现账号管理及其他相应的管理功能。

6、 应用情况

这套系统在该单位经过一周的试运行后，已正式运行两个月，用户数约百人，一直很稳定，期间，因操作系统故障，服务器重启两次，其他时间，一直处于运行状态，性能稳定，响应速度快。

四、FAQ

1、 在启动james时，提示POP3或SMTP不能使用？

请检查一下，看“管理工具—>服务”里面，是不是启动了别的邮件服务器，已将110或25端口占用了。

2、 JAVA_HOME找不到？

请在run.bat中指定JAVA_HOME，若还不行，请在“我的电脑—>系统—>高级—>环境变量”中添加一项JAVA_HOME（一般不推荐这么做）。

3、 服务器启动正常，但客户端不能收发邮件？

请检查客户端配置是否正常，参照前面所讲，另外，请检查james下的config.xml，是否把localhost改成了机器名。

五、总结

总体而言，James是一款十分优秀的邮件服务器，具有性能稳定、扩展性好、可配置性强、响应速度快、源码公开等优点。同时，由于James的后台管理不够方便、缺少必要的技术支持等原因，限制了james的高端企业级应用。

就目前情况而言，James主要用于1000用户量以内的邮件系统，而且当James用于商业性项目时，开发商一般需要对James进行相应的包装，主要是后台管理这一块。

Astro.Qi 2008-06-26 11:52 发表评论
]]>Apache james mailserver + Claros inTouch webmailhttp://www.blogjava.net/AstroQi/archive/2008/06/26/210764.htmlAstro.QiAstro.QiThu, 26 Jun 2008 02:44:00 GMThttp://www.blogjava.net/AstroQi/archive/2008/06/26/210764.htmlhttp://www.blogjava.net/AstroQi/comments/210764.htmlhttp://www.blogjava.net/AstroQi/archive/2008/06/26/210764.html#Feedback30http://www.blogjava.net/AstroQi/comments/commentRss/210764.htmlhttp://www.blogjava.net/AstroQi/services/trackbacks/210764.html阅读全文

Astro.Qi 2008-06-26 10:44 发表评论
]]>FCKeditor2.6 for JSP 配置方法http://www.blogjava.net/AstroQi/archive/2008/06/24/210344.htmlAstro.QiAstro.QiTue, 24 Jun 2008 08:55:00 GMThttp://www.blogjava.net/AstroQi/archive/2008/06/24/210344.htmlhttp://www.blogjava.net/AstroQi/comments/210344.htmlhttp://www.blogjava.net/AstroQi/archive/2008/06/24/210344.html#Feedback10http://www.blogjava.net/AstroQi/comments/commentRss/210344.htmlhttp://www.blogjava.net/AstroQi/services/trackbacks/210344.html阅读全文

Astro.Qi 2008-06-24 16:55 发表评论
]]>