LoginAny 使用笔记
 
想实现在家办公,当公司有急事的时候，可以在家就处理掉；不必在家里和公司之间copy文件，免去劳苦奔波之苦。于是开始用远程软件。
 
1. VNN. 免费，主要面向游戏平台。
申请2个用户，互相加为密友，能够2台机器互访，但是只有vnnc302201-winall.zip版本能用(密友功能)，且不能升级，一旦升级之后，将没有了密友功能。
用了一段时间，很不错。但不久之后，本地域内3389端口封了。理解，因为远程桌面的3389是个不安全的端口。

其实，把被控机器的Terminal Service 3389端口改掉, 理论上也是可行的，但是还是比较麻烦。
 
2. Hamachi,  很好用的的软件。推荐，IP局域网穿透。 3389端口还是不能连接，道理同上。
 
3. 改用LoginAny. 免费版每月只能远程桌面20分钟，文件传输3次。速度超快。 远程桌面是LoginAny开发的，所以不再用3389端口。

自己研究下能否逆向工程下…

———先看文件传输功能———–
打开eXeScope分析资源，首先查看文字:"文件传输已经达到最大使用次数!",String Id: 484
得知Dialog: 1218是提示对话框， Dialog: 1219是文件传输Form.

打开OllyICE,反编译后，
- 搜索4C2(1218), 找提示对话框的代码，自己标注附近的代码，这是一个功能函数。
搜索4C3(1219), 找文件传输Form相关代码。
搜索1E4(484)， 找"文件传输已经达到最大使用次数!"的相关代码。
004938D0  /$  55            push    ebp
004938D1  |.  8BEC          mov     ebp, esp
004938D3  |.  6A FF         push    -1
004938D5  |.  68 87C25B00   push    005BC287                                           ;  SE 处理程序安装
004938DA  |.  64:A1 0000000>mov     eax, dword ptr fs:[0]
004938E0  |.  50            push    eax
004938E1  |.  64:8925 00000>mov     dword ptr fs:[0], esp
004938E8  |.  81EC BC000000 sub     esp, 0BC
004938EE  |.  A1 BCEB6200   mov     eax, dword ptr [62EBBC]
004938F3  |.  33C5          xor     eax, ebp
004938F5  |.  8945 EC       mov     dword ptr [ebp-14], eax
004938F8  |.  898D 40FFFFFF mov     dword ptr [ebp-C0], ecx
004938FE  |.  C785 4CFFFFFF>mov     dword ptr [ebp-B4], 1
00493908  |.  6A 01         push    1
0049390A  |.  8B85 4CFFFFFF mov     eax, dword ptr [ebp-B4]
00493910  |.  50            push    eax
00493911  |.  8B8D 40FFFFFF mov     ecx, dword ptr [ebp-C0]
00493917  |.  E8 D4EFFFFF   call    004928F0                                           ;  关键Call !!!!
0049391C  |.  85C0          test    eax, eax
0049391E  |.  75 05         jnz     short 00493925
00493920  |.  E9 F8000000   jmp     00493A1D
00493925  |>  C785 48FFFFFF>mov     dword ptr [ebp-B8], 0
0049392F  |.  8D4D F0       lea     ecx, dword ptr [ebp-10]
00493932  |.  FF15 28B95C00 call    dword ptr [<&MFC71.#310_ATL::CStringT<char,StrTrai>;  MFC71.7C173199
00493938  |.  C745 FC 00000>mov     dword ptr [ebp-4], 0
0049393F  |.  6A 00         push    0
00493941  |.  8D8D 54FFFFFF lea     ecx, dword ptr [ebp-AC]
00493947  |.  E8 64D30800   call    00520CB0
0049394C  |.  C645 FC 01    mov     byte ptr [ebp-4], 1
00493950  |.  8B8D 4CFFFFFF mov     ecx, dword ptr [ebp-B4]
00493956  |.  51            push    ecx
00493957  |.  68 DD000000   push    0DD
0049395C  |.  8D55 F0       lea     edx, dword ptr [ebp-10]
0049395F  |.  52            push    edx
00493960  |.  8D85 54FFFFFF lea     eax, dword ptr [ebp-AC]
00493966  |.  50            push    eax
00493967  |.  8D8D 48FFFFFF lea     ecx, dword ptr [ebp-B8]
0049396D  |.  51            push    ecx
0049396E  |.  8B8D 40FFFFFF mov     ecx, dword ptr [ebp-C0]
00493974  |.  E8 A7190000   call    00495320                                           ;  MessageBox ….
00493979  |.  85C0          test    eax, eax
0049397B  |.  75 21         jnz     short 0049399E
0049397D  |.  C645 FC 00    mov     byte ptr [ebp-4], 0
00493981  |.  8D8D 54FFFFFF lea     ecx, dword ptr [ebp-AC]
00493987  |.  E8 24D40800   call    00520DB0
0049398C  |.  C745 FC FFFFF>mov     dword ptr [ebp-4], -1
00493993  |.  8D4D F0       lea     ecx, dword ptr [ebp-10]
00493996  |.  FF15 68B95C00 call    dword ptr [<&MFC71.#578_ATL::CStringT<char,StrTrai>;  MFC71.7C1771B1
0049399C  |.  EB 7F         jmp     short 00493A1D
0049399E  |>  8B95 48FFFFFF mov     edx, dword ptr [ebp-B8]
004939A4  |.  52            push    edx
004939A5  |.  68 2CF16200   push    0062F12C
004939AA  |.  51            push    ecx
004939AB  |.  8BCC          mov     ecx, esp
004939AD  |.  89A5 44FFFFFF mov     dword ptr [ebp-BC], esp
004939B3  |.  8D45 F0       lea     eax, dword ptr [ebp-10]
004939B6  |.  50            push    eax
004939B7  |.  FF15 38B95C00 call    dword ptr [<&MFC71.#297_ATL::CStringT<char,StrTrai>;  MFC71.7C14E575
004939BD  |.  8985 3CFFFFFF mov     dword ptr [ebp-C4], eax
004939C3  |.  8D8D 54FFFFFF lea     ecx, dword ptr [ebp-AC]
004939C9  |.  51            push    ecx
004939CA  |.  B9 E4F26200   mov     ecx, 0062F2E4
004939CF  |.  E8 ECDAFCFF   call    004614C0                                           ;  调用打开文件传输Form
004939D4  |.  8985 38FFFFFF mov     dword ptr [ebp-C8], eax
004939DA  |.  8B95 38FFFFFF mov     edx, dword ptr [ebp-C8]
004939E0  |.  8995 50FFFFFF mov     dword ptr [ebp-B0], edx
004939E6  |.  6A 05         push    5
004939E8  |.  8B8D 50FFFFFF mov     ecx, dword ptr [ebp-B0]
004939EE  |.  E8 6DCC1100   call    <jmp.&MFC71.#6090_CWnd::ShowWindow>
004939F3  |.  8B8D 50FFFFFF mov     ecx, dword ptr [ebp-B0]
004939F9  |.  E8 12D8FAFF   call    00441210
004939FE  |.  C645 FC 00    mov     byte ptr [ebp-4], 0
00493A02  |.  8D8D 54FFFFFF lea     ecx, dword ptr [ebp-AC]
00493A08  |.  E8 A3D30800   call    00520DB0
00493A0D  |.  C745 FC FFFFF>mov     dword ptr [ebp-4], -1
00493A14  |.  8D4D F0       lea     ecx, dword ptr [ebp-10]
00493A17  |.  FF15 68B95C00 call    dword ptr [<&MFC71.#578_ATL::CStringT<char,StrTrai>;  MFC71.7C1771B1
00493A1D  |>  8B4D F4       mov     ecx, dword ptr [ebp-C]
00493A20  |.  64:890D 00000>mov     dword ptr fs:[0], ecx
00493A27  |.  8B4D EC       mov     ecx, dword ptr [ebp-14]
00493A2A  |.  33CD          xor     ecx, ebp
00493A2C  |.  E8 5ADE1100   call    005B188B
00493A31  |.  8BE5          mov     esp, ebp
00493A33  |.  5D            pop     ebp
00493A34  \.  C3            retn
 
在0049 3917发现关键Call.
决定修改其后的跳转，
00493920  |.  E9 F8000000   jmp     00493A1D  这一行是跳过调用打开文件传输Form的代码。
把它改为：
00493920  |.  90 90909090   Nop               什么也不做
经试验，文件传输功能可以超过3次的使用了。

———远程桌面的功能———-

远程桌面的功能只能连接20分钟。 解决办法还是老一套：
打开eXeScope分析资源，找到对话框：远程桌面,ID=1306.

打开OllyICE,搜索常量1306，很快定位下面代码：

00493670  /$  55            push    ebp
00493671  |.  8BEC          mov     ebp, esp
00493673  |.  6A FF         push    -1
00493675  |.  68 69C25B00   push    005BC269                                           ;  SE 处理程序安装
0049367A  |.  64:A1 0000000>mov     eax, dword ptr fs:[0]
00493680  |.  50            push    eax
00493681  |.  64:8925 00000>mov     dword ptr fs:[0], esp
00493688  |.  81EC D4000000 sub     esp, 0D4
0049368E  |.  A1 BCEB6200   mov     eax, dword ptr [62EBBC]
00493693  |.  33C5          xor     eax, ebp
00493695  |.  8945 EC       mov     dword ptr [ebp-14], eax
00493698  |.  898D 30FFFFFF mov     dword ptr [ebp-D0], ecx
0049369E  |.  C785 50FFFFFF>mov     dword ptr [ebp-B0], 0
004936A8  |.  6A 01         push    1
004936AA  |.  8B85 50FFFFFF mov     eax, dword ptr [ebp-B0]
004936B0  |.  50            push    eax
004936B1  |.  8B8D 30FFFFFF mov     ecx, dword ptr [ebp-D0]
004936B7  |.  E8 34F2FFFF   call    004928F0                                           ;  关键Call–remote desk.
004936BC  |.  85C0          test    eax, eax
004936BE  |.  75 05         jnz     short 004936C5
004936C0  |.  E9 F0010000   jmp     004938B5
004936C5  |>  C785 4CFFFFFF>mov     dword ptr [ebp-B4], 0
004936CF  |.  6A 00         push    0
004936D1  |.  8D8D 54FFFFFF lea     ecx, dword ptr [ebp-AC]
004936D7  |.  E8 D4D50800   call    00520CB0
004936DC  |.  C745 FC 00000>mov     dword ptr [ebp-4], 0
004936E3  |.  8D4D F0       lea     ecx, dword ptr [ebp-10]
004936E6  |.  FF15 28B95C00 call    dword ptr [<&MFC71.#310_ATL::CStringT<char,StrTrai>;  MFC71.7C173199
004936EC  |.  C645 FC 01    mov     byte ptr [ebp-4], 1
004936F0  |.  8B8D 50FFFFFF mov     ecx, dword ptr [ebp-B0]
004936F6  |.  51            push    ecx
004936F7  |.  68 19010000   push    119
004936FC  |.  8D55 F0       lea     edx, dword ptr [ebp-10]
004936FF  |.  52            push    edx
00493700  |.  8D85 54FFFFFF lea     eax, dword ptr [ebp-AC]
00493706  |.  50            push    eax
00493707  |.  8D8D 4CFFFFFF lea     ecx, dword ptr [ebp-B4]
0049370D  |.  51            push    ecx
0049370E  |.  8B8D 30FFFFFF mov     ecx, dword ptr [ebp-D0]
00493714  |.  E8 071C0000   call    00495320                                           ;  消息处理
00493719  |.  85C0          test    eax, eax
0049371B  |.  75 24         jnz     short 00493741
0049371D  |.  C645 FC 00    mov     byte ptr [ebp-4], 0
00493721  |.  8D4D F0       lea     ecx, dword ptr [ebp-10]
00493724  |.  FF15 68B95C00 call    dword ptr [<&MFC71.#578_ATL::CStringT<char,StrTrai>;  MFC71.7C1771B1
0049372A  |.  C745 FC FFFFF>mov     dword ptr [ebp-4], -1
00493731  |.  8D8D 54FFFFFF lea     ecx, dword ptr [ebp-AC]
00493737  |.  E8 74D60800   call    00520DB0                                           ;  字符处理
0049373C  |.  E9 74010000   jmp     004938B5
00493741  |>  817D A4 01030>cmp     dword ptr [ebp-5C], 90301
00493748  |.  0F83 E8000000 jnb     00493836
0049374E  |.  8B95 4CFFFFFF mov     edx, dword ptr [ebp-B4]
00493754  |.  52            push    edx
00493755  |.  6A 00         push    0
00493757  |.  51            push    ecx
00493758  |.  8BCC          mov     ecx, esp
0049375A  |.  89A5 38FFFFFF mov     dword ptr [ebp-C8], esp
00493760  |.  8D45 F0       lea     eax, dword ptr [ebp-10]
00493763  |.  50            push    eax
00493764  |.  FF15 38B95C00 call    dword ptr [<&MFC71.#297_ATL::CStringT<char,StrTrai>;  MFC71.7C14E575
0049376A  |.  8985 2CFFFFFF mov     dword ptr [ebp-D4], eax
00493770  |.  8D8D 54FFFFFF lea     ecx, dword ptr [ebp-AC]
00493776  |.  51            push    ecx
00493777  |.  B9 E4F26200   mov     ecx, 0062F2E4
0049377C  |.  E8 BFD7FCFF   call    00460F40                                           ;  ???? XX new opeator
00493781  |.  8985 28FFFFFF mov     dword ptr [ebp-D8], eax
00493787  |.  8B95 28FFFFFF mov     edx, dword ptr [ebp-D8]
0049378D  |.  8995 48FFFFFF mov     dword ptr [ebp-B8], edx
00493793  |.  83BD 48FFFFFF>cmp     dword ptr [ebp-B8], 0
0049379A  |.  0F85 94000000 jnz     00493834
004937A0  |.  8D8D 40FFFFFF lea     ecx, dword ptr [ebp-C0]
004937A6  |.  FF15 28B95C00 call    dword ptr [<&MFC71.#310_ATL::CStringT<char,StrTrai>;  MFC71.7C173199
004937AC  |.  C645 FC 02    mov     byte ptr [ebp-4], 2
004937B0  |.  8D8D 44FFFFFF lea     ecx, dword ptr [ebp-BC]
004937B6  |.  FF15 28B95C00 call    dword ptr [<&MFC71.#310_ATL::CStringT<char,StrTrai>;  MFC71.7C173199
004937BC  |.  C645 FC 03    mov     byte ptr [ebp-4], 3
004937C0  |.  FF15 90AA5C00 call    dword ptr [<&KERNEL32.GetLastError>]               ; [GetLastError
004937C6  |.  50            push    eax
004937C7  |.  68 42010000   push    142
004937CC  |.  8D85 44FFFFFF lea     eax, dword ptr [ebp-BC]
004937D2  |.  50            push    eax
004937D3  |.  FF15 3CB95C00 call    dword ptr [<&MFC71.#2321_ATL::CStringT<char,StrTra>;  MFC71.7C18B260
004937D9  |.  83C4 0C       add     esp, 0C
004937DC  |.  68 00E00000   push    0E000
004937E1  |.  8D8D 40FFFFFF lea     ecx, dword ptr [ebp-C0]
004937E7  |.  FF15 2CB95C00 call    dword ptr [<&MFC71.#4035_ATL::CStringT<char,StrTra>;  MFC71.7C153789
004937ED  |.  6A 40         push    40
004937EF  |.  8D8D 40FFFFFF lea     ecx, dword ptr [ebp-C0]
004937F5  |.  FF15 30B95C00 call    dword ptr [<&MFC71.#876_ATL::CSimpleStringT<char,1>;  MFC71.7C158BCD
004937FB  |.  50            push    eax
004937FC  |.  8D8D 44FFFFFF lea     ecx, dword ptr [ebp-BC]
00493802  |.  FF15 30B95C00 call    dword ptr [<&MFC71.#876_ATL::CSimpleStringT<char,1>;  MFC71.7C158BCD
00493808  |.  50            push    eax
00493809  |.  8B8D 30FFFFFF mov     ecx, dword ptr [ebp-D0]
0049380F  |.  E8 5ECE1100   call    <jmp.&MFC71.#4104_CWnd::MessageBoxA>
00493814  |.  C645 FC 02    mov     byte ptr [ebp-4], 2
00493818  |.  8D8D 44FFFFFF lea     ecx, dword ptr [ebp-BC]
0049381E  |.  FF15 68B95C00 call    dword ptr [<&MFC71.#578_ATL::CStringT<char,StrTrai>;  MFC71.7C1771B1
00493824  |.  C645 FC 01    mov     byte ptr [ebp-4], 1
00493828  |.  8D8D 40FFFFFF lea     ecx, dword ptr [ebp-C0]
0049382E  |.  FF15 68B95C00 call    dword ptr [<&MFC71.#578_ATL::CStringT<char,StrTrai>;  MFC71.7C1771B1
00493834  |>  EB 60         jmp     short 00493896                                     ;  !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
00493836  |>  8B8D 4CFFFFFF mov     ecx, dword ptr [ebp-B4]
0049383C  |.  51            push    ecx
0049383D  |.  68 2CF16200   push    0062F12C
00493842  |.  51            push    ecx
00493843  |.  8BCC          mov     ecx, esp
00493845  |.  89A5 34FFFFFF mov     dword ptr [ebp-CC], esp
0049384B  |.  8D55 F0       lea     edx, dword ptr [ebp-10]
0049384E  |.  52            push    edx
0049384F  |.  FF15 38B95C00 call    dword ptr [<&MFC71.#297_ATL::CStringT<char,StrTrai>;  MFC71.7C14E575
00493855  |.  8985 24FFFFFF mov     dword ptr [ebp-DC], eax
0049385B  |.  8D85 54FFFFFF lea     eax, dword ptr [ebp-AC]
00493861  |.  50            push    eax
00493862  |.  B9 E4F26200   mov     ecx, 0062F2E4
00493867  |.  E8 74D9FCFF   call    004611E0                                           ;  调用1：远程桌面的Form
0049386C  |.  8985 20FFFFFF mov     dword ptr [ebp-E0], eax
00493872  |.  8B8D 20FFFFFF mov     ecx, dword ptr [ebp-E0]
00493878  |.  898D 3CFFFFFF mov     dword ptr [ebp-C4], ecx
0049387E  |.  6A 05         push    5
00493880  |.  8B8D 3CFFFFFF mov     ecx, dword ptr [ebp-C4]
00493886  |.  E8 D5CD1100   call    <jmp.&MFC71.#6090_CWnd::ShowWindow>
0049388B  |.  8B8D 3CFFFFFF mov     ecx, dword ptr [ebp-C4]
00493891  |.  E8 1A72F9FF   call    0042AAB0
00493896  |>  C645 FC 00    mov     byte ptr [ebp-4], 0
0049389A  |.  8D4D F0       lea     ecx, dword ptr [ebp-10]
0049389D  |.  FF15 68B95C00 call    dword ptr [<&MFC71.#578_ATL::CStringT<char,StrTrai>;  MFC71.7C1771B1
004938A3  |.  C745 FC FFFFF>mov     dword ptr [ebp-4], -1
004938AA  |.  8D8D 54FFFFFF lea     ecx, dword ptr [ebp-AC]
004938B0  |.  E8 FBD40800   call    00520DB0
004938B5  |>  8B4D F4       mov     ecx, dword ptr [ebp-C]
004938B8  |.  64:890D 00000>mov     dword ptr fs:[0], ecx
004938BF  |.  8B4D EC       mov     ecx, dword ptr [ebp-14]
004938C2  |.  33CD          xor     ecx, ebp
004938C4  |.  E8 C2DF1100   call    005B188B
004938C9  |.  8BE5          mov     esp, ebp
004938CB  |.  5D            pop     ebp
004938CC  \.  C3            retn

找到关键Call.
004936B7  |.  E8 34F2FFFF   call    004928F0    ;  关键Call–remote desk.

修改关键call之后的跳转：

004936C0  |.  E9 F0010000   jmp     004938B5
修改为什么都不作。免得它影响后面的代码。
用9090909090 填充。

经试验，远程桌面功能可以超过20分钟的使用了。

实际摸索中还是走了不少弯路，总结经验为：在OllyDbg中，看过的弄明白的函数，要自己加上注释。 在看其他相关的代码的时候，极有可能就碰到了自己曾经注释过的代码，这样一下子就全通了。

启动电脑进入Xp系统后按以下步骤操作，

jxl操作excel例子（转）

package com.dbs.vote.common.test.excel;

import java.io.File;  
import java.io.FileOutputStream;  
import java.io.OutputStream;  
import java.util.ArrayList;  
import java.util.Date;  
 
import jxl.Cell;  
import jxl.CellType;  
import jxl.Sheet;  
import jxl.Workbook;  
import jxl.WorkbookSettings;  
import jxl.format.Alignment;  
import jxl.format.Border;  
import jxl.format.BorderLineStyle;  
import jxl.format.Colour;  
import jxl.format.VerticalAlignment;  
import jxl.write.Formula;  
import jxl.write.Label;  
import jxl.write.NumberFormat;  
import jxl.write.WritableCellFeatures;  
import jxl.write.WritableCellFormat;  
import jxl.write.WritableFont;  
import jxl.write.WritableSheet;  
import jxl.write.WritableWorkbook;  
import jxl.write.WriteException;  
 
public class JExcelUtils {  
 
    /** 
     * 生成Excel文件 
     * @param path         文件路径 
     * @param sheetName    工作表名称 
     * @param dataTitles   数据标题 
     */ 
   public void createExcelFile(String path,String sheetName,String[] dataTitles){  
       WritableWorkbook workbook;  
       try{  
           OutputStream os=new FileOutputStream(path);   
           workbook=Workbook.createWorkbook(os);   
 
           WritableSheet sheet = workbook.createSheet(sheetName, 0); //添加第一个工作表  
           initialSheetSetting(sheet);  
             
           Label label;  
           for (int i=0; i<dataTitles.length; i++){  
               //Label(列号,行号,内容,风格)  
               label = new Label(i, 0, dataTitles[i],getTitleCellFormat());   
               sheet.addCell(label);   
           }  
 
           //插入一行  
           insertRowData(sheet,1,new String[]{"200201001","张三","100","60","100","260"},getDataCellFormat(CellType.STRING_FORMULA));  
             
           //一个一个插入行  
           label = new Label(0, 2,"200201002",getDataCellFormat(CellType.STRING_FORMULA));   
           sheet.addCell(label);  
             
           label = new Label(1, 2,"李四",getDataCellFormat(CellType.STRING_FORMULA));   
           sheet.addCell(label);  
             
           insertOneCellData(sheet,2,2,70.5,getDataCellFormat(CellType.NUMBER));  
           insertOneCellData(sheet,3,2,90.523,getDataCellFormat(CellType.NUMBER));  
           insertOneCellData(sheet,4,2,60.5,getDataCellFormat(CellType.NUMBER));  
 
           insertFormula(sheet,5,2,"C3+D3+E3",getDataCellFormat(CellType.NUMBER_FORMULA));  
             
           //插入日期  
           mergeCellsAndInsertData(sheet, 0, 3, 5, 3, new Date(), getDataCellFormat(CellType.DATE));  
             
           workbook.write();   
           workbook.close();  
       }catch(Exception e){  
           e.printStackTrace();  
       }  
   }  
     
   /** 
    * 初始化表格属性 
    * @param sheet 
    */ 
   public void initialSheetSetting(WritableSheet sheet){  
      try{  
           //sheet.getSettings().setProtected(true); //设置xls的保护，单元格为只读的  
           sheet.getSettings().setDefaultColumnWidth(10); //设置列的默认宽度  
           //sheet.setRowView(2,false);//行高自动扩展   
           //setRowView(int row, int height);--行高   
           //setColumnView(int  col,int width); --列宽  
           sheet.setColumnView(0,20);//设置第一列宽度  
      }catch(Exception e){  
          e.printStackTrace();  
      }  
   }  
     
   /** 
    * 插入公式 
    * @param sheet 
    * @param col 
    * @param row 
    * @param formula 
    * @param format 
    */ 
   public void insertFormula(WritableSheet sheet,Integer col,Integer row,String formula,WritableCellFormat format){  
       try{  
           Formula f = new Formula(col, row, formula, format);  
           sheet.addCell(f);  
       }catch(Exception e){  
           e.printStackTrace();  
       }  
   }  
     
   /** 
    * 插入一行数据 
    * @param sheet       工作表 
    * @param row         行号 
    * @param content     内容 
    * @param format      风格 
    */ 
   public void insertRowData(WritableSheet sheet,Integer row,String[] dataArr,WritableCellFormat format){  
       try{  
           Label label;  
           for(int i=0;i<dataArr.length;i++){  
               label = new Label(i,row,dataArr[i],format);  
               sheet.addCell(label);  
           }  
       }catch(Exception e){  
           e.printStackTrace();  
       }  
   }  
     
   /** 
    * 插入单元格数据 
    * @param sheet 
    * @param col 
    * @param row 
    * @param data 
    */ 
   public void insertOneCellData(WritableSheet sheet,Integer col,Integer row,Object data,WritableCellFormat format){  
       try{  
           if(data instanceof Double){  
               jxl.write.Number  labelNF = new jxl.write.Number(col,row,(Double)data,format);   
               sheet.addCell(labelNF);   
           }else if(data instanceof Boolean){  
               jxl.write.Boolean labelB = new jxl.write.Boolean(col,row,(Boolean)data,format);   
               sheet.addCell(labelB);   
           }else if(data instanceof Date){  
               jxl.write.DateTime labelDT = new jxl.write.DateTime(col,row,(Date)data,format);   
               sheet.addCell(labelDT);   
               setCellComments(labelDT, "这是个创建表的日期说明！");  
           }else{  
               Label label = new Label(col,row,data.toString(),format);  
               sheet.addCell(label);                 
           }  
       }catch(Exception e){  
           e.printStackTrace();  
       }  
 
  }  
     
   /** 
    * 合并单元格，并插入数据 
    * @param sheet 
    * @param col_start 
    * @param row_start 
    * @param col_end 
    * @param row_end 
    * @param data 
    * @param format 
    */ 
   public void mergeCellsAndInsertData(WritableSheet sheet,Integer col_start,Integer row_start,Integer col_end,Integer row_end,Object data, WritableCellFormat format){  
      try{  
          sheet.mergeCells(col_start,row_start,col_end,row_end);//左上角到右下角  
          insertOneCellData(sheet, col_start, row_start, data, format);  
      }catch(Exception e){  
          e.printStackTrace();  
      }  
 
   }  
     
   /** 
    * 给单元格加注释 
    * @param label 
    * @param comments 
    */ 
   public void setCellComments(Object label,String comments){  
       WritableCellFeatures cellFeatures = new WritableCellFeatures();  
       cellFeatures.setComment(comments);  
       if(label instanceof jxl.write.Number){  
           jxl.write.Number num = (jxl.write.Number)label;  
           num.setCellFeatures(cellFeatures);  
       }else if(label instanceof jxl.write.Boolean){  
           jxl.write.Boolean bool = (jxl.write.Boolean)label;  
           bool.setCellFeatures(cellFeatures);  
       }else if(label instanceof jxl.write.DateTime){  
           jxl.write.DateTime dt = (jxl.write.DateTime)label;  
           dt.setCellFeatures(cellFeatures);  
       }else{  
           Label _label = (Label)label;  
           _label.setCellFeatures(cellFeatures);  
       }  
   }  
     
   /** 
   * 读取excel 
   * @param inputFile 
   * @param inputFileSheetIndex 
   * @throws Exception 
   */ 
   public ArrayList<String> readDataFromExcel(File inputFile, int inputFileSheetIndex){  
      ArrayList<String> list = new ArrayList<String>();  
      Workbook book = null;  
      Cell cell = null;  
      WorkbookSettings setting = new WorkbookSettings();   
      java.util.Locale locale = new java.util.Locale("zh","CN");   
      setting.setLocale(locale);  
      setting.setEncoding("ISO-8859-1");  
      try{  
          book = Workbook.getWorkbook(inputFile, setting);  
      }catch(Exception e){  
          e.printStackTrace();    
      }  
 
      Sheet sheet = book.getSheet(inputFileSheetIndex);  
      for (int rowIndex = 0; rowIndex < sheet.getRows(); rowIndex++) {//行  
       for (int colIndex = 0; colIndex < sheet.getColumns(); colIndex++) {//列  
           cell = sheet.getCell(colIndex, rowIndex);  
           //System.out.println(cell.getContents());  
           list.add(cell.getContents());  
       }  
      }  
      book.close();  
 
      return list;  
   }  
 
   /** 
    * 得到数据表头格式 
    * @return 
    */ 
   public WritableCellFormat getTitleCellFormat(){  
       WritableCellFormat wcf = null;  
       try {  
           //字体样式  
           WritableFont wf = new WritableFont(WritableFont.TIMES,12, WritableFont.NO_BOLD,false);//最后一个为是否italic  
           wf.setColour(Colour.RED);  
           wcf = new WritableCellFormat(wf);  
           //对齐方式  
           wcf.setAlignment(Alignment.CENTRE);  
           wcf.setVerticalAlignment(VerticalAlignment.CENTRE);  
           //边框  
           wcf.setBorder(Border.ALL,BorderLineStyle.THIN);  
             
           //背景色  
           wcf.setBackground(Colour.GREY_25_PERCENT);  
       } catch (WriteException e) {  
        e.printStackTrace();  
       }  
       return wcf;  
   }  
     
   /** 
    * 得到数据格式 
    * @return 
    */ 
   public WritableCellFormat getDataCellFormat(CellType type){  
       WritableCellFormat wcf = null;  
       try {  
           //字体样式  
           if(type == CellType.NUMBER || type == CellType.NUMBER_FORMULA){//数字  
              NumberFormat nf = new NumberFormat("#.00");  
              wcf = new WritableCellFormat(nf);   
           }else if(type == CellType.DATE || type == CellType.DATE_FORMULA){//日期  
               jxl.write.DateFormat df = new jxl.write.DateFormat("yyyy-MM-dd hh:mm:ss");   
               wcf = new jxl.write.WritableCellFormat(df);   
           }else{  
               WritableFont wf = new WritableFont(WritableFont.TIMES,10, WritableFont.NO_BOLD,false);//最后一个为是否italic  
               wcf = new WritableCellFormat(wf);  
           }  
           //对齐方式  
           wcf.setAlignment(Alignment.CENTRE);  
           wcf.setVerticalAlignment(VerticalAlignment.CENTRE);  
           //边框  
           wcf.setBorder(Border.LEFT,BorderLineStyle.THIN);  
           wcf.setBorder(Border.BOTTOM,BorderLineStyle.THIN);  
           wcf.setBorder(Border.RIGHT,BorderLineStyle.THIN);  
           //背景色  
           wcf.setBackground(Colour.WHITE);  
             
           wcf.setWrap(true);//自动换行  
             
       } catch (WriteException e) {  
        e.printStackTrace();  
       }  
       return wcf;  
   }  
     
   /** 
    * 打开文件看看 
    * @param exePath 
    * @param filePath 
    */ 
   public void openExcel(String exePath,String filePath){  
       Runtime r=Runtime.getRuntime();   
       String cmd[]={exePath,filePath};   
       try{   
           r.exec(cmd);   
       }catch(Exception e){  
           e.printStackTrace();  
       }  
   }  
     
   public static void main(String[] args){  
       String[] titles = {"学号","姓名","语文","数学","英语","总分"};   
       JExcelUtils jxl = new JExcelUtils();  
       String filePath = "E:/test.xls";  
       jxl.createExcelFile(filePath,"成绩单",titles);  
       jxl.readDataFromExcel(new File(filePath),0);  
       jxl.openExcel("C:/Program Files/Microsoft Office/OFFICE11/EXCEL.EXE",filePath);  
   }  
} 

使用 AppFuse 的七个理由

学习 Java 开放源码工具 —— 并使用这些工具提高生产效率

文档选项 将此页作为电子邮件发送 未显示需要 JavaScript 的文档选项 级别： 初级 Matt Raible (mraible@virtuas.com), 开放源码实践先驱, Virtuas Open Source Solutions 2006 年 8 月 31 日 开始学习在 Java™ 平台上使用诸如 Spring、Hibernate 或 MySQL 之类的开放源码工具时可能非常困难。再加上 Ant 或 Maven，以及与 DWR 一起的小 Ajax，还有 Web 框架 —— 即 JSF，我们必须睁大眼睛盯着如何配置应用程序。AppFuse 减少了集成开放源码项目的痛苦。它可以把测试变成一等公民，让我们可以从数据库表生成整个 UI，并使用 XFire 来支持 Web 服务。另外，AppFuse 的社区也非常健全，这是不同 Web 框架用户可以一起融洽相处的地方之一。 AppFuse 是一个开放源码的项目和应用程序，它使用了在 Java 平台上构建的开放源码工具来帮助我们快速而高效地开发 Web 应用程序。我最初开发它是为了减少在为客户构建新 Web 应用程序时所花费的那些不必要的时间。从核心上来说，AppFuse 是一个项目骨架，类似于通过向导创建新 Web 项目时 IDE 所创建的东西。当我们使用 AppFuse 创建一个项目时，它会提示我们将使用开放源码框架，然后才创建项目。它使用 Ant 来驱动测试、代码生成、编译和部署。它提供了目录和包结构，以及开发基于 Java 语言的 Web 应用程序所需要的库。 与大部分 “new project” 向导不同，AppFuse 创建的项目从最开始就包含很多类和文件。这些文件用来实现特性，不过它们同时也会在您开发应用程序时被用作示例。通过使用 AppFuse 启动新项目，我们通常可以减少一到两周的开发时间。我们不用担心如何将开放源码框架配置在一起，因为这都已经完成了。我们的项目都已提前配置来与数据库进行交互，它会部署到应用服务器上，并对用户进行认证。我们不必实现安全特性，因为这都早已集成了。 当我最初开发 AppFuse 时，它只支持 Struts 和 Hibernate。经过几年的努力，我发现了比 Struts 更好的 Web 框架，因此我还添加了为这些 Web 框架使用的选项。现在，AppFuse 可以支持 Hibernate 或 iBATIS 作为持久性框架。对于 Web 框架来说，我们可以使用 JavaServer Faces（JSF）、Spring MVC、Struts、Tapestry 或 WebWork。 AppFuse 提供了很多应用程序需要的一些特性，包括： 认证和授权 用户管理 Remember Me（这会保存您的登录信息，这样就不用每次都再进行登录了） 密码提醒 登记和注册 SSL 转换 E-mail URL 重写 皮肤 页面修饰 模板化布局 文件上载 这种 “开箱即用” 的功能是 AppFuse 与其他 CRUD 代 框架的区别之一（CRUD 取自创建、检索、更新 和删除 几个操作的英文首字母），包括 Ruby on Rails、Trails 和 Grails。上面提到的这些框架，以及 AppFuse，都让我们可以从数据库表或现有的模型对象中生成主页/细节页。 图 1 阐述了一个典型 AppFuse 应用程序的概念设计： 图 1. 典型的 AppFuse 应用程序 清单 1 给出了我们在创建 devworks 项目时所使用的命令行交互操作，同时还给出了所生成的结果。这个项目使用了 WebWork 作为自己的 Web 框架（请参考下面 参考资料 一节给出的链接）。 清单 1. 使用 AppFuse 创建新项目 alotta:~/dev/appfuse mraible$ ant new Buildfile: build.xml clean: [echo] Cleaning build and distribution directories init: new: [echo] [echo] +-------------------------------------------------------------+ [echo] | -- Welcome to the AppFuse New Application Wizard! -- | [echo] | | [echo] | To create a new application, please answer the following | [echo] | questions. | [echo] +-------------------------------------------------------------+ [input] What would you like to name your application [myapp]? devworks [input] What would you like to name your database [mydb]? devworks [input] What package name would you like to use [org.appfuse]? com.ibm [input] What web framework would you like to use [webwork,tapestry,spring,js f,struts]? webwork [echo] Creating new application named 'devworks'... [copy] Copying 359 files to /Users/mraible/Work/devworks [copy] Copying 181 files to /Users/mraible/Work/devworks/extras [copy] Copying 1 file to /Users/mraible/Work/devworks [copy] Copying 1 file to /Users/mraible/Work/devworks install: [echo] Copying WebWork JARs to ../../lib [copy] Copying 6 files to /Users/mraible/Work/devworks/lib [echo] Adding WebWork entries to ../../lib.properties [echo] Adding WebWork classpath entries [echo] Removing Struts-specific JARs [delete] Deleting directory /Users/mraible/Work/devworks/lib/struts-1.2.9 [delete] Deleting directory /Users/mraible/Work/devworks/lib/strutstest-2.1.3 [echo] Deleting struts_form.xdt for XDoclet [delete] Deleting directory /Users/mraible/Work/devworks/metadata/templates [echo] Deleting Struts merge-files in metadata/web [delete] Deleting 7 files from /Users/mraible/Work/devworks/metadata/web [echo] Deleting unused Tag Libraries and Utilities [delete] Deleting 2 files from /Users/mraible/Work/devworks/src/web/org/appfu se/webapp [echo] Modifying appgen for WebWork [copy] Copying 12 files to /Users/mraible/Work/devworks/extras/appgen [echo] Replacing source and test files [delete] Deleting directory /Users/mraible/Work/devworks/src/web/org/appfuse/ webapp/form [delete] Deleting directory /Users/mraible/Work/devworks/src/web/org/appfuse/ webapp/action [copy] Copying 13 files to /Users/mraible/Work/devworks/src [delete] Deleting directory /Users/mraible/Work/devworks/test/web/org/appfuse /webapp/form [delete] Deleting directory /Users/mraible/Work/devworks/test/web/org/appfuse /webapp/action [copy] Copying 5 files to /Users/mraible/Work/devworks/test [echo] Replacing web files (images, scripts, JSPs, etc.) [delete] Deleting 1 files from /Users/mraible/Work/devworks/web/scripts [copy] Copying 34 files to /Users/mraible/Work/devworks/web [delete] Deleting: /Users/mraible/Work/devworks/web/WEB-INF/validator-rules-c ustom.xml [echo] Modifying Eclipse .classpath file [echo] Refactoring build.xml [echo] ---------------------------------------------- [echo] NOTE: It's recommended you delete extras/webwork as you shouldn't ne ed it anymore. [echo] ---------------------------------------------- [echo] Repackaging info written to rename.log [echo] [echo] +-------------------------------------------------------------+ [echo] | -- Application created successfully! -- | [echo] | | [echo] | Now you should be able to cd to your application and run: | [echo] | > ant setup test-all | [echo] +-------------------------------------------------------------+ BUILD SUCCESSFUL Total time: 15 seconds 为什么使用 WebWork？ Struts 社区最近在热情地拥抱 WebWork，这种结合导致为 Java 平台提供了一个非常优秀的新 Web 框架：Struts 2。当然，Spring MVC 是一个非常优秀的基于请求的框架，但是它不能像 Struts 2 一样支持 JSF。基于内容的框架（例如 JSF 和 Tapestry）也都很好，但是我发现 WebWork 更为直观，更容易使用（更多有关 Structs 2 和 JSF 的内容请参看 参考资料）。 在创建一个新项目之后，我们就得到了一个类似于图 2 所示的目录结构。Eclipse 和 Intellij IDEA 项目文件都是作为这个过程的一部分创建的。 图 2. 项目的目录结构 这个目录结构与 Sun 为 Java 2 Platform Enterprise Edition（J2EE）Web 应用程序推荐的目录结构非常类似。在 2.0 版本的 AppFuse 中，这个结构会变化成适合 Apache Maven 项目的标准目录结构（有关这两个目录介绍的内容，请参看 参考资料 中的链接）。AppFuse 还会从 Ant 迁移到 Maven 2 上，从而获得相关下载的能力和对生成 IDE 项目文件的支持。目前基于 Ant 的系统要求提交者维护项目文件，而 Maven 2 可以通过简单地使用项目的 pom.xml 文件生成 IDEA、Eclipse 和 NetBeans 项目文件。（这个文件位于您项目的根目录中，是使用 Maven 构建应用程序所需要的主要组件）。它与利用 Ant 所使用的 build.xml 文件非常类似。） 现在我们对 AppFuse 是什么已经有一点概念了，在本文剩下的部分中，我们将介绍使用 AppFuse 的 7 点理由。即使您选择不使用 AppFuse 来开始自己的项目，也会看到 AppFuse 可以为您提供很多样板代码，这些代码可以在基于 Java 语言的 Web 应用程序中使用。由于它是基于 Apache 许可证的，因此非常欢迎您在自己的应用程序中重用这些代码。 理由 1：测试 测试是在软件开发项目中很少被给予足够信任的一个环节。注意我并不是说在软件开发的一些刊物中没有得到足够的信任！很多文章和案例研究都给出了测试优先的开发方式和足够的测试覆盖面以提高软件的质量。然而，测试通常都被看作是一件只会延长项目开发时间的事情。实际上，如果我们使用测试优先的方法在编写代码之前就开始撰写测试用例，我相信我们可以发现这实际上会加速 开发速度。另外，测试优先也可以使维护和重用更加 容易。如果我们不编写代码来测试自己的代码，那么就需要手工对应用程序进行测试 —— 这通常效率都不高。自动化才是关键。 当我们首次开始使用 AppFuse 时，我们可能需要阅读这个项目 Web 站点上提供的快速入门指南和教程（请参看 参考资料 中的链接）。这些教程的编写就是为了您可以首先编写测试用例；它们直到编写接口和/或实现之后才能编译。如果您有些方面与我一样，就会在开始编写代码之前就已经编写好测试用例了；这是真正可以加速编写代码的惟一方式。如果您首先编写了代码的实现，通过某种方式验证它可以工作，那么您可能会对自己说，“哦，看起来不错 —— 谁需要测试呢？我还有更多的代码需要编写！”这种情况不幸的一面是您通常都会做一些事情 来测试自己的代码；您简单地跳过了可以自动化进行测试的地方。 AppFuse 的文档展示了如何测试应用程序的所有 层次。它从数据库层开始入手，使用了 DbUnit（请参看 参考资料）在运行测试之前提前使用数据来填充自己的数据库。在数据访问（DAO）层，它使用了 Spring 的 AbstractTransactionalDataSourceSpringContextTests 类（是的，这的确是一个类的名字！）来允许简单地加载 Spring 上下文文件。另外，这个类对每个 testXXX() 方法封装了一个事务，并当测试方法存在时进行回滚。这种特性使得测试 DAO 逻辑变得非常简单，并且不会对数据库中的数据造成影响。 在服务层，jMock （请参看 参考资料）用来编写那些可以消除 DAO 依赖的真正 单元测试。这允许进行验证业务逻辑正确的快速测试；我们不用担心底层的持久性逻辑。 HtmlUnit 支持 HtmlUnit 团队在 1.8 发行版中已经完成了相当多的工作来确保包可以与流行的 Ajax 框架（Prototype 和 Scriptaculous）很好地工作。 在 Web 层，测试会验证操作（Struts/WebWork）、控件（Spring MVC）、页面（Tapestry）和管理 bean（JSF）如我们所期望的一样进行工作。Spring 的 spring-mock.jar 可以非常有用地用来测试所有这些框架，因为它包含了一个 Servlet API 的仿真实现。如果没有这个有用的库，那么测试 AppFuse 的 Web 框架就会变得非常困难。 UI 通常是开发 Web 应用程序过程中最为困难的一部分。它也是顾客最经常抱怨的地方 —— 这既是由于它并不是非常完美，也是由于它的工作方式与我们期望的并不一样。另外，没有什么会比在客户面前作演示的过程中看到看到异常堆栈更糟糕的了！您的应用程序可能会非常可怕，但是客户可能会要求您做到十分完美。永远不要让这种事情发生。Canoo WebTest 可以对 UI 进行测试。它使用了 HtmlUnit 来遍历测试 UI，验证所有的元素都存在，并可以填充表单的域，甚至可以验证一个假想的启用 Ajax 的 UI 与我们预期的工作方式一样。（有关 WebTest 和 HTMLUnit 的链接请参看 参考资料。） 为了进一步简化 Web 的测试，Cargo（请参看 参考资料）对 Tomcat 的启动和停止（分别在运行 WebTest 测试之前和之后）进行了自动化。 回页首 理由 2：集成 正如我在本文简介中提到的一样，很多开放源码库都已经预先集成到 AppFuse 中了。它们可以分为以下几类： 编译、报告和代码生成：Ant、Ant Contrib Tasks、Checkstyle、EMMA、Java2Html、PMD 和 Rename Packages 测试框架：DbUnit、Dumbster、jMock、JUnit 和 Canoo WebTest 数据库驱动程序：MySQL 和 PostgreSQL 持久性框架：Hibernate 和 iBATIS IoC 框架：Spring Web 框架：JSF、Spring MVC、Struts、Tapestry 和 WebWork Web 服务：XFire Web 工具：Clickstream、Display Tag、DWR、JSTL、SiteMesh、Struts Menu 和 URL Rewrite Filter Security：Acegi Security JavaScript 和 CSS：Scriptaculous、Prototype 和 Mike Stenhouse 的 CSS Framework 除了这些库之外，AppFuse 还使用 Log4j 来记录日志，使用 Velocity 来构建 e-mail 和菜单模板。Tomcat 可以支持最新的开发，我们可以使用 1.4 或 5 版本的 Java 平台来编译或构建程序。我们应该可以将 AppFuse 部署到任何 J2EE 1.3 兼容的应用服务器上；这已经经过了测试，我们知道它在所有主要版本的 J2EE 服务器和所有主要的 servlet 容器上都可以很好地工作。 图 3 给出了上面创建的 devworks 项目的 lib 目录。这个目录中的 lib.properties 文件控制了每个依赖性的版本号，这意味着我们可以简单地通过把这些包的新版本放到这个目录中并执行诸如 ant test-all -Dspring.version=2.0 之类的命令来测试这些包的新版本。 图 3. 项目依赖性 预先集成这些开放源码库可以在项目之初极大地提高生产效率。尽管我们可以找到很多文档介绍如何集成这些库，但是定制工作示例并简单地使用它来开发应用程序要更加简单。 除了可以简化 Web 应用程序的开发之外，AppFuse 让我们还可以将 Web 服务简单地集成到自己的项目中。尽管 XFire 也在 AppFuse 下载中一起提供了，不过如果我们希望，也可以自己集成 Apache Axis（请参看 参考资料 中有关 Axis 集成的教程）。另外，Spring 框架和 XFire 可以一起将服务层作为 Web 服务非常简单地呈现出来，这就为我们提供了开发面向服务架构的能力。 另外，AppFuse 并不会将我们限定到任何特定的 API 上。它只是简单地对可用的最佳开放源码解决方案重新进行打包和预先集成。AppFuse 中的代码可以处理这种集成，并实现了 AppFuse 的基本安全性和可用性特性。只要可能，就会减少代码，以便向 AppFuse 的依赖框架添加一个特性。例如，AppFuse 自带的 Remember Me 和 SSL 切换特性最近就因为类似的特性而从 Acegi Security 中删除了。 回页首 理由 3：自动化 Ant 使得简化了从编译到构建再到部署的自动化过程。Ant 是 AppFuse 中的一等公民，这主要是因为我发现在命令行中执行操作比从 IDE 中更加简单。我们可以使用 Ant 实现编译、测试、部署和执行任何代码生成的任务。 尽管这种能力对于有些人来说非常重要，但是它并不适用于所有的人。很多 AppFuse 用户目前都使用 Eclipse 或 Intellij IDEA 来构建和测试自己的项目。在这些 IDE 中运行 Ant 的确可以工作，但是这样做的效率通常都不如使用 IDE 内置的 JUnit 支持来运行测试效率高。 幸运的是，AppFuse 支持在 IDE 中运行测试，不过管理这种特性对于 AppFuse 开发人员来说就变得非常困难了。最大的痛苦在于 XDoclet 用来生成 Hibernate 映射文件和 Web 框架所使用的一些工件（例如 ActionForms 和 Struts 使用的 struts-config.xml）。IDE 并不知道需要生成的代码，除非我们配置使用 Ant 来编译它们，或者安装了一些可以认识 XDoclet 的插件。 这种对知识的缺乏是 AppFuse 2.0 切换到 JDK 5 和 Maven 2 上的主要原因。JDK 5、注释和 Struts 2 将让我们可以摆脱 XDoclet。Maven 2 将使用这些生成的文件和动态类路径来生成 IDE 项目文件，这样对项目的管理就可以进行简化。目前基于 Ant 的编译系统已经为不同的层次生成了一些工件（包括 dao.jar、service.jar 和 webapp.war），因此切换到 Maven 的模型上应该是一个非常自然的调整。 除了 Ant 之外（它对于编译、测试、部署和报告具有丰富的支持），对于 CruiseControl 的支持也构建到了 AppFuse 中。CruiseControl 是一个 Continuous Integration 应用程序，让我们可以在源代码仓库中代码发生变化时自动运行所有的测试。extras/cruisecontrol 目录包含了我们为基于 AppFuse 的项目快速、简单地设置 Continuous Integration 时所需要的文件。 设置 Continuous Integration 是软件开发周期中我们首先要做的事情之一。它不但激发程序员去编写测试用例，而且还通过 “You broke the build!” 游戏促进了团队之间的合作和融合。 回页首 理由 4：安全特性和可扩展性 AppFuse 最初是作为我为 Apress 编写的书籍 Pro JSP 中示例应用程序的一部分开发的。这个示例应用程序展示了很多安全特性和用于简化 Struts 开发的特性。这个应用程序中的很多安全特性在 J2EE 的安全框图中都不存在。使用容器管理认证（CMA）的认证方法非常简单，但是 Remember Me、密码提示、SSL 切换、登记和用户管理等功能却都不存在。另外，基于角色的保护方法功能在非 EJB 环境中也是不可能的。 最初，AppFuse 使用自己的代码和用于 CMA 的解决方案完全实现了这些特性。我在 2004 年年初开始学习 Spring 时就听说过有关 Acegi Security 的知识。我对 Acegi 所需要的 XML 的行数（175）与 web.xml 中所需要的 CMA 的行数（20）进行了比较，很快就决定丢弃 Acegi 了，因为它太过复杂了。 一年半之后 —— 在为另外一本书 Spring Live 中编写了一章有关使用 Acegi Security 的内容之后 —— 我就改变了自己的想法。Acegi 的确（目前仍然）需要很多 XML，但是一旦我们理解了这一点，它实际上是相当简单的。当我们最终作出改变，使用 Acegi Security 的特性来全部取代 AppFuse 的特性之后，我们最终删除了大量的代码。类之上的类都已经没有了，“Acegi handles that now” 中消失的部分现在全部进入了 CVS 的 Attic 中了。 Acegi Security 是 J2EE 安全模型中曾经出现过的最好模型。它让我们可以实现很多有用的特性，这些特性在 Servlet API 的安全模型中都不存在：认证、授权、角色保护方法、Remember Me、密码加密、SSL 切换、用户切换和注销。它让我们还可以将用户证书存储到 XML 文件、数据库、LDAP 或单点登录系统（例如 Yale 的 Central Authentication Service (CAS) 或者 SiteMinder）中。 AppFuse 对很多与安全性相关的特性的实现从一开始都是非常优秀的。现在 AppFuse 使用了 Acegi Security，这些特性 —— 以及更多特性 —— 都非常容易实现。Acegi 有很多地方都可以进行扩充：这是它使用巨大的 XML 配置文件的原因。正如我们已经通过去年的课程对 Acegi 进行集成一样，我们已经发现对很多 bean 的定义进行定制可以更加紧密地与 AppFuse 建立联系。 Spring IoC 容器和 Acegi Security 所提供的简单开发、容易测试的代码和松耦合特性的组合是 AppFuse 是这么好的一种开发平台的主要原因。这些框架都是不可插入的，允许生成干净的可测试代码。AppFuse 集成了很多开放源码项目，依赖注入允许对应用程序层进行简单的集成。 回页首 理由 5：使用 AppGen 生成代码 有些人会将代码生成称为代码气味的散播（code smell）。在他们的观点中，如果我们需要生成代码，那么很可能就会做一些错事。我倾向于这种确定自己代码使用的模式和自动化生成代码的能力应该称为代码香味的弥漫（code perfume）。如果我们正在编写类似的 DAO、管理器、操作或控件，并且不想为它们生成代码，那么这就需要根据代码的气味来生成代码。当然，当语言可以为我们提供可以简化任务的特性时，一切都是那么美好；不过代码生成通常都是一个必需 —— 通常其生产率也非常高 —— 的任务。 AppFuse 中提供了一个基于 Ant 和 XDoclet 的代码生成工具，名叫 AppGen。默认情况下，常见的 DAO 和管理器都可以允许我们对任何普通老式 Java 对象（POJO）进行 CRUD 操作，但是在 Web 层上这样做有些困难。AppGen 有几个特性可以用来执行以下任务： （使用 Middlegen 和 Hibernate 工具）从数据库表中生成 POJO 从 POJO 生成 UI 为 DAO、管理器、操作/控制器和 UI 生成测试 在运行 AppGen 时，您会看到提示说 AppGen 要从数据库表或 POJO 中生成代码。如果在命令行中执行 ant install-detailed，AppGen 就会安装 POJO 特定的 DAO、管理器以及它们的测试。运行 ant install 会导致 Web 层的类重用通用的 DAO 和默认存在的管理器。 为了阐述 AppGen 是如何工作的，我们在 devworks MySQL 数据库中创建了如清单 2 所示的表： 清单 2. 创建一个名为 cat 的数据库表 create table cat ( cat_id int(8) auto_increment, color varchar(20) not null, name varchar(20) not null, created_date datetime not null, primary key (cat_id) ) type=InnoDB; 在 extras/appgen 目录中，运行 ant install-detailed。这个命令的输出结果对于本文来说实在太长了，不过我们在清单 3 中给出了第一部分的内容： 清单 3. 运行 AppGen 的 install-detailed 目标 $ ant install-detailed Buildfile: build.xml init: [mkdir] Created dir: /Users/mraible/Work/devworks/extras/appgen/build [echo] [echo] +-------------------------------------------------------+ [echo] | -- Welcome to the AppGen! -- | [echo] | | [echo] | Use the "install" target to use the generic DAO and | [echo] | Manager, or use "install-detailed" to general a DAO | [echo] | and Manager specifically for your model object. | [echo] +-------------------------------------------------------+ [input] Would you like to generate code from a table or POJO? (table,pojo) table [input] What is the name of your table (i.e. person)? cat [input] What is the name, if any, of the module for your table (i.e. organization)? [echo] Running Middlegen to generate POJO... 要对 cat 表使用这个新生成的代码，我们需要修改 src/dao/com/ibm/dao/hibernate/applicationContext-hibernate.xml，来为 Hibernate 添加 Cat.hbm.xml 映射文件。清单 3 给出了我们修改后的 sessionFactory bean 的样子： 清单 4. 将 Cat.hbm.xml 添加到 sessionFactory bean 中 <bean id="sessionFactory" class="..."> <property name="dataSource" ref="dataSource"/> <property name="mappingResources"> <list> <value>com/ibm/model/Role.hbm.xml</value> <value>com/ibm/model/User.hbm.xml</value> <value>com/ibm/model/Cat.hbm.xml</value> </list> </property> ... </bean> 在运行 ant setup deploy 之后，我们就应该可以在部署的应用程序中对 cat 表执行 CRUD 操作了： 图 4. Cat 列表 图 5. Cat 表单 我们在上面的屏幕快照中看到的记录都是作为代码生成的一部分创建的，因此现在就有测试数据了。 回页首 理由 6：文档 我们可以找到 AppFuse 各个风味的教程，并且它们都以 6 种不同的语言给出了：中文、德语、英语、韩语、葡萄牙语和西班牙语。使用风味（flavor） 一词，我的意思是不同框架的组合，例如 Spring MVC 加上 iBATIS、Spring MVC 加上 Hibernate 或 JSF 加上 Hibernate。使用这 5 种 Web 框架和两种持久框架，可以有好几种组合。有关它们的翻译，AppFuse 为自己的默认特性提供了 8 种翻译。可用语言包括中文、荷兰语、德语、英语、法语、意大利语、葡萄牙语和西班牙语。 除了核心教程之外，还添加了很多教程（请参看 参考资料） 来介绍与各种数据库、应用服务器和其他开放源码技术（包括 JasperReports、Lucene、Eclipse、Drools、Axis 和 DWR）的集成。 回页首 理由 7：社区 Apache 软件基金会对于开放源码有一个有趣的看法。它对围绕开放源码项目开发一个开放源码社区最感兴趣。它的成员相信如果社区非常强大，那么产生高质量的代码就是一个自然的过程。下面的内容引自 Apache 主页： “我们认为自己不仅仅是一组共享服务器的项目，而且是一个开发人员和用户的社区。” AppFuse 社区从 2003 年作为 SourceForge 上的一个项目（是 struts.sf.net 的一部分）启动以来，已经获得了极大的增长。通过在 2004 年 3 月转换到 java.net 上之后，它已经成为这里一个非常流行的项目，从 2005 年 1 月到 3 月成为访问量最多的一个项目。目前它仍然是一个非常流行的项目（有关 java.net 项目统计信息的链接，请参看 参考资料），不过在这个站点上它正在让位于 Sun 赞助的很多项目。 在 2004 年年末，Nathan Anderson 成为继我之后第一个提交者。此后有很多人都加入了进来，包括 Ben Gill、David Carter、Mika G?ckel、Sanjiv Jivan 和 Thomas Gaudin。很多现有的提交者都已经通过各种方式作出了自己的贡献，他们都帮助 AppFuse 社区成为一个迅速变化并且非常有趣的地方。 邮件列表非常友好，我们试图维护这样一条承诺 “没有问题是没有人理会的问题”。我们的邮件列表归档文件中惟一一条 “RTFM” 是从用户那里发出的，而不是从开发者那里发出的。我们绝对信奉 Apache 开放源码社区的哲学。引用我最好的朋友 Bruce Snyder 的一句话，“我们为代码而来，为人们而留下”。目前，大部分开发者都是用户，我们通常都喜欢有一段美妙的时间。另外，大部分文档都是由社区编写的；因此，这个社区的知识是非常渊博的。 回页首 结束语 我们应该尝试使用 AppFuse 进行开发，这是因为它允许我们简单地进行测试、集成、自动化，并可以安全地生成 Web 应用程序。其文档非常丰富，社区也非常友好。随着其支撑框架越来越好，AppFuse 也将不断改进。 从 AppFuse 2.0 开始，我们计划迁移到 JDK 5（仍然支持部署到 1.4）和 Maven 2 上去。这些工具可以简化使用 AppFuse 的开发、安装和升级。我们计划充分利用 Maven 2 的功能来处理相关依赖性。我们将碰到诸如 appfuse-hibernate-2.0.jar 和 appfuse-jsf-2.0.jar 之类的工件。这些工件都可以在 pom.xml 文件中进行引用，它们负责提取其他相关依赖性。除了在自己的项目中使用 AppFuse 基类之外，我们还可以像普通的框架一样在 JAR 中对这些类简单地进行扩展，这应该会大大简化它的升级过程，并鼓励更多用户将自己希望的改进提交到这个项目中。 如果没有其他问题，使用 AppFuse 可以让您始终处于 Java Web 开发的技术前沿上 —— 就像我们一样！ 参考资料 学习 您可以参阅本文在 developerWorks 全球站点上的 英文原文 。 AppFuse：该项目的主页。 AppFuse Demos：查看演示和视频。 Struts 2 和 JSF：了解为什么要将这些技术放到一起工作。 Sun 的 J2EE 项目目录结构指南：AppFuse 非常接近于这些指南。 Maven 的 Standard Directory Layout：AppFuse 2.0 将转换到这个目录结构上。 AppFuse 快速入门指南：快速入门并使用 AppFuse。 AppFuse 教程：深入学习更多有关使用 AppFuse 的知识。 Apache Axis 集成：如何将 Apache Axis 集成到自己的 AppFuse 项目中。 Java.net 项目状态：请查看 2005 年 1 月、2 月 和 3 月 的动态。还可以查看 java.net 上的最佳项目 。 获得产品和技术 AppFuse on java.net：下载不同风味的 AppFuse。 WebWork：了解这个易于使用的 Web 框架。 DbUnit：查看更多有关 JUnit 扩展的内容。 jMock：创建动态仿真对象来简化真正的单元测试。 Canoo WebTest：自动化 Web 应用程序的 UI 测试。 HtmlUnit：WebTest 的优秀 JavaScript 支持背后的基础。 Cargo：自动启动和停止容器。 Greenbox：一种代码生成框架。 讨论 AppFuse 论坛：与同行开发人员交流技巧。 关于作者 Matt Raible 居住在美国科罗拉多州的丹佛，他在那里是 Spring 和 Web 框架对 Virtuas Open Source Solutions 的实践先驱。他在开放源码领域具有丰富的经验，是这个领域的专家。他在这个领域中既是用户，又是一名开发人员。Matt 是 SourceBeat Publishing 上 Spring Live 的作者。他还为 Apress 的书籍 Pro JSP Third Edition 作出了很大的贡献。他是很多开放源码会议的积极倡导者，包括 ApacheCon、MySQL User's Conference 和 OSCON，同时他还是 http://raibledesigns.com 上一名非常活跃的博客。Raible 的大部分生活都被计算机所包围了，尽管他是在连电都没有的 Montana 长大的。当不工作的时候时，他总是试图让妻子 Julie 成为世界上最幸福的女人，或者与他们的孩子 Abbie 和 Jack 一起玩耍。

1.   概述

开源的BI项目在在2005年之前并没有太大的发展，到了2005年才开始呈现繁荣之势，并在2006年蓬勃发展。这些众多的BI项目从规模和对BI系统支撑的完善程度上来说，大体可以分为Framework、Stand-alone Tools和BI Suit三种类型。

l         Framework

开源框架，这是在商业BI系统中所没有的。我们可以使用它们来构建自己的BI工具，或者增强和扩展我们的BI解决方案。

l         Stand-alone Tools

独立的BI工具，这是开源项目中数量最多的一类。很多工具只侧重BI系统中的某个环节和方面，如ETL、Report、OLAP和Database等等。

l         BI Suit

在统一的架构下提供了多种BI系统的特性的工具集合。就目前的情况看，不管是商业软件还是开源软件，还没有任何一个套件提供了完整的端到端的BI解决方案。这些开源的BI Suit是通过连接多个其他的组件和工具的方式形成套件的，由于BI系统涉及到的工具是非常多的，所以整合一套完整的BI解决方案是很困难的。

2.   BI解决方案中的工具

一个完整的BI解决方案中有多种工具来完成BI系统中各个阶段的工作。

2.1. ETL工具

数据抽取、转换和加载工具。优秀的ETL工具应该具有以下特性：

1、  Workflow Management, Job Execution and Scheduling Manager。能方便地定义流程并自动化执行ETL任务。

2、  Centralized Metadata Repository and Management。集中存储和管理符合业界标准的元数据。

3、  Data Profile and Validation。可以检验数据的质量。

4、  High Performance。在大负荷的任务执行中仍然有良好的性能。

5、  Scalable, Platform Independent。具有良好的弹性，支持多种操作系统和数据库系统，能操作多种异构的数据源。

6、  Open Architecture and API。具有开放的架构和易于使用的二次开发接口。

目前较为知名的开源ETL工具有：

1、  KETL，由具有IBM和KPMG背景的Kinetic Networks公司开发，现在已经有三年多的产品应用历史，成功应用于一些产品中，在点击流（ClickStream）分析应用中表现出色。KETL采用Plug-in的架构，使用Java开发。

2、  KETTLE，为一个元数据驱动的ETL工具。已经加入Pentaho。

3、  Clover ETL，为一个基于Java的ETL Framework，可以用来开发自己的ETL应用。

4、  Enhydra Octopus，为一个基于Java的ETL工具，使用JDBC来连接各种数据源，易于使用和部署。曾有人应用于电信网络资源分析系统中。

2.2. 报表工具

优秀的报表工具通常具有以下特性：

1、  支持多种数据源。

2、  直观的可视化设计器，简单易用的报表定制功能。

3、  方便的数据访问和格式化，丰富的数据呈现方式。

4、  符合数据呈现的通用标准，能和应用程序很好地进行结合。

5、  易于扩展和部署。

目前较为知名的开源报表工具有：

1、  JasperReports，一个优秀的Java报表工具，始于2001，现在JasperSoft公司持续开发和支持该工具。该工具类似于商业软件Crystal Report，支持PDF、HTML、XLS、CSV和XML文件输出格式，现在是Java开发者最常用的报表工具。

2、  OpenReports，提供基于web的灵活报表解决方案，通过浏览器自动生成动态PDF,XLS,HTMLCSV 和Chart报表，它是用Java开发的，使用JasperReports 作为报表引擎，利用到的开源技术有Hibernate,Veloctiy,Webwork。

3、  JFreeReport，现在是Pentaho的一部分，它是一个优秀的用来生成报表的Java类库。它为Java应用程序提供一个灵活的打印 功能并支持输出到打印机和PDF, Excel, HTML和XHTML, PlainText, XML和CSV文件中。

4、  Eclipse BIRT，是Eclipse下面的一个企业智能和报表 工具，能为J2EE的WEB应用程序创建漂亮醒目的PDF或者HTML格式的报表，它提供了核心的报表功能。

2.3. OLAP工具

联机分析处理工具。目前开源的OLAP工具也分为MOLAP、ROLAP和HOLAP，优秀的OLAP工具通常有以下特性：

1、  良好的执行性能，能快速地进行分析处理工作。

2、  良好的适用性和可伸缩性。

3、  开放式接口和丰富的API。

目前较为知名的开源OLAP工具有：

1、  Mondrian，是Pentaho的一部分，为一个用Java开发的OLAP服务器，实现了MDX语言、XML解析和JOLAP规范，可以不写SQL就能分析存储于SQL 数据库的庞大数据集，可以封装JDBC数据源并把数据以多维的方式展现出来。

2、  JPivot，是一个JSP 自定制的标签库，可以绘制一个OLAP表格和图表。用户可以执行 典型的OLAP导航，如下钻，切片和方块。它使用Mondrian 作为其OLAP服务器。它使用WCF (Web Component Framework) ，基于XML/XSLT来渲染Web UI组件。JPivot在元数据缓存方面的过于简化的整体性初始化装载的做法将限制它只能处理很小的立方体（Cube）。

2.4. 数据库

开源的数据库也有很多，大多数为关系型数据库，少数为应用于数据仓库环境做了专门的优化工作。Bizgres以PostgreSQL为基础进行了数据仓库环境下的优化，提高了分析查询性能。

3.   开源BI套件

下面列出相对成熟和完整，并且有借鉴意义的开源BI套件。

3.1. Bizgres

为GreenPlum公司主导的开源项目，和Sun公司达成合作关系。Bizgres为BI应用而对PostgreSQL做了优化，提高了大负荷的并行计算能力，在BI环境中，相对于普通的关系型数据库具有卓越的数据处理性能。Bizgres的数据库平台可以和KETL和JasperReports进行整合，从而形成一个BI套件：

1、  数据库：BI专业数据库Bizgres，或者大型应用中的高性能服务器Bizgres MPP，能比普通关系数据库快20倍

2、  ETL工具：KETL

3、  报表工具：JasperReports

3.2. Openi

是一个Java开发的Web应用，能对OLAP服务器、关系数据库和数据挖掘服务器进行分析和报表展示，非常易于使用和部署，界面美观友好，后续还将支持数据挖掘和ETL等。Openi主要包括：

1、  OLAP展示：JPivot

2、  报表工具：JFreeChart

3、  分析数据源连接器

3.3. Pentaho

是一个以工作流为核心的、强调面向解决方案而非工具组件的BI套件，整合了多个开源项目，目标是和商业BI相抗衡。它包括：

1、  工作流引擎：Shark and JaWE

2、  数据库：Firebird RDBMS

3、  集成管理和开发环境：Eclipse

4、  报表工具：Eclipse BIRT

5、  ETL工具：Enhydra/Kettle

6、  OLAP Server：Mondrian

7、  OLAP展示：JPivot

8、  数据挖掘组件：Weka

9、  应用服务器和Portal服务器：JBoss

10、              单点登陆服务及LDap认证：JOSSO

11、              自定义脚本支持：Mozilla Rhino Javascript脚本处理器

由上可见Pentaho是一个很完善的BI解决方案。Pentaho偏向于与业务流程相结合的BI解决方案，侧重于大中型企业应用。

3.4. SpagoBI

SpagoBI 集成了Mondrain和JProvit，能够通过OpenLaszlo产生实时报表。SpagoBI使用java开发，不依赖于具体的操作系统，有很强的扩展能力。它主要包括：

1、  报表工具：JasperReports /Eclipse BIRT/ iReport

2、  OLAP Server：Mondrian

3、  OLAP展示：JPivot

4、  数据挖掘组件：Weka

5、  Map引擎：Geo

6、  ETL：BIE

7、  搜索引擎：Lucene

8、  Dashboard：OpenLaszlo

9、  Portal Server：JBoss/ Tomcat/ JOnAS

根据其Roadmap可以看出，SpagoBI将融入更多的BI功能，甚至BI之外的功能。

一、概述

　　在JBuilder中也支持开发基于weblogic的web service，不过实际上在JBuilder下开发web service也是基于ant任务来生成和构造web service的。但是，当初笔者在一个项目中使用JBuilder下自动生成构造ant脚本生成的web service时碰到了一个问题，通过JBuilder生成的web service，如果你的web service调用接口中存在一个或者多个String类型参数的时候，在生成的wsdl文件中对该接口的参数命名不会按照你的后端组件对应方法中参数的名字，而是以string、string0、string1…等形式命名的。而在那个项目中需要在Delphi环境中调用web service，问题就出现了，string在Delphi中是关键词，产生了冲突，不能进行调用。于是笔者决定采用自编写ant脚本的方式来生成和构造web service来解决前面所述Delphi调用的问题。

　　BEA Weblogic提供了一些Ant任务，用来帮助开发者生成、构造一个Web服务的重要部件，（例如：序列化类、客户端jar支持库、以及web-services.xml描述文件），并且把一个Weblogic Web 服务的所有部分打包成一个可部署的EAR文件。

　　BEA Weblogic所提供的Web服务Ant任务，支持从实现了Web Service接口的普通JAVA源文件和EJB jar生成Web Service部件，也支持从WSDL描述文件生成，同时支持基于http/https传输协议和JMS传输协议的Web Service。在这一节我们只讲述通过基于一个普通JAVA类作为后端组件来实现的Web Service，传输协议使用http（基于https的方式将在后述关于Web Service安全的部分讲述）。

二、使用Weblogic ant工具生成Web Service

　　我们先建立D:\wls_ws_demo的工作目录，在此目录下分别建立src、build、ddfiles、webapp、test目录。具体用途后文会涉及到。

　　首先我们编写一个实现了两个Web Service接口的普通JAVA类：

package com.wnetw.ws.demo;

public class HelloWorldWS{

  public String sayHello(){
	return "Hello World!";
  }

  public String welcome(String name){
	return "Hello " + name + ",Welcome to WebService!";
  }

}

　　上面两个方法就不需要解释了，很简单。把此类按封装包一致的路径放置在src目录下。

<property name="build.compiler" value="modern"/>
  <property name="src.dir" value="src"/>
  <property name="build.dir" value="build"/>
  <property name="war.file" value="${build.dir}/
　applications/HelloWorldWS.war" />
  <property name="ear.file" value="${build.dir}/
applications/HelloWorldWS.ear" />
  <property name="clients.lib" value="${build.dir}/
clientslib/HelloWorldWS_clients.jar"/>
  <property name="bea.home" value="D:/bea"/>
  <property name="wls.dir" value="${bea.home}/weblogic81/server"/>
  <property name="wlslib.dir" value="${wls.dir}/lib"/>
  <property name="wlsext.dir" value="${wls.dir}/ext"/>
  <property name="namespace" value="http://www.wnetw.com/demo/"/>
  <path id="classpath">
    <dirset dir="${build.dir}/classes">
      <include name="**"/>
    </dirset>
    <fileset dir="${wlslib.dir}">
      <include name="**/weblogic.jar"/>
      <include name="**/webservices.jar"/>
    </fileset>
  </path>
  <property name="javac.fork" value="no"/>
  <property name="javac.debug" value="no"/>
  <property name="javac.optimize" value="on"/>
  <property name="javac.listfiles" value="yes"/>
  <property name="javac.failonerror" value="yes"/>

　　上面的属性应该不是很难理解，关键的是对于bea weblogic server安装目录和构造生成文件的路径说明，其次是对classpath的设置，需要用到的两个weblogic库是weblogic.jar和webservices.jar。

　　接着我们看看我们在本节中使用的Weblogic提供的Ant任务：

1、source2wsdd

　　source2wsdd Ant任务最基本的功能是根据我们编写的普通JAVA类源文件生成一个Web Service所必需的两个部件：web-services.xml和.wsdl描述文件。

<target name="genwsdd">
    <source2wsdd javaSource="${src.dir}/com/wnetw/ws/
demo/HelloWorldWS.java"
             ddFile="${build.dir}/wsddfiles/web-services.xml"
             wsdlFile="${build.dir}/wsddfiles/HelloWorldWS.wsdl"
             serviceURI="/HelloWorldWS">
      <classpath refid="classpath"/>
    </source2wsdd>
  </target>

属性说明

　　javaSource：指定web service的实现后端组件，这里是普通JAVA类com.wnetw.ws.demo HelloWorldWS.java。注意属性里面是对源文件目录路径设置，而不是包路径。

　　ddFile：生成的web service部署描述符文件web-services.xml的存放路径。

　　wsdlFile：生成的.wsdl文件存放的路径和名字。

　　serviceURI：客户应用程序调用此Web服务的URL中的Web Service URI部分。注意：必须以“/”开头。例如：/ HelloWorldWS 。同时这个URI属性也会成为生成的web-services.xml 部署描述符文件中<web-service>元素的uri属性。

　　例如：本机访问本web service例子的url是http://localhost:7001/ WSDemo/ HelloWorldWS

　　上面的serviceURI属性就指定了上述url中的/ HelloWorldWS这一部分。

2、clientgen

　　clientgen可以用来生成JAVA环境下客户端应用调用一个Web Service客户端jar支持库。可以通过wsdl文件来生成，也可以通过一个包含web service实现的ear文件来生成。

<target name="genclient">
    <clientgen wsdl="${build.dir}/wsddfiles/HelloWorldWS.wsdl"
               packageName="com.wnetw.ws.demo.client"
               clientJar="${clients.lib}"
               keepGenerated="false">
      <classpath refid="classpath"/>
    </clientgen>
  </target>

　　这里采用从前面source2wsdd任务生成的wsdl文件来生成客户端jar支持库。通过wsdl属性指定。

3、war

　　这是ant提供的标准任务，这里与其他普通的war包有一点区别是，需要把web-services.xml文件打包到war中去。

　　说明：需要准备web.xml，后面对于安全设置的时候还需要weblogic.xml文件，这里先都打包进去，这些文件都需要提前编辑准备好：

---Web.xml---
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web 
Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
  <mime-mapping>
    <extension>wsdl</extension>
    <mime-type>text/xml</mime-type>
  </mime-mapping>
</web-app>

---weblogic.xml---
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE weblogic-web-app PUBLIC "-//BEA Systems, Inc.//DTD Web 
Application 7.0//EN" "http://www.bea.com/servers/wls700
/dtd/weblogic700-web-jar.dtd">
<weblogic-web-app>
</weblogic-web-app>

　　这个文件没设置，在后面关于安全的处理里面需要这里配置角色映射。

　　下面是war ant脚本示例：

<target name="genwar">
    <war destfile="${war.file}" webxml="webapp/WEB-INF/web.xml">
      <classes dir="${build.dir}/classes"/>
      <webinf dir="${build.dir}/wsddfiles">
        <include name="web-services.xml"/>
      </webinf>
      <webinf dir="webapp/WEB-INF">
        <include name="weblogic.xml"/>
      </webinf>
    </war>
  </target>

4、ear

　　这也是ant标准任务，需要注意的是必须提前编写application.xml文件，下面针对本文例子的application.xml文件：

<!DOCTYPE application PUBLIC '-//Sun Microsystems, Inc.//DTD J2EE 
Application 1.3//EN' 'http://java.sun.com/dtd/application_1_3.dtd'>
<application>
  <display-name></display-name>
  <module>
    <web>
      <web-uri>HelloWorldWS.war</web-uri>
      <context-root>WSDemo</context-root>
    </web>
  </module>
</application>

　　说明：context-root元素指定此Web Service所在Web应用的应用根。

　　例如：本机访问本web service例子的url是http://localhost:7001/
WSDemo/ HelloWorldWS

　　上面的context-root元素就指定了上述url中的WSDemo这一部分。

　　下面是本文例子的ear ant任务脚本：

<target name="genear">
    <ear destfile="${ear.file}" appxml="ddfiles/application.xml">
      <fileset dir="${build.dir}/applications" includes="*.war"/>
    </ear>
  </target>

　　核心的ant任务说明完了，下面是完整的ant脚本文件：

--- build_wls_all.xml---
<project name="wls_ws_demo" default="all" basedir=".">

  <property name="build.compiler" value="modern"/>
  <property name="src.dir" value="src"/>
  <property name="build.dir" value="build"/>
  <property name="war.file" value="${build.dir}/applications/
HelloWorldWS.war" />
  <property name="ear.file" value="${build.dir}/applications/
HelloWorldWS.ear" />
  <property name="clients.lib" value="${build.dir}/clientslib/
HelloWorldWS_clients.jar"/>
  <property name="bea.home" value="D:/bea"/>
  <property name="wls.dir" value="${bea.home}/weblogic81/server"/>
  <property name="wlslib.dir" value="${wls.dir}/lib"/>
  <property name="wlsext.dir" value="${wls.dir}/ext"/>
  <property name="namespace" value="http://www.wnetw.com/demo/"/>
  <path id="classpath">
    <dirset dir="${build.dir}/classes">
      <include name="**"/>
    </dirset>
    <fileset dir="${wlslib.dir}">
      <include name="**/weblogic.jar"/>
      <include name="**/webservices.jar"/>
    </fileset>
  </path>
  <property name="javac.fork" value="no"/>
  <property name="javac.debug" value="no"/>
  <property name="javac.optimize" value="on"/>
  <property name="javac.listfiles" value="yes"/>
  <property name="javac.failonerror" value="yes"/>

  <target name="all" depends="clean,mdir,compile,genwsdd,
genclient,genwar,genear"/>
  
  <target name="clean">
    <delete dir="${build.dir}"/>
  </target>
  
  <target name="mdir">
    <mkdir dir="${build.dir}"/>
    <mkdir dir="${build.dir}/classes"/>
    <mkdir dir="${build.dir}/applications"/>
    <mkdir dir="${build.dir}/clientslib"/>
    <mkdir dir="${build.dir}/wsddfiles"/>
  </target>
  
  <target name="compile">
    <javac encoding="GBK" srcdir="${src.dir}" destdir=
"${build.dir}/classes">
      <classpath refid="classpath"/>
    </javac>
  </target>

  <target name="genwsdd">
    <source2wsdd javaSource="${src.dir}/com/wnetw/ws/
demo/HelloWorldWS.java"
                 ddFile="${build.dir}/wsddfiles/web-services.xml"
                 wsdlFile="${build.dir}/wsddfiles/HelloWorldWS.wsdl"
                 serviceURI="/HelloWorldWS">
      <classpath refid="classpath"/>
    </source2wsdd>
  </target>

  <target name="genclient">
    <clientgen wsdl="${build.dir}/wsddfiles/HelloWorldWS.wsdl"
               packageName="com.wnetw.ws.demo.client"
               clientJar="${clients.lib}"
               keepGenerated="false">
      <classpath refid="classpath"/>
    </clientgen>
  </target>

  <target name="genwar">
    <war destfile="${war.file}" webxml="webapp/WEB-INF/web.xml">
      <classes dir="${build.dir}/classes"/>
      <webinf dir="${build.dir}/wsddfiles">
        <include name="web-services.xml"/>
      </webinf>
      <webinf dir="webapp/WEB-INF">
        <include name="weblogic.xml"/>
      </webinf>
    </war>
  </target>
  
  <target name="genear">
    <ear destfile="${ear.file}" appxml="ddfiles/application.xml">
      <fileset dir="${build.dir}/applications" includes="*.war"/>
    </ear>
  </target>

</project>

　　运行ant生成Web Service：

　　打开命令行窗口，转到工作目录D:\wls_ws_demo下，在此目录下先运行D:\bea\weblogic81\server\bin\setWLSEnv.cmd（此cmd文件具体路径与你的weblogic platform81实际安装目录相关）进行环境设置，然后运行：D:\bea\weblogic81\server\bin\ant.bat -buildfile build_wls_all.xml。

　　运行结束，出现“BUILD SUCCESSFUL”，那就代表OK了。转到工作目录下的build目录，你就会看到HelloWorldWS.ear这个文件。

三、测试Web Service

　　本节将讲述对前一节里生成的Web Service HelloWorldWS进行测试。

　　启动Weblogic Server，进入Weblogic Server控制台，在Deployments->Applications下部署上节生成的HelloWorldWS.ear。

1、通过Weblogic自动生成的测试主页测试

　　部署成功后，在浏览器中输入http://localhost:7001/WSDemo/HelloWorldWS访问Weblogic Server默认生成的上述HelloWorldWS Web Service的测试主页。

如下图：

　　图上列出了HelloWorldWS Web Service上的两个方法：welcome和sayHello。

　　点击welcome连接进入wecome方法的测试页，如下图：

　　在上述页面输入“老Z”，提交后就会看到如下图页面：

　　测试的结果跟上节中的HelloWorldWS.java实现此方法的结果是一样的。测试sayHello方法跟上面过程一样。

　　在测试主页中还能看到在JAVA环境下，基于clientgen ant任务生成的jar客户端stub支持库调用此HelloWorldWS Web服务的代码示例。

2、使用JAVA程序调用Web Service

　下面实际编写一个java测试程序来调用上述Web Service。

--- HelloWorldWSTest.java ---
import com.wnetw.was.demo.client.*;

public class HelloWorldWSTest {

  public static void main(String[] args){
    try{
      HelloWorldWS_Impl ws = new HelloWorldWS_Impl("http://localhost:7001
/WSDemo/HelloWorldWS?WSDL");
      HelloWorldWSPort port = ws.getHelloWorldWSPort();
      System.out.println(port.welcome(“老Z”));
    }catch(Exception e){
      e.printStackTrace();
      System.out.println(e);
    }
  }

}

　　编译、运行上述测试程序的时候首先需要weblogic客户端webservice支持库webserviceclient.jar，还需要前面clientgen ant任务生成的jar客户端stub支持库HelloWorldWS_clients.jar。在下面的编译、运行测试程序的ant脚本中可以看到在classpath中引入了上述两个jar。

　　编译、运行测试程序的ant脚本如下：

<project name="wls_ws_demo" default="all" basedir=".">

  <property name="build.compiler" value="modern"/>
  <property name="bea.home" value="D:/bea"/>
  <property name="wls.dir" value="${bea.home}/weblogic81/server"/>
  <property name="wlslib.dir" value="${wls.dir}/lib"/>
  <property name="wlsext.dir" value="${wls.dir}/ext"/>
  <path id="classpath">
    <fileset dir="${wlslib.dir}">
      <include name="**/webserviceclient.jar"/>
    </fileset>
    <fileset dir="build/clientslib">
      <include name="**/HelloWorldWS_clients.jar"/>
    </fileset>
    <pathelement path="test"/>
  </path>
  <property name="javac.fork" value="no"/>
  <property name="javac.debug" value="no"/>
  <property name="javac.optimize" value="on"/>
  <property name="javac.listfiles" value="yes"/>
  <property name="javac.failonerror" value="yes"/>

  <target name="all" depends="compile,run"/>
  
  <target name="compile">
    <javac encoding="GBK" srcdir="test" destdir="test">
      <classpath refid="classpath"/>
    </javac>
  </target>

  <target name="run">
    <java classname="HelloWorldWSTest">
      <classpath refid="classpath"/>
    </java>
  </target>

</project>

3、在VB下调用Web Service

　　下面我在VB环境下来调用下这个Web Service，笔者使用的是Visual Basic 6.0，要在VB下调用Web Service需要先安装Microsoft SOAP toolkit。

　　新建一个VB工程，然后把Microsoft Soap Type Library引用进来，如下图：

　　新建一个form1，添加一个按钮command1，在form1源代码窗口中整个拷贝如下代码：

Dim soap As MSSOAPLib.SoapClient
Private Sub Command1_Click()

MsgBox soap.sayHello()
MsgBox soap.welcome("老Z")

If Err <> 0 Then
    MsgBox "Web Service调用失败： " + Err.Description
End If
End Sub

Private Sub Form_Load()
Set soap = New MSSOAPLib.SoapClient

On Error Resume Next

Call soap.mssoapinit("http://localhost:7001/WSDemo/HelloWorldWS?WSDL")

If Err <> 0 Then
    MsgBox "初始化SOAP失败： " + Err.Description
End If

End Sub

　　然后运行工程，点击窗口上的按钮就开始调用前面部署的Web Service（确保Weblogic Server在运行中），成功的话会得到如下图的两个MessageBox：

四、使用非内建数据类型

　　前面例子中的Web Service方法中使用的参数和返回值都是String，类似String，int等数据类型是属于Weblogic web service所支持的内建类型，关于Weblogic web service所支持的内建数据类型请参见：http://e-docs.bea.com/wls/docs81/webserv/implement.html#1054236

　　所支持的XML非内建类型请参见：

http://e-docs.bea.com/wls/docs81/webserv/assemble.html#1060805

　　所支持的Java非内建数据类型请参见：

http://e-docs.bea.com/wls/docs81/webserv/assemble.html#1068595

　　WebLogic Server能够对内建数据类型进行XML与Java表示之间的转换。但是，如果你在web service操作中使用了非内建数据类型，那么你必须提供以下信息，以确保weblogic server能够正确地进行转换。

• 用于处理数据的Java表示与XML之间的转换的序列化类；
• 包含了数据类型Java表示的Java类；
• 数据类型的XML Schema表示；
• web-services.xml部署描述文件中的数据类型映射信息。

　　Weblogic Server中带有servicegen和autotype Atn任务，这两个任务通过对web service的无状态EJB或者Java类后端组件的内省，从而自动生成上述部件。上述Ant任务能够处理许多非内建数据类型，所以大多数的开发者并不需要手工生成上述的部件。

　　有时，你可能也需要手工去创建非内建数据类型部件。因为你的数据类型可能很复杂，以致Ant任务不能正确生成前述部件。你也可能想要自己控制数据在XML和Java表示之间的转换过程，而不依赖Weblogic Server所使用的缺省转换程序。

　　本节将演示在Weblogic web service中如何处理非内建(自定义)的数据类型。

　　我们先编写一个数值Bean类UserInfo，如下：

package com.wnetw.ws.demo;

import java.util.*;

public class UserInfo{
  private Integer userid;
  private String username;
  private String sex;
  private Date birthday;
  private int level;
  private double salary;
  private telcodes list;

  public UserInfo(){}

  public Integer getUserid(){
	return userid;
  }

  public void setUserid(Integer userid){
	this.userid = userid;
  }

  public String getUsername(){
	return username;
  }

  public void setUsername(String username){
	this.username = username;
  }

  public String getSex(){
	return sex;
  }

  public void setSex(String sex){
	this.sex = sex;
  }

  public Date getBirthday(){
	return birthday;
  }

  public void setBirthday(Date birthday){
	this.birthday = birthday;
  }

  public int getLevel(){
	return level;
  }

  public void setLevel(int level){
	this.level = level;
  }

  public double getSalary(){
	return salary;
  }

  public void setSalary(double salary){
	this.salary = salary;
  }

  public List getTelcodes(){
	return telcodes;
  }

  public void setTelcodes (List telcodes){
	this. telcodes = telcodes;
  }

}

　　在前文中的后端组件类HelloWorldWS.java中增加一个方法：

public UserInfo getUserInfo(Integer userid){
	UserInfo userinfo = new UserInfo();
	userinfo.setUserid(userid);
	userinfo.setUsername("李泽林");
	userinfo.setSex("男");
	userinfo.setBirthday(new Date());
	userinfo.setLevel(2);
	userinfo.setSalary(1000.51);
	List telcodes = new ArrayList();
	telcodes.add("123");
	telcodes.add("321");
	userinfo.setTelcodes (telcodes);
    return userinfo;
  }

　　在这个方法里，返回值是UserInfo，这是我们前面定义的数值Bean，由于这是非内建类型，而且也不属于受支持的非内建类型，所以需要我们必须自己来处理XML和UserInfo Java表示数据类型之间的转换。

　　在本文的例子中，我们使用Weblogic Server的autotype任务来做这件事情。我们先在build目录建一个autotype目录，然后在前文中ant完整脚本中的compile任务之后增加下述脚本：

<target name="gentypeinfo">
    <autotype javatypes="com.wnetw.ws.demo.UserInfo"
              targetNamespace="${namespace}"
              packageName="com.wnetw.ws.demo"
              destDir="${build.dir}/autotype"
              keepGenerated="true">
      <classpath refid="classpath"/>
    </autotype>
    <copy todir="${build.dir}/classes">
      <fileset dir="${build.dir}/autotype">
        <include name="**/*.class"/>
      </fileset>
    </copy>
  </target>

　　autotype Ant任务有几个常用属性，下面简要说明下：

　　javatypes：需要进行类型转换的非内建（自定义）数据类型java类，注意取值是全限定类名，不需要带上java或者class扩展名。如果存在多个这样的数据类型类，用逗号“,”隔开；

　　targetNamespace：在对数据类型映射到XML的时候使用的命名空间；

　　packageName：生成的序列化相关类的封装包；

　　destDir：生成的序列化相关类存放的目录；

　　keepGenerated：是否保留中间java源文件，取值为：true或者false。

　　关于autotype任务的详细信息请参考：

http://e-docs.bea.com/wls/docs81/webserv/anttasks.html#1080062

　　上述ant任务成功运行后就会生成build/autotype/目录下生成types.xml文件以及按包封装的数据转换类的源文件和class文件。

　　由于增加了自定义数据类型，所以我们还得更新source2wsdd任务脚本，以下是增加了自定义数据类型处理后的source2wsdd任务脚本：

<target name="genwsdd">
    <source2wsdd javaSource="${src.dir}/com/wnetw/ws/demo/HelloWorldWS.java"
                 typesInfo="${build.dir}/autotype/types.xml"
                 ddFile="${build.dir}/wsddfiles/web-services.xml"
                 wsdlFile="${build.dir}/wsddfiles/HelloWorldWS.wsdl"
                 serviceURI="/HelloWorldWS">
      <classpath refid="classpath"/>
    </source2wsdd>
  </target>

　　跟以前的脚本相比，增加了typesInfo属性来指定自定义数据类型的XML描述文件。

　　增加了对自定义数据类型支持后的完整脚本请参考本文代码下载文件。

　　按照第一节所述方法运行ant脚本build_wls_all.xml后，再部署build\applications\目录下的HelloWorldWS.ear。就可以按照以前说的方法进行测试了。

　　这一次在Weblogic Server自动生成的web service测试主页：

http://localhost:7001/WSDemo/HelloWorldWS

　　可以发现多了一个叫getUserInfo的方法连接，进入此方法的调用测试页面，调用此方法后就可以看到此web service方法的调用结果，以下是结果截图：

　　从调用测试结果页面可以看到，这一次的Return Value是：

com.wnetw.ws.demo.UserInfo@82d235

　　这正是我们的web service方法返回值类型类型的一个对象，图中的下面也以SOAP消息的形式描述了调用的输入和返回结果。

　　我们接着修改测试类HelloWorldWSTest.java，如以下：

import com.wnetw.ws.demo.client.*;

import com.wnetw.ws.demo.UserInfo;

public class HelloWorldWSTest {

  public static void main(String[] args){
    try{
      HelloWorldWS_Impl ws = new HelloWorldWS_Impl("http://localhost:7001
/WSDemo/HelloWorldWS?WSDL");
      HelloWorldWSPort port = ws.getHelloWorldWSPort();
      System.out.println(port.sayHello());
      System.out.println(port.welcome("老Z"));
      System.out.println("开始测试自定义数据类型的返回值。。。");
	  UserInfo info = port.getUserInfo(100);
	  System.out.println(info);
      System.out.println(info.getUsername());

    }catch(Exception e){
      e.printStackTrace();
      System.out.println(e);
    }
  }

}

　　看看以下代码好像有点问题，UserInfo info = port.getUserInfo(123);我们在HelloWorldWS.java类中定义的对应方法是getUserInfo(Integer userid)，参数是Integer的，但是上述测试类代码中却使用int类型，这是正确的。我们可以把clientgen任务中的keepGenerated属性设为true，把自动生成的java源代码保留下来，build成功后，我们打开build\clientslib目录下HelloWorldWS_clients.jar文件中的com.wnetw.ws.demo.client.HelloWorldWSPor.java源文件，可以看到如下代码：

package com.wnetw.ws.demo.client;

/**
 * Generated interface, do not edit.
 *
 * This stub interface was generated by weblogic
 * webservice stub gen on Sat Sep 17 16:11:21 CST 2005 */

public interface HelloWorldWSPort extends java.rmi.Remote{

  /**
   * welcome 
   */

  public java.lang.String welcome(java.lang.String name) 
       throws java.rmi.RemoteException ;
  /**
   * sayHello 
   */

  public java.lang.String sayHello() 
       throws java.rmi.RemoteException ;
  /**
   * getUserInfo 
   */

  public com.wnetw.ws.demo.UserInfo getUserInfo(int userid) 
       throws java.rmi.RemoteException ;
}

　　其中的getUserInfo(int userid)方法是使用int参数的！如果你使用Integer类型参数，反而会编译通不过！只能认为这是weblogic server ant任务对数据类型映射的具体实现了，如果你仔细看了本节前面所述对java内建数据类型的支持列表，那么也是好理解的，因为java数据类型到XML Schema数据类型映射中，java中的int和java.lang.Integer都映射到了int。所以web service服务端接收到的SOAP消息中只会是XML Schema int类型，无法区分客户端使用的会是int或者java.lang.Integer，所以在ant工具根据wsdl文件自动生成客户端支持类的时候就只能使用int了，没法区分int或者java.lang.Integer。这是个有意思的问题^-^一不小心也许会在你工作中浪费不必要的时间。当然如果有必要，你完全可以手动修改、甚至完全自己来生成客户端支持库和数据类型转换类。不过嘛，除了出于研究和特殊情况外这是没有必要的。

　　我们接着看看HelloWorldWS_clients.jar中还有什么东西，发现有个language_builtins这样的包，从包名也许你能猜到这是干什么的，是对java语言内建数据类型处理的包，此包下面是util包，里面有ListCodec.class类。看看我们的UserInfo类，里面使用了List类，这个包里面的类正是用来处理java.util.List数据类型的，java.util.List属于Weblogic server web service所支持的非内建数据类型，也就是说不需要通过autotype明确来标志生成相关的数据转换类和类型信息。但是，java.util.List又有别于int、java.lang.String等wls web service所支持的内建类型，对于java.util.List等受支持的非内建类型由ant任务自动生动相关数据类型处理信息，不需要手工干预。对比来看，int、java.lang.String等wls web service所支持的内建类型是直接映射，不需要数据类型转换相关类。Java.util.List最终映射成了XML Shema SOAP Array类型。其他类型请参考：http://e-docs.bea.com/wls/docs81/webserv/assemble.html#1068595

　　运行修改后的build_wls_test.xml脚本，成功的话应该得到如下图类似结果：

　　增加了自定义数据类型后，VB测试客户端的处理也得增加一些处理来测试返回值为UserInfo的web service方法，如下面代码：

Set Nodes = soap.getUserInfo(100)

MsgBox Nodes(0).nodeName + ":" + Nodes(0).Text

MsgBox Nodes(1).nodeName + ":" + Nodes(1).Text

MsgBox Nodes(2).nodeName + ":" + Nodes(2).xml

MsgBox Nodes(3).nodeName + ":" + Nodes(3).Text

MsgBox Nodes(4).nodeName + ":" + Nodes(4).Text

MsgBox Nodes(5).nodeName + ":" + Nodes(5).Text

MsgBox Nodes(6).nodeName

　　完整VB测试客户端代码请见本文附带下载代码。

五、配置Web Service安全

　　Weblogic Web Service包括三种不同概念的安全设置：

• 消息层安全：对SOAP消息中数据的数字签名或者加密；
• 传输层安全：使用SSL来保证客户应用与Web Service之间连接的安全性；
• 访问控制：指定何种用户、组、角色被允许访问该Web Service。

　　在这里我们主要针对访问控制概念上的安全处理。

　　Weblogic Web Service最终是作为一个标准的J2EE ear打包文件提供进行部署的，其中包含了一个war包，也就是说web service是以web应用的形式提供并部署的，这从前面的章节就可以看出。

　　所以，针对web service的访问控制安全处理与J2EE中对于Web资源的访问控制处理是一样的。具体的说就是对特定Web资源增加安全约束。具体配置就是通过在Web应用部署描述符web.xml增加相应的元素：需要进行安全约束的资源集合、授权访问的角色列表、对用户数据的安全约束、角色映射等信息。

　　在这里，我们需要对前面用到的web.xml文件进行修改，如下所示：

<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web 
Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>

  <mime-mapping>
    <extension>wsdl</extension>
    <mime-type>text/xml</mime-type>
  </mime-mapping>
  
  <security-constraint>
    <display-name>SecurityConstraint</display-name>
    <web-resource-collection>
      <web-resource-name>HelloWorldWS</web-resource-name>
      <url-pattern>/*</url-pattern>
      <http-method>GET</http-method>
      <http-method>POST</http-method>
    </web-resource-collection>
    <auth-constraint>
      <role-name>testrole</role-name>
    </auth-constraint>
  </security-constraint>

  <security-role>
    <role-name>testrole</role-name>
  </security-role>
  
</web-app>

　　然后运行ant构造脚本，部署ear。部署成功后，你会在weblogic server运行命令行窗口中看到如下类似信息：

<2005-9-24 下午22时03分45秒 CST> <Warning> <HTTP> <BEA-101304> 
<Webapp: ServletC
ontext(id=11680063,name=WSDemo,context-path=/WSDemo), 
the role: testrole defined
 in web.xml has not been mapped to principals in 
security-role-assignment in web
logic.xml. Will use the rolename itself as the principal-name.>

　　这是因为没有进行角色映射，所以直接使用角色名作为用户名了。这只是一个警告信息，没有关系。后面将会讲述怎么进行角色映射。

　　然后进入weblogic server Console，新建一个名叫testrole的用户。接着在左侧目录树中一次展开Deployments-Applications- HelloWorldWS- WSDemo，在WSDemo节点上鼠标右击，选择Define Security Policy…

　　在Policy Condition项选择User name of the caller，点击增加，在接着出现的窗口中填入testrole,OK之后，点击上图页面中的Apply。接下来就可以跟以前一样测试了。

　　浏览器中输入http://localhost:7001/WSDemo/HelloWorldWS，这个时候会弹出来一个登陆框，如下图：

　　现在可以看到，访问控制起作用了。输入testrole以及拟增加用户的时候指定的密码后，就能进入到和以前一样的测试主页了。

　　上面那种使用角色名和用户名对应的方式显示在实际应用中是不方便的，因为具体会有什么样的用户会访问此web service在构建时是不确定的。我们可以使用角色映射的方式来避免这个问题。

　　进行角色映射需要在weblogic.xml文件中配置，下面我将对testrole映射到一个group，weblogic.xml文件如下所示：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE weblogic-web-app PUBLIC "-//BEA Systems, Inc.//DTD Web
 Application 7.0//EN" "http://www.bea.com/servers/wls700/dtd
/weblogic700-web-jar.dtd">

<weblogic-web-app>

  <security-role-assignment>
    <role-name>testrole</role-name>
    <principal-name>test_group</principal-name>
  </security-role-assignment>

</weblogic-web-app>

　　在web.xml文件中指定的授权访问角色testrole映射到了test_group，也就是说test_group组中的所有用户都有权访问。这样一来用户授权和实现就解耦了。

　　使用ant脚本重新构建，然后部署ear。接着进入weblogic server console，删除testrole用户，新建test_group组，新建一个叫test_user的用户，并指派给test_group组。接着按照前面一样Define Security Policy，这一次在Policy Condition部分选择Caller is member of the group，然后点Add进入授权group指定页面，输入test_group，点增加-点OK，回到Define Security Policy主页面，点击Apply就好了。

　　然后我们在浏览中进入http://localhost:7001/WSDemo/HelloWorldWS，弹出登陆框，这一次我们可以使用test_group中的任何成员用户来登陆了，前面例子是test_user。这样在以后，需要分配新的用户授权访问此Web Service的时候就知需要在Cosole在test_group中增加一个成员就行了，不需要重新构建web service了。

　　加入了访问控制后，在调用web service的时候就需要提供授权凭证了，下面是需要增加的代码信息：

• JAVA客户

  HelloWorldWS_Impl ws = new HelloWorldWS_Impl("http://localhost:7001/WSDemo/HelloWorldWS?WSDL");
  HelloWorldWSPort port = ws.getHelloWorldWSPort("test_user","test_user");
  改成
  HelloWorldWS_Impl ws = new HelloWorldWS_Impl();
  //因为加入了访问控制，所以对于http://localhost:7001/WSDemo/HelloWorldWS?WSDL的访问也需授权，所以我们使用缺省构建器，这样就会使用客户端支持库jar中的静态wsdl文件了。
  HelloWorldWSPort port = ws.getHelloWorldWSPort(“test_user”, “test_user”);
  //后面的参数是test_user的密码，根据你具体的密码更改

• VB客户端

  Call soap.mssoapinit("HelloWorldWS.wsdl")
  ‘由于http://localhost:7001/WSDemo/HelloWorldWS?WSDL需要授权访问，所以我们把脚本生成的HelloWorldWS.wsdl文件直接拷贝到VB项目目录下，使用这个静态文件来初始化soap对象。
  ‘后面增加下属代码
  soap.ConnectorProperty("AuthUser") = "test_user"
  soap.ConnectorProperty("AuthPassword") = "test_user"

　　在我们运行上述两个测试程序的时候会发现调用不成功。原因接下来进行说明。

　　我们打开工作目录中下build\wsddfiles这个目录中的HelloWorldWS.wsdl这个文件，在最后可以看到下面的service元素内容，如下：

<service   name="HelloWorldWS">
  <port    name="HelloWorldWSPort"
    binding="tns:HelloWorldWSPort">
   <soap:address  location="http://pls.set.the.end.point.address/">
   </soap:address>
  </port>
 </service>

　　问题就出在这里，soap:address节点的location属性有问题，因为客户端soap初始化后，会使用这个URL来调用本wsdl中描述的web service操作，显然这个地址与我们部署的实际地址是不一样的。所以我们把location属性改为我们部署的web service实际访问URL：

http://localhost:7001/WSDemo/HelloWorldWS。这就是上述两个测试程序不能正确运行的原因。

　　笔者也没有找到如何在生成web service部件时设置此正确属性的方法，正是因为需要修改上述wsdl文件属性，所以我们需要把build脚本分成两部分来执行，先生成相关部件，然后修改wsdl文件的上述属性，最后才进行打包和客户端支持库的生成，把build_wls_all.xml分开成了build_wls_1.xml和build_wls_2.xml两个build脚本文件。在运行完后build_wls_1.xml修改上述属性，然后运行build_wls_2.xml即可。

　　部署成功后，就可以测试上面两个调用例子了，注意把修改好的wsdl文件拷贝到VB项目目录中去。

　　如果在web.xml中<security-constraint>元素里加入下述项目

<user-data-constraint>
      <transport-guarantee>CONFIDENTIAL</transport-guarantee>
</user-data-constraint>

　　那就会强制要求客户端使用https进行访问，其他更多信息请参考J2EE中Web应用安全方面的资料。

六、杂项设置

　　本节要说的实际也是安全性方面的问题，只不过和一般的安全性概念不一样，这里讲的是针对在生产部署环境下的考虑。

1、定制主页

　　在生产环境下，一般是不允许公开web service默认主页的。其次由于通过主页：

http://localhost:7001/WSDemo/HelloWorldWS?WSDL

　　访问的wsdl描述符文件是动态生成，同时加入了访问控制安全约束后，客户程序访问此文件也存在问题，所以通常在生产环境下将禁止访问web service默认主页以及动态wsdl文件，可以使用专门的静态web站点来提供必要的信息，以及通过静态web站点来发布wsdl。

　　要禁用默认主页以及wsdl文件，需要在web-services.xml描述符文件中进行设置。如下所示在web-service节点中加入下面两个属性：

exposeWSDL="False"

exposeHomePage="False"

修改后类似下面示例：

。。。
<web-services>
 <web-service   name="HelloWorldWS"
   targetNamespace="http://tempuri.org/"
   uri="/HelloWorldWS"
   exposeWSDL="False"
   exposeHomePage="False">
。。。

　　这个修改也需要在运行build_wls_1.xml之后进行修改，才能保证应用打包部署后使得此设置生效。

　　在禁止了默认主页和WSDL文件后，为了保证web service更新后不需要更新客户程序的文件，所以最好建立一个静态web站点来发布web service，也就是发布wsdl文件。在用于发布wsdl的web应用中需要在web.xml中加入以下的Mime类型映射：

<mime-mapping>
<extension>wsdl</extension>
<mime-type>text/xml</mime-type>
</mime-mapping>

2、启用https协议

　　除了上一节中在web.xml中加入

<user-data-constraint>
      <transport-guarantee>CONFIDENTIAL</transport-guarantee>
</user-data-constraint>

　　来启用https通讯协议外，还可以在通过在web-service.xml文件中，在web-service（注意不是web-services）节点中加入下面属性：

protocol="https"

　　上述属性能保证客户端必须使用https来访问本web service。

七、结束语

　　本文只是针对很小的一方面来讲述基于weblogic ant任务开发web service的，只是起个抛砖引玉的作用。其次，通过本文你也能了解到web service的本质过程，无论通过什么工具来开发，本质上都是生成基础部件，然后打包。如果需要全面了解weblogic server web service开发方面的知识请参考bea文档：

http://e-docs.bea.com/wls/docs81/webservices.html

　　同时本文使用的环境是window 2000 server和weblogic platform8.1英文版。

　　本文示例项目代码可从以下地址下载：

http://www.wnetw.com/jclub_resources/technology/attachfiles/wls_ws_demo.rar

　　在本系列的第一部分，我介绍了如何实现面向方面领域的“HelloWorld”：跟踪和记录方面。利用Spring框架所提供的面向方面编程(Aspect-Oriented Programming，AOP)功能，您看到了如何使用before-、after-和基于异常的通知，以及如何使用基于正则表达式的简单切入点。跟踪和记录方面提供了非常不错的上手例子，而本文将进一步介绍一种新的通知形式：around通知。

　　比起第一部分中介绍的那些通知类型，around形式的通知是一种更具侵入性也更强大的面向对象概念。本文将描述around通知的每个特性，以便您可以在自己的Spring AOP应用程序中正确地使用它。在本文最后，我将向您展示如何使用around通知来截获和改变应用程序中各个特性相互作用的方式，以便实现Cuckoo's Egg（杜鹃的蛋）面向方面设计模式。

概述Spring AOP、IoC和代理
　　在第一部分，我们快速浏览了Spring的一些AOP特性，而没有阐明Spring如何实现AOP的细节。要理解Spring框架如何运转，尤其是它如何实现其AOP功能，首先您要明白，Spring是一个依赖于控制反转(Inversion of Control，IoC)设计模式的轻量级框架。

　　注意：本文的目的不是要深入介绍IoC模式，介绍IoC只是为了使您明白该设计模式是如何影响Spring AOP实现的。有关IoC模式的更详细的介绍请参见本文末尾的参考资料。

　　IoC设计模式的出现已经有一段时间了。一个最明显的例子就是J2EE架构本身。随着企业开发尤其是J2EE平台的出现，应用程序开始依赖于由外部容器所提供的一些特性，比如bean创建、持久性、消息传递、会话以及事务管理。

　　IoC引入了一个新概念：由组件构成的框架，它与J2EE容器有许多类似之处。IoC框架分离了组件所依赖的功能，并且，根据Sam Newman文章中的说法，提供了“连接组件的‘胶水’”。

　　对组件所依赖特性的控制 被反转 了，这样外部框架就可以尽可能透明地提供这些特性了。IoC模式真正意识到了从传统的由依赖于功能的组件来负责这些功能，到由独立的框架来配置和提供这些功能的方式转变。

　　图1显示了一些构成IoC模式的不同组件角色的例子。

图1. 没有对BusinessLogic bean应用方面时的顺序图.

　　图字：

　　Component：组件

　　Provides Facilities：提供功能

　　Relies on and conforms to：依赖于并服从

　　Manages the services the framework can then use to provide facilities：管理框架随后可以用来提供功能的服务

　　Service：服务

　　Your Component：您的组件

　　IoC Framework：IoC框架

　　External services：外部服务

　　IoC模式使用3种不同的方法来解除组件与服务控制的耦合：类型1、类型2和类型3。

• 类型1：接口注入
  这是大部分J2EE实现所使用的方法。组件显式地服从于一组接口，带有关联的配置元数据，以便允许框架对它们进行正确的管理。
• 类型2：Setter注入
  外部元数据被用来配置组件相互作用的方式。在第一部分中，我们就是使用这种IoC方法利用springconfig.xml文件来配置Spring组件的。
• 类型3：构造函数注入
  组件（包括构造组件时要用的参数）注册到框架，而框架提供组件的实例以及所有要应用的指定功能。

　　IoC在组件开发和企业开发中越来越受欢迎。IoC的实际例子包括传统的J2EE解决方案，比如：JBoss、Apache基金会的Avalon项目以及本文的Spring框架。实际上，Spring框架构建于IoC模式的基础上是为了帮助将它的轻量级功能注入到它的相关应用程序的组件中。

　　那么IoC对于Spring AOP有何意义呢？Spring的IoC特性是使用IoC springconfig.xml配置文件对应用程序应用方面的推动因素之一。springconfig.xml配置文件通知Spring框架运行时有关应用程序的组件要被注入的功能类型的信息，所以自然轻量级的AOP功能就以同样的方式应用了。然后Spring使用代理模式围绕现有的类和bean实现指定的AOP功能。

　　图2显示了Spring及其IoC框架如何使用代理对象提供AOP功能（根据springconfig.xml文件中的IoC配置。）

图2. springconfig.xml配置文件改变了Spring框架IoC，以便随后向第一部分中的一个顺序图提供AOP代理（单击图像查看大图）

　　在本系列下面的部分，您将不断看到现在包含在顺序图中的代理对象。这只是为了说明对于Spring AOP来说没有“魔法”，实际上只有一个面向对象设计模式的良好例子。

回到AOP：使用around通知的积极方面
　　在第一部分，您看到了如何使用Spring AOP来实现跟踪和记录方面。跟踪和记录都是“消极”方面，因为它们的出现并不会对应用程序的其他行为产生影响。它们都使用了消极的before和after形式的通知。

　　但是如果您希望改变应用程序的常规行为呢？例如说，您希望重写一个方法？这样的话，您就需要使用更积极的around形式的通知。

　　第一部分的简单例子应用程序包括IbusinessLogic接口、BusinessLogic类和MainApplication类，如下所示：

public interface IBusinessLogic
{
  public void foo();
}


public class BusinessLogic 
  implements IBusinessLogic
{
  public void foo() 
  {
     System.out.println(
       "Inside BusinessLogic.foo()");
  }
}

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class MainApplication
{
  public static void main(String [] args)
  {
    // Read the configuration file
    ApplicationContext ctx = 
      new FileSystemXmlApplicationContext(
        "springconfig.xml");

    //Instantiate an object
    IBusinessLogic testObject = 
      (IBusinessLogic) ctx.getBean(
        "businesslogicbean");

    // Execute the public 
    // method of the bean
    testObject.foo();
  }
}

　　要对一个BusinessLogic类的实例彻底重写对foo()方法的调用，需要创建around通知，如下面的AroundAdvice类所示：

import org.aopalliance.intercept.MethodInvocation;
import org.aopalliance.intercept.MethodInterceptor;

public class AroundAdvice 
   implements MethodInterceptor
{
   public Object invoke(
      MethodInvocation invocation)
      throws Throwable
   {
      System.out.println(
         "Hello world! (by " + 
         this.getClass().getName() + 
         ")");

      return null;
   }
}

　　要在Spring中用作around通知，AroundAdvice类必须实现MethodInterceptor接口和它的invoke(..)方法。每当截获到方法的重写，invoke(..)方法就会被调用。最后一步是改变包含在应用程序的springconfig.xml文件中的Spring运行时配置，以便可以对应用程序应用AroundAdvice。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC  "-//SPRING//DTD BEAN//EN"
    "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

   <!-- Bean configuration -->
   <bean id="businesslogicbean"
   class="org.springframework.aop.framework.ProxyFactoryBean">
      <property name="proxyInterfaces">
         <value>IBusinessLogic</value>
      </property>
      <property name="target">
         <ref local="beanTarget"/>
      </property>
      <property name="interceptorNames">
         <list>
            <value>theAroundAdvisor</value>
         </list>
         </property>
   </bean>
   <!-- Bean Classes -->
   <bean id="beanTarget"
   class="BusinessLogic"/>

   <!-- Advisor pointcut definition for around advice -->
   <bean id="theAroundAdvisor"
      class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
      <property name="advice">
         <ref local="theAroundAdvice"/>
      </property>
      <property name="pattern">
         <value>.*</value>
      </property>
   </bean>
	
   <!-- Advice classes -->
   <bean id="theAroundAdvice"
      class="AroundAdvice"/>

</beans>

　　根据该springconfig.xml配置文件，theAroundAdvisor截获所有对BusinessLogic类的方法的调用。接下来，theAroundAdvisor被关联到theAroundAdvice，表明当截获一个方法时，就应该使用在AroundAdvice类中指定的通知。既然已经指定了around通知的正确配置，下一次执行MainApplication类时，BusinessLogic bean的foo()方法就会被截获并重写，如图3所示：

图3. 使用around通知重写对BusinessLogic类中的foo()方法的调用

　　前面的例子显示，BusinessLogic类中的foo()方法可以通过AroundAdvice类中的invoke(..)方法彻底重写。原来的foo()方法完全不能被invoke(..)方法调用。如果希望从around通知内调用foo()方法，可以使用proceed()方法，可从invoke(..)方法的MethodInvocation参数中得到它。

public class AroundAdvice 
   implements MethodInterceptor
{
   public Object invoke(
      MethodInvocation invocation) 
      throws Throwable
   {
      System.out.println(
         "Hello world! (by " + 
         this.getClass().getName() + 
         ")");

      invocation.proceed();

      System.out.println("Goodbye! (by " + 
         this.getClass().getName() + 
         ")");

      return null;
   }
}

　　图4显示了对proceed()的调用如何影响操作的顺序（与图3所示的初始around通知执行相比较）。

图4. 从around通知内使用proceed()调用原来的方法

　　当调用proceed()时，实际是在指示被截获的方法（在本例中是foo()方法）利用包含在MethodInvocation对象中的信息运行。您可以通过调用MethodInvocation类中的其他方法来改变该信息。

　　您可能希望更改包含在MethodInvocation类中的信息，以便在使用proceed()调用被截获的方法之前对被截获方法的参数设置新值。

　　通过对MethodInvocation对象调用getArguments()方法，然后在返回的数组中设置其中的一个参数对象，最初传递给被截获的方法的参数可以被更改。

　　如果IbusinessClass和BusinessLogic类的foo()方法被更改为使用整型参数，那么就可以将传递给被截获的调用的值由在AroundAdvice的notify(..)方法中传递改为在foo(int)中传递。

public class AroundAdvice 
   implements MethodInterceptor
{
   public Object invoke(
      MethodInvocation invocation) 
      throws Throwable
   {
      System.out.println(
         "Hello world! (by " + 
         this.getClass().getName() + 
         ")");
      
      invocation.getArguments()[0] = new Integer(20);
      
      invocation.proceed();
      
      System.out.println(
         "Goodbye! (by " + 
         this.getClass().getName() + 
         ")");
      
      return null;
   }
}

　　在本例中，被截获的方法的第一个形参被假设为int。实参本身是作为对象传递的，所以通过将其包装在Integer类实例中的方法，基本的int类型的形参被改为对应数组中的新值。如果您将该参数设置为一个非Integer对象的值，那么在运行时就会抛出IllegalArgumentException异常。

　　您还将注意到，invoke(..)方法必须包含一个return语句，因为该方法需要返回值。但是，被重写的foo()方法并不返回对象，所以invoke(..)方法可以以返回null结束。如果在foo()方法不需要的情况下，您仍然返回了一个对象，那么该对象将被忽略。

　　如果foo()方法确实需要返回值，那么需要返回一个与foo()方法的初始返回类型在同一个类或其子类中的对象。如果foo()方法返回一个简单类型，例如，一个integer，那么您需要返回一个Integer类的对象，当方法被重写时，该对象会自动由AOP代理拆箱，如图5所示：

图5. around通知的装箱和自动拆箱

　　图字：

　　Object invoke：对象调用

　　The integer return value is boxed in a Integer object in the AroundAdvice and then unboxed by the AOP Proxy：整型返回值被装箱在AroundAdvic通知的一个Integer对象中，然后由AOP代理拆箱。

　　面向方面编程还是一个比较新的领域，尤其是与衍生出它的面向对象编程相比。设计模式通常被认为是常见问题的通用解决方案，因为面向方面发展的时间还不长，所以已发现的面向方面设计模式比较少。

　　此处要介绍的是一种正在浮现的模式，即Cuckoo's Egg设计模式。该模式还有其他的叫法，它在面向对象领域的对等体包括模仿对象（Mock Object）和模仿测试（Mock Testing），甚至代理模式也与它有一些类似之处。

　　Cuckoo's Egg面向方面设计模式可以被定义为应用程序上下文中功能部件的透明和模块化的置换。就像杜鹃偷偷地把自己的蛋放在另一种鸟的巢中一样，Cuckoo's Egg设计模式用一个替代功能部件实现置换现有的功能部件,而使造成的干扰尽可能少。

　　这种置换的实现方式可以是静态的、动态的、部分的、完全的，针对一个对象的多个部分，或针对多个组件。使用面向方面的方法可以透明地实现功能部件的置换，而无需对应用程序的其余部分进行更改。要置换应用程序中现有功能部件的替代功能部件就是“杜鹃的蛋”。图6显示了Cuckoo's Egg设计模式中的主要组成元素。

图6. Cuckoo's Egg设计模式中的主要组成元素

　　图字：

　　Application：应用程序

　　Component：组件

　　Replacement Feature：替代功能部件

　　Component 1 and 2 together encompass a distinct feature of the software：组件1和2共同包含了软件的一个独立的功能部件

　　The Cuckoo's Egg pattern transparently replaces an existing feature of the software：Cuckoo's Egg模式透明地置换了软件现有的功能部件

　　Before the pattern is applied：应用该模式前

　　After the pattern is applied：应用该模式后

　　Cuckoo's Egg设计模式依赖于around通知的概念。您需要借助于积极的和侵入性的around通知来截获并有效置换应用程序中现有的功能部件。

　　有关Cuckoo's Egg设计模式的更多信息，以及AspectJ中的一个可选实现，请参见《AspectJ Cookbook》（O'Reilly，2004年12月出版）。

　　要使用Spring AOP实现Cuckoo's Egg设计模式，需要声明一个around通知来截获所有对要置换的功能部件的调用。与hot-swappable target sources（Spring AOP的一个功能部件，将在本系列的另一篇文章中介绍）不同，around通知的显式使用使得Cuckoo's Egg实现可以有效地跨越对象边界（因此也可以跨越bean边界）进行整个功能部件的置换，如图7所示。

图7. 一个跨越bean边界的组件

　　图字：

　　A feature crosses the boundaries of BusinessLogic and BusinessLogic2 by depending on behavior supplied separately by the two beans：一个功能部件通过依赖于由BusinessLogic和BusinessLogic2各自提供的行为而跨越了这两个bean的边界

　　下面的代码显示了一个具有两个bean的简单应用程序，其中有一个功能部件跨越了该应用程序的多个方面。要置换的功能部件可以被视为包含IBusinessLogic bean中的foo()方法和IBusinessLogic2 bean中的bar()方法。IBusinessLogic2 bean中的baz()方法不是 该功能部件的一部分，所以不进行置换。

public interface IBusinessLogic
{
   public void foo();
}

public interface IBusinessLogic2
{
   public void bar();
   
   public void baz();
}

　　该例子的完整源代码可在本文末尾的参考资料小节中下载。

　　此处，ReplacementFeature类扮演了“杜鹃的蛋”的角色，它提供了将被透明地引入应用程序的替代实现。ReplacementFeature类实现了所有在该类引入时要被置换的方法。

public class ReplacementFeature
{
   public void foo()
   {
      System.out.println(
         "Inside ReplacementFeature.foo()");
   }
   
   public void bar()
   {
      System.out.println(
         "Inside ReplacementFeature.bar()");
   }
}

　　现在需要声明一个around通知来截获对跨越bean的功能部件的方法调用。CuckoosEgg类提供了某种around通知来检查被截获的方法，并将适当的方法调用传递给ReplacementFeature类的实例。

public class CuckoosEgg implements MethodInterceptor
{
   public ReplacementFeature replacementFeature =
       new ReplacementFeature();
   
   public Object invoke(MethodInvocation invocation)
       throws Throwable
   {
      if (invocation.getMethod().getName().equals("foo"))
      {
         replacementFeature.foo();
      }
      else
      {
         replacementFeature.bar();
      }
      
      return null;
   }
}

　　因为与Spring框架关系密切，Cuckoo's Egg设计的详细信息被放在springconfig.xml配置文件中。对springconfig.xml文件的更改将确保所有对IbusinessLogic和IBusinessLogic2 bean的foo()方法和bar()方法的调用都将被截获，并传递给CuckoosEgg类的around通知。

   ...
   
   <!--CONFIG-->
   <bean id="businesslogicbean" 
      class="org.springframework.aop.framework.ProxyFactoryBean">
      <property name="proxyInterfaces">
         <value>IBusinessLogic</value>
      </property>
      <property name="target">
         <ref local="beanTarget"/>
      </property>
      <property name="interceptorNames">
         <list>
            <value>theCuckoosEggAdvisor</value>
         </list>
      </property>
   </bean>
   
   <bean id="businesslogicbean2" 
      class="org.springframework.aop.framework.ProxyFactoryBean">
      <property name="proxyInterfaces">
         <value>IBusinessLogic2</value>
      </property>
      <property name="target">
         <ref local="beanTarget2"/>
      </property>
      <property name="interceptorNames">
         <list>
            <value>theCuckoosEgg2Advisor</value>
         </list>
      </property>
   </bean>

   <!--CLASS-->
   <bean id="beanTarget" class="BusinessLogic"/>
   <bean id="beanTarget2" class="BusinessLogic2"/>
   
   <!--ADVISOR-->
   <bean id="theCuckoosEggAdvisor" 
      class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
      <property name="advice">
         <ref local="theReplacementFeaturePart1Advice"/>
      </property>
      <property name="pattern">
         <value>IBusinessLogic.*</value>
      </property>
   </bean>
   
   <bean id="theCuckoosEgg2Advisor" 
      class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
      <property name="advice">
         <ref local="theReplacementFeaturePart2Advice"/>
      </property>
      <property name="pattern">
         <value>IBusinessLogic2.bar*</value>
      </property>
   </bean>
   
   <!--ADVICE-->
   <bean id="theReplacementFeaturePart1Advice" class="CuckoosEgg"/>
   <bean id="theReplacementFeaturePart2Advice" class="CuckoosEgg"/>
   
   ...

　　当使用修改后的springconfig.xml文件运行例子应用程序时，要替换的、被指定为功能部件的一部分的方法调用完全被截获并传递给ReplacementFeature类。

　　通常，即使在同一个实现环境中，我们也可以用不同的方法来实现同一种设计模式。实现上例的另一种方法是实现两个独立的通知。

　　最后需要注意的是，使用Cuckoo's Egg设计模式置换的功能部件，不管它是跨越bean的还是在一个类中，它的生命周期与它所置换的功能部件的目标生命周期匹配。在上例中这没什么问题，因为只有一个功能部件实例被置换了，而且唯一的Cuckoo's Egg通知只维护一个替代功能部件。

　　这个例子非常简单，而在实践中，您很可能必须处理大量需要用各自的Cuckoo's Egg实例置换的功能部件实例。在这种情况下，单个的方面实例需要被关联到单个的要置换的功能部件实例。本系列的下一篇文章将会考虑方面生命周期的用法，届时将解决这个问题。

结束语
　　本文介绍了如何在Spring框架内谨慎使用around形式的通知。around形式的通知常用于实现Cuckoo's Egg设计模式时，所以我们引入了一个例子来说明如何使用Spring AOP实现这种面向方面设计模式。

　　在本系列的第三部分中，您将看到如何使用Spring框架中其他的AOP基本概念。这些概念包括：控制方面生命周期、使用基于introduction通知的积极方面改变应用程序的静态结构，以及使用control flow切入点实现对方面编织的更细微的控制。

　　参考资料

• Spring框架教程——向您展示Spring框架的内部运作方式
• 本文的完整源代码
• Spring Java/J2EE框架
• “Comparing the Inversion of Control and Dependency Injection Design Patterns”
• IoC模式概述
• Spring框架参考文档第5章——介绍Spring中的所有AOP特性

　　原文出处
An Introduction to Aspect-Oriented Programming with the Spring Framework, Part 2 http://www.onjava.com/pub/a/onjava/2004/10/20/springaop2.html

　　作为这个介绍Spring框架中的面向方面编程(Aspect-Oriented Programming，AOP)的系列的第一部分，本文介绍了使您可以使用Spring中的面向方面特性进行快速开发的基础知识。使用跟踪和记录方面（面向方面领域的HelloWorld）作为例子，本文展示了如何使用Spring框架所独有的特性来声明切入点和通知以便应用方面。本系列的第二部分将更深入地介绍如何运用Spring中的所有通知类型和切入点来实现更实用的方面和面向方面设计模式。对于AOP的更一般性的介绍，请查看ONJava站点上Graham O'Regan的文章，“Introduction to Aspect-Oriented Programming”。

　　本文的目的不是要介绍构成模块化J2EE系统——即Spring框架——的所有重要元素，我们将只把注意力放在Spring所提供的AOP功能上。由于Spring的模块化设计方法，我们可以只使用该框架的AOP元素，而无需对构成Spring框架的其他模块做太多考虑。

在AOP方面，Spring提供了什么？
　　“它的目标不是提供最完善的AOP实现（虽然Spring AOP非常强大）；而是要提供AOP实现与Spring IoC的紧密集成，以便帮助解决企业应用中的常见问题。”
Spring Framework参考文档

　　为了实现这个目标，Spring框架目前支持一组AOP概念，从切入点到通知。本文将展示如何使用Spring框架中所实现的如下AOP概念：

• 通知（Advice）：如何将before通知、afterReturning通知和afterThrowing通知声明为bean。
• 切入点（Pointcut）：如何声明静态切入点逻辑以将XML Spring Bean Configuration文件中的所有内容联系在一起。
• Advisor：关联切入点定义与通知bean的方式。

设置场景：一个简单的例子应用程序
　　“一般而言，Spring并不是预描述的。虽然使用好的实践非常容易，但是它避免强制推行一种特定的方法。”
Spring Framework参考文档

　　要试用Spring框架的AOP功能，首先我们要创建一个简单的Java应用程序。IbusinessLogic接口和BusinessLogic类为Spring框架中的bean提供了简易构件块。虽然该接口对于我们的简单应用程序逻辑来说不是必需的，但是它是Spring框架所推荐的良好实践。

public interface IBusinessLogic
{
    public void foo();
}

public class BusinessLogic 
    implements IBusinessLogic
{
    public void foo() 
    {
        System.out.println(
        "Inside BusinessLogic.foo()");
    }
}

　　可以编写MainApplication类，借此练习BusinessLogic bean的公有方法。

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class MainApplication
{
    public static void main(String [] args)
    {
        // Read the configuration file
        ApplicationContext ctx = 
          new FileSystemXmlApplicationContext(
            "springconfig.xml");

        //Instantiate an object
        IBusinessLogic testObject = 
          (IBusinessLogic) ctx.getBean("businesslogicbean");

        // Execute the public 
        // method of the bean
        testObject.foo();
    }
}

　　在BusinessLogic类及其关联接口中没有什么需要注意的。但是，MainApplication类初始化BusinessLogic对象的方式很有意思。通过使用ctx.getBean("businesslogicbean")调用，MainApplication将加载和管理BusinessLogic类的bean实例的任务转交给了Spring框架。

　　允许Spring控制BusinessLogic bean的初始化，这使得Spring运行时有机会在bean被返回给应用程序之前执行J2EE系统所需的所有与bean相关的管理任务。然后Spring运行时配置可以决定对bean应用哪些任务和模块。该配置信息由一个XML文件提供，类似于下面所示的：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC
    "-//SPRING//DTD BEAN//EN"
    "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

   <!-- Bean configuration -->
   <bean id="businesslogicbean"
   class="org.springframework.aop.framework.ProxyFactoryBean">
      <property name="proxyInterfaces">
         <value>IBusinessLogic</value>
      </property>
      <property name="target">
         <ref local="beanTarget"/>
      </property>
   </bean>
   <!-- Bean Classes -->
   <bean id="beanTarget"
   class="BusinessLogic"/>

</beans>

　　该配置文件，即springconfig.xml，指定要加载一个接口与IbusinessLogic相匹配的bean。该bean随后被关联到BusinessLogic实现类。看起来好像是费了很大力气只为了加载一个简单的bean并调用一个方法，但是您要知道，这个配置文件只是使Spring框架可以透明地对应用程序应用其组件的众多特性的一个体现。

　　图1显示了基本的顺序图：MainApplication原样执行，没有应用方面。

图1.没有对BusinessLogic bean应用方面时的顺序图

　　请查看本文末尾处的参考资料，获取这个简单Spring应用程序的源代码。

应用方法跟踪（Method Tracing）方面
　　可能最基本的方面就是方法跟踪方面了。这可能是您找得到的最简单的方面了，因此它是研究新的AOP实现的一个很好的起点。

　　方法跟踪方面在一个目标应用程序内捕获对所跟踪的方法的调用以及方法的返回值，并以某种方式显示这种信息。在AOP中，通知的before和after类型用于捕获这些类型的联结点，因为这两种通知可以在方法调用联结点之前或之后触发。使用Spring框架，方法跟踪方面的before通知是在TracingBeforeAdvice类中声明的。

import java.lang.reflect.Method;
import org.springframework.aop. MethodBeforeAdvice;

public class TracingBeforeAdvice 
   implements MethodBeforeAdvice
{
    public void before(Method m, 
                     Object[] args, 
                     Object target) 
                     throws Throwable
    {
        System.out.println(
          "Hello world! (by " + 
          this.getClass().getName() + 
          ")");
    }
}

　　类似地，after通知可以在TracingAfterAdvice类中声明。

import java.lang.reflect.Method;
import org.springframework.aop.AfterReturningAdvice;

public class TracingAfterAdvice 
   implements AfterReturningAdvice
{
    public void afterReturning(Object object, 
                             Method m, 
                             Object[] args, 
                             Object target) 
                             throws Throwable
    {
        System.out.println(
          "Hello world! (by " + 
          this.getClass().getName() + 
          ")");
    }
}

　　这两个类都通过实现Spring框架的适当通知接口而表示了特定的通知。每种类型的通知都指定实现before(..)或afterReturning(..)方法，以便使Spring运行时可以告诉通知适当的联结点会在何时出现。值得注意的是，TracingAfterAdvice实际上是从AfterReturningAdvice扩展而来的，表示只有在联结点在无异常的情况下获得返回值时才运行通知。

　　为了将通知与应用程序中的适当联结点关联起来，必须对springconfig.xml进行一些修改。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC
    "-//SPRING//DTD BEAN//EN"
    "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

   <!-- Bean configuration -->
   <bean id="businesslogicbean"
   class="org.springframework.aop.framework.ProxyFactoryBean">
      <property name="proxyInterfaces">
         <value>IBusinessLogic</value>
      </property>
      <property name="target">
         <ref local="beanTarget"/>
      </property>
      <property name="interceptorNames">
         <list>
            <value>theTracingBeforeAdvisor</value>
            <value>theTracingAfterAdvisor</value>
         </list>
         </property>
   </bean>
   <!-- Bean Classes -->
   <bean id="beanTarget"
   class="BusinessLogic"/>

   <!-- Advisor pointcut definition for before advice -->
   <bean id="theTracingBeforeAdvisor"
      class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
      <property name="advice">
         <ref local="theTracingBeforeAdvice"/>
      </property>
      <property name="pattern">
         <value>.*</value>
      </property>
   </bean>
	
   <!-- Advisor pointcut definition for after advice -->
   <bean id="theTracingAfterAdvisor"
      class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
      <property name="advice">
         <ref local="theTracingAfterAdvice"/>
      </property>
      <property name="pattern">
         <value>.*</value>
      </property>
   </bean<

   <!-- Advice classes -->
   <bean id="theTracingBeforeAdvice"
      class="TracingBeforeAdvice"/>
   <bean id="theTracingAfterAdvice"
      class="TracingAfterAdvice"/>

</beans>

　　theTracingBeforeAdvisor和theTracingAfterAdvisor advisor被添加到前面所声明的businesslogicbean。每个advisor都可能截获所有bean所关联到的联结点。Advisor本身就是bean，而它唯一的作用就是将切入点定义与通知bean关联起来。本例中的切入点定义是在静态对象层次结构中指定相关联结点的正则表达式。

　　因为本例中使用了org.springframework.aop.support.RegexpMethodPointcutAdvisor切入点advisor，切入点逻辑是使用正则表达式指定的。正则表达式用于识别公有接口对IbusinessLogici接口的联结点。下面是一些可以用来指定IBusinessLogic接口上的不同联结点集合的正则表达式例子：

• <value>.*</value>：该表达式选择advisor所关联到的一个或多个bean上的所有联结点。
• <value>./IBusinessLogic/.foo</value>：该表达式只选择IbusinessLogic接口上的foo()方法的联结点。如果是advisor所关联到的bean，则该表达式只选择IBusinessLogic接口上的联结点。

　　springconfig.xml文件中最后的bean声明指定实现通知bean的类。

　　既然已经指定了跟踪方面的正确配置，那么下一次执行MainApplication时，这些方面就会在初始化过程中被编织进去，而BusinessLogic bean中的所有方法都将被跟踪，如图2所示。

　　
图2. 方法跟踪方面应用到BusinessLogic bean之后的顺序图（单击图像查看大图）

　　方法跟踪方面和例子应用程序的源代码可在本文末尾的参考资料小节进行下载。

方面的重用
　　可以对方法跟踪方面进行扩展，提供一个稍微复杂的记录（Logging）方面。记录方面提供了一个很不错的重用例子，因为记录方面所需的许多特性都已经包含在方法跟踪方面中了。

　　在本例中，记录方面扩展了方法跟踪方面，以便显示附加的与（在应用程序的执行过程中）所引发的异常有关的信息。

　　要完全使用记录方面，需要对应用程序做一些更改。BusinessLogicException异常类提供了一个可以由IBusinessLogicInterface接口和BusinessLogic实现类新增的void bar()方法引发的异常。

public class BusinessLogicException 
   extends Exception
{

}

public interface IBusinessLogic
{
    public void foo();
   
    public void bar() 
      throws BusinessLogicException;
}

public class BusinessLogic 
   implements IBusinessLogic
{
    public void foo() 
    {
        System.out.println(
          "Inside BusinessLogic.foo()");
    }
     
    public void bar() 
       throws BusinessLogicException
    {
        System.out.println(
        "Inside BusinessLogic.bar()");
          throw new BusinessLogicException();
    }
}

　　MainApplication类现在将对void bar()方法进行一次额外的调用，并处理选中的、可能由该方法引发的异常。

import org.springframeworkcontext.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class MainApplication
{
    public static void main(String [] args)
    {
        // Read the configuration file
        ApplicationContext ctx =
          new FileSystemXmlApplicationContext(
            "springconfig.xml");

       //Instantiate an object
       IBusinessLogic testObject = 
          (IBusinessLogic) ctx.getBean(
            "businesslogicbean");

       //Execute the public methods of the bean
       testObject.foo();
      
       try
       {
           testObject.bar();
       }
       catch(BusinessLogicException ble)
       {
           System.out.println(
             "Caught BusinessLogicException");
       }
    }
}

　　来自方法跟踪方面的TracingBeforeAdvice和TracingAfterAdvice通知可以整体重用。LoggingThrowsAdvice类为新的异常记录提供了通知。

import org.springframework.aop.ThrowsAdvice;
import java.lang.reflect.Method;

public class LoggingThrowsAdvice 
   implements ThrowsAdvice
{
    public void afterThrowing(Method method, 
                            Object[] args, 
                            Object target, 
                            Throwable subclass)
    {
       System.out.println(
         "Logging that a " + 
         subclass + 
         "Exception was thrown.");
    }
}

　　应用记录方面的最后一步是修改springconfig.xml配置文件，使其包含新添加的LoggingThrowsAdvice通知。

　　图3显示了运行MainApplication并使用Spring框架应用了记录方面的UML顺序图。

　　
图3. 记录方面应用到BusinessLogic bean之后的顺序图（单击图像查看大图）

　　此处的记录方面清楚地说明了如何重用现有方面以及如何在Spring框架中使用通知的throws形式。通过为before和after通知声明新的通知来重写现有的方法跟踪方面实现，可以实现更复杂的记录方面，记录到更复杂的记录框架，比如LOG4J。关于记录方面和例子应用程序的源代码，请参见本文末尾的参考资料小节。

结束语
　　本文展示了使用Spring框架中的基本AOP结构所应用的一些简单方面。在本系列的下一篇文章中，我们将介绍一些更实用的方面，探讨方面的生命周期，使用Spring框架的around通知，并使用Spring来应用AOP模式。

　　参考资料

• 本文的源代码
• Spring Java/J2EE Framework
• Spring AOP Framework
• "Introduction to Aspect-Oriented Programming"

　　原文出处:An Introduction to Aspect-Oriented Programming with the Spring Framework, Part 1http://www.onjava.com/pub/a/onjava/2004/07/14/springaop.html

1.引言

SOA是一种构造分布式系统的方法，它将业务应用功能以服务的形式提供出来，以便更好的复用、组装和与外部系统集成，从而降低开发成本，提高开发效率。SOA的目标是为企业构建一个灵活，可扩展的IT基础架构来更好地支持随需应变的商务应用。

随着SOA技术和产品的不断成熟，现在越来越多的用户开始了解并认同SOA的理念，但对SOA项目的实施还缺乏信心。其主要原因是：SOA应用开发还相对比较复杂。

一年多来，本文作者所在的部门已经从事了许多国内外的SOA项目的实施和支持工作，积累了许多SOA应用开发经验。我们希望能够通过一系列的文章与读者分享这些想法，帮助您更好地构建SOA应用。

本文将从Web Service调用入手，在解决一系列具体问题的过程中，使用IoC (Inversion of Control) 和AOP (Aspect- Oriented Programming) 等方法重构Web Service的访问代码，使得业务逻辑与Web Service访问解耦，为您提供一个更加灵活和易于扩展的访问模式。

Spring是一个流行的轻量级容器，对IoC和AOP提供了良好的支持。本文为您提供了一个基于Spring的实现供您下载学习。示例代码工程使用Eclipse3.1/3.02和JDK1.4开发, 您还需要Spring 1.2.5和Axis1.3提供的支持。详细的下载信息请参见参考资源部分。

2.Web Service调用

Web Service是目前实现SOA应用的一项基本的，适用的技术，它为服务的访问提供了一个被广泛接受的开放标准。为了便于说明问题，我们将使用XMethods 网站（http://www.xmethods.net/）发布的货币兑换服务作为示例。并针对JAX-RPC 1.1，说明如何编写Web Service 的调用代码。

2.1 示例说明

http://xmethods.net 作为最早推出Web Service实际示例的网站，提供了很多优秀的Web Service 样例。其中有一个汇率计算服务，可以返回两个国家之间的货币兑换比例。获取该服务的详细信息，请参考该服务的服务描述文档（获取WSDL 文档） 。在此就不具体解析该服务描述文档了。读者可以从WSDL2Java生成的接口中了解该服务的用法：

												
														public interface CurrencyExchangePortType extends java.rmi.Remote {
public float getRate(String country1, String country2) throws java.rmi.RemoteException;
}

												
										

2.2 客户端调用方法

JAX-RPC作为Java平台的RPC服务调用标准接口，为Web Service客户端调用提供了3种方法，分别是DII，动态代理，和静态Stub。 DII（Dynamic Invocation Interface）采用直接调用方式，可以在程序中设置诸多的调用属性，使用较为灵活，但是调用过程却相对繁琐复杂，易造成代码膨胀且可重用性低，每次调用不同的Web Service都要重复进行大量编码。

JAX-RPC中动态代理（Dynamic Proxy）的方法实现对Web Service的动态调用，可以在运行时根据用户定义的Client端接口创建适配对象。从而避免了直接操作底层的接口，减少了客户端的冗余，屏蔽了调用相关的复杂性。

使用静态Stub和Service Locator是目前最常用的调用方式。JAX-RPC使用静态的Stub方式包装对底层接口的调用，从而提供一种更为简便的调用方式。使用该方式需要利用支持环境（比如Axis）所提供的工具根据WSDL预生成Web Service客户端的实现代码。因此如果服务的WSDL发生变化，就必须重新生成新的客户端代码并进行重新部署。

为了更详细的了解静态Stub的调用方式，您可以将示例代码的WebServiceClient.jar导入到您现有Eclipse工作区之中。

客户端生成代码包括如下4个类：如图 1 所示：

在上图中包括的几个类中：

CurrencyExchangePortType：服务端点接口，定义了Web Service的方法签名。

CurrencyExchangeService：Service接口，定义了获取服务端点接口的方法。

CurrencyExchangeServiceLocator：ServiceLocator类，实现了Service接口。

CurrencyExchangeBindingStub： Stub实现类，实现了服务端点接口，封装了对Web Service访问的底层逻辑。

使用Stub调用Web Service的过程也非常简单，读者可以参考清单 1：

												
														try {
	//创建ServiceLocator
	CurrencyExchangeServiceLocator locator = new
	CurrencyExchangeServiceLocator();
	//设定端点地址
	URL endPointAddress = new URL("http://services.xmethods.net:80/soap");
	//创建Stub实例
	CurrencyExchangePortType stub =
	locator.getCurrencyExchangePort(endPointAddress);
	//设定超时为120秒
	((CurrencyExchangeBindingStub)stub).setTimeout(120000);
	//调用Web Service计算人民币与美元的汇率
	float newPrice = stub.getRate("China", "USA") * 100;
} catch (MalformedURLException mex) {
	//...
} catch (ServiceException sex) {
	//...
} catch (RemoteException rex) {
	//...
}

												
										

3.重构Web Service调用代码

3.1 实例代码中的"坏味道"

上面的基于Service Locator的Web Service访问代码虽然简单但暴露出以下几个问题：

1．访问Web Service所需的配置代码被嵌入应用逻辑之中
在Web Service调用中，我们需要设定一系列必要的参数。比如：服务端点地址、用户名/密码、超时设定等等。这些参数在开发和运行环境中都有可能发生变化。我们必须提供一种机制：在环境变化时，不必修改源代码就可以改变Web Service的访问配置。

2 客户端代码与Web Service访问代码绑定
在上面的代码中，业务逻辑与Web Service的Stub创建和配置代码绑定在一起。这也不是一种良好的编程方式。客户端代码只应关心服务的接口，而不应关心服务的实现和访问细节。比如，我们既可以通过Web Service的方式访问远程服务，也可以通过EJB的方式进行访问。访问方式对业务逻辑应该是透明的。

这种分离客户端代码与服务访问代码的方式也有利于测试。这样在开发过程中，负责集成的程序员就可能在远程服务还未完全实现的情况下，基于服务接口编写集成代码，并通过编写POJO（Plain Old Java Object）构建伪服务实现来进行单元测试和模拟运行。这种开发方式对于保证分布式系统代码质量具有重要意义。

因此，为了解决上面的问题我们需要：

1、将Web Service访问的配置管理与代码分离；

2、解除客户端代码与远程服务之间的依赖关系；

3.2 利用IoC模式进行重构代码

我们先介绍在Core J2EE Patterns一书中提到的一种业务层模式：Business Delegate。它所要解决的问题是屏蔽远程服务访问的复杂性。它的主要思想就是将Business Delegate作为远程服务的客户端抽象，隐藏服务访问细节。Business Delegate还可以封装并改变服务调用过程，比如将远程服务调用抛出的异常（例如RemoteException）转换为应用级别的异常类型。

其类图如图 2 所示：

Business Delegate模式实现很好地实现了客户端与远程访问代码的解耦，但它并不关注Delegate与远程服务之间的解耦。为了更好解决Business Delegate和远程服务之间的依赖关系，并更好地进行配置管理，我们可以用IoC模式来加以解决。

IoC（Inversion of Contro）l意为控制反转，其背后的概念常被表述为"好莱坞法则"："Don't call me, I'll call you." IoC将一部分责任从应用代码交给framework（或者控制器）来做。通过IoC可以实现接口和具体实现的高度分离，降低对象之间的耦合程度。Spring是一个非常流行的IoC容器，它通过配置文件来定义对象的生命周期和依赖关系，并提供了良好的配置管理能力。

现在我们来重构我们的Web Service应用程序，我们首先为Business Delegate定义一个接口类型，它提供了一个应用级组件接口，所有客户端都应通过它来执行汇率计算，而不必关心实现细节，如清单 2 所示：

												
														Public interface CurrencyExchangeManager {
	//货币兑换计算
	//新价格 = 汇率 * 价格
public float calculate(String country1, String country2, float price) 
throws CurrencyExchangeException;
}

												
										

Business Delegate的实现非常简单，主要工作是包装汇率计算 Web Service的调用，如清单 3 所示。

												
														public class CurrencyExchangeManagerImpl implements CurrencyExchangeManager {
	//服务实例
	private CurrencyExchangePortType stub;
	//获取服务实例
	public CurrencyExchangePortType getStub() {
		return stub;
	}
	//设定服务实例
	public void setStub(CurrencyExchangePortType stub) {
		this.stub = stub;
	}
	//实现货币兑换
	public float calculate(String country1, String country2, float price)
throws CurrencyExchangeException {
		try {
			//通过Stub调用WebService
			float rate = stub.getRate(country1, country2);
			return rate * price;
		} catch (RemoteException rex) {
			throw new CurrencyExchangeException(
					"Failed to get exchange rate!", rex);
		}
	}
}

												
										

下面我们需要讨论如何利用Spring的IoC机制，来创建和配置对象，并定义它们的依赖关系。

Spring利用类工厂来创建和配置对象。在Spring框架中，已经为基于JAX－RPC的Web Service调用提供了一个客户端代理的类工厂实现：JaxRpcPortProxyFactoryBean。在配置文件bean.xml中，我们将使用JaxRpcPortProxyFactoryBean来创建和配置Web Service的客户端代理"CurrencyExchangeService"，如清单 5 所示。我们还将定义一个名为"CurrencyExchangeManager"的CurrencyExchangeManagerImpl实例，并建立它与CurrencyExchangeService之间的依赖关系。有关Spring 配置和JaxRpcPortProxyFactoryBean的使用细节请参见参考资料。

												
														<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
	<bean id="CurrencyExchangeService"
	class="org.springframework.remoting.jaxrpc.JaxRpcPortProxyFactoryBean">
		<property name="serviceInterface">	
		<value>net.xmethods.www.sd.CurrencyExchangeService_wsdl.
		CurrencyExchangePortType</value>
		</property>
		<property name="wsdlDocumentUrl">		
		<value>http://www.xmethods.net/sd/2001/CurrencyExchangeService.
		wsdl</value>
		</property>
		<property name="namespaceUri">
			<value>http://www.xmethods.net/sd/CurrencyExchangeService.
			wsdl</value>
		</property>
		<property name="serviceName">
			<value>CurrencyExchangeService</value>
		</property>
		<property name="portName">
			<value>CurrencyExchangePort</value>
		</property>
		<property name="endpointAddress">
			<value>http://services.xmethods.net:80/soap</value>		
		</property>
	</bean>	
	<bean id="CurrencyExchangeManager"
	class="test.ws.CurrencyExchangeManagerImpl">
		<property name="stub">
			<ref bean="CurrencyExchangeService"/>
		</property>
	</bean>
</beans>

												
										

最后我们创建一个测试程序来验证我们的代码，如清单6 所示：

												
														public class Main {
	// For test only
	public static void main(String[] args) {
		// Spring Framework将根据配置文件创建并配置CurrencyExchangeManager实例
		ApplicationContext ctx = new FileSystemXmlApplicationContext("bean.xml");
		// 获取CurrencyExchangeManager实例
		CurrencyExchangeManager manager = (CurrencyExchangeManager) ctx
				.getBean("CurrencyExchangeManager");
		try {
			System.out.println(manager.calculate("China", "USA", 100));
			System.out.println(manager.calculate("China", "Japan", 200));
			System.out.println(manager.calculate("China", "USA", 200));
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}
}

												
										

此时运行测试客户端，等待片刻将会看见测试结果，如清单 7 所示：

												
														12.34
2853.26
24.68

												
										

注：该结果会随着汇率的变化而出现不同的值。

该程序的类图和顺序图如图3及图4所示：

从上面的类图我们可以看到，我们的测试程序（Main.java）通过Spring框架获取了BusinessDelegate的实例。而且Spring 框架还会根据配置中的依赖关系，在运行时将Web Service的客户端代理" 注射"到CurrencyExchangeManagerImpl实例中，这就是依赖注入（Dependency Injection）。通过这种方式解决了应用逻辑和BusinessDelegate之间的依赖关系，以及BusinessDelegate的实现与远程服务之间的依赖关系，如图 4 所示。

Spring框架提供的ApplicationContext实现会根据配置文件中的描述信息来实现对象生命周期管理，配置管理以及依赖管理等功能。这一切对于应用程序是透明的，应用程序代码只依赖接口进行编程，而无需考虑其它复杂问题。无论是Web Service的配置发生变化，或是改用不同的服务实现时，都不会对客户端应用代码的产生影响。这很好地实现了业务逻辑与Web Service调用之间的解耦。

3.3 构建自己的 Web Service代理工厂

Spring所提供的JaxRpcPortProxyFactoryBean封装了构造Web Service客户端代理的细节，可以通过参数配置来创建Dynamic Proxy和DII类型的Web Service客户端代理。（如果您希望深入了解其实现细节可以参考org.springframework.remoting.jaxrpc包下的源代码。）但由于JaxRpcPortProxyFactoryBean需要使用者对WSDL中Port，Service，名空间等概念有深入的了解；而且如果Web Service使用了复杂数据类型，开发人员需要手工定义类型映射代码。所以JaxRpcPortProxyFactoryBean并不适合Web Service的初学者来使用。

为了进一步简化Web Service代理的创建，并帮助读者更好地理解类工厂在Spring框架下的作用。我们提供了一个基于静态Stub的Web Service客户端代理工厂实现。其核心代码非常简单，就是通过ServiceLocator提供的方法来创建Web Service客户端代理。

其主要代码如清单8所示：

												
														public class WebServiceStubFactoryBean implements FactoryBean, 
InitializingBean {
	private Class serviceInterface;
	private Class serviceLocator;
	private Object stub;
     …
	public void afterPropertiesSet() throws Exception {
         //利用serviceLocator和服务接口创建Web Service客户端代理
		stub = ((javax.xml.rpc.Service)
		serviceLocator.newInstance()).getPort(serviceInterface);
	    //为Stub设定endpointAddress，usernam, 超时等参数
		preparePortStub((javax.xml.rpc.Stub) stub);
	}
	public Object getObject() {
          // 返回客户端代理
		return stub;
	}
	public Class getObjectType() {
          // 返回服务接口
		return serviceInterface;
	}
	public boolean isSingleton() {
		return true;
	}
}

												
										

我们需要修改配置文件bean.xml中有关Web Service代理创建的部分，让新的Web Service 代理工厂发挥作用。如清单9所示：

												
														<bean id="CurrencyExchangeService" class="test.ws.WebServiceStubFactoryBean">
	<property name="serviceInterface">
	<value>net.xmethods.www.sd.CurrencyExchangeService_wsdl.CurrencyExchangePortType</value>
	</property>
	<property name="serviceLocator">
	<value>net.xmethods.www.sd.CurrencyExchangeService_wsdl.CurrencyExchangeServiceLocator</value>
	</property>
	<property name="endpointAddress2">
		<value>http://services.xmethods.net:80/soap</value>
	</property>
	<property name="timeout">
		<value>120000</value>
	</property>
</bean>

												
										

得益于Spring框架，虽然我们已经替换了对象的类工厂，却并不需要更改应用代码。通过Spring框架的IoC机制，我们可以完全使用面向接口的编程方式，而将实现的创建、配置和依赖管理交由Spring在运行时完成。即使实现发生了变化，也不需要改变应用程序结构。

4.新的思考

故事并没有结束，在开发过程中，我们又遇到了一系列关于Web Service调用的问题。

4.1性能

系统性能是分布式应用中的一个重要问题。许多用户都担心由Web Service技术所引入的额外开销是否会影响到产品的性能。随着技术的不断发展，Web Service引擎性能已经有了很大提高，一般来说使用Web Service的系统的性能可以满足绝大部分应用的需求。但在特定情况下，如果系统性能无法满足客户需求，我们首先需要对系统性能进行科学地分析和测定才能定位真正的性能瓶颈。这个问题在上文简单的示例中并不难解决，只需要在Web Service调用前后加入日志代码记录调用时间即可实现。但在实际系统中，比如一个产品目录的Web Service可能提供数十种查询方法，而程序中很多组件都会依赖于该服务提供的查询功能。如果在系统中所有的地方加入性能测定代码，这个工作就变得非常繁琐和困难。我们需要用一种更加优雅的解决方式，在增添新功能的同时并不影响系统代码或结构。

4.2缓存

在项目实践中，一个有效的改善Web Service系统性能的方法就是利用缓存来减少Web Service的重复调用。在具体实现中我们可以采用客户端缓存和服务器端缓存等不同方式，他们具有不同的特点和适用范围。在本文例子中，我们希望实现客户端缓存来提高系统性能。但由于Web Service业务逻辑的差别，我们希望能够为特定的Web Service提供特定的缓存策略，而且这些策略应该是能够被灵活配置的，它们不应于应用程序的逻辑代码耦合在一起。

4.3故障恢复：

对于Web Service应用，系统的可用性也是一个需要考虑的重要问题。在运行时由于网络运行环境的复杂性和不确定性，用户希望能够对Web Service访问提供一定的故障恢复机制：比如重试或者访问备份服务（当系统在调用Web Service失败后，使用备份Web Service的服务地址来继续访问）。这些故障恢复策略应该是可配置的，对应用逻辑透明的。

5.使用AOP解决SOA应用中的Crosscutting Concern

通过对上边一系列问题的分析，读者也许会发现这些问题并不是Web Service访问的核心问题，但会影响系统中许多不同的组件。而且其中一些问题需要我们能够灵活配置不同的实现策略，因此我们不应该将处理这些问题的代码与应用代码混合。

下面我们将利用AOP（Aspect-Oriented Programming）提供的方法来解决上述的问题。AOP是一种新兴的方法学，它最基本的概念就是关注隔离（Separation of Concern）。AOP提供了一系列的技术使得我们能够从代码中分离那些影响到许多系统模块的crosscutting concerns，并将他们模块化为Aspects。AOP的主要目的仍然是解耦，在分离关注点后，才能将关注点的变更控制一定范围内，增加程序的灵活性，才能使得关注能够根据需求和环境作出随时调整。

我们将利用Spring所提供的AOP功能支持来解决以上问题。这里我们只简单地介绍涉及到的AOP基本概念以及实现，如果您希望更好地了解AOP的概念以及Spring AOP支持的细节请参见参考资料。

• Joinpoint 是程序的运行点。在Spring AOP中，一个Joinpoint对应着一个方法调用。
• Advice 定义了AOP框架在特定的Joinpoint的处理逻辑。Spring AOP框架通过interceptor方式实现了advice，并且提供了多种advice类型。其中最基本的"around advice"会在一个方法调用之前和之后被执行。

下面我们将利用Spring提供的MethodInterceptor来为Web Service调用实现我们的定义的处理逻辑。

5.1 PerformanceMonitorInterceptor

性能测量是AOP最简单的例子之一，我们可以直接利用Spring提供的实现在bean.xml中声明我们的WebServicePerformanceMonitorInterceptor。

5.2 CacheInterceptor

为了不引入缓存策略的复杂性，我们只提供了一个利用HashMap的简单实现：它利用 Web Service的调用参数列表作为HashMap键值。在Web Service调用之前，首先检查缓存中是否拥有与现在参数列表相同的项，如果有则返回缓存的结果，否则调用Web Service并将<参数列表，结果>记录在HashMap中。在实际应用中，您应该根据具体情况来选择、构造适合Web Service的业务特性的Cache实现，也可以采用成熟的Cache实现。

在下面代码实现中有一个生成Web Service调用主键的小技巧。因为Web Service引擎要求所有调用参数必须是可序列化的，所以我们可以利用Java提供的序列化功能来实现对象的克隆。如清单10所示：

												
														public class SimpleCacheInterceptor implements MethodInterceptor {
	private Map cache = new HashMap();
	private Object cloneObject(Object obj) throws Exception {
		Object newObj = null;
		if (obj != null) {
			// 通过序列化/反序列化来克隆对象
			ByteArrayOutputStream bos = new ByteArrayOutputStream();
			ObjectOutputStream out = new ObjectOutputStream(bos);
			out.writeObject(obj);
			out.flush();
			out.close();
			ObjectInputStream in = new ObjectInputStream(
					new ByteArrayInputStream(bos.toByteArray()));
			newObj = in.readObject();
		}
		return newObj;
	}
	//基于参数列表数组，生成用于HashMap的键值
public Object generateKey(Object[] args) throws Exception {
		Object[] newArgs = (Object[]) cloneObject(args);
		List key = Arrays.asList(newArgs);
		return key;
	}
	//实现使用缓存技术的invoke方法
	public Object invoke(MethodInvocation methodInvocation) throws Throwable {
		Object result = null;
		Object data = null;
		Object key = null;

		try {
			key = generateKey(methodInvocation.getArguments());
			data = cache.get(key);
		} catch (Exception ex) {
			logger.error("Failed to find from the cache", ex);
		}

		if (data == null) {
			//如果Cache中没有缓存结果，调用服务执行生成用于HashMap的键值
			result = methodInvocation.proceed();
			try {
				data = cloneObject(result);
				cache.put(key, data);
			} catch (Exception ex) {
				logger.error("Failed to cache the result!", ex);
			}
		} else {
			result = data;
		}
		return result;
	}
}

												
										

5.3 FailoverInterceptor

下面代码提供了一个基于服务备份切换的故障恢复实现，在运行时，如果Interceptor检测到服务调用由于网络故障抛出异常时，它将使用备份服务的端点地址并重新调用。如清单11所示：

												
														public class SimpleFailoverInterceptor implements MethodInterceptor {	…
     …
	//实现支持端点运行时切换的invoke方法
	public Object invoke(MethodInvocation methodInvocation) throws Throwable {
		Object result = null;
		try {
			result = methodInvocation.proceed();
		} catch (Throwable ex) {
	        if (isNetworkFailure(ex)) {
                  //切换服务端点地址
				switchEndPointAddress((Stub) methodInvocation.getThis());
				result = methodInvocation.proceed();
			} else {
				throw ex;
			}
		}
		return result;
	}
}

												
										

为了支持备份服务切换的功能，我们在WebServicePortProxyFactoryBean中为填加了配置参数"endpointAddress2"，它会在创建的Web Service客户端代理对象中记录备份URL。

我们可以在CurrencyExchangeService加入下列参数来试验SimpleFailoverInterceptor的功能。其中第一个端点地址为一个错误的URL。在第一次调用服务时，SimpleFailoverInterceptor会侦测到网络故障的发生，并自动切换使用第二个端点地址继续访问。如清单12所示：

												
																
<property name="endpointAddress">
	<value>http://localhost/wrong_endpoint_address</value>
</property>
<property name="endpointAddress2">
	<value>http://services.xmethods.net:80/soap</value>
</property>

												
										

5.4配置文件和运行结果

现在我们需要在Spring配置文件中，为所有interceptor添加定义，并描述如何为CurrencyExchangeService构建AOP Proxy。需要指出的是，我们要在interceptorName列表中声明interceptor链的调用顺序，还要将原有CurrencyExchangeManager引用的stub对象替换为新AOP Proxy。如清单13所示：

												
														<bean id="WebServicePerformanceMonitorInterceptor"
class="org.springframework.aop.interceptor.PerformanceMonitorInterceptor">
	<property name="prefix">
		<value>Web Service </value>
	</property>
	<property name="suffix">
		<value></value>
	</property>
</bean>
<bean id="CacheInterceptor" class="test.ws.SimpleCacheInterceptor"/>
<bean id="FailoverInterceptor" class="test.ws.SimpleFailoverInterceptor"/>	
<bean id="CurrencyExchangeProxy"
class="org.springframework.aop.framework.ProxyFactoryBean">
	<property name="proxyInterfaces">	
	<value>net.xmethods.www.sd.CurrencyExchangeService_wsdl.
	CurrencyExchangePortType</value>
	</property>
	<property name="target"> 
		<ref local="CurrencyExchangeService"/> 
	</property>
	<property name="interceptorNames">
		<list>
			<value>WebServicePerformanceMonitorInterceptor</value>
			<value>CacheInterceptor</value>
			<value>FailoverInterceptor</value>
		</list>
	</property>
</bean>	
<bean id="CurrencyExchangeManager"
class="test.ws.CurrencyExchangeManagerImpl">
	<property name="stub">
		<ref bean="CurrencyExchangeProxy"/>
	</property>
</bean>

												
										

这里我们通过为AOP 的ProxyFactoryBean为 Web Service Stub创建了一个AOP代理，并且建立了一个Interceptor链。这样在调用Web Service时，Spring框架会依次调用Interceptor执行。实例执行的顺序图将如图5所示：

5.5 Interceptor与JAX-RPC Handler的关系与区别

SOAP Message Handler是JAX-RPC为用户自定义Web Service处理过程提供的一种扩展机制。在处理Web Service请求/响应过程中，Web Service 引擎会根据部署描述中的定义，按照一定的次序调用Handler的处理代码。用户编写的Handler实现可以截获并修改Web Service消息和处理流程，从而实现对Web Service引擎处理行为的定制和增强。

比如，我们可以实现一个服务器端Handler，记录Web Service在受到请求消息和发出响应消息之间的时间间隔来实现对服务器端业务性能的测定。而且我们只需在部署描述中增加Handler声明即可，无需修改任何服务器端代码。

从此可以看出，JAX-RPC Handler与我们在上文中所提供的AOP Interceptor都可以帮助我们的SOA应用程序实现关注分离（Separate Concern）的目标，在不改变应用代码的同时，增强或改变Web Service服务访问的功能。虽然我们可以利用它们实现一些类似的功能，但它们具有着不同的特点和适用范围。

JAX-RPC Handler是Web Service引擎的扩展机制。如果我们需要实现对SOAP消息进行的修改和处理，加入自定义的SOAP Header或对消息内容进行加密，Handler是我们的最佳选择。而AOP是针对对象级别的扩展机制，它更适合对应用层逻辑进行操作。

比如，我们在上文展示的利用AOP实现的CacheInterceptor，它缓存的是Web Service调用参数和结果。而我们也可以通过JAX-RPC Handler实现一个面向SOAP消息的实现，它将缓存Web Service的请求消息和响应消息。这两个实现相比，基于AOP的实现更加简单、直观、快速、对资源消耗也比较小。而面向SOAP消息的实现则更加灵活，对于不采用RPC方式的Web Service访问也能提供支持。

所以在具体的实践过程中，开发人员应该根据具体的需求选择合适的技术，也可以将这两种技术结合使用。

6.总结

"分而治之"的方法是人们解决复杂问题的一种常见做法。而IoC、AOP等技术都体现了这种思想。通过更好的切分程序逻辑，使得程序结构更加良好，更加富有弹性，易于变化。也使得开发人员可以更加专注于业务逻辑本身，而将一部分其他逻辑交给容器和框架进行处理。

在本文中，我们通过一个Web Service访问的实例，具体描述了SOA应用中所遇到的一系列具体问题，并描述如何利用IoC和AOP等技术进行代码重构，构建更加结构良好、灵活的SOA应用。综上所述，我们可以看到：

1使用IoC框架来实现对象的生命周期管理、配置管理和依赖管理，可以解除业务逻辑对服务调用的依赖关系；

2 使用AOP方法来解决Web Service调用中的crosscutting concerns，将为系统增加新的功能而不必更改应用程序。

3通过IoC和AOP来屏蔽Web Service访问的复杂性，使得开发人员可以更加专注于业务逻辑本身，也使得系统更加稳定和富有弹性。

代码：下载

　　正则表达式(regular expression)对象包含一个正则表达式模式(pattern)。它具有用正则表达式模式去匹

配或代替一个串(string)中特定字符(或字符集合)的属性(properties)和方法(methods)。

正则表达式构造函数： new RegExp("pattern"[,"flags"]);
参数说明：
pattern -- 一个正则表达式文本
flags -- 如果存在，将是以下值：
g: 全局匹配
i: 忽略大小写
gi: 以上组合

在构造函数中，一些特殊字符需要进行转意(在特殊字符前加"\")。正则表达式中的特殊字符：
字符  含意 
\ 转意，即通常在"\"后面的字符不按原来意义解释，如/b/匹配字符"b"，当b前面加了反斜杆后/\b/，转意为

匹配一个单词的边界。
-或-
对正则表达式功能字符的还原，如"*"匹配它前面元字符0次或多次，/a*/将匹配a,aa,aaa，加了"\"后，/a\*/

将只匹配"a*"。 
^  匹配一个输入或一行的开头，/^a/匹配"an A"，而不匹配"An a" 
$  匹配一个输入或一行的结尾，/a$/匹配"An a"，而不匹配"an A" 
*  匹配前面元字符0次或多次，/ba*/将匹配b,ba,baa,baaa 
+  匹配前面元字符1次或多次，/ba*/将匹配ba,baa,baaa 
?  匹配前面元字符0次或1次，/ba*/将匹配b,ba 
(x)  匹配x保存x在名为$1...$9的变量中 
x|y  匹配x或y 
{n}  精确匹配n次 
{n,}  匹配n次以上 
{n,m}  匹配n-m次 
[xyz]  字符集(character set)，匹配这个集合中的任一一个字符(或元字符) 
[^xyz]  不匹配这个集合中的任何一个字符 
[\b]  匹配一个退格符
\b  匹配一个单词的边界 
\B  匹配一个单词的非边界
\cX  这儿，X是一个控制符，/\cM/匹配Ctrl-M 
\d  匹配一个字数字符，/\d/ = /[0-9]/ 
\D  匹配一个非字数字符，/\D/ = /[^0-9]/ 
\n  匹配一个换行符 
\r  匹配一个回车符 
\s  匹配一个空白字符，包括\n,\r,\f,\t,\v等 
\S  匹配一个非空白字符，等于/[^\n\f\r\t\v]/ 
\t  匹配一个制表符 
\v  匹配一个重直制表符 
\w  匹配一个可以组成单词的字符(alphanumeric，这是我的意译，含数字)，包括下划线，如[\w]匹配"$5.98"

中的5，等于[a-zA-Z0-9] 
\W  匹配一个不可以组成单词的字符，如[\W]匹配"$5.98"中的$，等于[^a-zA-Z0-9]。

说了这么多了，我们来看一些正则表达式的实际应用的例子：
HTML代码的屏蔽
 function mask_HTMLCode(strInput) {
   var myReg = /<(\w+)>/;
   return strInput.replace(myReg, "&lt;$1&gt;");
 }
E-mail地址验证:
 function test_email(strEmail) {
  var myReg = /^[_a-z0-9]+@([_a-z0-9]+\.)+[a-z0-9]{2,3}$/;
  if(myReg.test(strEmail)) return true;
  return false;
 }

正则表达式对象的属性及方法：
　　预定义的正则表达式拥有有以下静态属性：input, multiline, lastMatch, lastParen, leftContext,

rightContext和$1到$9。其中input和multiline可以预设置。其他属性的值在执行过exec或test方法后被根据

不同条件赋以不同的值。许多属性同时拥有长和短(perl风格)的两个名字，并且，这两个名字指向同一个值。(

JavaScript模拟perl的正则表达式)

正则表达式对象的属性：
属性 含义
$1...$9 如果它(们)存在，是匹配到的子串 
$_ 参见input 
$* 参见multiline 
$& 参见lastMatch 
$+ 参见lastParen 
$` 参见leftContext 
$''　　　　　　　　　 参见rightContext 
constructor　　　  创建一个对象的一个特殊的函数原型 
global　　　　　　  是否在整个串中匹配(bool型) 
ignoreCase　　　　 匹配时是否忽略大小写(bool型) 
input　　　　　　　 被匹配的串 
lastIndex　　　　  最后一次匹配的索引 
lastParen　　　　  最后一个括号括起来的子串 
leftContext　　　  最近一次匹配以左的子串 
multiline　　　　  是否进行多行匹配(bool型) 
prototype　　　　  允许附加属性给对象 
rightContext　　　 最近一次匹配以右的子串 
source　　　　　　  正则表达式模式 
lastIndex　　　　  最后一次匹配的索引 

正则表达式对象的方法：
方法 含义
compile　　　　　  正则表达式比较 
exec　　　　　　　 执行查找 
test　　　　　　　 进行匹配 
toSource　　　　　 返回特定对象的定义(literal

representing)，其值可用来创建一个新的对象。重载Object.toSource方法得到的。 
toString　　　　　 返回特定对象的串。重载Object.toString方法得到的。 
valueOf　　　　　  返回特定对象的原始值。重载Object.valueOf方法得到
 

例子：
<script language = "JavaScript">
var myReg = /(w+)s(w+)/;
var str  = "John Smith";
var newstr = str.replace(myReg, "$2, $1");
document.write(newstr);
</script>
将输出"Smith, John"

那么，字符的全角和半角转换有什么用处呢？一般说来，我们做的网页都是中文的，要求用户填入的信息也多是汉字，那么很多特殊字符都是全角的，比如说填写多条信息，用逗号分隔，这里的逗号多半都是全角的。而提交到后台（服务器端）处理，或者是查询（构建select语句）或者是入库（提交给DBMS），都是基于西文体系的，因此必须将这些字符转换成对应的半角字符。
下面举一个JavaScript的通用代码例子，详细介绍一下如何将这些全角字符转换成半角字符。
function SD(sbc, dbc)
{
 this.sbc = sbc;
 this.dbc = dbc;
}

var sdArray = new Array();
var sdCount;
var i = 0;

sdArray[i++] = new SD("０", "0");
sdArray[i++] = new SD("１", "1");
sdArray[i++] = new SD("２", "2");
sdArray[i++] = new SD("３", "3");
sdArray[i++] = new SD("４", "4");
sdArray[i++] = new SD("５", "5");
sdArray[i++] = new SD("６", "6");
sdArray[i++] = new SD("７", "7");
sdArray[i++] = new SD("８", "8");
sdArray[i++] = new SD("９", "9");
sdArray[i++] = new SD("ａ", "a");
sdArray[i++] = new SD("ｂ", "b");
sdArray[i++] = new SD("ｃ", "i");
sdArray[i++] = new SD("ｄ", "d");
sdArray[i++] = new SD("ｅ", "e");
sdArray[i++] = new SD("ｆ", "f");
sdArray[i++] = new SD("ｇ", "g");
sdArray[i++] = new SD("ｈ", "h");
sdArray[i++] = new SD("ｉ", "i");
sdArray[i++] = new SD("ｊ", "j");
sdArray[i++] = new SD("ｋ", "k");
sdArray[i++] = new SD("ｌ", "l");
sdArray[i++] = new SD("ｍ", "m");
sdArray[i++] = new SD("ｎ", "n");
sdArray[i++] = new SD("ｏ", "o");
sdArray[i++] = new SD("ｐ", "p");
sdArray[i++] = new SD("ｑ", "q");
sdArray[i++] = new SD("ｒ", "r");
sdArray[i++] = new SD("ｓ", "s");
sdArray[i++] = new SD("ｔ", "t");
sdArray[i++] = new SD("ｕ", "u");
sdArray[i++] = new SD("ｖ", "v");
sdArray[i++] = new SD("ｗ", "w");
sdArray[i++] = new SD("ｘ", "x");
sdArray[i++] = new SD("ｙ", "y");
sdArray[i++] = new SD("ｚ", "z");
sdArray[i++] = new SD("Ａ", "A");
sdArray[i++] = new SD("Ｂ", "B");
sdArray[i++] = new SD("Ｃ", "C");
sdArray[i++] = new SD("Ｄ", "D");
sdArray[i++] = new SD("Ｅ", "E");
sdArray[i++] = new SD("Ｆ", "F");
sdArray[i++] = new SD("Ｇ", "G");
sdArray[i++] = new SD("Ｈ", "H");
sdArray[i++] = new SD("Ｉ", "I");
sdArray[i++] = new SD("Ｊ", "J");
sdArray[i++] = new SD("Ｋ", "K");
sdArray[i++] = new SD("Ｌ", "L");
sdArray[i++] = new SD("Ｍ", "M");
sdArray[i++] = new SD("Ｎ", "N");
sdArray[i++] = new SD("Ｏ", "O");
sdArray[i++] = new SD("Ｐ", "P");
sdArray[i++] = new SD("Ｑ", "Q");
sdArray[i++] = new SD("Ｒ", "R");
sdArray[i++] = new SD("Ｓ", "S");
sdArray[i++] = new SD("Ｔ", "T");
sdArray[i++] = new SD("Ｕ", "U");
sdArray[i++] = new SD("Ｖ", "V");
sdArray[i++] = new SD("Ｗ", "W");
sdArray[i++] = new SD("Ｘ", "X");
sdArray[i++] = new SD("Ｙ", "Y");
sdArray[i++] = new SD("Ｚ", "Z");
sdArray[i++] = new SD("．", ".");
sdArray[i++] = new SD("　", " ");
sdArray[i++] = new SD("（", "(");
sdArray[i++] = new SD("）", ")");
sdArray[i++] = new SD("｛", "{");
sdArray[i++] = new SD("｝", "}");
sdArray[i++] = new SD("［", "[");
sdArray[i++] = new SD("］", "]");
sdArray[i++] = new SD("＜", "<");
sdArray[i++] = new SD("＞", ">");
sdArray[i++] = new SD("「", "“");
sdArray[i++] = new SD("」", "”");
sdArray[i++] = new SD("｀", "`");
sdArray[i++] = new SD("～", "~");
sdArray[i++] = new SD("！", "!");
sdArray[i++] = new SD("＠", "@");
sdArray[i++] = new SD("＃", "#");
sdArray[i++] = new SD("％", "%");
sdArray[i++] = new SD("＾", "^");
sdArray[i++] = new SD("※", "&");
sdArray[i++] = new SD("＊", "*");
sdArray[i++] = new SD("－", "-");
sdArray[i++] = new SD("＿", "_");
sdArray[i++] = new SD("＋", "+");
sdArray[i++] = new SD("＝", "=");
sdArray[i++] = new SD("｜", "|");
sdArray[i++] = new SD("＼", "\\");
sdArray[i++] = new SD("■", "-");
sdArray[i++] = new SD("＇", "'");
sdArray[i++] = new SD("＂", "\"");
sdArray[i++] = new SD("／", "/");
sdArray[i++] = new SD("；", ";");
sdArray[i++] = new SD("：", ":");
sdArray[i++] = new SD("，", ",");
sdArray[i++] = new SD("。", ".");
sdArray[i++] = new SD("？", "?");

sdCount = i;

function sbc2dbc(src)
{
 var k;
 var i;
 var len = src.length;
 var result = "";
 
 for (k=0; k<len; k++)
 {
  ch = src.charAt(k);
  for (i=0; i<sdCount; i++)
  {
   if (sdArray[i].sbc == ch)
   {
    result += sdArray[i].dbc;
    break;
   }
  }
  
  if (i == sdCount) //没有查到对应的全角字符
  {
   result += ch;
  }
 }
 
 return result;
}
代码的原理就不详细介绍了， src参数就是需要转换的字符串，直接调用sbc2dbc函数就可以把src里面所有的全角字符转换成半角字符。
为什么没有半角字符转换成全角字符的函数？呵呵，因为没有想到那里会用到，如果你在开发中真有此需求，相信根据上面的源码，你也可以写出对应的转换函数。祝你顺利。

     在JSP中我们经常要调用服务器端的一些dos命令，已达到一些特殊的效果，但同时调用服务器端的dos命令也存在着一些安全隐患，因此需要慎重使用。

     以下以一个例子来说明用jsp执行dos的过程，比如在服务器端每天都会自动生成一个目录（目录名称为当天的日期），再此目录下会生成一些当天的新闻文件，管理员会把这些文件几个月作一次备份，备份完后在把这些文件删除。

     如果在服务器上，我们可以在dos下直接执行c:\j2sdk\jar cf d:\bak\200502.jar d:\news\20050101 命令， 然后再把20050101目录删除即可。

     在JSP中我们应当这么来写

<%
//执行dos命令
String commandstr = "c:/j2sdk/jar cf d:/bak/200502.jar d:/news/20050101";
Process p ;
try {
   p = Runtime.getRuntime().exec(commandstr);
//等待刚刚执行的命令的结束  
while (true){  
           if(p.waitFor() == 0)   break;
   }    
   
} catch (Exception e) {
    out.println(e.toString());
   }

//删除已经打包的文件及其目录
File f = new File("d:/news/20020101");
String[] allFiles = f.list();
for (int i = 0; i < allFiles.length; i++) {
   File delF = new File("d:/news/20050101/"+allFiles[i]);
   delF.delete();
}
File delD = new File("d:/news/20050101");
delD.delete();
%>

     在jsp中以下代码必须执行，如果没有该代码，则由于删除文件的速度快于打包的速度，因此当压缩包还没有打包完成，一些文件已经被删除，加入下面的代码，会在此一直做循环，一直p.waitFor()（这个方法的说明是：等待子进程的结束，如果已经结束，一般返回0）返回0为止才会接着执行后面的代码
while (true){  
           if(p.waitFor() == 0)   break;
   }