网上的MSSQL虚拟主机价格也贵，要想不让数据库超容，只好压缩下数据库日志，或者删除数据库日志。
下面我给大家介绍一个方法

1、打开企业管理器
2、打开要处理的数据库
3、点击菜单>工具>SQL查询分析器
4、在输入窗口里面输入:
DUMP TRANSACTION [数据库名] WITH NO_LOG
BACKUP LOG [数据库名] WITH NO_LOG
DBCC SHRINKDATABASE([数据库名])
点击执行！这样子数据库就操作成功了。

程序里面的方法：
压缩数据库日志
--1.清空日志
exec('DUMP TRANSACTION [' @dbname '] WITH NO_LOG')
--2.截断事务日志：
exec('BACKUP LOG [' @dbname '] WITH NO_LOG')
--3.收缩数据库文件(如果不压缩,数据库的文件不会减小
exec('DBCC SHRINKDATABASE([' @dbname '])')

　　当前静态语言有:Java、C/C++、C#、Delphi、VB等。

　　动态语言有:ASP、PHP、CGI、lisp、Perl、python,Smalltalk、Ruby等。

　　对于动态语言，每个人心中都有自己的排序，各自喜好不同。但是对于动态语言越来越受重视是很多人的共识。众多的动态语言当中，谁将成为主流语言，众说纷芸，各持已见。而我最看好的动态语言将从下面三种语言中产生。为什么我会锁定在三种语言上呢?除了语言自身的优势外，另外一点最主要的原因就是其被后的力量。任何一种产品想成为主流都离不开强大的财团支持，开发语言也不例外。

　　1、php 动态语言之精典

　　对于php语言，笔者的个人感情较浓，从第一次接触它就被其简单、灵活、功能之强大所征服。更快的处理效率，迅速的部署及PHP的跨平台的特性让其应用更为广泛，相信俱有跨平台特性的动态语言中没有任何一个语言能及php语言的普及率高。很多大的网站使用着PHP，历史证明，它是一个经得起考验的动态语言。另外，php的开源环境也相当出色。世界各地数以万计的程序员，采用PHP编写程序。你可以从PHP相关的网站、社区等找到各类优秀的开源程序代码。

　　最近IBM、Oracle 正尝试把PHP 应用到SOA 之中，再一次证明了PHP的优秀。虽然PHP存在着维护困难，复用性低等问题，但这些并不能影响其最终成为主流的动态语言。前不久IBM还基于Apache Geronimo项目推出了为it WebSphere Application Server Community Edition开发的PHP集成工具集。该工具集能让开发人员在SOA中开发服务时使用PHP和Java。zend也推出了php的开发框架，这些技术将帮助软件公司创建企业级PHP应用。　PHP会变得更加广泛，从当前网站技术上的胜行，到企业级WEB应用，php必将成为最有竞争力的动态语言。

　　2、在java的基础上产生新的语言

　　java语言的发展是有目共睹的，早已成为时下最为主流的开发语言。在java环境下的应用层出不穷，特别是JDK1.5发布之后，java在性能上的提升已今非惜比。对于动态语言的支持早就在日程当中。

　　在Lang.net 2006 会议上, Sun公司宣布将积极参与让JVM支持动态语言的开发项目.将会增加一个新的JVM 指令——invokedynamic，用来设计对动态语言对象的支持。然而主仅仅是一个开始。我想java平台将会全面支持动态语言，俱备运行时更改类结构或相关配置。另外很类技术人员都知道Sun已经整体收购了JRuby项目，sun公司对于动态语言的发展是有备而战的。目前java平台下的动态语言有Groovy、nice、BeanShell、Jython、JRuby、Rhino(JavaScript)、Jacl(TCL)、Bistro(SmallTalk)、Kawa(Lisp/Schema)，真是越来越多了。java下这么多的动态语言建议选择Groovy，感觉血统较为正宗，兼容Java的语法，java程序员学习起来较为容易，上手较快。

　　由于2EE太过于复杂，面对当前的行业需要，必将会在java语言的基础上发展出一种新的基于java的动态语言，使WEB开发过程变得更快，更简洁，但又不失java自身的特点。使Java在WEB开发能力上达到前所未有的提升。由于sun及IBM公司的推动，反微软企业的支持，还有企业的认可，基于java语言所产生的动态语言也必将会成为动态语言家族中有力的竞争对手。

　　3、.net的动态语言

　　微软的动态语言用的人最多的应该是asp，现在发展到ASP.NET。看微软在开发语言方面的发展，他们一定不会放弃这块肥肉，并会加大投入力度，与其它的动态语言提供商火拼到底。只要是有利可图的地方，没有微软不想伸脚的，更何况这是一块大肥肉呢。

　　前不久微软CLR开发组的负责人Jim Hugunin表示，微软将加强对CLR中的动态语言的支持。并将会发布成熟的软件模式，细化到代码中，放在库中供开发者调用，以帮助他们通过.Net Framework上的动态语言开发自己的应用程序。种种迹像表明微软在动态语言方面没闲着，正紧锣密鼓实施着一系例动作。

　　我把微软的动态语言列为最可能成为主流动态语言的原因是因为其Windows的平台无所不在。这是无法否认的。微软势比处投入重手，增强竞争能力。以微软的人力、财力，想不分给微软一块蛋糕是不可能的。有钱就是好，投入大笔的资金，什么都可以做。

　　有人一定会反问我，为什么把其它的动态语言抛开不谈。Perl语言过时了，虽然还有一些公司在使用，但早已不是主流。python、Ruby最近几年开始火起来的动态语言，我并不看好它们，虽然它们是很优秀的语言，但是优秀并不帶表会成为主流。正如操作系统一样，大家都有个共识就是，unix、 Linux很优秀,但是并不是主流系统。当然会有人反驳说应用场景不同，不能一概而论。那么开发语言也一样，我说的是大众主流，大众主流就是指最广泛的被采用。

　　有人说，未来动态语言会取代静态语言，将一统天下，我并不这样认为，相信应该是动态语言与静态语言互相辅助，各在其擅长的方面发挥作用。比如多线程，目前的动态语言支持都不如静态语言的好，很多还不支持。

　　对于语言的选择，一般性的应用，完全可以采用动态语言完成，也可以采用静态语言，这要看撑握语言的人或是需求而决定。更为灵活，更容易扩展及复用的方式是采用动态语言+静态语言的方式。前台功能采用动态语言实现，后台服务采用静态语言实现，充分利用各自的优势。当前在java的WEB应用开发过程中，采用模板技术就是这类应用模式的一个雏型。java的模板技术很多都支持简单的编程，如逻辑控制等。当然现在还不能称其为一种语言，但是相信，这一切随着动态语言的发展并将成为一种新的语言。

　　动态语言必将大行其道，但是不是独行，而将与静态语言相辅相成。

O2 Xda Flame 硬启
1、第一步，先同时按住无线键及照像键再捅PP，第二步（很重要），此时无线键及照像键和PP三键已同时按住，松开时一定要先松开PP，而无线键及照像键不松开等待大概1~2秒后会跳出硬启界面；第三步，按照硬启界面的提示，连按两次左软键，既可完成硬启。
O2-XDA-Graphite：按住导航摇杆键(向上)键＋再短按开机键 然后选择yes 就可以了

O2-Xda-Life：尖笔保持在重设键上，并同时按下开关键。萤幕会指示你同时按著绿色（拨出）及红色（终止通话）键来确定执行hard reset。

O2-XDA-Stealth：Windows键+OK键+重启(捅屁股）。

O2-ZINC：在开机的情况下按住关机键再捅小PP，直到出现二行英文字母再按短信键最后按拨号键.硬启开始。

6900：同时按住接听和挂断键后，捅屁股（捅后释放）。

的硬启动大全 586 686、696、818、828硬启动：按住电源键，用触摸笔捅一下机器下面电源尾插旁边的小孔（resert）就可以了。

828+硬启动方法:同时按住电源键和像机键,在用触笔捅828的小孔（resert）,就OK了!
818pro 硬启动方法:同时按住手机音量键上下两边的照相跟语音键再按开机键，直到屏幕出黑屏并提示按手机的拨号键后开始FMART.. 830：（包括S200、Ｏ2的830） 　　1、同时按住照相键和下面的语音拨号键，保持住不要松开。　　
2、捅一下复位键。此时注意按住照相键和语音键不要松开，等到出现白色字的英文硬复位提醒出来为止。 　　
3、按照英文提示按绿色的拨号键开始硬启 。注意按其它任何键就会取消上面2步所作的努力。
838的硬启动方法: 关机状态下，同时按住手机两边最顶上的按扭再按开机键，直到屏幕出黑屏并提示再按手机的拨号键后开始硬启开机状态下，左边录音键+右边voice command语音命令键+中间确认键+重起RESET键（按一下便松开），此动作持续3秒以上，屏幕出现确认窗口后，按后按send拨号键 XDA ATOM：按住电源戳RESET键，然后同时按下通话和挂断键。

C720: 1.按住左右两个快速键。 2.短按开关键1.5秒后放开(仍然按住快速键)。3.此时手机画面出现重新开机的讯息，依照系统指示输入0以后即可进行恢复默认值的动作。

C730: 关机状态下：按住左右"－"键不松手，按下电源键，出现提示，松手按下拨号键就可以了。

CHT9000: 同时按住左右软键，然后捅小孔，然后打开硬键盘，按R和空格，再按照提示完成硬启动。

D600：同时按住左右横键，再按住开机键，只到出现白色英文就放开手，然后按绿色拨号键，OK

D810: 同时按住: "- -" 两个键,再短按开机键. 2.出来英文提示,再按电话接听键,接下来按K键(挂机键下面那个OK).

D900 硬启: 按住键盘第一排的第二个和第五个键不放,再按电源键就可以了.这是屏幕会出现提示.按提示作就行了. P800/P800W/HTC3300/T版的硬启方法：按住滑鼠两侧的带“—”的键不放手，用笔捅一下resert,带出现提示，按拨号键，松手就可以了。或者，直接在设置----回复出厂设置就可以了

E616: 左右手的拇指一起按下功能键，即圆圈旁边的两个带横杠的按键，同时用笔点机身底部重启的小洞持续2秒,松笔后，等待2 秒，按一下绿色的打电话那个键就OK啦。

E806：拍照键+滚轮垂直按+开机键。

P4550：同时按住左右横键，再用手写笔按一下小孔.出现英文菜单,按一下拔号键.然后是进程条出现.完毕再按拔号键,自动重启.完成硬启

P660：同时按住左右功能键再按一下（大概一秒钟）开机键（左右功能键一直不要放）等待屏幕出现英文，放开再按通话键。

P800: 同时按住左右横键，在捅一下小孔，屏幕出现文按绿色拨号键OK。

S1：、同时按住接听和挂断键后，点按软启动键（按后释放）2、继续按住接听和挂断键，直到出现硬启动界面3、按确认键

U1000: 音量向下+RESET 出现英文按导航键确认-

565、575、585、566、586：先按—和—不放，在按开机键，有提示后按0
686，696，818，828：先按开关按键，同时再戳RESET口，此动作持续30秒以上
P100：看到五位方向键上面的四个按钮，按住最左边（键1）和左右边的按钮（键4），同时戳一下重起键，然后重起键松开，按钮键不要松开，间隔7—10秒左右即可
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
神达
A501: 在关机状态下同时按着开机键和拨号键！当机子震动就可以拉

A701 按住左侧边的音量下键，在按开机关机键约2秒，手机震动即可。

P550: 其一:在关机状态下,按住方向上键的同时，把冷启动键从OFF 打到 ON，直到有开机画面出现;
其二:打开“开始”--“设置”--“系统”--选择“Sys Info”--“Clean Boot”--恢复出厂,点击“开始”输入：000确定后设备重启.
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
ASUS 华硕
P525、P535: 按住向上导航键向上推不放，同时用笔尖按RESET键，这时屏幕会出现一个警告画面，再按电话接听键就可以完成硬启动

P526、P527、P550：1.滚轮向上按住 再用笔点重启按钮。出现提示后，按打电话键。

P735：1、按reset重启一次，然后按向上键+reset，最后屏幕提示按接听键。

P750：按向上推着摇杆，点Reset,，不放手，直到出现选择提示屏，按接听电话键硬启

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
三星I718硬启:同时按住拨号键和挂断键不放+RESET
三星I308硬启：在关机状态，同时按下“电源键”＋“0＋键“，进入格机模式，提入密码，如果没有更改过密码，请输入“1234”，
过二、三分钟，就完成格机，恢复手机出厂的状态，原来存在手机的信息都将丢失。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－6828：同时按住开机键＋拨号键＋挂机键＋点重启小孔就ok了

38XX，39XX，22XX，51XX，54XX，55XX，21XX，24XX，27XX，47XX，3715，1950：按最外的左键和右键（就是1键和4键）,同时用笔按复位按钮，此动作持续30秒以上
19XX，6515，6315：先按开关按键，同时再戳RESET口，此动作持续30秒以上
2190，2490，2790：日历键+收件箱键+电源键+重起RESET键，此动作持续30秒以上
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
HKC W1000：先关机，然后C网通话 + 拍照 + 开机,开机会看到屏幕蓝屏就可以了。

MATE-PDAG：按住手机左侧的语音键盘和右侧的照相键，再捅一下小也，屏幕上出现英文字母YES.NO,选择YES格机，NO不格。

明基P50：按住电源键，同时按重起RESET键

联想ET600: 下面两个应用键同时按住，再用笔点下面的reset

夏新e85：关屏幕，下电池，上电池，同时按通话键，侧面照相键，再按一下挂机键，出现清除内存的字样后就可松开通话键，侧面照相键，硬启成功

斯达康P903:同时按下开关以及RESET键，然后同时松开，再按下“挂断键”约5秒左右，屏幕便会提示询问是否清除本机内存，接下来要在倒计时结束时按住左软键不放，直到屏幕提示“yes”，便可以硬启手机，和其他PPC手机相比，算是比较麻烦的一款。

倚天：X500 X600 X800, 按住电源然后同时用手写笔捅reset，马上放开后立即用手按住挂机键不放，直到屏幕出现yes跟no的选择后才放手，立即然后按住拨号键...

总结如下:

1.检查是否关闭了server服务
2.、“本地连接”→属性→常规，检查是否安装了“Microsoft网络文件和打印机共享”、“Microsoft网络客户端”以及TCP/IP协议；
3.在控制面板→管理工具→本地安全策略→本地策略→用户权利指派里，“从网络访问此计算机”中加入guest帐户，而“拒绝从网络访问这台计算机”中删除guest帐户
4.去掉我的电脑→工具→文件夹选项→查看→去掉“使用简单文件共享（推荐）”前的勾
5.在控制面板→管理工具→本地安全策略→本地策略→安全选项里，把“网络访问：本地帐户的共享和安全模式”设为“仅来宾-本地用户以来宾的身份验证”（可选，此项设置可去除访问时要求输入密码的对话框，也可视情况设为“经典-本地用户以自己的身份验证”）；
6.右击“我的电脑”→“属性”→“计算机名”，该选项卡中有没有出现你的局域网工作组名称，如“work”等。然后单击“网络 ID”按钮，开始“网络标识向导”：单击“下一步”，选择“本机是商业网络的一部分，用它连接到其他工作着的计算机”；单击“下一步”，选择“公司使用没有域的网络”；单击“下一步”按钮，然后输入你的局域网的工作组名，如“work”，再次单击“下一步”按钮，最后单击“完成”按钮完成设置。

在虚拟主机的环境下，因为没有管理员权限，只有数据库使用权限，定时备份SQL数据是

个比较麻烦的问题。解决思路如下：（仅对SQL2000有效)
1. 利用T-SQL备份数据库到指定目录，文件名根据日期指定。
2. 利用Resin的定时功能，定时执行备份。
3. 用户定时下载备份并且删除过期备份。

导出全部数据到Excel也比较实用。下面提供的方法可以导出库中的全部表，也可以指定

几个表导出。注意：
1. 因为是导出全部数据，在数据比较多的情况下慎用。
2. 理论上应该适用各种JDBC数据库，仅对SQL2000测试过
3. 对于B/S下载，建议不要在服务器上生成文件，以免造成垃圾文件。直接从HTTP的Response中取得OutputStream进行输出。
4. Excel操作的API请到这里下载：http://www.andykhan.com/jexcelapi/

package steeven;
import jxl.write.*;
import java.util.*;
import java.sql.Statement;
import java.sql.ResultSet;
import java.sql.Types;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.DateFormat;
import java.io.*;

/**
 * <p>Title: 数据库备份</p>
 * <p>Description: 在Java中备份数据库</p>
 * @author steeven
 * @version 1.0
 */
public class DBackup{
    Context ctx ;
    public DBackup(Context ctx) {
        this.ctx = ctx;
    }
    /**
     * 备份SQL2000数据库到文件，整个数据库备份
     * 文件名后面将追加备份年月日。例如：c:\dbBackup\mydb031109
     * @param file 导出的文件名全路径。例如："c:\\dbBackup\\mydb"
     */
    public void backup(String dbName, String file)throws SQLException{
        String sql = "BACKUP DATABASE ["+dbName+"] TO DISK = N'";
        sql += file + new SimpleDateFormat("yyMMdd").format(new Date());
        sql += "' WITH  NOINIT ,  NOUNLOAD ,  NAME = N'lvdong',  NOSKIP , 

STATS = 10,  NOFORMAT";
        Statement stmt = ctx.getConnection().createStatement();
        stmt.executeUpdate(sql);
    }
    /**
     * 导出整个数据库到Excel
     * @param conn 数据库连接
     * @param out 输出Stream
     */
    public static void db2Excel(Connection conn,OutputStream out)throws

Exception{
        db2Excel(conn,out,getTables(conn));
    }
    /**
     * 导出数据库中指定的表名到Excel
     * @param conn 数据库连接
     * @param out 输出Stream
     * @param tables 表名
     * @throws Exception
     */
    public static void db2Excel(Connection conn,OutputStream out,List

tables)throws Exception{
        WritableWorkbook wb = jxl.Workbook.createWorkbook(out);
        for (int i = 0; i < tables.size(); i++) {
            WritableSheet sheet = wb.createSheet(tables.get(i).toString(),i);
            writeSheet(sheet,tables.get(i).toString(),conn);
        }
        wb.write();
        wb.close();
    }
    /**
     * 导出表数据到Excel的sheet
     */
    public static void writeSheet(
        WritableSheet sheet,String table,Connection conn)
        throws Exception
    {
        //取得所有表数据
        String sql = "select * from "+DB.ESC1+table+DB.ESC2;
        ResultSet rs = conn.createStatement().executeQuery(sql);
        //根据ResultSet的MetaData取得表头，列数，列宽
        java.sql.ResultSetMetaData meta = rs.getMetaData();
        int n = meta.getColumnCount();
        int row = 0;
        WritableCellFormat fmt = new WritableCellFormat();
        fmt.setBackground(jxl.format.Colour.YELLOW);
        for (int i = 0; i < n; i++){
            //导出表头
            sheet.addCell(new Label(i, row, meta.getColumnLabel(i + 1),fmt));
            //设定列宽
//            sheet.setColumnView(i,meta.getColumnDisplaySize(i+1));
        }
        row++;
        while(rs.next()){
            for (int i = 0; i < n; i++){
                //根据列的类型决定Excel中对应的Cell类型，缺省为文本。
                WritableCell cell ;
                switch(meta.getColumnType(i+1)){
                    case Types.BIT:
                    case Types.BIGINT:
                    case Types.BOOLEAN:
                    case Types.DECIMAL:
                    case Types.FLOAT:
                    case Types.INTEGER:
                    case Types.NUMERIC:
                    case Types.REAL:
                    case Types.SMALLINT:
                    case Types.TINYINT:
                        double val = rs.getDouble(i+1);
                        if (rs.wasNull()) cell = new jxl.write.Blank(i,row);
                        cell = new jxl.write.Number(i, row, val);
                        break;
                    case Types.DATE:
                    case Types.TIME:
                    case Types.TIMESTAMP:
                        Date date = rs.getDate(i + 1);
                        if (rs.wasNull()) cell = new jxl.write.Blank(i,row);
                        else cell = new jxl.write.DateTime(i, row, date);
                        break;
                    default:
                        cell = new Label(i, row, rs.getString(i + 1));
                } //end of switch
                sheet.addCell(cell);
            }//end of for each column
            row++;
        }//end of while(rs.next())
    }
    /**
     * 从Connection的MetaData取得所有数据表的名称
     */
    public static List getTables(Connection conn)throws Exception{
        ResultSet rs = conn.getMetaData().getTables(
            null,null,null,new String[]{"Table"});
        List list = new ArrayList();
        while(rs.next())
            list.add(rs.getString(3));
        rs.close();
        return list;
    }

    public static void main(String[] args) throws Exception{
        Connection conn = DB.getConn();
        FileOutputStream out = new FileOutputStream("c:\\test.xls");
        db2Excel(conn,out);
        out.close();
        conn.close();
    }
}

对服务器来说，我们有几点是要长期观察的，任何一点都可能是瓶颈：
1. CPU：动态文件的解析需要比较多的CPU，CPU出现瓶颈就要看是不是哪个功能过长时间占用线程，如果是就分出去。或者就是每一个请求处理时间不长，但是访问量很高，那么就加服务器。CPU是好东西，不能让他干等，不做事情。
2. 内存：缓存从IIS进程独立出去，一般对WEB服务器来说内存不够的情况不是很多。内存比磁盘快，要合理利用。
3. 磁盘IO：用性能监视器找到哪些文件IO特别大，找到了就分到独立的一组文件服务器上去，或者直接做CDN。磁盘慢，大规模读取数据的应用靠缓存，大规模写入数据的应用可以靠队列来降低突发的并发。
4. 网络：我们知道，网络的通讯是比较慢的，比磁盘还慢，如果是做分布式缓存，分布式计算的话，要考虑到物理服务器之间网络通讯的时间，当然，在流量大了以后，这可以提高系统的接纳能力一个等级。静态内容可以借助CSD分担一部分，在做服务器假设的时候还要考虑中国特色的电信网通情况以及防火墙。

对SQL SERVER数据库服务器来说[UPDATE]：
其实还是水平分割和纵向分割，一个二维表，水平分割就是横过来切一刀，纵向分割就是竖直切一刀：
1、纵向分割就是，我们不同的应用可以分到不同的DB中，不同的实例中，或者说把某个拥有很多字段的表拆分成小表。
2、横向分割就是，某些应用可能不负载，比如用户注册，但是用户表会非常大，可以把大表分开。可以采用表分区，数据存储在不同文件上，然后再部署到独立物理服务器增加IO吞吐以改善读写性能，土一点的做法就是自己定期把老的数据存档。表分区的另外一个优势可以增加数据查询速度，因为我们的页索引可以有多层了，就像一个文件夹中的文件不要太多，多分几层文件夹一样。
3、还可以通过数据库镜像、复制订阅、事物日志，把读写分开到不同的镜像物理数据库上，一般来说够用，如果还不行可以用硬件来实现数据库的负载均衡。当然，对于BI，我们可能还会有数据仓库。

架构上考虑到了这些之后，流量大了，就可以在这个的基础上再去调整或者做WEB服务器或者应用服务器的负载均衡。很多时候我们都是在重复发现问题-》找到瓶颈-》解决这个过程。

典型的架构如下：


动态WEB服务器配好点的CPU，静态WEB服务器和文件服务器磁盘好点
应用服务器内存大点，缓存服务器也是，数据库服务器当然内存和CPU都要好


请大家讨论。。。。

转自http://blog.csdn.net/LoveCherry/archive/2008/06/19/2564096.aspx

***

（**大学网络智能计算实验室）

1 前言

伴随着WEB服务技术的出现，不同应用系统之间的集成变为现实。遵循松耦合的结构模型以及公共服务调用规范，WEB服务技术使得异构系统之间的集成问题变得更容易。但是，如何实现WEB服务的自动发现，组合，调用等一系列问题急需进一步研究。软件Agent技术以其自身的优点，被广泛视为一种解决上述相关问题的良药。不幸的是，WEB服务技术与Agent技术都是各自遵循相应的规范和标准发展起来的，不仅体系结构不尽相同，通信协议也完全不同。因此，WEB服务与Agent技术的集成问题备受业界关注。

本人的研究关注的是WEB服务技术与Agent技术集成众多方面中的一个，即如何将一个具有移动性质的软件Agent服务发布成一个Web Service。除非特别申明，否则下文所指的Agent即为具有移动性质的软件Agent。

2研究现状

这个领域的研究工作主要有：

文献【1】里提出了一种WEB服务与遵循FIPA规范的Agent系统之间的集成架构建议。

图表 1 WEB服务与Agent集成架构

从图中我们可以看出，一个FIPA Agent 服务到WEB服务网关在两个环境的边界，通过将ACL消息转换成WEB服务调用，使得FIPA Agent可以访问WEB服务。相反的另一方，WEB服务到FIPA Agent网关将Agent服务注册到UDDI注册服务器中，方便其它WEB服务客户端调用。

或许是受到了这个集成架构建议的启示，两个先锋组织分别设计并实现了集成架构建议中的两个重要方面问题：文献【2】能够让Agent调用现有的WEB服务；文献【3】能够将Agent发布为WEB服务。文献【3】的软件实现产品WSAI（Web Service Agent Integration）从第一个版本便被开放为开源项目。

本人的研究方向和文献【3】相同，即将Agent所提供的服务发布为WEB服务。经过分析WSAI的理论方法及技术方法发现，发现由如下不足的地方：

1、仅局限于静态的Agent，不能解决Agent移动后，WEB服务的可用性，限制了Agent的最大特点-移动性。

2、限于JADE Agent系统平台Agent单线程的特性，使得Agent异步、有状态通信与WEB服务的通信模型不能很好的集成。

3、被发布为WEB服务的Agent仅仅局限于遵循FIPA Agent规范的Agent。事实上，Agent界有主要有两大规范，其一是FIPA组织制定的，其二是OMG组织下的Agent小组。

4、从技术的角度讲，WSAI设计的网关以及WSDL接口均需要开发人员手工安装、编写，未实现自动化。

鉴于以上种种不足，本人希望在WSAI的基础上，提出一种更健壮、支持面更广的，能将Agent发布为WEB服务的框架。

3 Agent与WEB服务集成框架

图表 2 Agent与WEB服务集成框架

Agent与WEB服务集成框架的核心是WAG（Web Service Agent Gateway），它负责将Agent发布为WEB服务。而WAG的实际工作全部由GA（Gateway Agent）来承担。初步设计的GA主要结构如下图所示：

3.1 Gateway Agent

在接下来的时间里，这一部分的主要工作包括：

3.1.1 Agent Web服务的调用机制

描述从WEB服务客户端调用开始，到调用目标Agent服务后，最终返回结果的整个过程。

3.1.2目标Agent位置管理机制

当目标Agent发生移动以后，该机制负责WEB服务的可用性，也即WEB服务调用可达到目标Agent服务。

3.2 SOAP引擎

负责接收来自WEB服务客户端的调用，并将其SOAP消息转换成JAVA类的Web Service接口。此外，所有的AG将在该引擎中注册。SOAP引擎可采用现有的开源项目。

3.3 Gateway Controller

负责AG的加载，并发布为Web服务或者将AG在UDDI注册中心中注册。

4 结束语

接下来的研究工作将围绕WAG的几大组件展开。目前暂时设计了整体框架结构，当然随着研究工作的进一步深入，现有框架的结构需要进一步完善。

 参考文献

【】FIPA specification. http://www.fipa.org/specifications/index.html

【】Sommers, Frank: Publish and find UDDI tModels with JAXR and WSDL

【】Agenticities Web Services Working Grroup. Integrating Web Services into Agentcities Technical Recommendation, Http://www.agentcities.org/Srec/00006/

【】Globus Alliance, IBM, and HP,”Web service Resource Framework”, http://www.golubs.org

【】Whitestein Information Techology Group. Web service agent Integration Project

    http://wsai.sourceforge.net/index.html

【】Thang Xuan Nguyen. WS2JAE: Integrating Web Service With Jade Agents.

　　二、开发 J2ME应用程序
　　在本节中，我们将介绍使用 EclipseMe 插件构建 J2ME 应用程序的基本步骤。首先，您将创建一个 J2ME 项目。然后，您可以开始您的J2ME开发之旅。
　　
　　1 创建 J2ME项目
　　要创建一个 J2ME 项目，回到"File"菜单，选择"New"项，并在子菜单中选择"Project"。然后执行以下步骤：
　　
　　（1.） 进入"J2ME"选项，选择"J2ME Midlet Suite"并单击"Next"（参见图4）。
　　
　　（2.） 填上项目名，并单击"Next"（参见图5）。
　　
　　（3.） 选择可能的平台定义。可以选择"J2ME Wireless Toolkit 2.1 MIDP1.0 Platform"或者"J2ME Wireless Toolkit 2.1 MIDP1.0 Platform",默认为前者。（参见图6）。
　　
　　（4.） 单击"Next"，出现J2ME项目有关设置，这里我们均采用默认设置（参见图7）。
　　
　　（5.） 单击"Finish"，完成项目创建。
　　
　　最终创建 J2ME 项目的结果如图8所示。

　

　

　

　

　

　　2开发 J2ME项目
　　要创建一个 J2ME 应用程序，回到"File"菜单，选择"New"项，并在子菜单中选择"Other"。然后执行以下步骤：
　　
　　（1）. 进入"J2ME"选项，选择"J2ME Midlet"并单击"Next"（参见图9）。
　　
　　（2）. 填上应用程序名，其他设置采用默认设置，并单击"Finish"（参见图10），完成应用程序创建。
　　
　　

　

　

　　系统会自动生成HelloWorld.java程序以及一段自动生成的代码，最终的程序代码见清单1。
　　
　　清单 1. HelloWorld.java
　　
　　/**
　　 * HelloWorld.java
　　 *
　　 * @author WanHui
　　 */
　　import javax.microedition.lcdui.Display;
　　import javax.microedition.lcdui.TextBox;
　　import javax.microedition.midlet.MIDlet;
　　public class HelloWorld extends MIDlet {
　　 private TextBox textbox;
　　 /**
　　 * Constructor of the HelloWorld class
　　 */
　　 public HelloWorld() {
　　 textbox = new TextBox("", "Hello World!", 20, 0);
　　 }
　　 /*
　　 * The startApp method is used for starting or restarting a MIDlet.
　　 *
　　 * @see javax.microedition.midlet.MIDlet#startApp()
　　 */
　　 public void startApp() {
　　 Display.getDisplay(this).setCurrent(textbox);
　　 }
　　 /*
　　 * The pauseApp method is called by the system to ask a MIDlet to "pause"
　　 *
　　 * @see javax.microedition.midlet.MIDlet#pauseApp()
　　 */
　　 public void pauseApp() {
　　 }
　　 /*
　　 * The destroyApp method is called by the system when the MIDlet is about to
　　 * be destroyed
　　 *
　　 * @see javax.microedition.midlet.MIDlet#destroyApp(boolean)
　　 */
　　 public void destroyApp(boolean unconditional) {
　　 }
　　}
　　
　　3 运行J2ME应用程序
　　要运行一个 J2ME 应用程序，选中一个应用程序，本文中为HelloWorld.java，然后回到"Run"菜单，选择"Run As"项，并在子菜单中选择"1 Emulated J2ME Midlet"。然后Eclipse会启动J2ME Wireless Toolkit 2.1中的模拟器得到运行结果见图11。
　　
　　

　　结束语
　　在本文中，我们介绍了 Eclipse IDE 开发环境下使用EclipseMe插件开发J2ME程序。您已经学习了在Eclipse环境下如何创建了一个简单的J2ME应用程序。

Email:ltdreamboy@yahoo.com.cn

前言

jar文件的用法.

具体的打包例子

加入第三方类库

其它信息

前言

jar文件的用法.

用法：jar {ctxu}[vfm0Mi] [jar-文件] [manifest-文件] [-C 目录] 文件名 ...

选项：

• -c 创建新的存档
• -t 列出存档内容的列表
• -x 展开存档中的命名的（或所有的〕文件
• -u 更新已存在的存档
• -v 生成详细输出到标准输出上
• -f 指定存档文件名
• -m 包含来自标明文件的标明信息
• -0 只存储方式；未用ZIP压缩格式
• -M 不产生所有项的清单（manifest〕文件
• -i 为指定的jar文件产生索引信息
• -C 改变到指定的目录，并且包含下列文件：

如果一个文件名是一个目录，它将被递归处理。

清单（manifest〕文件名和存档文件名都需要被指定，按'm' 和 'f'标志指定的相同顺序。

示例1：将两个class文件存档到一个名为 'classes.jar' 的存档文件中：

       jar cvf classes.jar Foo.class Bar.class

       jar cvfm classes.jar mymanifest -C foo/ .

具体的打包例子

2004-11-21  20:34    <DIR>          images

2004-11-22  02:19             2,519 CellandMaskDialog.class

2004-11-22  02:19               449 CellEx$1.class

2004-11-22  02:19            13,523 CellEx.class

2004-11-22  02:19             4,636 CellExAction.class

2004-11-22  02:19             2,008 CellImagePanel.class

2004-11-22  02:19             1,919 CellMask.class

2004-11-22  02:19             2,009 CellMaskPanel.class

2004-11-22  02:19             2,139 OptionDialog.class

2004-11-22  02:19               592 PngFilter.class

9 File(s)         29,794 bytes

1 Dir(s)   1,102,630,912 bytes free

>jar -cvf output.jar *.class images

output.jar 为归档后新生成的 .jar 文件， *.class images 为放入归档中的文件。 即是说， 将*.class以及images目录放入一个名为output.jar的文件当中(即归档文件)。如果你有多个目录则:

>jar -cvf output.jar *.class images folder1 folder2 foldern

Manifest-Version: 1.0

Created-By: 1.4.2_05 (Sun Microsystems Inc.)

Main-Class: CellEx

好了,所有条件都具备了,现在我们来看看如何创建你的可执行jar文件,为了显得更加清晰,现在我们的目录结构如下:

2004-11-22  02:15                91 MANIFEST.MF

2004-11-21  20:34    <DIR>          images

2004-11-22  02:19             2,519 CellandMaskDialog.class

2004-11-22  02:19               449 CellEx$1.class

2004-11-22  02:19            13,523 CellEx.class

2004-11-22  02:19             4,636 CellExAction.class

2004-11-22  02:19             2,008 CellImagePanel.class

2004-11-22  02:19             1,919 CellMask.class

2004-11-22  02:19             2,009 CellMaskPanel.class

2004-11-22  02:19             2,139 OptionDialog.class

2004-11-22  02:19               592 PngFilter.class

10 File(s)         29,794 bytes

1 Dir(s)   1,102,630,912 bytes free

开始创建可执行jar文件(注意在此我们加了 m 参数,以及 MANIFEST.MF 文件,请注意 MANIFEST.MF 文件的位置,在 output.jar 文件后):

>jar -cvfm output.jar MANIFEST.MF *.class images

如果在linux等其它系统,你需要通过命令行: >java -jar output.jar 来执行.

加入第三方类库

下例中我们加入了一个第三方类库

Class-Path: lib/jfig2.jar

Main-Class: CellEx

其它信息

写完CORBA系列后，本想接着写写其它几种典型的远程通信协议：RMI、XML-RPC、SOAP，但由于工作的原因，加之房子装修等麻烦事，一直没有心情动笔。今天接到装修公司老板电话说开工证要晚几天办下来，要停工4-5天，狂怒后突然有了静下心来完成原本想写的东西的想法，既来之，则安之（i.e.郁闷啊，郁闷啊，就习惯了...）

大卫注2：

这个系列基本上是一份笔记，没有加入太多我自己的东西，仅仅记录了自己在使用过程中遇到的问题，及其解决办法。

例子代码：

class Program

    {

        static void Main(string[] args)

        {

            int obj = 2;

            Test<int> test = new Test<int>(obj);

            Console.WriteLine("int:" + test.obj);

            string obj2 = "hello world";

            Test<string> test1 = new Test<string>(obj2);

            Console.WriteLine("String:" + test1.obj);

            Console.Read();

        }

    }

    class Test<T>

    {

        public T obj;

        public Test(T obj)

        {

            this.obj = obj;

        }

}

    输出结果是：

    int:2

String:hello world

程序分析：

1、 Test是一个泛型类。T是要实例化的范型类型。如果T被实例化为int型，那么成员变量obj就是int型的，如果T被实例化为string型，那么obj就是string类型的。

2、 根据不同的类型，上面的程序显示出不同的值。

C#泛型机制：

C#泛型能力有CLR在运行时支持：C#泛型代码在编译为IL代码和元数据时，采用特殊的占位符来表示范型类型，并用专有的IL指令支持泛型操作。而真正的泛型实例化工作以“on-demand”的方式，发生在JIT编译时。

看看刚才的代码中Main函数的元数据

.method private hidebysig static void Main(string[] args) cil managed

{

 .entrypoint

 // Code size       79 (0x4f)

 .maxstack 2

 .locals init ([0] int32 obj,

           [1] class CSharpStudy1.Test`1<int32> test,

           [2] string obj2,

           [3] class CSharpStudy1.Test`1<string> test1)

 IL_0000: nop

 IL_0001: ldc.i4.2

 IL_0002: stloc.0

 IL_0003: ldloc.0

 IL_0004: newobj     instance void class CSharpStudy1.Test`1<int32>::.ctor(!0)

 IL_0009: stloc.1

 IL_000a: ldstr      "int:"

 IL_000f: ldloc.1

 IL_0010: ldfld      !0 class CSharpStudy1.Test`1<int32>::obj

 IL_0015: box        [mscorlib]System.Int32

 IL_001a: call       string [mscorlib]System.String::Concat(object,

                                                              object)

 IL_001f: call       void [mscorlib]System.Console::WriteLine(string)

 IL_0024: nop

 IL_0025: ldstr      "hello world"

 IL_002a: stloc.2

 IL_002b: ldloc.2

 IL_002c: newobj     instance void class CSharpStudy1.Test`1<string>::.ctor(!0)

 IL_0031: stloc.3

 IL_0032: ldstr      "String:"

 IL_0037: ldloc.3

 IL_0038: ldfld      !0 class CSharpStudy1.Test`1<string>::obj

 IL_003d: call       string [mscorlib]System.String::Concat(string,

                                                              string)

 IL_0042: call       void [mscorlib]System.Console::WriteLine(string)

 IL_0047: nop

 IL_0048: call       int32 [mscorlib]System.Console::Read()

 IL_004d: pop

 IL_004e: ret

} // end of method Program::Main

    再来看看Test类中构造函数的元数据

.method public hidebysig specialname rtspecialname

        instance void .ctor(!T obj) cil managed

{

 // Code size       17 (0x11)

 .maxstack 8

 IL_0000: ldarg.0

 IL_0001: call       instance void [mscorlib]System.Object::.ctor()

 IL_0006: nop

 IL_0007: nop

 IL_0008: ldarg.0

 IL_0009: ldarg.1

 IL_000a: stfld      !0 class ConsoleCSharpTest1.Test`1<!T>::obj

 IL_000f: nop

 IL_0010: ret

} // end of method Test`1::.ctor

1、第一轮编译时，编译器只为Test<T>类型产生“泛型版”的IL代码与元数据——并不进行泛型的实例化，T在中间只充当占位符。例如：Test类型元数据中显示的<!T>

2、JIT编译时，当JIT编译器第一次遇到Test<int>时，将用int替换“范型版”IL代码与元数据中的T——进行泛型类型的实例化。例如：Main函数中显示的<int>

3、CLR为所有类型参数为“引用类型”的泛型类型产生同一份代码；但是如果类型参数为“值类型”，对每一个不同的“值类型”，CLR将为其产生一份独立的代码。因为实例化一个引用类型的泛型，它在内存中分配的大小是一样的，但是当实例化一个值类型的时候，在内存中分配的大小是不一样的。

C#泛型特点：

1、如果实例化泛型类型的参数相同，那么JIT编辑器会重复使用该类型，因此C#的动态泛型能力避免了C++静态模板可能导致的代码膨胀的问题。

2、C#泛型类型携带有丰富的元数据，因此C#的泛型类型可以应用于强大的反射技术。

3、C#的泛型采用“基类、接口、构造器，值类型/引用类型”的约束方式来实现对类型参数的“显示约束”，提高了类型安全的同时，也丧失了C++模板基于“签名”的隐式约束所具有的高灵活性

C#泛型继承：

C#除了可以单独声明泛型类型（包括类与结构）外，也可以在基类中包含泛型类型的声明。但基类如果是泛型类，它的类型要么以实例化，要么来源于子类（同样是泛型类型）声明的类型参数，看如下类型

class C<U,V>

class D:C<string,int>

class E<U,V>:C<U,V>

class F<U,V>:C<string,int>

class G:C<U,V> //非法

E类型为C类型提供了U、V，也就是上面说的来源于子类

F类型继承于C<string,int>，个人认为可以看成F继承一个非泛型的类

G类型为非法的，因为G类型不是泛型，C是泛型，G无法给C提供泛型的实例化

泛型类型的成员：

泛型类型的成员可以使用泛型类型声明中的类型参数。但类型参数如果没有任何约束，则只能在该类型上使用从System.Object继承的公有成员。如下图：

泛型接口：

泛型接口的类型参数要么已实例化，要么来源于实现类声明的类型参数

泛型委托：

泛型委托支持在委托返回值和参数上应用参数类型，这些参数类型同样可以附带合法的约束

delegate bool MyDelegate<T>(T value);

class MyClass

{

    static bool F(int i){...}

    static bool G(string s){...}

    static void Main()

    {

        MyDelegate<string> p2 = G;

        MyDelegate<int> p1 = new MyDelegate<int>(F);

    }

}

泛型方法：

1、C#泛型机制只支持“在方法声明上包含类型参数”——即泛型方法。

2、C#泛型机制不支持在除方法外的其他成员（包括属性、事件、索引器、构造器、析构器）的声明上包含类型参数，但这些成员本身可以包含在泛型类型中，并使用泛型类型的类型参数。

3、泛型方法既可以包含在泛型类型中，也可以包含在非泛型类型中。

泛型方法声明：如下

public static int FunctionName<T>(T value){...}

泛型方法的重载：

public void Function1<T>(T a);

public void Function1<U>(U a);

这样是不能构成泛型方法的重载。因为编译器无法确定泛型类型T和U是否不同，也就无法确定这两个方法是否不同

public void Function1<T>(int x);

public void Function1(int x);

这样可以构成重载

public void Function1<T>(T t) where T:A;

public void Function1<T>(T t) where T:B;

这样不能构成泛型方法的重载。因为编译器无法确定约束条件中的A和B是否不同，也就无法确定这两个方法是否不同

泛型方法重写：

在重写的过程中，抽象类中的抽象方法的约束是被默认继承的。如下：

abstract class Base

{

    public abstract T F<T,U>(T t,U u) where U:T;

    public abstract T G<T>(T t) where T:IComparable;

}

class MyClass:Base

{

    public override X F<X,Y>(X x,Y y){...}

    public override T G<T>(T t) where T:IComparable{}

}

对于MyClass中两个重写的方法来说

F方法是合法的，约束被默认继承

G方法是非法的，指定任何约束都是多余的

泛型约束：

1、C#泛型要求对“所有泛型类型或泛型方法的类型参数”的任何假定，都要基于“显式的约束”，以维护C#所要求的类型安全。

2、“显式约束”由where子句表达，可以指定“基类约束”，“接口约束”，“构造器约束”，“值类型/引用类型约束”共四种约束。

3、“显式约束”并非必须，如果没有指定“显式约束”，范型类型参数将只能访问System.Object类型中的公有方法。例如：在开始的例子中，定义的那个obj成员变量。比如我们在开始的那个例子中加入一个Test1类，在它当中定义两个公共方法Func1、Func2，如下图：

基类约束：

class A

    {

        public void Func1()

        { }

    }

    class B

    {

        public void Func2()

        { }

    }

    class C<S, T>

        where S : A

        where T : B

    {

        public C(S s,T t)

        {

            //S的变量可以调用Func1方法

            s.Func1();

            //T的变量可以调用Func2方法

            t.Func2();

        }

    }

接口约束：

interface IA<T>

    {

        T Func1();

    }

    interface IB

    {

        void Func2();

    }

    interface IC<T>

    {

        T Func3();

    }

    class MyClass<T, V>

        where T : IA<T>

        where V : IB, IC<V>

    {

        public MyClass(T t,V v)

        {

            //T的对象可以调用Func1

            t.Func1();

            //V的对象可以调用Func2和Func3

            v.Func2();

            v.Func3();

        }

    }

构造器约束：

class A

        {

            public A()

            { }

        }

        class B

        {

            public B(int i)

            { }

        }

        class C<T> where T : new()

        {

            T t;

            public C()

            {

                t = new T();

            }

        }

        class D

        {

            public void Func()

            {

                C<A> c = new C<A>();

                C<B> d = new C<B>();

            }

        }

    d对象在编译时报错：The type B must have a public parameterless constructor in order to use it as parameter 'T' in the generic type or method C<T>

    注意：C#现在只支持无参的构造器约束

    此时由于我们为B类型写入了一个有参构造器，使得系统不会再为B自动创建一个无参的构造器，但是如果我们将B类型中加一个无参构造器，那么对象d的实例化就不会报错了。B类型定义如下：

        class B

        {

            public B()

            { }

            public B(int i)

            { }

        }

值类型/引用类型：

public struct A { }

        public class B { }

        public class C<T> where T : struct

        {

        }

        C<A> c1 = new C<A>();

        C<B> c2 = new C<B>();

    c2对象在编译时报错：The type 'B' must be a non-nullable value type in order to use it as parameter 'T' in the generic type or methor 'C<T>'

总结：

1、C#的泛型能力由CLR在运行时支持，它既不同于C++在编译时所支持的静态模板，也不同于Java在编译器层面使用“擦拭法”支持的简单的泛型。

2、C#的泛型支持包括类、结构、接口、委托四种泛型类型，以及方法成员。

3、C#的泛型采用“基类，接口，构造器，值类型/引用类型”的约束方式来实现对类型参数的“显式约束”，它不支持C++模板那样的基于签名的隐式约束。

无法显示 XML 页。

使用 XSL 样式表无法查看 XML 输入。请更正错误然后单击 刷新按钮，或以后重试。

名称以无效字符开头。处理资源 'http://localhost/likong/' 时出错。第 1 行，位置: 2

<%@ Page language="c#"  ValidateRequest="false"  Codebehind="default.aspx.cs" AutoEventWireup="false" Inherits="Socut.Cla...

为了让SOA的应用能够更加的成熟，一些标准化组织(主要有W3C，OASIS)对Web Services的功能进行了扩展，为此制定了一系列的WS-*规范。通过这些规范，使得Web Services在实际应用中的能力得到了很大的增强，这些能力主要体现在对服务质量的保障上，例如安全，可靠性，事务等等。其中，WS-Addressing规范作为一个基础，为其余的规范提供了重要的支持功能，因此有必要在了解其他规范前，首先深入了解WS-Addressing规范。本文将从概念上介绍该规范，并希望通过WSE3.0的实例来看看该规范是如何被实践的。

        理论篇
        WS-Addressing 问题的引出
        WS-Addressing EndpointReference
        WS-Addressing Message Addressing Properties

        实践篇
        Applied WSE 3.0 to Web Service Project   
        Use Web Service Thought Message --- SoapClient

鉴于SOA的概念并没有为大家所广泛理解，在适当的时候有必要写一个SOA乱弹。
不过先请你记住以下几句话：

SOA is an integration solution.
SOA is message oriented first.
The Key character of SOA is loosely coupled.
SOA is enriched by creating composite apps.

相关资源：
Web Services的设计与模式
Web Services Security系列

参考资料：WS-Addressing Specification

    WSDL是一个用于精确描述Web服务的文档，WSDL文档是一个遵循WSDL XML模式的XML文档。WSDL 文档将Web服务定义为服务访问点或端口的集合。在 WSDL 中，由于服务访问点和消息的抽象定义已从具体的服务部署或数据格式绑定中分离出来，因此可以对抽象定义进行再次使用：消息，指对交换数据的抽象描述；而端 口类型，指操作的抽象集合。用于特定端口类型的具体协议和数据格式规范构成了可以再次使用的绑定。将Web访问地址与可再次使用的绑定相关联，可以定义一 个端口，而端口的集合则定义为服务。

   一个WSDL文档通常包含7个重要的元素，即types、import、message、portType、operation、binding、 service元素。这些元素嵌套在definitions元素中，definitions是WSDL文档的根元素。文章的下一部分将会详细介绍WSDL 的基本结构。

二：WSDL的基本结构--概述

如第一部分最后描述的那样，一个基本的WSDL文档包含7个重要的元素。下面将分别介绍这几个元素以及他们的作用。

WSDL 文档在Web服务的定义中使用下列元素：

• Types - 数据类型定义的容器，它使用某种类型系统(一般地使用XML Schema中的类型系统)。
• Message - 通信消息的数据结构的抽象类型化定义。使用Types所定义的类型来定义整个消息的数据结构。
• Operation - 对服务中所支持的操作的抽象描述，一般单个Operation描述了一个访问入口的请求/响应消息对。
• PortType - 对于某个访问入口点类型所支持的操作的抽象集合，这些操作可以由一个或多个服务访问点来支持。
• Binding - 特定端口类型的具体协议和数据格式规范的绑定。
• Port - 定义为协议/数据格式绑定与具体Web访问地址组合的单个服务访问点。
• Service- 相关服务访问点的集合。

  可以参考下图来理解一下WSDL的文档结构图：

WSDL的xml schema可以参照如下网址：http://schemas.xmlsoap.org/wsdl/

三：WSDL的基本结构--详述

本节将通过一个例子详细描述WSDL文档每个元素的作用。下面一个例子是一个简单的WSDL文档的内容，该文档的产生可以参见我的另外一篇文章：xfire开发实例--HelloWorld篇 。

一个简单的Web Service的WSDL文档，该服务支持名为sayHello的唯一操作，该操作通过在http上运行SOAP协议来实现的。该请求接受一个字符串name，经过处理后返回一个简单的字符串。文档如下：

♦ types元素使用XML模式语言声明在WSDL文档中的其他位置使用的复杂数据类型与元素；

♦ import元素类似于XML模式文档中的import元素，用于从其他WSDL文档中导入WSDL定义；

♦ message元素使用在WSDL文档的type元素中定义或在import元素引用的外部WSDL文档中定义的XML模式的内置类型、复杂类型或元素描述了消息的有效负载；

♦ portType元素和operation元素描述了Web服务的接口并定义了他的方法。portType元素和operation元素类似于 java接口和接口中定义的方法声明。operation元素使用一个或者多个message类型来定义他的输入和输出的有效负载；

♦ Binding元素将portType元素和operation元素赋给一个特殊的协议和编码样式；

♦ service元素负责将Internet地址赋给一个具体的绑定；

1、definitions元素

所有的WSDL文档的根元素均是definitions元素。该元素封装了整个文档，同时通过其name提供了一个WSDL文档。除了提供一个命名空间外，该元素没有其他作用，故不作详细描述。

下面的代码是一个definitions元素的结构：

2、types元素

 WSDL采用了W3C XML模式内置类型作为其基本类型系统。types元素用作一个容器，用于定义XML模式内置类型中没有描述的各种数据类型。当声明消息部分的有效负载 时，消息定义使用了在types元素中定义的数据类型和元素。在本文的WSDL文档中的types定义：

上面是数据定义部分，该部分定义了两个元素，一个是sayHello，一个是sayHelloResponse：

sayHello：定义了一个复杂类型，仅仅包含一个简单的字符串，将来用来描述操作的参入传入部分；

sayHelloResponse：定义了一个复杂类型，仅仅包含一个简单的字符串，将来用来描述操作的返回值；

3、import元素

import元素使得可以在当前的WSDL文档中使用其他WSDL文档中指定的命名空间中的定义元素。本例子中没有使用import元素。通常在用户希望模块化WSDL文档的时候，该功能是非常有效果的。

import的格式如下：

<wsdl:import namespace="http://xxx.xxx.xxx/xxx/xxx" location="http://xxx.xxx.xxx/xxx/xxx.wsdl"/>

必须有namespace属性和location属性：

namespace属性：值必须与正导入的WSDL文档中声明的targetNamespace相匹配；

location属性：必须指向一个实际的WSDL文档，并且该文档不能为空。

4、message元素

message元素描述了Web服务使用消息的有效负载。message元素可以描述输出或者接受消息的有效负载；还可以描述SOAP文件头和错误detail元素的内容。定义message元素的方式取决于使用RPC样式还是文档样式的消息传递。在本文中的message元素的定义，本文档使用了采用文档样式的消息传递：

该部分是消息格式的抽象定义：定义了两个消息sayHelloResponse和sayHelloRequest：

sayHelloRequest：sayHello操作的请求消息格式，由一个消息片断组成，名字为parameters,元素是我们前面定义的types中的元素；

sayHelloResponse：sayHello操作的响应消息格式，由一个消息片断组成，名字为parameters,元素是我们前面定义的types中的元素；

 如果采用RPC样式的消息传递，只需要将文档中的element元素应以修改为type即可。

5、portType元素

portType元素定义了Web服务的抽象接口。该接口有点类似Java的接口，都是定义了一个抽象类型和方法，没有定义实现。在WSDL中， portType元素是由binding和service元素来实现的，这两个元素用来说明Web服务实现使用的Internet协议、编码方案以及 Internet地址。

一个portType中可以定义多个operation，一个operation可以看作是一个方法，本文中WSDL文档的定义：

    <wsdl:portType name="HelloServicePortType">
        <wsdl:operation name="sayHello">
            <wsdl:input name="sayHelloRequest"
                message="tns:sayHelloRequest" />
            <wsdl:output name="sayHelloResponse"
                message="tns:sayHelloResponse" />
        </wsdl:operation>
    </wsdl:portType>

portType定义了服务的调用模式的类型，这里包含一个操作sayHello方法，同时包含input和output表明该操作是一个请求／响 应模式，请求消息是前面定义的sayHelloRequest，响应消息是前面定义的sayHelloResponse。input表示传递到Web服务 的有效负载，output消息表示传递给客户的有效负载。

６、binding

binding元素将一个抽象portType映射到一组具体协议(SOAO和HTTP)、消息传递样式、编码样式。通常binding元素与协议专有的元素和在一起使用，本文中的例子：

这部分将服务访问点的抽象定义与SOAP HTTP绑定，描述如何通过SOAP/HTTP来访问按照前面描述的访问入口点类型部署的访问入口。其中规定了在具体SOAP调用时，应当使用的soapAction是""。

具体的使用需要参考特定协议定义的元素。

７、service元素和port元素

service元素包含一个或者多个port元素，其中每个port元素表示一个不同的Web服务。port元素将URL赋给一个特定的binding，甚至可以使两个或者多个port元素将不同的URL赋值给相同的binding。文档中的例子：

这部分是具体的Web服务的定义，在这个名为HelloService的Web服务中，提供了一个服务访问入口，访问地址是http://localhost:8080/xfire/services/HelloService，使用的消息模式是由前面的binding所定义的。

　　本文简单介绍了WSDL规范的用途，基本结构和使用方法，希望对大家学习WSDL有帮助。

删除用RowFilter筛选之后的记录集，用While循环是可以做到的，而用For循环却不行。

While(dataView.count>0)
{
  dataView.Delete(this.dataView.Count-1)
//....
}
因此，除了通过数据绑定到DataGridView,DataGrid外，可以通过循环来取经过RowFilter筛选后的记录集：
方法有很多，如：

 foreach (DataRowView row in dataView)
{
   MessageBox.Showrow.Row[4].ToString());
}