原文地址：http://www.ibm.com/developerworks/cn/java/j-jar/

JAR 文件是什么？

JAR 文件格式以流行的 ZIP 文件格式为基础，用于将许多个文件聚集为一个文件。与 ZIP 文件不同的是，JAR 文件不仅用于压缩和发布，而且还用于部署和封装库、组件和插件程序，并可被像编译器和 JVM 这样的工具直接使用。在 JAR 中包含特殊的文件，如 manifests 和部署描述符，用来指示工具如何处理特定的 JAR。

一个 JAR 文件可以用于：

• 用于发布和使用类库
• 作为应用程序和扩展的构建单元
• 作为组件、applet 或者插件程序的部署单位
• 用于打包与组件相关联的辅助资源

JAR 文件格式提供了许多优势和功能，其中很多是传统的压缩格式如 ZIP 或者 TAR 所没有提供的。它们包括：

• 安全性。可以对 JAR 文件内容加上数字化签名。这样，能够识别签名的工具就可以有选择地为您授予软件安全特权，这是其他文件做不到的，它还可以检测代码是否被篡改过。
• 减少下载时间。如果一个 applet 捆绑到一个 JAR 文件中，那么浏览器就可以在一个 HTTP 事务中下载这个 applet 的类文件和相关的资源，而不是对每一个文件打开一个新连接。
• 压缩。JAR 格式允许您压缩文件以提高存储效率。
• 传输平台扩展。Java 扩展框架 (Java Extensions Framework) 提供了向 Java 核心平台添加功能的方法，这些扩展是用 JAR 文件打包的 (Java 3D 和 JavaMail 就是由 Sun 开发的扩展例子 )。
• 包密封。存储在 JAR 文件中的包可以选择进行 密封，以增强版本一致性和安全性。密封一个包意味着包中的所有类都必须在同一 JAR 文件中找到。
• 包版本控制。一个 JAR 文件可以包含有关它所包含的文件的数据，如厂商和版本信息。
• 可移植性。处理 JAR 文件的机制是 Java 平台核心 API 的标准部分。

压缩的和未压缩的 JAR

jar工具 ( 有关细节参阅 jar 工具 ) 在默认情况下压缩文件。未压缩的 JAR 文件一般可以比压缩过的 JAR 文件更快地装载，因为在装载过程中要解压缩文件，但是未压缩的文件在网络上的下载时间可能更长。

META-INF 目录

大多数 JAR 文件包含一个 META-INF 目录，它用于存储包和扩展的配置数据，如安全性和版本信息。Java 2 平台识别并解释 META-INF 目录中的下述文件和目录，以便配置应用程序、扩展和类装载器：

• MANIFEST.MF。这个 manifest 文件定义了与扩展和包相关的数据。
• INDEX.LIST。这个文件由 jar工具的新选项 -i生成，它包含在应用程序或者扩展中定义的包的位置信息。它是 JarIndex 实现的一部分，并由类装载器用于加速类装载过程。
• xxx.SF。 这是 JAR 文件的签名文件。占位符 xxx标识了签名者。
• xxx.DSA。 与签名文件相关联的签名程序块文件，它存储了用于签名 JAR 文件的公共签名。

jar 工具

为了用 JAR 文件执行基本的任务，要使用作为 Java Development Kit 的一部分提供的 Java Archive Tool ( jar工具 )。用 jar命令调用 jar工具。表 1 显示了一些常见的应用：

表 1. 常见的 jar工具用法

功能	命令
用一个单独的文件创建一个 JAR 文件	jar cf jar-file input-file...
用一个目录创建一个 JAR 文件	jar cf jar-file dir-name
创建一个未压缩的 JAR 文件	jar cf0 jar-file dir-name
更新一个 JAR 文件	jar uf jar-file input-file...
查看一个 JAR 文件的内容	jar tf jar-file
提取一个 JAR 文件的内容	jar xf jar-file
从一个 JAR 文件中提取特定的文件	jar xf jar-file archived-file...
运行一个打包为可执行 JAR 文件的应用程序	java -jar app.jar

回页首

可执行的 JAR

一个 可执行的 jar文件是一个自包含的 Java 应用程序，它存储在特别配置的 JAR 文件中，可以由 JVM 直接执行它而无需事先提取文件或者设置类路径。要运行存储在非可执行的 JAR 中的应用程序，必须将它加入到您的类路径中，并用名字调用应用程序的主类。但是使用可执行的 JAR 文件，我们可以不用提取它或者知道主要入口点就可以运行一个应用程序。可执行 JAR 有助于方便发布和执行 Java 应用程序。

创建可执行 JAR

创建一个可执行 JAR 很容易。首先将所有应用程序代码放到一个目录中。假设应用程序中的主类是 com.mycompany.myapp.Sample。您要创建一个包含应用程序代码的 JAR 文件并标识出主类。为此，在某个位置 ( 不是在应用程序目录中 ) 创建一个名为 manifest的文件，并在其中加入以下一行：

 Main-Class: com.mycompany.myapp.Sample

然后，像这样创建 JAR 文件：

 jar cmf manifest ExecutableJar.jar application-dir

所要做的就是这些了 -- 现在可以用 java -jar执行这个 JAR 文件 ExecutableJar.jar。

一个可执行的 JAR 必须通过 menifest 文件的头引用它所需要的所有其他从属 JAR。如果使用了 -jar选项，那么环境变量 CLASSPATH 和在命令行中指定的所有类路径都被 JVM 所忽略。

启动可执行 JAR

既然我们已经将自己的应用程序打包到了一个名为 ExecutableJar.jar 的可执行 JAR 中了，那么我们就可以用下面的命令直接从文件启动这个应用程序：

 java -jar ExecutableJar.jar

回页首

包密封

密封 JAR 文件中的一个包意味着在这个包中定义的所有类都必须在同一个 JAR 文件中找到。这使包的作者可以增强打包类之间的版本一致性。密封还提供了防止代码篡改的手段。

要密封包，需要在 JAR 的 manifest 文件中为包添加一个 Name头，然后加上值为“true”的 Sealed头。与可执行的 JAR 一样，可以在创建 JAR 时，通过指定一个具有适当头元素的 manifest 文件密封一个 JAR，如下所示：

 Name: com/samplePackage/   Sealed: true

Name头标识出包的相对路径名。它以一个“/”结束以与文件名区别。在 Name头后面第一个空行之前的所有头都作用于在 Name头中指定的文件或者包。在上述例子中，因为 Sealed头出现在 Name 头后并且中间没有空行，所以 Sealed头将被解释为只应用到包 com/samplePackage 上。

如果试图从密封包所在的 JAR 文件以外的其他地方装载密封包中的一个类，那么 JVM 将抛出一个 SecurityException。

扩展打包
扩展为 Java 平台增加了功能，在 JAR 文件格式中已经加入了扩展机制。扩展机制使得 JAR 文件可以通过 manifest 文件中的 Class-Path头指定所需要的其他 JAR 文件。

假设 extension1.jar 和 extension2.jar 是同一个目录中的两个 JAR 文件，extension1.jar 的 manifest 文件包含以下头：

 Class-Path: extension2.jar

这个头表明 extension2.jar 中的类是 extension1.jar 中的类的 扩展类。extension1.jar 中的类可以调用 extension2.jar 中的类，并且不要求 extension2.jar 处在类路径中。

在装载使用扩展机制的 JAR 时，JVM 会高效而自动地将在 Class-Path头中引用的 JAR 添加到类路径中。不过，扩展 JAR 路径被解释为相对路径，所以一般来说，扩展 JAR 必须存储在引用它的 JAR 所在的同一目录中。

例如，假设类 ExtensionClient引用了类 ExtensionDemo, 它捆绑在一个名为 ExtensionClient.jar 的 JAR 文件中，而类 ExtensionDemo则捆绑在 ExtensionDemo.jar 中。为了使 ExtensionDemo.jar 可以成为扩展，必须将 ExtensionDemo.jar 列在 ExtensionClient.jar 的 manifest 的 Class-Path头中，如下所示：

 Manifest-Version: 1.0   Class-Path: ExtensionDemo.jar

在这个 manifest 中 Class-Path头的值是没有指定路径的 ExtensionDemo.jar，表明 ExtensionDemo.jar 与 ExtensionClient JAR 文件处在同一目录中。

回页首

JAR 文件中的安全性

JAR 文件可以用 jarsigner工具或者直接通过 java.securityAPI 签名。一个签名的 JAR 文件与原来的 JAR 文件完全相同，只是更新了它的 manifest，并在 META-INF 目录中增加了两个文件，一个签名文件和一个签名块文件。

JAR 文件是用一个存储在 Keystore数据库中的证书签名的。存储在 keystore 中的证书有密码保护，必须向 jarsigner工具提供这个密码才能对 JAR 文件签名。

图 1. Keystore 数据库

JAR 的每一位签名者都由在 JAR 文件的 META-INF 目录中的一个具有 .SF 扩展名的签名文件表示。这个文件的格式类似于 manifest 文件 -- 一组 RFC-822 头。如下所示，它的组成包括一个主要部分，它包括了由签名者提供的信息、但是不特别针对任何特定的 JAR 文件项，还有一系列的单独的项，这些项也必须包含在 menifest 文件中。在验证一个签名的 JAR 时，将签名文件的摘要值与对 JAR 文件中的相应项计算的摘要值进行比较。

清单 1. 签名 JAR 中的 Manifest 和 signature 文件

Contents of signature file META-INF/MANIFEST.MF   Manifest-Version: 1.0   Created-By: 1.3.0 (Sun Microsystems Inc.)   Name: Sample.java   SHA1-Digest: 
3+DdYW8INICtyG8ZarHlFxX0W6g=   Name: Sample.class   SHA1-Digest: YJ5yQHBZBJ3SsTNcHJFqUkfWEmI=   Contents of signature file META-INF/JAMES.SF   
Signature-Version: 1.0   SHA1-Digest-Manifest: HBstZOJBuuTJ6QMIdB90T8sjaOM=   Created-By: 1.3.0 (Sun Microsystems Inc.)   Name: Sample.java   SHA1-Digest: 
qipMDrkurQcKwnyIlI3Jtrnia8Q=   Name: Sample.class   SHA1-Digest: pT2DYby8QXPcCzv2NwpLxd8p4G4=

数字签名

一个数字签名是 .SF 签名文件的已签名版本。数字签名文件是二进制文件，并且与 .SF 文件有相同的文件名，但是扩展名不同。根据数字签名的类型 -- RSA、DSA 或者 PGP -- 以及用于签名 JAR 的证书类型而有不同的扩展名。

Keystore

要签名一个 JAR 文件，必须首先有一个私钥。私钥及其相关的公钥证书存储在名为 keystores的、有密码保护的数据库中。JDK 包含创建和修改 keystores 的工具。keystore 中的每一个密钥都可以用一个别名标识，它通常是拥有这个密钥的签名者的名字。

所有 keystore 项 ( 密钥和信任的证书项 ) 都是用唯一别名访问的。别名是在用 keytool -genkey 命令生成密钥对 ( 公钥和私钥 ) 并在 keystore 中添加项时指定的。之后的 keytool命令必须使用同样的别名引用这一项。

例如，要用别名“james”生成一个新的公钥 / 私钥对并将公钥包装到自签名的证书中，要使用下述命令：

 keytool -genkey -alias james -keypass jamespass          -validity 80 -keystore jamesKeyStore          -storepass jamesKeyStorePass

这个命令序列指定了一个初始密码“jamespass”，后续的命令在访问 keystore “jamesKeyStore”中与别名“james”相关联的私钥时，就需要这个密码。如果 keystore“jamesKeyStore”不存在，则 keytool会自动创建它。

jarsigner 工具

jarsigner工具使用 keystore 生成或者验证 JAR 文件的数字签名。

假设像上述例子那样创建了 keystore “jamesKeyStore”，并且它包含一个别名为“james”的密钥，可以用下面的命令签名一个 JAR 文件：

 jarsigner -keystore jamesKeyStore -storepass jamesKeyStorePass            -keypass jamespass -signedjar SSample.jar Sample.jar james

这个命令用密码“jamesKeyStorePass”从名为“jamesKeyStore”的 keystore 中提出别名为“james”、密码为“jamespass”的密钥，并对 Sample.jar 文件签名、创建一个签名的 JAR -- SSample.jar。

jarsigner工具还可以验证一个签名的 JAR 文件，这种操作比签名 JAR 文件要简单得多，只需执行以下命令：

 jarsigner -verify SSample.jar

如果签名的 JAR 文件没有被篡改过，那么 jarsigner工具就会告诉您 JAR 通过验证了。否则，它会抛出一个 SecurityException， 表明哪些文件没有通过验证。

还可以用 java.util.jar和 java.securityAPI 以编程方式签名 JAR( 有关细节参阅 参考资料)。也可以使用像 Netscape Object Signing Tool 这样的工具。

回页首

JAR 索引

如果一个应用程序或者 applet 捆绑到多个 JAR 文件中，那么类装载器就使用一个简单的线性搜索算法搜索类路径中的每一个元素，这使类装载器可能要下载并打开许多个 JAR 文件，直到找到所要的类或者资源。如果类装载器试图寻找一个不存在的资源，那么在应用程序或者 applet 中的所有 JAR 文件都会下载。对于大型的网络应用程序和 applet，这会导致启动缓慢、响应迟缓并浪费带宽。

从 JDK 1.3 以后，JAR 文件格式开始支持索引以优化网络应用程序中类的搜索过程，特别是 applet。JarIndex 机制收集在 applet 或者应用程序中定义的所有 JAR 文件的内容，并将这些信息存储到第一个 JAR 文件中的索引文件中。下载了第一个 JAR 文件后，applet 类装载器将使用收集的内容信息高效地装载 JAR 文件。这个目录信息存储在根 JAR 文件的 META-INF 目录中的一个名为 INDEX.LIST 的简单文本文件中。

创建一个 JarIndex
可以通过在 jar命令中指定 -i选项创建一个 JarIndex。假设我们的目录结构如下图所示：

图 2. JarIndex

您将使用下述命令为 JarIndex_Main.jar、JarIndex_test.jar 和 JarIndex_test1.jar 创建一个索引文件：

 jar -i JarIndex_Main.jar JarIndex_test.jar SampleDir/JarIndex_test1.jar

INDEX.LIST 文件的格式很简单，包含每个已索引的 JAR 文件中包含的包或者类的名字，如清单 2 所示：

清单 2. JarIndex INDEX.LIST 文件示例

 JarIndex-Version: 1.0   JarIndex_Main.jar   sp   JarIndex_test.jar   Sample   SampleDir/JarIndex_test1.jar   org   org/apache   org/apache/xerces   
org/apache/xerces/framework   org/apache/xerces/framework/xml4j

回页首

结束语

JAR 格式远远超出了一种压缩格式，它有许多可以改进效率、安全性和组织 Java 应用程序的功能。因为这些功能已经建立在核心平台 -- 包括编译器和类装载器 -- 中了，所以开发人员可以利用 JAR 文件格式的能力简化和改进开发和部署过程。.

参考资料

• 您可以参阅本文在 developerWorks 全球站点上的 英文原文.
• 参阅 jar 实用程序的命令行选项的文档。
• Raffi Krikorian 在 ONJava 上发表的文章提供了有关 programmatically signing a JAR file的帮助。
• 文章“ Java Web Start”( developerWorks，2001 年 9 月 ) 描述了如何使用这种技术，以便允许应用程序可以指定所需的 JAR 文件并动态下载它们。
• 在 developerWorks Java 技术专区 上可以找到数百篇关于 Java 编程的各个方面的文章。

Which version of the JDK is required for which versions of JBoss AS?

Notes:

• JBoss AS 3.2.6+ and 4.0.1+ are the ONLY versions to be fully functional under JDK 5, due to JMX issues.  See RunJBossWithJ2SDK1.5Beta for more details.

• JBoss AS 3.2.6 doesn't run with JDK 1.3. This issue is fixed in the JBoss AS 3.2.7.

• JBoss AS 4.0.0 runs under JDK 1.5, but the jconsole utility will not work with it. You need 4.0.1, 3.2.7 to use jconsole.

• Compliation using JDK 5 requires use of the -source 1.4 javac argument to avoid errors due to JDK 5 reserved words like enum.

• JBoss AS 4.0.3+ and JBoss AS 5 source code has been fixed such that it no longer uses the enum reserved word in variable names.

• The current group of 64 bit JVMs have some stability issues.  Please do extensive testing on the 64 bit JVM before using it in Production. (PeterJ: I think this warning no longer applies.)

• 64 bit hardware does provide some performance gains for 32 or 64 bit JVMs.

• Be careful running the JDK1.3 on 64bit version of Linux.  See Linux64andJDK1.3 for details.

• Since JBoss v4.0.3, compiling the server with JDKv1.4 and JDKv5 produces somewhat different outputs. A JDKv1.4 compilation produces the classic jboss distribution. A JDKv5 compilation includes JDK5 only features, like EJB3.

• JBoss AS 4.2.x needs an out-of-tree patch to build with JDK 6, see JBossWithJDK6 for details

    先从面说起，硬盘一般是由一片或几片圆形薄膜叠加而成。我们所说，每个圆形薄膜都有两个“面”，这两个面都是用来存储数据的。按照面的多少，依次称为0 面、1面、2面……由于每个面都专有一个读写磁头，也常用0头(head)、1头……称之。按照硬盘容量和规格的不同，硬盘面数(或头数)也不一定相同， 少的只有2面，多的可达数十面。各面上磁道号相同的磁道合起来，称为一个柱面(Cylinder)。

    上面我们提到了磁道的概念。那么究竟何为磁道呢？由于磁盘是旋转的，则连续写入的数据是排列在一个圆周上的。我们称这样的圆周为一个磁道。如果读写磁头沿 着圆形薄膜的半径方向移动一段距离，以后写入的数据又排列在另外一个磁道上。根据硬盘规格的不同，磁道数可以从几百到数千不等；一个磁道上可以容纳数KB 的数据，而主机读写时往往并不需要一次读写那么多，于是，磁道又被划分成若干段，每段称为一个扇区。一个扇区一般存放512字节的数据。扇区也需要编号， 同一磁道中的扇区，分别称为1扇区，2扇区……

    计算机对硬盘的读写，处于效率的考虑，是以扇区为基本单位的。即使计算机只需要硬盘上存储的某个字节，也必须一次把这个字节所在的扇区中的512字节全部 读入内存，再使用所需的那个字节。不过，在上文中我们也提到，硬盘上面、磁道、扇区的划分表面上是看不到任何痕迹的，虽然磁头可以根据某个磁道的应有半径 来对准这个磁道，但怎样才能在首尾相连的一圈扇区中找出所需要的某一扇区呢？原来，每个扇区并不仅仅由512个字节组成的，在这些由计算机存取的数据的 前、后两端，都另有一些特定的数据，这些数据构成了扇区的界限标志，标志中含有扇区的编号和其他信息。计算机就凭借着这些标志来识别扇区。硬盘的数据结构 在上文中，我们谈了数据在硬盘中的存储的一般原理。为了能更深入地了解硬盘，我们还必须对硬盘的数据结构有个简单的了解。硬盘上的数据按照其不同的特点和 作用大致可分为5部分：MBR区、DBR区、FAT区、DIR区和DATA区。

我们来分别介绍一下：

1、MBR区

      MBR（Main Boot Record 主引导记录区）位于整个硬盘的0磁道0柱面1扇区。不过，在总共512字节的主引导扇区中，MBR只占用了其中的446个字节，另外的64个字节交给了 DPT（Disk Partition Table硬盘分区表），最后两个字节“55，AA”是分区的结束标志。这个整体构成了硬盘的主引导扇区。

    主引导记录中包含了硬盘的一系列参数和一段引导程序。其中的硬盘引导程序的主要作用是检查分区表是否正确并且在系统硬件完成自检以后引导具有激活标志的分 区上的操作系统，并将控制权交给启动程序。MBR是由分区程序（如Fdisk．exe）所产生的，它不依赖任何操作系统，而且硬盘引导程序也是可以改变 的，从而实现多系统共存。

    下面，我们以一个实例让大家更直观地来了解主引导记录：

    例：80 01 01 00 0B FE BF FC 3F 00 00 00 7E 86 BB 00 在这里我们可以看到，最前面的“80”是一个分区的激活标志，表示系统可引导；“01 01 00”表示分区开始的磁头号为01，开始的扇区号为01，开始的柱面号为00；“0B”表示分区的系统类型是FAT32，其他比较常用的有 04（FAT16）、07（NTFS）；“FE BF FC”表示分区结束的磁头号为254，分区结束的扇区号为63、分区结束的柱面号为764；“3F 00 00 00”表示首扇区的相对扇区号为63；“7E 86 BB 00”表示总扇区数为12289622。

2、DBR区

    DBR（Dos Boot Record）是操作系统引导记录区的意思。它通常位于硬盘的0磁道1柱面1扇区，是操作系统可以直接访问的第一个扇区，它包括一个引导程序和一个被称为 BPB（Bios Parameter Block）的本分区参数记录表。引导程序的主要任务是当MBR将系统控制权交给它时，判断本分区跟目录前两个文件是不是操作系统的引导文件（以DOS为 例，即是Io．sys和Msdos．sys）。如果确定存在，就把它读入内存，并把控制权 交给该文件。BPB参数块记录着本分区的起始扇区、结束扇区、文件存储格式、硬盘介质描述符、根目录大小、FAT个数，分配单元的大小等重要参数。DBR 是由高级格式化程序（即Format．com等程序）所产生的。

3、FAT区

    在DBR之后的是我们比较熟悉的FAT（File Allocation Table文件分配表）区。在解释文件分配表的概念之前，我们先来谈谈簇（Cluster）的概念。文件占用磁盘空间时，基本单位不是字节而是簇。一般情 况下，软盘每簇是1个扇区，硬盘每簇的扇区数与硬盘的总容量大小有关，可能是4、8、16、32、64…… 同一个文件的数据并不一定完整地存放在磁盘的一个连续的区域内，而往往会分成若干段，像一条链子一样存放。这种存储方式称为文件的链式存储。由于硬盘上保 存着段与段之间的连接信息（即FAT），操作系统在读取文件时，总是能够准确地找到各段的位置并正确读出。 为了实现文件的链式存储，硬盘上必须准确地记录哪些簇已经被文件占用，还必须为每个已经占用的簇指明存储后继内容的下一个簇的簇号。对一个文件的最后一 簇，则要指明本簇无后继簇。这些都是由FAT表来保存的，表中有很多表项，每项记录一个簇的信息。由于FAT对于文件管理的重要性，所以FAT有一个备 份，即在原FAT的后面再建一个同样的FAT。初形成的FAT中所有项都标明为“未占用”，但如果磁盘有局部损坏，那么格式化程序会检测出损坏的簇，在相 应的项中标为“坏簇”，以后存文件时就不会再使用这个簇了。FAT的项数与硬盘上的总簇数相当，每一项占用的字节数也要与总簇数相适应，因为其中需要存放 簇号。FAT的格式有多种，最为常见的是FAT16和FAT32。

4、DIR区

   DIR（Directory）是根目录区，紧接着第二FAT表（即备份的FAT表）之后，记录着根目录下 每个文件(目录)的起始单元，文件的属性等。定位文件位置时，操作系统根据DIR中的起始单元，结合FAT表就可以知道文件在硬盘中的具体位置和大小了。

5、数据(DATA)区

    数据区是真正意义上的数据存储的地方，位于DIR区之后，占据硬盘上的大部分数据空间。

一、硬盘的物理结构：

　    硬盘存储数据是根据电、磁转换原理实现的。硬盘由一个或几个表面镀有磁性物质的金属或玻璃等物质盘片以及盘片两面所安装的磁头和相应的控制电路组成(图 1)，其中盘片和磁头密封在无尘的金属壳中。

   硬盘工作时，盘片以设计转速高速旋转，设置在盘片表面的磁头则在电路控制下径向移动到指定位置然后将数据存储或读取出来。当系统向硬盘写入数据时，磁头中 “写数据”电流产生磁场使盘片表面磁性物质状态发生改变，并在写电流磁场消失后仍能保持，这样数据就存储下来了；当系统从硬盘中读数据时，磁头经过盘片指 定区域，盘片表面磁场使磁头产生感应电流或线圈阻抗产生变化，经相关电路处理后还原成数据。因此只要能将盘片表面处理得更平滑、磁头设计得更精密以及尽量 提高盘片旋转速度，就能造出容量更大、读写数据速度更快的硬盘。这是因为盘片表面处理越平、转速越快就能越使磁头离盘片表面越近，提高读、写灵敏度和速 度；磁头设计越小越精密就能使磁头在盘片上占用空间越小，使磁头在一张盘片上建立更多的磁道以存储更多的数据。

二、硬盘的逻辑结构：

    硬盘由很多盘片(platter)组成，每个盘片的每个面都有一个读写磁头。如果有N个盘片。就有2N个面，对应2N个磁头(Heads)，从0、1、2 开始编号。每个盘片被划分成若干个同心圆磁道(逻辑上的，是不可见的。)每个盘片的划分规则通常是一样的。这样每个盘片的半径均为固定值R的同心圆再逻辑 上形成了一个以电机主轴为轴的柱面(Cylinders)，从外至里编号为0、1、2……每个盘片上的每个磁道又被划分为几十个扇区(Sector)，通 常的容量是512byte，并按照一定规则编号为1、2、3……形成Cylinders×Heads×Sector个扇区。这三个参数即是硬盘的物理参 数。我们下面的很多实践需要深刻理解这三个参数的意义。
    硬盘存储数据是根据电、磁转换原理实现的。硬盘由一个或几个表面镀有磁性物质的金属或玻璃等物质盘片以及盘片两面所安装的磁头和相应的控制电路组成(图 1)，其中盘片和磁头密封在无尘的金属壳中。

三、磁盘引导原理：

3.1 MBR(master boot record)扇区：

　　计算机在按下power键以后，开始执行主板bios程序。进行完一系列检测和配置以后。开始按bios中设定的系统引导顺序引导系统。假定现 在是硬盘。Bios执行完自己的程序后如何把执行权交给硬盘呢。交给硬盘后又执行存储在哪里的程序呢。其实，称为mbr的一段代码起着举足轻重的作用。 MBR(master boot record),即主引导记录，有时也称主引导扇区。位于整个硬盘的0柱面0磁头1扇区(可以看作是硬盘的第一个扇区)，bios在执行自己固有的程序以 后就会jump到mbr中的第一条指令。将系统的控制权交由mbr来执行。在总共512byte的主引导记录中，MBR的引导程序占了其中的前446个字 节(偏移0H~偏移1BDH)，随后的64个字节(偏移1BEH~偏移1FDH)为DPT(Disk PartitionTable，硬盘分区表)，最后的两个字节“55 AA”(偏移1FEH~偏移1FFH)是分区有效结束标志。

　　MBR不随操作系统的不同而不同，意即不同的操作系统可能会存在相同的MBR，即使不同，MBR也不会夹带操作系统的性质。具有公共引导的特 性。

　　我们来分析一段mbr。下面是用winhex查看的一块希捷120GB硬盘的mbr。

MBR扇区代码

    你的硬盘的MBR引导代码可能并非这样。不过即使不同，所执行的功能大体是一样的。这里找wowocock关于磁盘mbr的反编译，已加了详细的注释，感 兴趣可以细细研究一下。

    我们看DPT部分。操作系统为了便于用户对磁盘的管理。加入了磁盘分区的概念。即将一块磁盘逻辑划分为 几块。磁盘分区数目的多少只受限于C～Z的英文字母的数目，在上图DPT共64个字节中如何表示多个分区的属性呢?microsoft通过链接的方法解决 了这个问题。在DPT共64个字节中，以16个字节为分区表项单位描述一个分区的属性。也就是说，第一个分区表项描述一个分区的属性，一般为基本分区。第 二个分区表项描述除基本分区外的其余空间，一般而言，就是我们所说的扩展分区。这部分的大体说明见表1。

  DPT代码分析

  注：上表中的超过1字节的数据都以实际数据显示，就是按高位到地位的方式显示。存储时是按低位到高位存储的。两者表现不同，请仔细看清楚。以后出现的表， 图均同。

　　也可以在winhex中看到这些参数的意义：
      

    说明： 每个分区表项占用16个字节，假定偏移地址从0开始。如图3的分区表项3。分区表项4同分区表项3。

　　1、0H偏移为活动分区是否标志，只能选00H和80H。80H为活动，00H为非活动。其余值对microsoft而言为非法值。

　　2、重新说明一下(这个非常重要)：大于1个字节的数被以低字节在前的存储格式格式(little endian format)或称反字节顺序保存下来。低字节在前的格式是一种保存数的方法，这样，最低位的字节最先出现在十六进制数符号中。例如，相对扇区数字段的值 0x3F000000的低字节在前表示为0x0000003F。这个低字节在前的格式数的十进制数为63。

　　3、系统在分区时，各分区都不允许跨柱面，即均以柱面为单位，这就是通常所说的分区粒度。有时候我们分区是输入分区的大小为7000M，分出来 却是6997M，就是这个原因。 偏移2H和偏移6H的扇区和柱面参数中,扇区占6位(bit)，柱面占10位(bit)，以偏移6H为例，其低6位用作扇区数的二进制表示。其高两位做柱 面数10位中的高两位，偏移7H组成的8位做柱面数10位中的低8位。由此可知，实际上用这种方式表示的分区容量是有限的，柱面和磁头从0开始编号,扇区 从1开始编号,所以最多只能表示1024个柱面×63个扇区×256个磁头×512byte=8455716864byte。即通常的8.4GB(实际上 应该是7.8GB左右)限制。实际上磁头数通常只用到255个(由汇编语言的寻址寄存器决定),即使把这3个字节按线性寻址，依然力不从心。 在后来的操作系统中，超过8.4GB的分区其实已经不通过C/H/S的方式寻址了。而是通过偏移CH～偏移FH共4个字节32位线性扇区地址来表示分区所 占用的扇区总数。可知通过4个字节可以表示2^32个扇区，即2TB=2048GB，目前对于大多数计算机而言，这已经是个天文数字了。在未超过 8.4GB的分区上，C/H/S的表示方法和线性扇区的表示方法所表示的分区大小是一致的。也就是说，两种表示方法是协调的。即使不协调，也以线性寻址为 准。(可能在某些系统中会提示出错)。超过8.4GB的分区结束C/H/S一般填充为FEH FFH FFH。即C/H/S所能表示的最大值。有时候也会用柱面对1024的模来填充。不过这几个字节是什么其实都无关紧要了。

　　虽然现在的系统均采用线性寻址的方式来处理分区的大小。但不可跨柱面的原则依然没变。本分区的扇区总数加上与前一分区之间的保留扇区数目依然必 须是柱面容量的整数倍。(保留扇区中的第一个扇区就是存放分区表的MBR或虚拟MBR的扇区，分区的扇区总数在线性表示方式上是不计入保留扇区的。如果是 第一个分区，保留扇区是本分区前的所有扇区。

　　附：分区表类型标志如图4

3.2 扩展分区

  扩展分区中的每个逻辑驱动器都存在一个类似于MBR的扩展引导记录( Extended Boot Record, EBR)，也有人称之为虚拟mbr或扩展mbr，意思是一样的。扩展引导记录包括一个扩展分区表和该扇区的标签。扩展引导记录将记录只包含扩展分区中每个 逻辑驱动器的第一个柱面的第一面的信息。一个逻辑驱动器中的引导扇区一般位于相对扇区32或63。但是，如果磁盘上没有扩展分区，那么就不会有扩展引导记 录和逻辑驱动器。第一个逻辑驱动器的扩展分区表中的第一项指向它自身的引导扇区。第二项指向下一个逻辑驱动器的EBR。如果不存在进一步的逻辑驱动器，第 二项就不会使用，而且被记录成一系列零。如果有附加的逻辑驱动器，那么第二个逻辑驱动器的扩展分区表的第一项会指向它本身的引导扇区。第二个逻辑驱动器的 扩展分区表的第二项指向下一个逻辑驱动器的EBR。扩展分区表的第三项和第四项永远都不会被使用。

    通过一幅4分区的磁盘结构图可以看到磁盘的大致组织形式。如图5

    关于扩展分区，如图6所示，扩展分区中逻辑驱动器的扩展引导记录是一个连接表。该图显示了一个扩展分区上的三个逻辑驱动器，说明了前面的逻辑驱动器和最后 一个逻辑驱动器之间在扩展分区表中的差异。

   除了扩展分区上最后一个逻辑驱动器外，表2中所描述的扩展分区表的格式在每个逻辑驱动器中都是重复的：第一个项标识了逻辑驱动器本身的引导扇区，第二个项 标识了下一个逻辑驱动器的EBR。最后一个逻辑驱动器的扩展分区表只会列出它本身的分区项。最后一个扩展分区表的第二个项到第四个项被使用。

    扩展分区表项中的相对扇区数字段所显示的是从扩展分区开始到逻辑驱动器中第一个扇区的位移的字节数。总扇区数字段中的数是指组成该逻辑驱动器的扇区数 目。总扇区数字段的值等于从扩展分区表项所定义的引导扇区到逻辑驱动器末尾的扇区数。

    有时候在磁盘的末尾会有剩余空间，剩余空间是什么呢？我们前面说到，分区是以1柱面的容量为分区粒度的，那么如果磁盘总空间不是整数个柱面的话，不够一个 柱面的剩下的空间就是剩余空间了，这部分空间并不参与分区，所以一般无法利用。照道理说，磁盘的物理模式决定了磁盘的总容量就应该是整数个柱面的容量，为 什么会有不够一个柱面的空间呢。在我的理解看来，本来现在的磁盘为了更大的利用空间，一般在物理上并不是按照外围的扇区大于里圈的扇区这种管理方式，只是 为了与操作系统兼容而抽象出来CHS。可能其实际空间容量不一定正好为整数个柱面的容量。

本文阐述如何使用 JVMTI 创建 Java 应用程序的调试和分析工具。这种工具（也称作代理）在应用程序中发生事件时，能够使用该接口提供的功能对事件通知进行注册，并查询和控制该应用程序。这里提供了 JVMTI 的文档资料。JVMTI 代理对于调试和调优应用程序十分有用。它可以对应用程序的各个方面予以说明，如内存分配情况、CPU 利用情况及锁争夺情况。

尽管 JVMPI 现在仍处于实验阶段，很多 Java 技术开发人员已经在使用它了，而且已经把它应用到多种市场上提供的 Java 应用程序 Profiler。请注意，极力鼓励开发人员使用 JVMTI 而不使用 JVMPI。JVMPI 在不久的将来将被废止。

JVMTI 在多个方面改进了 JVMPI 的功能和性能。例如：

• JVMTI 依赖于每个事件的回调。这比 JVMPI 设计使用需要编组和取消编组的事件结构更有效。
• JVMTI 包含四倍于 JVMPI 的函数（包括用于获取关于变量、字段、方法和类的信息的更多函数）。有关 JVMTI 函数的完整索引，请参见函数索引页。
• JVMTI 比 JVMPI 提供更多类型的事件通知，包括异常事件、字段访问和修改事件、断点和单步骤事件等。
• 有些从未被充分利用的 JVMPI 事件，如 Arena 的 new 和 delete，或者通过字节码工具很容易就能获得的内容，或者 JVMTI 函数本身（如 heap dump 和 object allocation）往往被 丢掉。 对这些事件的描述位于事件索引页。
• JVMTI 是基于功能的，而 JVMPI 对于相应性能影响却是“要么全有，要么全无”。
• JVMPI 堆功能不可伸缩。
• JVMPI 没有错误返回信息。
• JVMPI 在 VM 实现方面具有很强的侵入性，容易导致维护问题和性能受损。
• JVMPI 是个实验产品，不久将废止。

在本文的以下部分，我们介绍一个简单代理，它使用 JVMTI 函数从 Java 应用程序提取信息。 代理的编写必须使用本地代码。这里给出的示例代理是使用 C 语言编写的。您可以于此下载完整的示例代理代码。 下面几段介绍如何初始化一个代理，以及代理如何使用 JVMTI 函数提取关于 Java 应用程序的信息，以及如何编译和运行代理。此示例代码和编译步骤特定于 UNIX 环境，但是经过修改后也可用于 Windows。这里介绍的代理可用于在任何 Java 应用程序中分析线程和确定 JVM 内存使用情况。

这里包含一个用 Java 语言编写的简单程序，称作 SimpleThread.java，并可从这里下载。我们使用 ThreadSample.java 演示此代理的预期输出。

JVMTI 的功能很多，在此无法详述；但本文中的代码可以提供一个出发点，让您去开发符合自己特定需求的分析工具。

代理初始化

本节介绍用于初始化代理的代码。首先，代理必须包括 jvmti.h 文件，语句为 #include <jvmti.h>。

另外，代理必须包含一个名为 Agent_OnLoad 的函数，加载库时要调用这一函数。Agent_OnLoad 函数用于在初始化 Java virtual machine (JVM) 之前设置所需的功能。Agent_OnLoad 签名如下所示：

 JNIEXPORT jint JNICALL Agent_OnLoad(JavaVM *jvm, char *options, void *reserved) {

            ...

            /* We return JNI_OK to signify success */

            return JNI_OK;

            }

            

在我们的示例代码中，我们必须为将要使用的 JVMTI 函数和事件启用多种功能。一般情况下均需（在某些情况下必须）将这些功能添加到 Agent_OnLoad 函数中。有关每种函数或事件所需的功能的说明，参见 Java 虚拟机工具接口页。例如，要使用 InterruptThread 函数，can_signal_thread 功能必须为 true。我们把示例所需的全部功能都设置为 true，然后使用 AddCapabilities 函数将它们添加到 JVMTI 环境中：

 static jvmtiEnv *jvmti = NULL;

            static jvmtiCapabilities capa;

            jvmtiError error;

            ...

            (void)memset(&capa, 0, sizeof(jvmtiCapabilities));

            capa.can_signal_thread = 1;

            capa.can_get_owned_monitor_info = 1;

            capa.can_generate_method_entry_events = 1;

            capa.can_generate_exception_events = 1;

            capa.can_generate_vm_object_alloc_events = 1;

            capa.can_tag_objects = 1;

            error = (*jvmti)->AddCapabilities(jvmti, &capa);

            check_jvmti_error(jvmti, error, "Unable to get necessary JVMTI capabilities.");

            ...

            

此外，Agent_OnLoad 函数通常用于注册事件通知。在此示例中，我们在使用 SetEventNotificationMode 函数的 Agent_OnLoad 中启用了多个事件，如 VM Initialization Event、VM Death Event 和 VM Object Allocation, 如下所示：

 error = (*jvmti)->SetEventNotificationMode

            (jvmti, JVMTI_ENABLE, JVMTI_EVENT_VM_INIT, (jthread)NULL);

            error = (*jvmti)->SetEventNotificationMode

            (jvmti, JVMTI_ENABLE, JVMTI_EVENT_VM_DEATH, (jthread)NULL);

            error = (*jvmti)->SetEventNotificationMode

            (jvmti, JVMTI_ENABLE, JVMTI_EVENT_VM_OBJECT_ALLOC, (jthread)NULL);

            check_jvmti_error(jvmti, error, "Cannot set event notification");

            ...

注意，在此示例中，NULL 是作为第三个参数传递的，它可以全局地启用事件通知。如果需要，可以为某个特殊线程启用或禁用某些事件。

我们为其注册的每个事件还都必须具有一个指定的回调函数，当该事件发生时将调用它。例如，如果一个 Exception 类型的 JVMTI Event 发生，示例代理会将其发送到回调方法 callbackException() 中。

使用 jvmtiEventCallbacks 结构和 SetEventCallbacks 函数可以完成此任务：

jvmtiEventCallbacks callbacks;

            ...

            (void)memset(&callbacks, 0, sizeof(callbacks));

            callbacks.VMInit = &callbackVMInit; /* JVMTI_EVENT_VM_INIT */

            callbacks.VMDeath = &callbackVMDeath; /* JVMTI_EVENT_VM_DEATH */

            callbacks.Exception = &callbackException;/* JVMTI_EVENT_EXCEPTION */

            callbacks.VMObjectAlloc = &callbackVMObjectAlloc;/* JVMTI_EVENT_VM_OBJECT_ALLOC */

            error = (*jvmti)->SetEventCallbacks(jvmti, &callbacks,(jint)sizeof(callbacks));

            check_jvmti_error(jvmti, error, "Cannot set jvmti callbacks");

            ...

            

我们还将设置一个全局代理数据区域以在整个代码中使用。

/* Global agent data structure */

            typedef struct {

            /* JVMTI Environment */

            jvmtiEnv *jvmti;

            jboolean vm_is_started;

            /* Data access Lock */

            jrawMonitorID lock;

            } GlobalAgentData;

            static GlobalAgentData *gdata;

在 Agent_OnLoad 函数中，我们执行以下设置：

/* Setup initial global agent data area

            * Use of static/extern data should be handled carefully here.

            * We need to make sure that we are able to cleanup after

            * ourselves so anything allocated in this library needs to be

            * freed in the Agent_OnUnload() function.

            */

            static GlobalAgentData data;

            (void)memset((void*)&data, 0, sizeof(data));

            gdata = &data;

            ...

            /* Here we save the jvmtiEnv* for Agent_OnUnload(). */

            gdata->jvmti = jvmti;

            ...

我们在 Agent_OnLoad() 中创建一个原始监视器，然后把代码 VM_INIT、VM_DEATH 和 EXCEPTION 包装于 JVMTI RawMonitorEnter() 和 RawMonitorExit() 接口 。

/* Here we create a raw monitor for our use in this agent to

            * protect critical sections of code.

            */

            error = (*jvmti)->CreateRawMonitor(jvmti, "agent data", &(gdata->lock));

            /* Enter a critical section by doing a JVMTI Raw Monitor Enter */

            static void

            enter_critical_section(jvmtiEnv *jvmti)

            {

            jvmtiError error;

            error = (*jvmti)->RawMonitorEnter(jvmti, gdata->lock);

            check_jvmti_error(jvmti, error, "Cannot enter with raw monitor");

            }

            /* Exit a critical section by doing a JVMTI Raw Monitor Exit */

            static void

            exit_critical_section(jvmtiEnv *jvmti)

            {

            jvmtiError error;

            error = (*jvmti)->RawMonitorExit(jvmti, gdata->lock);

            check_jvmti_error(jvmti, error, "Cannot exit with raw monitor");

            }

卸载代理时，VM 将调用 Agent_OnUnload。此函数用于清理在 Agent_OnLoad 期间分配的资源。

/* Agent_OnUnload: This is called immediately before the shared library

            * is unloaded. This is the last code executed.

            */

            JNIEXPORT void JNICALL Agent_OnUnload(JavaVM *vm)

            {

            /* Make sure all malloc/calloc/strdup space is freed */

            }

使用 JVMTI 分析线程

本节介绍如何获取关于在 JVM 中运行的用户线程的信息。如前所述，启动 JVM 时，JVMTI 代理库中的启动函数 Agent_OnLoad 将被调用。在 VM 初始化过程中，JVMTI_EVENT_VM_INIT 类型的 JVMTI Event 将生成并被发送到代理代码的 callbackVMInit 例程中。一旦 VM 初始化事件被接收（即 调用VMInit 回调），代理即可结束其初始化。现在，此代理可以自由调用任何 Java Native Interface (JNI) 或 JVMTI 函数。此时，我们已经处于活动阶段，将启用本 VMInit 回调例程中的 Exception 事件(JVMTI_EVENT_EXCEPTION)。

error = (*jvmti)->SetEventNotificationMode

            (jvmti, JVMTI_ENABLE, JVMTI_EVENT_EXCEPTION, (jthread)NULL);

无论何时，只要在 Java 编程语言方法中首次探测到异常，就会生成 Exception 事件。此异常可能由 Java 编程语言抛出，也可能由本地方法抛出；但是如果由本地方法抛出，直到 Java 编程语言方法首次发现此异常时该事件才会生成。如果异常已被处理并清除，则异常事件不会生成。

出于演示目的，下面给出了所用的示例 Java 应用程序。主线程创建了 5 个线程，这 5 个线程退出前各自抛出一个异常。一旦启动 JVM，JVMTI_EVENT_VM_INIT 将生成并被发送到代理代码中进行处理，因为我们已经在代理代码中启用了 VMInit 和 Exception 事件。随后，当 Java 线程抛出一个异常时，JVMTI_EVENT_EXCEPTION 将被发送到代理代码中。然后，代理代码 会分析此线程信息并显示当前线程名、它所属的线程组、此线程所拥有的监视器、线程状态、线程堆栈跟踪及 JVM 中的所有用户线程。

 public class SimpleThread {

            static MyThread t;

            public static void main(String args[]) throws Throwable{

            t = new MyThread();

            System.out.println("Creating and running 10 threads...");

            for(int i = 0; i < 5; i++) {

            Thread thr = new Thread(t,"MyThread"+i);

            thr.start();

            try {

            thr.join();

            } catch (Throwable t) {

            }

            }

            }

            }

            class MyThread implements Runnable {

            Thread t;

            public MyThread() {

            }

            public void run() {

            /* NO-OP */

            try {

            "a".getBytes("ASCII");

            throwException();

            Thread.sleep(1000);

            } catch (java.lang.InterruptedException e){

            e.printStackTrace();

            } catch (Throwable t) {

            }

            }

            public void throwException() throws Throwable{

            throw new Exception("Thread Exception from MyThread");

            }

            } 

我们来看一下 Java 应用程序内部抛出一个异常时 JVMTI 代理代码的执行情况。

 throw new Exception("Thread Exception from MyThread");

JVMTI 异常事件生成后将被发送到代理代码的 Exception 回调例程中。代理必须添加 can_generate_exception_events 功能才能启用异常事件。我们使用 JVMTI GetMethodName 接口来显示生成异常的方法名和例程签名。

err3 = (*jvmti)->GetMethodName(jvmti, method, &name, &sig, &gsig);

            printf("Exception in Method:%s%s\n", name, sig);

我们使用 JVMTI GetThreadInfo 和 GetThreadGroupInfo 接口来显示当前线程和组详细信息。

err = (*jvmti)->GetThreadInfo(jvmti, thr, &info);

            if (err == JVMTI_ERROR_NONE) {

            err1 = (*jvmti)->GetThreadGroupInfo(jvmti,info.thread_group, &groupInfo);

            ...

            if ((err == JVMTI_ERROR_NONE) && (err1 == JVMTI_ERROR_NONE ))

            {

            printf("Got Exception event, Current Thread is : %s and Thread Group is: %s\n",

            ((info.name==NULL) ? ""

            : info.name), groupInfo.name);

            }

            }

这将在您的终端上产生以下输出：

Got Exception event, Current Thread is : MyThread0 and Thread Group is: main

使用 JVMTI GetOwnedMonitorInfo 接口可以获取关于指定线程所拥有的监视器的信息。此函数 不要求挂起线程。

err = (*jvmti)->GetOwnedMonitorInfo(jvmti, thr, νm_monitors, &arr_monitors);

            printf("Number of Monitors returned : %d\n", num_monitors);

            

使用 JVMTI GetThreadState 接口可以获取线程的状态信息。

线程状态可以为以下值之一：

• 线程已终止
• 线程活动
• 线程可运行
• 线程休眠
• 线程在等待通知
• 线程处于对象等待状态
• 线程为本地状态
• 线程已挂起
• 线程已中断

err = (*jvmti)->GetThreadState(jvmti, thr, &thr_st_ptr);

            if ( thr_st_ptr & JVMTI_THREAD_STATE_RUNNABLE ) {

            printf("Thread: %s is Runnable\n", ((info.name==NULL) ? "" : info.name));

            flag = 1;

            }

JVMTI 函数 GetAllThreads 用于显示 JVM 已知的所有活动线程。这些线程是关联到 VM 的 Java 编程语言线程。

以下代码对此进行了说明：

 /* Get All Threads */

            err = (*jvmti)->GetAllThreads(jvmti, &thr_count, &thr_ptr);

            if (err != JVMTI_ERROR_NONE) {

            printf("(GetAllThreads) Error expected: %d, got: %d\n", JVMTI_ERROR_NONE,  err);

            describe(err);

            printf("\n");

            }

            if (err == JVMTI_ERROR_NONE && thr_count >= 1) {

            int i = 0;

            printf("Thread Count: %d\n", thr_count);

            for ( i=0; i < thr_count; i++) {

            /* Make sure the stack variables are garbage free */

            (void)memset(&info1,0, sizeof(info1));

            err1 = (*jvmti)->GetThreadInfo(jvmti, thr_ptr[i], &info1);

            if (err1 != JVMTI_ERROR_NONE) {

            printf("(GetThreadInfo) Error expected: %d, got: %d\n", JVMTI_ERROR_NONE, err1);

            describe(err1);

            printf("\n");

            }

            printf("Running Thread#%d: %s, Priority: %d, context class loader:%s\n", i+1,info1.name,

            info1.priority,(info1.context_class_loader == NULL ? ": NULL" : "Not Null"));

            /* Every string allocated by JVMTI needs to be freed */

            err2 = (*jvmti)->Deallocate(jvmti, (void*)info1.name);

            if (err2 != JVMTI_ERROR_NONE) {

            printf("(GetThreadInfo) Error expected: %d, got: %d\n", JVMTI_ERROR_NONE, err2);

            describe(err2);

            printf("\n");

            }

            }

            }

这将在您的终端上产生以下输出：

Thread Count: 5

            Running Thread#1: MyThread4, Priority: 5, context class loader:Not Null

            Running Thread#2: Signal Dispatcher, Priority: 10, context class loader:Not Null

            Running Thread#3: Finalizer, Priority: 8, context class loader:: NULL

            Running Thread#4: Reference Handler, Priority: 10, context class loader:: NULL

            Running Thread#5: main, Priority: 5, context class loader:Not Null

            

JVMTI 接口 GetStackTrace 可用于获取关于线程堆栈的信息。如果 max_count 小于堆栈的深度，最深框架的 max_count 数将返回，否则返回整个堆栈。调用此函数无需挂起线程。

下例产生至多 5 个最深框架。如果存在任何框架，则还将输出当前执行的方法名。

            /* Get Stack Trace */

            err = (*jvmti)->GetStackTrace(jvmti, thr, 0, 5, &frames, &count);

            if (err != JVMTI_ERROR_NONE) {

            printf("(GetThreadInfo) Error expected: %d, got: %d\n", JVMTI_ERROR_NONE, err);

            describe(err);

            printf("\n");

            }

            printf("Number of records filled: %d\n", count);

            if (err == JVMTI_ERROR_NONE && count >=1) {

            char *methodName;

            methodName = "yet_to_call()";

            char *declaringClassName;

            jclass declaring_class;

            int i=0;

            printf("Exception Stack Trace\n");

            printf("=====================\n");

            printf("Stack Trace Depth: %d\n", count);

            for ( i=0; i < count; i++) {

            err = (*jvmti)->GetMethodName

            (jvmti, frames[i].method, &methodName, NULL, NULL);

            if (err == JVMTI_ERROR_NONE) {

            err = (*jvmti)->GetMethodDeclaringClass(jvmti, frames[i].method, &declaring_class);

            err = (*jvmti)->GetClassSignature(jvmti, declaring_class, &declaringClassName, NULL);

            if (err == JVMTI_ERROR_NONE) {

            printf("at method %s() in class %s\n", methodName, declaringClassName);

            }

            }

            }

            }

            

这将使您的终端产生以下输出：

Number of records filled: 3

            Thread Stack Trace

            =====================

            Stack Trace Depth: 3

            at method throwException() in class LmyThread;

            at method run() in class LMyThread;

            at method run() in class Ljava/lang/Thread;

            

使用 JVMTI 分析堆

本节介绍如何获取关于使用堆的信息的示例代码。例如，我们已经按“代理初始化”一节中所述为 VM Object Allocation 事件进行了注册。当 JVM 分配了 Java 编程语言可见但其他工具机制不能探测到的对象时，我们将得到通知。这一点与 JVMPI 截然不同，JVMPI 在分配任何对象时都将发送事件。在 JVMTI 中，针对用户分配的对象不会发送任何事件，因为它期望使用的是字节码工具。例如，在 SimpleThread.java 程序中，分配 MyThread 或 Thread 对象时，我们是不会得到通知的。以后将单独发表一篇文章，描写如何使用字节码工具获取此信息。

VM Object Allocation 事件对于确定有关由 JVM 分配的对象的信息十分有用。在 Agent_OnLoad 方法中，我们将 callbackVMObjectAlloc 注册为发送 VM Object Allocation 事件时调用的函数。回调函数参数包含关于已分配对象的信息，如对象类和对象大小的 JNI 本地参考。借助于 jclass 参数 object_klass，我们可以使用 GetClassSignature 函数获取关于类名的信息。我们可以把下面给出的对象类及其大小打印出来。注意避免过多的输出，我们仅需输出超过 50 个字节的对象信息就行了。

/* Callback function for VM Object Allocation events */

            static void JNICALL callbackVMObjectAlloc

            (jvmtiEnv *jvmti_env, JNIEnv* jni_env, jthread thread,

            jobject object, jclass object_klass, jlong size) {

            ...

            char *className;

            ...

            if (size > 50) {

            err = (*jvmti)->GetClassSignature(jvmti, object_klass, &className, NULL);

            if (className != NULL) {

            printf("\ntype %s object allocated with size %d\n", className, (jint)size);

            }

            ...

            

我们使用上面所介绍的 GetStackTrace 方法来输出正在分配该对象的线程的堆栈跟踪。我们依照该节所述获取指定深度的 框架。这些框架将作为 jvmtiFrameInfo 结构返回，这些结构包含每个框架的 jmethodID（即 frames[x].method）。GetMethodName 函数可以将 jmethodID 映射到特殊的方法名中。在此示例的最后部分，我们还将使用 GetMethodDeclaringClass 和 GetClassSignature 函数获取从其中调用过此方法的类的名称。

char *methodName;

            char *declaringClassName;

            jclass declaring_class;

            jvmtiError err;

            //print stack trace

            jvmtiFrameInfo frames[5];

            jint count;

            int i;

            err = (*jvmti)->GetStackTrace(jvmti, NULL, 0, 5, &frames, &count);

            if (err == JVMTI_ERROR_NONE && count >= 1) {

            for (i = 0; i < count; i++) {

            err = (*jvmti)->GetMethodName(jvmti, frames[i].method, &methodName, NULL, NULL);

            if (err == JVMTI_ERROR_NONE) {

            err = (*jvmti)->GetMethodDeclaringClass(jvmti, frames[i].method, &declaring_class);

            err = (*jvmti)->GetClassSignature(jvmti, declaring_class, &declaringClassName, NULL);

            if (err == JVMTI_ERROR_NONE) {

            printf("at method %s in class %s\n", methodName, declaringClassName);

            }

            }

            }

            }

            ...

            

注意，完成任务时应释放由这些函数分配给 char 数组的内存：

 err = (*jvmti)->Deallocate(jvmti, (void*)className);

            err = (*jvmti)->Deallocate(jvmti, (void*)methodName);

            err = (*jvmti)->Deallocate(jvmti, (void*)declaringClassName);

            ...

            

此代码的输出如下所示：

type Ljava/lang/reflect/Constructor; object allocated with size 64

            at method getDeclaredConstructors0 in class Ljava/lang/Class;

            at method privateGetDeclaredConstructors in class Ljava/lang/Class;

            at method getConstructor0 in class Ljava/lang/Class;

            at method getDeclaredConstructor in class Ljava/lang/Class;

            at method run in class Ljava/util/zip/ZipFile$1;

            

原始类的返回名称是相应原始类型的签名字符类型。例如，java.lang.Integer.TYPE 为“I”。

在 VM Object Allocation 的回调方法中，我们仍将使用 IterateOverObjectsReachableFromObject 函数演示如何获取关于堆的附加信息。在此示例中，我们将 JNI 参考作为一个参数传递给刚刚分配的对象，该函数将在此新分配对象所能直接或间接到达的所有对象中迭代。对于每个可到达的对象，另外还有一个定义的回调函数可对其进行描述。在此示例中，传递到 IterateOverObjectsReachableFromObject 的回调函数名为 reference_object：

err = (*jvmti)->IterateOverObjectsReachableFromObject

            (jvmti, object, &reference_object, NULL);

            if ( err != JVMTI_ERROR_NONE ) {

            printf("Cannot iterate over reachable objects\n");

            }

            ...

reference_object 函数定义如下：

/* JVMTI callback function. */

            static jvmtiIterationControl JNICALL

            reference_object(jvmtiObjectReferenceKind reference_kind,

            jlong class_tag, jlong size, jlong* tag_ptr,

            jlong referrer_tag, jint referrer_index, void *user_data)

            {

            ...

            return JVMTI_ITERATION_CONTINUE;

            }

            ...

在此示例中，我们使用 IterateOverObjectsReachableFromObject 函数计算新分配对象所能到达的所有对象的 总的大小，以及它们的对象类型。对象类型可以从 reference_kind 参数中确定。然后打印此信息以接收如下输出：

This object has references to objects of combined size 21232

            This includes 45 classes, 9 fields, 1 arrays, 0 classloaders, 0 signers arrays,

            0 protection domains, 19 interfaces, 13 static fields, and 2 constant pools.

            

注意，位于 JVMTI 中的类似迭代函数允许迭代的对象有：整个堆（可到达的和不可到达的）；根目录对象和根目录对象所能直接或间接到达的所有对象；堆中 是指定类的实例的所有对象。使用这些函数的技巧和前面所介绍的类似。在执行这些函数期间，堆的状态没有任何变化：没有分配任何对象，没有对任何对象进行垃 圾收集，并且对象的状态（包括堆值）也没有任何变化。结果，执行 Java 编程语言代码的线程、尝试恢复执行 Java 编程语言代码的线程和尝试执行 JNI 函数的线程都完全停了下来。所以，在对象参考回调函数中，不能使用任何 JNI 函数；在没有特别允许的情况下，也不允许使用任何 JVMTI 函数。

编译和执行示例代码

要编译并运行这里描述的示例应用程序的代码，请按以下步骤操作：

1. 设置 JDK_PATH 为指向 J2SE 1.5 发行版
   

   JDK_PATH="/home/xyz/j2sdk1.5.0/bin"

   
   
   
2. 使用 C 语言编译器构建共享库。我们使用的是 Sun Studio 8 C 编译器。
   

   CC="/net/compilers/S1Studio_8.0/SUNWspro/bin/cc" echo "...creating liba.so" ${CC} -G -KPIC -o liba.so -I${JDK_PATH}/include -I${JDK_PATH}/include/solaris a.c

   
   
   
3. 要加载并运行代理库，请在 VM 启动过程中使用下面的命令行参数之一。
   

   -agentlib:<jvmti-agent-library-name> -agentpath:/home/foo/jvmti/<jvmti-agent-library-name>

   
   
   然后如下运行示例 Java 应用程序：
   

   echo "...creating SimpleThread.class" ${JDK_PATH}/bin/javac -g -d . SimpleThread.java echo "...running SimpleThread.class" LD_LIBRARY_PATH=. CLASSPATH=. ${JDK_PATH}/bin/java -showversion -agentlib:a SimpleThread

   
   
   

注意：此示例代理代码是在 Solaris 9 Operating System 上构建和测试的。

结束语

在本文中，我们演示了 JVMTI 提供用于监控和管理 JVM 的一些接口。JVMTI 规范 (JSR-163) 旨在为需要访问 VM 状态的广泛的工具提供一个 VM 接口，这些工具包括但不限于：分析、调试、监控、线程分析和覆盖率分析工具。

建议开发人员不要使用 JVMPI 接口开发工具或调试实用工具，因为 JVMPI 是一种不受支持的实验技术。应考虑使用 JVMTI 编写 Java 虚拟机的所有分析和管理工具。

迅雷是基于P2SP的一款下载软件，能够大大增强下载速度，可谓迅雷不及掩耳盗铃之势如破竹。

P2SP的道理不复杂，就是指：如果多个服务器上有某个相同的文件，当某个用户下载其中一个服务器上的这一文件时，迅雷会自动查找到另外的几个服务器，同时下载这一文件，达到提速的目的。

     下载原理

还记得百度的mp3搜索么？你到mp3.baidu.com上搜索一个mp3，百度会给你列出她知道的所有服务器列表（这些服务器都是别人的），你可以在百度上点击该连接下载mp3，而不用登陆真正的服务器。

迅雷就是把这个过程自动化了，并且增加了判断文件唯一性的功能，画个图简单说明一下：

1．用户点击1.2.3.4上的QQ_1.exe文件的连接

2．用户客户机上的迅雷得到该文件的唯一的校验值。

3．迅雷自动向自己的资源服务器上搜索，查找到存放同一文件的其他的服务器列表

4．得到文件在该服务器上的目录和文件名（红色部分，有可能和原始连接中的文件名不相同），ftp://1.2.3.5/QQ_2.exe，http://1.2.3.6/QQ_3.exe，以及公网用户1.2.3.7有QQ.exe

5．迅雷自动向1.2.3.5和1.2.3.6上下载该文件的不同文件块，以达到加速下载的目的（紫色部分）。

6．用户向公网用户1.2.3.7发送一个UDP资源请求

7．1.2.3.7回应一个资源请求说：偶这儿有你要的文件

8．用户向公网用户1.2.3.7的3077端口发起请求，并传输数据。

9．下载完毕后，如果迅雷资源服务器上，该文件的服务器列表中没有目前用户点击下载的服务器1.2.3.4，则将这个新的服务器地址加入到该文件的服务器列表（蓝色部分）。

注：

1．上述过程中的6、7、8步骤中隐含了一个过程：判断用户是否是公网用户。

如果是公网用户，则该用户的IP地址和提供下载服务的端口也将记录在迅雷的资源服务器中，后续用户可以从该用户处下载；第三节有这个过程的说明。

2．迅雷如何区分不同的文件？很多文件名字不同但是内容相同，很多文件名字相同但是内容不同。搜索迅雷的相关信息只是得到了几句无关痛痒的废话：迅雷还使用了独创的文件校验机制,保证了用户下载文件的正确性和完整。至于什么方法不得而知

3．我们如何查看迅雷搜索到的资源列表？

在迅雷搜索到一系列的资源列表并且任务没有完成时，会在相同下载目录下建立一个临时文件，里面有搜索到的资源信息，其中peer就是搜索到的包含要下载文件的公网用户。


协议解析

分析第二节原理图中的下载过程，第1、2、5步和正常的下载是一模一样的，我们无法根本无法区分。那好，我们就在3、4、6上做文章。

除了上述用户下载一个具体文件的过程的各个报文外，还有交换资源信息报文，用户和用户之间的文件块传输报文、判断用户是否是公网用户的报文等。

1．资源请求报文

每次迅雷都会向219.134.132.47的tcp端口3076发出资源请求，该地址是写死在迅雷软件中的，并非依靠DNS请求得到。

如果该地址不可用，则会切换到另外两个可替换的地址219.134.132.42、219.134.132.86。

Web迅雷则使用219.134.132.46。

过滤掉这个报文，那么迅雷客户端就无法完成资源请求，无法从多点下载。用TP过滤掉报文后迅雷只能从原始连接下载，如下图：

协议报文特征如下：

2．资源搜索回应报文

过滤掉这个报文，那么迅雷客户端就无法得到资源列表，无法从多点下载。

协议报文特征如下：

3．用户之间的文件传输（握手报文）

用户之间是可以传送文件块的，下面的报文就是传送文件块开始之前的握手报文，3077端口为客户端的监听端口，用来把本地的文件传输给别人。（如果3077不能用,会转到其他端口）.

4．用户之间资源信息交换报文

5．提交新的资源信息报文

6．连接NAT测试服务器报文

迅雷每过几分钟就会向statnat1.sandai.net发送NAT测试报文，也就是告诉迅雷的资源服务器，自己是否是公网IP.该报文由于无返回报文，所以猜想采用的办法是采用STUN的方法：

将本机的IP地址放在UDP的payload里，如果迅雷的服务器收到报文发现IP层的源地址和payload里的IP地址一致，那么就是公网地址，否则就是处于防火墙后面或者需要经NAT才能上公网。

协议报文如下：

注：

sandai.net是xunlei旗下的一个网站，很少单独抛头露面，多出现在迅雷软件检索关联信息、显示广告的DNS请求报文中。

4TP过滤

如果TP武断的对迅雷进行过滤，只需要设定一个traffic management，把目的地址为219.134.132.0/24网段，目的端口为3076的报文全部过滤就可以防止迅雷下载，但是有可能会误报。下面的规则更详细一点，可以减少误报。

1．针对用户向服务器资源请求报文和资源回应报文的过滤

由于迅雷的服务器IP地址比较容易更换，所以建议过滤的DV：

协议：tcp

源端口/目的端口：3076

开始的四个字节：0x29000000

2．针对用户之间的资源信息交互报文的过滤

协议UDP

端口3076

前四个字节0x32000000

3．针对用户之间的文件传输（握手报文）的过滤

协议tcp

源端口或者目的端口可以为3077、3078

前四个字节为0x29000000

4．提交新的资源信息的报文的过滤

协议TCP

目的端口3076

前四个字节0x29000000

5．针对连接NAT测试服务器的报文的过滤

协议UDP

目的端口3076

前四个字节0x00000101

通讯方式

        迅雷支持Http连接、Ftp连接、MMS连接、RTSP连接以及其他代理模式。

　　迅雷查询和下载资源默认使用TCP 3076和3077端口，迅雷的雷区注册和登陆使用的是TCP 5200和6200端口。如果登陆端口TCP 6200、3076和3077端口都不通，就会自动跳转到Http的80端口登陆。（注：HTTP 80端口为上网浏览必须的端口。）

如何封堵迅雷？

　　由于迅雷会自动进行端口转换，而且最重要的是迅雷可以走80端口，所以我们建议你采取以下方法进行控制：

　　1)封堵迅雷的服务器的IP和迅雷的主要下载站点和占用的端口

　　2)通过限制主机的链接数来控制迅雷的下载（但是无法限制迅雷从单点高速下载）

        3)在用聚生网管封堵迅雷时，则可以选择P2P下载里面迅雷，除此之外，你还需要在禁止普通下载那里设置文件后缀名；如果你想完全控制迅雷的下载，还需要勾选上“禁止一且http”下载。　　

总之，控制迅雷,禁止迅雷,限制迅雷,封堵迅雷,监控迅雷,控制迅雷,禁止迅雷,限制 迅雷,封堵迅雷,监控迅雷,禁迅雷,限迅雷,封迅雷,禁迅雷,限迅雷,封迅雷,迅雷端口,迅雷协议,迅雷服务器IP,如何控制迅雷,如何禁止迅雷,如何限 制迅雷,如何封堵迅雷,如何监控迅雷,如何管理迅雷等等这些功能，聚生网管可以实现！

运行WMIC

WMIC命令行构成

实践应用

　　一、WEP:无线网络安全最初的保护者

　　相对于有线网络来说，通过无线局域网发送和接收数据更容易被窃听。设计一 个完善的无线局域网系统，加密和认证是需要考虑的两个必不可少的安全因素。无线局域网中应用加密和认证技术的最根本目的就是使无线业务能够达到与有线业务 同样的安全等级。针对这个目标，IEEE802.11标准中采用了WEP(Wired Equivalent Privacy:有线对等保密)协议来设置专门的安全机制，进行业务流的加密和节点的认证。它主要用于无线局域网中链路层信息数据的保密。WEP采用对称 加密机理，数据的加密和解密采用相同的密钥和加密算法。WEP 使用加密密钥(也称为 WEP 密钥)加密 802.11 网络上交换的每个数据包的数据部分。启用加密后，两个 802.11 设备要进行通信，必须具有相同的加密密钥，并且均配置为使用加密。如果配置一个设备使用加密而另一个设备没有，则即使两个设备具有相同的加密密钥也无法通 信。(如图一所示)

图一:WEP加密

　　WEP加密过程

　　WEP支持 64 位和128 位加密，对于 64 位加密，加密密钥为 10 个十六进制字符(0-9 和 A-F)或 5 个 ASCII 字符;对于 128 位加密，加密密钥为 26 个十六进制字符或 13 个 ASCII 字符。64 位加密有时称为 40 位加密;128 位加密有时称为 104 位加密。152 位加密不是标准 WEP 技术，没有受到客户端设备的广泛支持。WEP依赖通信双方共享的密钥来保护所传的加密数据帧。其数据的加密过程如下。

　　1、计算校验和(Check Summing)。

　　(1)对输入数据进行完整性校验和计算。

　　(2)把输入数据和计算得到的校验和组合起来得到新的加密数据，也称之为明文，明文作为下一步加密过程的输入。

　　2、加密。在这个过程中，将第一步得到的数据明文采用算法加密。对明文的加密有两层含义:明文数据的加密，保护未经认证的数据。

　　(1)将24位的初始化向量和40位的密钥连接进行校验和计算，得到64位的数据。

　　(2)将这个64位的数据输入到虚拟随机数产生器中，它对初始化向量和密钥的校验和计算值进行加密计算。

　　(3)经过校验和计算的明文与虚拟随机数产生器的输出密钥流进行按位异或运算得到加密后的信息，即密文。

　　3、传输。将初始化向量和密文串接起来，得到要传输的加密数据帧，在无线链路上传输。(如图二所示)

图二:WEP加密过程

　　在安全机制中，加密数据帧的解密过程只是加密过程的简单取反。解密过程如下。

　　1、恢复初始明文。重新产生密钥流，将其与接收到的密文信息进行异或运算，以恢复初始明文信息。

　　2、检验校验和。接收方根据恢复的明文信息来检验校验和，将恢复的明文信息分离，重新计算校验和并检查它是否与接收到的校验和相匹配。这样可以保证只有正确校验和的数据帧才会被接收方接受。

图三:WEP解密过程

　　可能没有玩过DD－WRT的玩家不知道DD－WRT是什么，我们打个比方：路由器的硬件就如同我们计算机的主板、内存、硬盘等，而实际上每台无线路由都有一个操作系统OS， 每个厂家的无线路由器操作系统都不相同，而且也没有对外公布代码，这就类似于windows操作系统，虽然我们可以正常使用这些无线设备，但是由于自带的 OS不能够随便修改，所以难免在实际使用上存在这样或那样的不足，可能不适合自己使用。在这种环境下DD-WRT驱动应运而生，准确的说就是有了DD- WRT之后，每台路由的功能可以由我们自己安装、配置，挺有意思的吧。

　　DD-WRT的第一个版本基于Sveasoft Inc公司的Alchemy开发出来的，而现在利用源代码进行hack并给大家带来福音的是一个叫Brain Slayer的疑似德国人，可以通过email找到他：brainslayer@braincontrol.org。DD－WRT带来的功能非常非常的丰 富，你能想到的都有、没见过的也有，这些也是要感谢这位神秘的Brain Slayer。

为什么要给无线路由器刷DD-WRT？

    但是刷新DD-WRT后能够为我们冲浪和管理网络带来什么好处呢？为什么我们要冒着设备被刷坏的危险更换固件驱动呢？一台无线路由器的操作系统OS相当于 他的大脑，那么刷新DD-WRT固件就意味着给这个无线路由器洗脑。经过洗脑操作后我们的无线设备将发挥更好的作用，所支持的功能更多，运行更加稳定。

    说的更直白一点，给无线路由刷DD-WRT就是抛弃原来设备的OS，更换一个新的OS，这样的操作有点类似于硬件爱好者常用的“超频”。DD-WRT是一 个第三方固件，它广泛地应用在基于Broadcom网络芯片设计的802.11g无线路由器，它的本质是一个Linux操作系统。市面主流品牌的无线路由 器由于某些原因不可能把所有网络功能都集中到一起，而且即使功能众多也未必适合所有用户的实际需求，这也是为什么很多用户都热衷于将自己的无线路由器操作 系统刷新为DD-WRT的原因。

    这些非商业的DD-WRT固件，功能强大，同时又具有友好的Web管理/配置界面，可以提供很多“原版”路由器不支持的功能，如调整无线发射功率等。一般 刷新了DD-WRT固件，就是想让无线路由器拥有更多、更强大的功能，相比传统无线路由器来说，DD-WRT无线路由器应用范围也更广。

DD-WRT特有的功能主要有以下几个：

    1． 支持花生壳的DDNS。

    2． 支持VPN的PPTP客户端和PPTP服务器端设置，可以提供VPN接入。

    3． 可以通过设置，轻松管理各种网络服务，例如彻底封杀BT，电驴，迅雷等。

    4． 支持UPNP和端口映射功能。

    5． 可以轻松实现无线路由器的定时开关。

    6． 可以利用Q0S、限速、限连接数等设置来优化宽带。

    7． 支持多国语言，可以搭配802.1X协议，EAP（Extensible Authentication Protocol，可扩展认证协议）来增加网络认证应用。

    8． 支持IPv6、SNMP协议，SSH服务等。

    另外，还有很多功能等待用户去发掘，这里就不一一介绍了。本文主要介绍如何将自己的无线路由器刷新成基于DD-WRT的无线路由器。

    不过有一点还是值得用户注意的，并不是所有的无线路由器都可以刷新成DD-WRT。DD-WRT支持的品牌型号很多，以下罗列出一些最常见的以供参考：

品牌	型号
Allnet	All0277
Askey	RT210W
Asus（ 华硕）	WL-500G deluxe  WL-500G premium  WL-300G
Belkin（贝尔金）	F5D7130/7330 (2mb flash) F5D7230-4 v1000, v1010, v1111 F5D7230-4 v1444 (2mb flash)
Buffalo（巴比禄）	WHR-G54S WHR-HP-G54 WHR-HP-G54S WZR-RS-G54 WBR-G54 WBR2-G54 WBR2-G54s WLA-G54
Linksys	WRT54G v1.0, v1.1, v2.0, v2.2, v3.0, v3.1, v4.0, v5.0 (2mb flash) WRT54GL v1.0, v1.1 WRT54GS v1.0, v1.1, v2.0, v2.1, v3.0, v4.0, v5.0 (2mb flash) WRTSL54GS v1.0
Motorola（摩托罗拉）	WR850G
Ravo	W54-RT
Siemens（西门子）	Gigaset SE505 Gigaset SX550i

    以上所列的多数无线路由器都拥有至少4MB的flash容量，所有的WRT54GS v4.0版本之前的型号都拥有8MB的flash容量，而也有部分路由器(包括WRT54G和WRT54GS的v5.0型号)仅有2MB的flash。 DD-WRT的完整版("full vision")和迷你版("mini vision")的安装都需要4MB的flash;而微型版("micro vision")需要2MB来安装。

    这些支持的设备刷新DD-WRT后的效果也是有很大差别的，笔者推荐拥有Buffalo WHR G54s、Ausu WL 500G Deluxe以及Motorola WR850G这几个产品的用户刷新，其刷新后的效果最为优秀。

　　值得注意的几点是：1、如果用的是Linksys的WRT54G系列路由器，一定要买V4版，因为扩展性最强，而V5、V6版在硬件配置上作了 削减，V7版就更不用考虑了。不过不幸的是，Linksys在中国只生产V7版，要买V4版的只能找库存了；2、由于Linksys的官方固件对可通过 web升级的文件尺寸作了限制，因此需要先用DD-WRT的mini版本升级，之后才可以升级其他的vpn/voip等高级版本，至于用tftp、 telnet还是web就看个人偏好了；3、如果使用web方式，建议用IE浏览器，使用firefox的至少要升级到1.5.0.x版本，否则会有兼容 性问题。

如何刷DD-WRT？

　　首先，先将路由器恢复到原厂设置，然后用网线将电脑和路由器的LAN口连接，在这个步骤肯定有许多朋友会问，能否用无线来刷DD－WRT？答案是不行的。因为路由器是在启动过程中被刷新，在这个过程中无线模块是不工作的。

　　将电脑的IP地址手动设为固定IP地址。如buffalo系列应该设为192.168.11.X，子网掩码为255.255.255.0，网关为192.168.11.1。

　　“开始”菜单－－“运行”－－键入”CMD"，点击“确定”进入到命令行模式。

　　键入cd\  回车，跳到C盘的根目录下。

　　接下来，将下载下来的DD-WRT固件，放在C盘的根目录下。

    提示：这里需要大家注意的是，不同品牌不同型号的无线路由器可能使用的DD-WRT驱动程序也不相同，有的由于内部FLASH容量等硬件差异可能只能使用PRO特别版或者MINI袖珍版，因此一定要下载适合自己产品的DD-WRT固件驱动程序，不能混用和错用。

　　键入tftp命令  tftp -i 192.168.11.1 PUT 固件名称。

　　因为固件名称下载下来的都比较长，你可以自己改名，比如，直接改为“dd”或者别的，也可以在键入TFTP命令之前输入DIR来查看一下。

　　接着拔下路由器电源，确认无误再插上。

　　看着路由器的灯，首先会是所有LAN口的灯都亮，然后只会有和你电脑连着的那个LAN口的灯亮着。

　　这时候你就要毫不犹豫的按下回车。然后又过一段时间，会出现传送数据成功的字样。如果你键入回车的时间晚了，在经过一段时间的等候，会给出一个出错的提示，你只要重新来过一遍就行，不会对你的路由器有影响。

出现传送成功字样后，请等待至少3分钟，路由器不能断电，也不要对路由器有所操作。这时

　　等待3分钟以后，将电脑的IP设为自动获取。最后因该会获得一个192.168.1.×××的地址，网关因该是192.168.1.1。

　　然后打开IE，输入192.168.1.1 用户名为root 密码为admin。DD-wrt的界面就会出现了。

　　至此，刷新DD固件就完成了。

刷写固件注意事项：

不正确的固件刷新步骤将损坏您的路由器。
请不要使用https连接来刷新或备份路由器固件。
固件的刷新和升级应该以有线连接的方式来完成。
利用无线连接刷新可能会由于先天的不稳定性而导致路由器损坏。
请关掉您的杀毒软件，不必要的病毒检测将会打断固件向路由器的上传。
请关掉所有您系统中的无线适配器，以保证是通过有线网来进行固件的上传。

特色功能之多种网络接入方式

　　对于一般无线产品来说，外网接入方式的Internet连接类型主要有静态IP和PPPOE（ADSL）两种，对于不用拨号而且需要自动获得 IP地址的有线电视网络以及部分小区宽带网络来说就没有很好的解决办法了。然而经过刷新之后的DD-WRT设备却可以完成这样的工作，它支持更多的外网连 接方式，在DD-WRT管理界面的“设置->基本设置”处的Internet连接类型有多个选项。

DD-WRT管理界面

　　在DD-WRT管理界面的“设置→基本设置→Internet连接类型”中有多个选项，其中的“自动配置DHCP”适用于小区宽带网络，另外对 于企业内部网络经常要用到VPN（虚拟专用网络）来连接多个分支网络，我们可以采用“Internet连接类型”中的“PPTP”和“L2TP”，直接把 设备连接到远程VPN服务器。

　　通过DD-WRT的外网设置可以使外网连接更加方便，以往不能解决的小区宽带网络问题也可以轻松解决。

封杀BT、电驴没商量

　　首先声明，笔者也是狂热的BT下载爱好者，写这个功能只是出于单纯的技术角度，还希望各位看官手下留情。

　　高速发展的互联网带给用户极其丰富的资源，BT、电驴等P2P下载软件更是方便用户找到其想要的资源。但是这些P2P下载软件占用了大量的宽带 资源，使整个局域网的其他用户网速变慢，严重的会造成网络瘫痪。网管也为封杀BT、电驴伤透的脑筋，因为BT、电驴太不好封。封端口吧，这些软件都可以随 意改端口；封BT的tracker吧，网上tracker服务器很多封不过来；即使你封了，BT还用DHT技术，在完全不连上Tracker服务器的情况 下，也可以很好的下载。还有电驴本来不需要服务器，你封都没地方封。但是有经验的网络管理员都会在linux系统上进行封杀工作，因为linux下采用的 是比较先进的封杀技术，可以使用ipp2p或L7来封杀BT、电驴等P2P软件。

    由于DD-WRT就是一个基于linux的路由OS（也就是固件），DD-WRT也有ipp2p和L7模块，用起来比linux还方便，而且DD-WRT可以直接在WEB配置，非常直观。

    那么如何用DD-WRT封杀BT和电驴呢？

    首先，登录DD-WRT管理界面，打开“访问限制”页。

DD-WRT管理界面 访问限制页

    设置非常简单，在状态项开启这条策略，策略名可以随便取，规则选允许，日期和时间大家可以根据自己的情况设置，默认是任何时间。

被封禁的服务

　　“被封禁的服务”这里，“捕获所有P2P协议”打钩，在下面的应用程序栏选上“bittorrent”和“edonkey”，你也可以加上“讯雷“、“KuGoo”等P2P软件，当然也可以根据自己实际情况自定义一些。

PC列表

    在PC列表页里编辑此策略应用的PC列表，如果你想对局域网机器全封，就在PC的IP范围里填入2~254,这样别人不管怎么改IP都不能BT、电驴；如 果你想就你一台不受限，比如你的IP是192.168.1.2,那就填入3~254；如果你就想封几台机器可以在“PC的IP地址”或“PC的MAC地址 ”栏输入相应的IP或MAC地址。

通过URL地址封锁Web站点

    如果你想禁止用户对BT、电驴站点的访问，可以在“通过URL地址封锁Web站点”填入BT、电驴的站点，还可以在“通过关键字封锁Web站点”填入关键 字来封锁带关键字的域名（同时封锁用户用引擎搜索这个关键字）,不要填入BT这个关键字哦，这个关键字太短，这样会使很多与BT不相关的但域名带BT这两 个字符的网站也同时被封锁。

新功能之DHCP转发

　　当企业内部拥有多台无线路由器，而提供给客户机的DHCP服务器却只有一台时，客户机要向DHCP服务器申请IP地址等网络参数就需要穿越多台 无线路由器，这对于其他无线路由器是不可能实现的，而DD-WRT则不同，DD-WRT所拥有的“DHCP转发”功能就能够“穿越”无线路由器。设置 DHCP转发参数是非常简单的，只需要指定转发到的DHCP服务器地址即可。

　　首先，在地址栏里输入DD-WRT的管理IP地址，回车，进入管理界面。

DD-WRT管理界面

　　然后，点任何设置修改标签时会出现用户认证的提示，输入正确的管理员帐户名和密码后登录。

登录界面

　　之后，在设置标签的“基本设置”中我们能够看到关于“网络地址服务器设置（DHCP）”的配置参数，一般我们都是选择DHCP服务器，然后设置 相应的地址信息即可。不过由于我们需要添加DHCP转发功能，所以在DHCP类型处通过下拉菜单选定“DHCP转发器”，并指定IP地址等参数即可。

基本设置界面

　　最后点“保存设置”按钮完成DHCP转发功能的配置工作。

　　通过DHCP转发功能，我们实现了穿越无线路由器，减少了企业网络服务器的数量，可以用一台DHCP服务器管理多台在不同无线路由器下的计算机。

最实用功能之调节发射功率

　　无线网络的关键就是无线信号的强弱，如果一个无线路由器发射功率比较低，那么当安装了无线网卡的计算机与它距离稍远一点的话，无线信号就会非常虚弱甚至接收不到信号。那么怎样做才能让无线设备信号更强呢？

    经过刷新之后DD-WRT无线路由就可以实现任意调节发射功率，这样我们就可以根据无线网卡距离DD-WRT无线路由器的远近来决定发射信号的强弱了。下面我们就和大家一起探讨一下如何来设置调节发射功率。

    首先，我们来看看默认情况下的接收情况。

    开启DD-WRT无线设备之后，用自己的无线网卡扫描网络中的无线信号就会看到SSID号为DD-WRT的无线网络信号强度为两格。

默认情况下信号强度

    打开浏览器在地址栏处输入http://192.168.1.1（路由器默认地址），回车，输入登录用户名和密码，然后找到“无线”标签下的“高级设置 ”，在Xmit功率处能够看到默认情况下，DD-WRT设备的发射功率为28mW，这个也是大多数无线设备的标准发射功率。从后面的提示可以看到我们能够 随意的修改这个发射功率，大小范围为0到251mW。

“高级设置”界面

    在本机打开无线信号扫描工具network stumbler，对当前的信号强度进行扫描，可以看到默认28mW的发射功率情况下无线网卡接收信号强度为-72dBm左右。

信号强度扫描

    接下来，让我们设置如何调解发射功率。
 
    我们可以直接在界面里，将Xmit功率调到范围之内的任意数值，截图中显示的是调到了最大的251mW。

信号调整到251mW

    再次启动network stumbler软件对无线网络进行扫描，会发现接收到的信号强度还是有所增加的，虽然不太明显但是至少稳定在了-70dBm，而且峰值还到达过 -68dBm左右。另外在XP系统自带的信号扫描工具中我们可以看到信号强度从原来的两格变成了三格。

信号强度显示为三格

　　发射功率既能增大也能减小，用户可以根据自己的实际需求来调节。

综述

　　以上向大家介绍了什么是DD-WRT，如何给无线路由刷DD-WRT，以及刷新之后的DD-WRT无线路由都带来了 哪些新的功能。实际上，刷新了DD-WRT固件驱动的无线路由器功能不仅仅局限于上面介绍的这些，它还拥有很多更高级的网络管理功能，诸如开启强大的 SPI防火墙、开启NAT功能以提高网络安全性以及网络唤醒WOL功能等，不过这些功能实现和设置起来比较复杂，我们会在今后的文章中为大家介绍，本文只 是对一些基本特色功能进行了介绍。

　　本文给大家介绍的这些功能已经足以让我们大开眼界，这也就是为什么有那么多无线设备发烧友都纷纷选择DD-WRT设 备的原因。DD-WRT适合那些对硬件和网络要求的读者，相信在今后的使用过程中，会逐渐发现它的功能真的很强大，大家可以自定义设置适合自己的实际网络 情况。

KlassMaster很强大的混淆工具，最大卖点应该是混淆时改程序的控制流程但程序功能不会发生变化这一点。
当然，字符加密功能也很强大，对逆向工程会带来很大的麻烦。

当然，价格也不低：）上次破解了4.5，一直在用。前两天发现已经更新到5.1了，
想办法弄了一个，企业版。

本来不打算散发该软件的破解，原因是一年前我收到了官方的邮件，要求我不要做影响他们
公司的事情，但又看到这么多朋友需要。那我就发布一个该软件的低版本，留下邮箱的我会
给每人发一份，同时希望大家在小范围传播就行了。

2.      main 函数创建一个名叫”jboss”的线程组, 然后创建一个属于该组的线程, 在线程中执行boot方法.

3.      boot 方法首先处理main函数中的参数(及一些其它的系统环境设置), 接着就用系统的属性创建了org.jboss.system.server.ServerLoader实例[new ServerLoader(props)].

4.      ServerLoader 注册Jboss相关的类路径, 包括XML解析器, jboss-jmx.jar, concurrent.jar及其它的一些额外的类路径.

5.      ServerLoader 通过load(ClassLoader)方法创建Jboss Server实例. 参数ClassLoader是ClassLoader parentCL = Thread.currentThread(). getContextClassLoader( )得到的当前线程的类加载器. 创建的Server实例是org.jboss.system.server.Server接口的实现. load(ClassLoader)方法的细节:

Ø        用jar包及在ServerLoader中注册的类路径创建一个URLClassLoader的实例, 把传入的ClassLoader作为该URLClassLoader的parent.

Ø        Server 接口的实现类由系统属性 jboss.server.type决定, 默认是      org.jboss.system.server.ServerImpl.

Ø        URLClassLoader 通过无参构造函数加载Server接口实现的实例. 在加载前把当前线程的类加载器置为该URLClassLoader, 在加载完成后再置回之前传入的ClassLoader.

6.      Server 实例用系统属性进行初始化[server.init(props)].

7.      服务起动[server.start()]. 起动过程的默认实现如下:

Ø        把当前线程类型加载器置为加载该Server接口实现实例的ClassLoader.

Ø        在jboss域内, 通过MBeanServerFactory的createMBeanServer(String)方法创建MbeanServer实例.

Ø        在MBean Server上注册ServerImpl和ServerConfigImpl两个MBean.

Ø        初始化统一的类加载仓库(unified class loader repository), 用来装载服务器配置目录及其它可选目录下的jar文件. 对于每一个jar文件和类目录都会创建一个相应的org.jboss.jmx.loading.UnifiedClassLoader实例, 并且注册到统一的仓库中. 其中一个UnifiedClassLoader实例会被设置为当前线程上下文的ClassLoader. [?: This effectively makes allUnifiedClassLoaders available through the thread context class loader.]

Ø        接下来创建org.jboss.system.ServiceController的MBean实例. ServiceController管理JBoss MBean服务的生命周期.

Ø        org.jboss.deployment.MainDeployer 实例被创建并起动. MainDeployer管理部署的依赖和部署的定向.

Ø        org.jboss.deployment. JARDeployer 实例被创建并起动. JARDeployer处理jar包的部署.

Ø        org.jboss.deployment. SARDeployer 实例被创建并起动. SARDeployer处理JBoss MBean服务的部署.

Ø        MainDeployer 对当前服务器文件环境里conf/jboss-service.xml定义的服务进行部署.

启动过程结束. 把当前线程上下文类加载器置回为起动前的ClassLoader.

    public static void main(String[] args)
    {
     String a = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";//这里不技持中文
     String ru;
     char[] ch;
     try{
      byte[] bt= a.getBytes("UTF-8");
      ch = encrypt(bt);
      //ru = new String(decrypt(ch));
      System.out.println(ru);
     }catch(Exception e){}
    }
    public static char[] encrypt(byte abyte0[])
    {
        int i = abyte0.length;
        int j = (i * 4 + 2) / 3;
        int k = ((i + 2) / 3) * 4;
        char ac[] = new char[k];
        int l = 0;
        for(int i1 = 0; l < i; i1++)
        {
            int j1 = abyte0[l++] & 0xff;
            int k1 = l >= i ? 0 : abyte0[l++] & 0xff;
            int l1 = l >= i ? 0 : abyte0[l++] & 0xff;
            int i2 = j1 >>> 2;
            int j2 = (j1 & 3) << 4 | k1 >>> 4;
            int k2 = (k1 & 0xf) << 2 | l1 >>> 6;
            int l2 = l1 & 0x3f;
            ac[i1++] = cChar[i2];
            ac[i1++] = cChar[j2];
            ac[i1] = i1 >= j ? '=' : cChar[k2];
            i1++;
            ac[i1] = i1 >= j ? '=' : cChar[l2];
        }

        return ac;
    }

    private static char cChar[];
    private static byte bByte[];

    static
    {
        cChar = new char[64];
        int i = 0;
        for(char c = 'A'; c <= 'Z'; c++)
            cChar[i++] = c;

        for(char c1 = 'a'; c1 <= 'z'; c1++)
            cChar[i++] = c1;

        for(char c2 = '0'; c2 <= '9'; c2++)
            cChar[i++] = c2;

        cChar[i++] = '+';
        cChar[i++] = '/';
        bByte = new byte[128];
        for(int j = 0; j < bByte.length; j++)
            bByte[j] = -1;

        for(int k = 0; k < 64; k++)
            bByte[cChar[k]] = (byte)k;

    }
}

public class WordtoHtml {
 /**
  *文档转换函数
  *@param docfile word文档的绝对路径加文件名(包含扩展名)
  *@param htmlfile 转换后的html文件绝对路径和文件名(不含扩展名)
  */
 public static void change(String docfile, String htmlfile) {
  ActiveXComponent app = new ActiveXComponent("Word.Application");// 启动word
  try {
   app.setProperty("Visible", new Variant(false));
    //设置word不可见
   Object docs = app.getProperty("Documents").toDispatch();
   Object doc = Dispatch.invoke(docs,"Open",Dispatch.Method,new Object[] { docfile, new Variant(false),new Variant(true) }, new int[1]).toDispatch();
   // 打开word文件
   Dispatch.invoke(doc, "SaveAs", Dispatch.Method, new Object[] {htmlfile, new Variant(8) }, new int[1]);
   // 作为html格式保存到临时文件
   Variant f = new Variant(false);
   Dispatch.call(doc, "Close", f);
  } catch (Exception e) {
   e.printStackTrace();
  } finally {
   app.invoke("Quit", new Variant[]{});
  }
 }
 public static void main(String[] strs){
  WordtoHtml.change("c:\\a\\运输管理调度系统总体方案.doc", "c:\\a\\t");
  
 }
}

if 的命令行帮助中关于此点的描述为:
  IF [NOT] string1==string2 command
在此有以下几点需要注意:
  1. 包含字符串的双引号不是语法所必须的, 而只是习惯上使用的一种"防空"字符
  2. string1 未必是参数, 它也可以是环境变量, 循环变量以及其他字符串常量或变量
  3. command 不是语法所必须的, string2 后跟一个空格就可以构成一个有效的命令行
================================================================
2、if [not] exist [路径\]文件名 待执行的命令
如果有指定的文件，则条件成立，运行命令，否则运行下一句。
如: if exist c:\config.sys type c:\config.sys
表示如果存在c:\config.sys文件，则显示它的内容。
****** willsort 编注 ********
也可以使用以下的用法:
  if exist <device> command
device 是指DOS系统中已加载的设备, 在win98下通常有:
  AUX, PRN, CON, NUL
  COM1, COM2, COM3, COM4
 
   LPT1, LPT2, LPT3, LPT4
  XMSXXXX0, EMMXXXX0
  A: B: C: ...,
  CLOCK$, CONFIG$, DblBuff$, IFS$HLP$
具体的内容会因硬软件环境的不同而略有差异, 使用这些设备名称时, 需要保证以下三点:
  1. 该设备确实存在(由软件虚拟的设备除外)
  2. 该设备驱动程序已加载(aux, prn等标准设备由系统缺省定义)
  3. 该设备已准备好(主要是指a: b: ..., com1..., lpt1...等)
可通过命令 mem/d | find "device" /i 来检阅你的系统中所加载的设备
另外, 在DOS系统中, 设备也被认为是一种特殊的文件, 而文件也可以称作字符设备; 因为设备(device)与文件都是使用句柄(handle)来管理的, 句柄就是名字, 类似于文件名, 只不过句柄不是应用于磁盘管理, 而是应用于内存管理而已, 所谓设备加载也即指在内存中为其分配可引用的句柄.
================================================================
3、if errorlevel <数字> 待执行的命令
很多DOS程序在运行结束后会返回一个数字值用来表示程序运行的结果(或者状态)，通过if errorlevel命令可以判断程序的返回值，根据不同的返回值来决定执行不同的命令(返回值必须按照从大到小的顺序排列)。如果返回值等于指定的数字，则条件成立，运行命令，否则运行下一句。
如if errorlevel 2 goto x2
==== willsort 编注 ====================================================
返回值从大到小的顺序排列不是必须的, 而只是执行命令为 goto 时的习惯用法, 当使用 set 作为执行命令时, 通常会从小到大顺序排列, 比如需将返回码置入环境变量, 就需使用以下的顺序形式:
if errorlevel 1 set el=1
if errorlevel 2 set el=2
if errorlevel 3 set el=3
if errorlevel 4 set el=4
if errorlevel 5 set el=5
...
当然, 也可以使用以下循环来替代, 原理是一致的:
for %%e in (1 2 3 4 5 6 7 8...) do if errorlevel %%e set el=%%e
更高效简洁的用法, 可以参考我写的另一篇关于获取 errorlevel 的文章
出现此种现象的原因是, if errorlevel 比较返回码的判断条件并非等于, 而是大于等于. 由于 goto 的跳转特性, 由小到大排序会导致在较小的返回码处就跳出; 而由于 set命令的 "重复" 赋值特性, 由大到小排序会导致较小的返回码 "覆盖" 较大的返回码.
另外, 虽然 if errorlevel=<数字> command 也是有效的命令行, 但也只是 command.com 解释命令行时将 = 作为命令行切分符而忽略掉罢了
================================================================
二、goto 批处理文件运行到这里将跳到goto所指定的标号(标号即label，标号用:后跟标准字符串来定义)处，goto语句一般与if配合使用，根据不同的条件来执行不同的命令组。
如:
goto end
:end
echo this is the end
标号用“:字符串”来定义，标号所在行不被执行。
==== willsort 编注 ====================================================
label 常被译为 "标签" , 但是这并不具有广泛的约定性.
goto <label> 与 :<label> 联用可实现执行中途的跳转, 再结合 if 可实现执行过程的条件分支, 多个 if 即可实现命令的分组, 类似 C 中 switch case 结构或者 Basic 中的 select case 结构, 大规模且结构化的命令分组即可实现高级语言中的函数功能. 以下是批处理和C/Basic在语法结构上的对照:
  Batch           C / Basic
  goto&:           goto&:
  goto&:&if         if{}&else{} / if&elseif&endif
  goto&:&if...       switch&case / select case
  goto&:&if&set&envar...   function() / function(),sub()
================================================================
三、choice 使用此命令可以让用户输入一个字符（用于选择），从而根据用户的选择返回不同的errorlevel，然后于if errorlevel配合，根据用户的选择运行不同的命令。
 
 注意：choice命令为DOS或者Windows系统提供的外部命令，不同版本的choice命令语法会稍有不同，请用choice /?查看用法。
choice的命令语法（该语法为Windows 2003中choice命令的语法，其它版本的choice的命令语法与此大同小异）：
CHOICE [/C choices] [/N] [/CS] [/T timeout /D choice] [/M text]
描述:
该工具允许用户从选择列表选择一个项目并返回所选项目的索引。
参数列表:
/C   choices   指定要创建的选项列表。默认列表是 "YN"。
/N         在提示符中隐藏选项列表。提示前面的消息得到显示，
        选项依旧处于启用状态。
/CS       允许选择分大小写的选项。在默认情况下，这个工具
        是不分大小写的。
/T   timeout   做出默认选择之前，暂停的秒数。可接受的值是从 0
        到 9999。如果指定了 0，就不会有暂停，默认选项
        会得到选择。
/D   choice   在 nnnn 秒之后指定默认选项。字符必须在用 /C 选
        项指定的一组选择中; 同时，必须用 /T 指定 nnnn。
/M   text     指定提示之前要显示的消息。如果没有指定，工具只
        显示提示。
/?         显示帮助消息。
注意:
ERRORLEVEL 环境变量被设置为从选择集选择的键索引。列出的第一个选
择返回 1，第二个选择返回 2，等等。如果用户按的键不是有效的选择，
该工具会发出警告响声。如果该工具检测到错误状态，它会返回 255 的
ERRORLEVEL 值。如果用户按 Ctrl+Break 或 Ctrl+C 键，该工具会返回 0
的 ERRORLEVEL 值。在一个批程序中使用 ERRORLEVEL 参数时，将参数降
序排列。
示例:
CHOICE /?
CHOICE /C YNC /M "确认请按 Y，否请按 N，或者取消请按 C。"
CHOICE /T 10 /C ync /CS /D y
CHOICE /C ab /M "选项 1 请选择 a，选项 2 请选择 b。"
CHOICE /C ab /N /M "选项 1 请选择 a，选项 2 请选择 b。"
==== willsort 编注 ====================================================
我列出win98下choice的用法帮助, 已资区分
Waits for the user to choose one of a set of choices.
等待用户选择一组待选字符中的一个
CHOICE [/C[:]choices] [/N] [/S] [/T[:]c,nn] [text]
/C[:]choices Specifies allowable keys. Default is YN
    指定允许的按键(待选字符), 默认为YN
/N     Do not display choices and ? at end of prompt string.
    不显示提示字符串中的问号和待选字符
/S     Treat choice keys as case sensitive.
    处理待选字符时大小写敏感
/T[:]c,nn   Default choice to c after nn seconds
    在 nn 秒后默认选择 c
text     Prompt string to display
    要显示的提示字符串
ERRORLEVEL is set to offset of key user presses in choices.
ERRORLEVEL 被设置为用户键入的字符在待选字符中的偏移值
================================================================
如果我运行命令：CHOICE /C YNC /M "确认请按 Y，否请按 N，或者取消请按 C。"
屏幕上会显示：
确认请按 Y，否请按 N，或者取消请按 C。 [Y,N,C]?

例：test.bat的内容如下（注意，用if errorlevel判断返回值时，要按返回值从高到低排列）:
@echo off
choice /C dme /M "defrag,mem,end"
if errorlevel 3 goto end
if errorlevel 2 goto mem
if errorlevel 1 goto defrag
:defrag
c:\dos\defrag
goto end
:mem
mem
goto end
:end
echo good bye
此批处理运行后，将显示“defrag,mem,end[D,M,E]?” ，用户可选择d m e ，然后if语句根据用户的选择作出判断，d表示执行标号为defrag的程序段，m表示执行标号为mem的程序段，e表示执行标号为end的程序段，每个程序段最后都以goto end将程序跳到end标号处，然后程序将显示good bye，批处理运行结束。
 
 四、for 循环命令，只要条件符合，它将多次执行同一命令。
语法：
对一组文件中的每一个文件执行某个特定命令。
FOR %%variable IN (set) DO command [command-parameters]
%%variable 指定一个单一字母可替换的参数。
(set)   指定一个或一组文件。可以使用通配符。
command   指定对每个文件执行的命令。
command-parameters
    为特定命令指定参数或命令行开关。
例如一个批处理文件中有一行:
for %%c in (*.bat *.txt) do type %%c
则该命令行会显示当前目录下所有以bat和txt为扩展名的文件的内容。
==== willsort 编注 ====================================================
需要指出的是, 当()中的字符串并非单个或多个文件名时, 它将单纯被当作字符串替换, 这个特性再加上()中可以嵌入多个字符串的特性, 很明显 for 可以被看作一种遍历型循环.
当然, 在 nt/2000/xp/2003 系列的命令行环境中, for 被赋予了更多的特性, 使之可以分析命令输出或者文件中的字符串, 也有很多开关被用于扩展了文件替换功能.
===============================================================＝
批处理示例
1. IF-EXIST
1) 首先用记事本在C:\建立一个test1.bat批处理文件，文件内容如下：
@echo off
IF EXIST \AUTOEXEC.BAT TYPE \AUTOEXEC.BAT
IF NOT EXIST \AUTOEXEC.BAT ECHO \AUTOEXEC.BAT does not exist
然后运行它：
C:\>TEST1.BAT
如果C:\存在AUTOEXEC.BAT文件，那么它的内容就会被显示出来，如果不存在，批处理就会提示你该文件不存在。
2) 接着再建立一个test2.bat文件，内容如下：
@ECHO OFF
IF EXIST \%1 TYPE \%1
IF NOT EXIST \%1 ECHO \%1 does not exist
执行:
C:\>TEST2 AUTOEXEC.BAT
该命令运行结果同上。
说明：
(1) IF EXIST 是用来测试文件是否存在的，格式为
IF EXIST [路径+文件名] 命令
(2) test2.bat文件中的%1是参数，DOS允许传递9个批参数信息给批处理文件，分别为%1~%9(%0表示test2命令本身) ，这有点象编程中的实参和形参的关系，%1是形参，AUTOEXEC.BAT是实参。
==== willsort 编注 ====================================================
DOS没有 "允许传递9个批参数信息" 的限制, 参数的个数只会受到命令行长度和所调用命令处理能力的限制. 但是, 我们在批处理程序中, 在同一时刻只能同时引用10个参数, 因为 DOS只给出了 %0~%9这十个参数引用符.
================================================================
3) 更进一步的，建立一个名为TEST3.BAT的文件，内容如下：
@echo off
IF "%1" == "A" ECHO XIAO
IF "%2" == "B" ECHO TIAN
IF "%3" == "C" ECHO XIN
如果运行：
C:\>TEST3 A B C
屏幕上会显示:
XIAO
TIAN
XIN
如果运行：
C:\>TEST3 A B
屏幕上会显示
XIAO
TIAN
在这个命令执行过程中，DOS会将一个空字符串指定给参数%3。
2、IF-ERRORLEVEL
建立TEST4.BAT，内容如下：
@ECHO OFF
XCOPY C:\AUTOEXEC.BAT D:\
IF ERRORLEVEL 1 ECHO 文件拷贝失败
IF ERRORLEVEL 0 ECHO 成功拷贝文件
然后执行文件:
C:\>TEST4
如果文件拷贝成功，屏幕就会显示“成功拷贝文件”，否则就会显示“文件拷贝失败”。
IF ERRORLEVEL 是用来测试它的上一个DOS命令的返回值的，注意只是上一个命令的返回值，而且返回值必须依照从大到小次序顺序判断。
因此下面的批处理文件是错误的：
@ECHO OFF
XCOPY C:\AUTOEXEC.BAT D:\
IF ERRORLEVEL 0 ECHO 成功拷贝文件
IF ERRORLEVEL 1 ECHO 未找到拷贝文件
IF ERRORLEVEL 2 ECHO 用户通过ctrl-c中止拷贝操作
IF ERRORLEVEL 3 ECHO 预置错误阻止文件拷贝操作
IF ERRORLEVEL 4 ECHO 拷贝过程中写盘错误
无论拷贝是否成功，后面的：
未找到拷贝文件
用户通过ctrl-c中止拷贝操作
 
 预置错误阻止文件拷贝操作
拷贝过程中写盘错误
都将显示出来。
以下就是几个常用命令的返回值及其代表的意义：
backup
0 备份成功
1 未找到备份文件
2 文件共享冲突阻止备份完成
3 用户用ctrl-c中止备份
4 由于致命的错误使备份操作中止
diskcomp
0 盘比较相同
1 盘比较不同
2 用户通过ctrl-c中止比较操作
3 由于致命的错误使比较操作中止
4 预置错误中止比较
diskcopy
0 盘拷贝操作成功
1 非致命盘读/写错
2 用户通过ctrl-c结束拷贝操作
3 因致命的处理错误使盘拷贝中止
4 预置错误阻止拷贝操作
format
0 格式化成功
3 用户通过ctrl-c中止格式化处理
4 因致命的处理错误使格式化中止
5 在提示“proceed with format（y/n）?”下用户键入n结束
xcopy
0 成功拷贝文件
1 未找到拷贝文件
2 用户通过ctrl-c中止拷贝操作
4 预置错误阻止文件拷贝操作
5 拷贝过程中写盘错误
==== willsort 编注 ====================================================
chkdsk
0   未找到错误
255 找到一个或多个错误
choice
0   用户按下ctrl+c/break
1   用户按下第一个键
255 检测到命令行中的错误条件
其它 用户按下的有效字符在列表中的位置
defrag
0   碎片压缩成功
1   出现内部错误
2   磁盘上没有空簇。要运行DEFRAG，至少要有一个空簇
3   用户用Ctrl+C退出了DEFRAG
4   出现一般性错误
5   DEFRAG在读簇时遇到错误
6   DEFRAG在写簇时遇到错误
7   分配空间有错
8   内存错
9   没有足够空间来压缩磁盘碎片
deltree
0   成功地删除一个目录
diskcomp
0   两盘相同
1   发现不同
2   按CTRL+C 终止了比较
3   出现严重错误
4   出现初始化错误
find
0   查找成功且至少找到了一个匹配的字符串
1   查找成功但没找到匹配的字符串
2   查找中出现了错误
keyb
0   键盘定义文件装入成功
1   使用了非法的键盘代码，字符集或语法
2   键盘定义文件坏或未找到
4   键盘、监视器通讯时出错
5   要求的字符集未准备好
move
0   成功地移动了指定的文件
1   发生了错误
msav /N
86   检查到了病毒
replace
0   REPLACE成功地替换或加入了文件
1   MS-DOS版本和REPLACE不兼容
2   REPLACE找不到源文件
3   REPLACE找不到源路径或目标路径
5   不能存取要替换的文件
8   内存不够无法执行REPLACE
11   命令行句法错误
restore
0   RESTORE成功地恢复了文件
1   RESTORE找不到要恢复的文件
3   用户按CTRL+C终止恢复过程
4   RESTORE因错误而终止
scandisk
0   ScanDisk在它检查的驱动器上未检测到任何错误
1   由于命令行的语法不对，不能运行ScanDisk
2   由于内存用尽或发生内部错误，ScanDisk意外终止
3   用户让ScanDisk中途退出
4   进行盘面扫描时，用户决定提前退出
254 ScanDisk找到磁盘故障并已全部校正
255 ScanDisk找到磁盘故障，但未能全部校正
setver
0   SETVER成功地完成了任务
1   用户指定了一个无效的命令开关
2   用户指定了一个非法的文件名
3   没有足够的系统内存来运行命令
4   用户指定了一个非法的版本号格式
5   SETVER在版本表中未找到指定的项
6   SETVER未找到SETVER.EXE文件
7   用户指定了一个非法的驱动器
8   用户指定了太多的命令行参数
9   SETVER检测到丢失了命令行参数
10   在读SETVER.EXE文件时，SETVER检测到发生错误
11   SETVER.EXE文件损坏
12   指定的SETVER.EXE文件不支持版本表
13   版本表中没有足够的空间存放新的项
14   在写SETVER.EXE文件时SETVER检测到发生错误
================================================================
3、IF STRING1 == STRING2
建立TEST5.BAT，文件内容如下：
@echo off
IF "%1" == "A" FORMAT A:
执行：
C:\>TEST5 A
屏幕上就出现是否将A:盘格式化的内容。
注意：为了防止参数为空的情况，一般会将字符串用双引号（或者其它符号，注意不能使用保留符号）括起来。
如：if [%1]==[A] 或者 if %1*==A*
5、GOTO
建立TEST6.BAT，文件内容如下：
@ECHO OFF
IF EXIST C:\AUTOEXEC.BAT GOTO _COPY
GOTO _DONE
:_COPY
COPY C:\AUTOEXEC.BAT D:\
:_DONE
注意：
(1) 标号前是ASCII字符的冒号":"，冒号与标号之间不能有空格。
(2) 标号的命名规则与文件名的命名规则相同。
(3) DOS支持最长八位字符的标号，当无法区别两个标号时，将跳转至最近的一个标号。
==== willsort 编注 ====================================================
1)标号也称作标签(label)
2)标签不能以大多数的非字母数字字符开始, 而文件名中则可以使用很多
3)当无法区别两个标签时, 将跳转至位置最靠前的标签
================================================================
6、FOR
建立C:\TEST7.BAT，文件内容如下：
@ECHO OFF
FOR %%C IN (*.BAT *.TXT *.SYS) DO TYPE %%C
运行：
C:\>TEST7
执行以后，屏幕上会将C:盘根目录下所有以BAT、TXT、SYS为扩展名的文件内容显示出来（不包括隐藏文件）。 
 

        StringBuffer sb = new StringBuffer();
        sb.append(ca);
        return sb.toString();
    }
    public String mix(String str1)
    {
     int MAX_COUNT = 20;
        char ca[] = str1.toCharArray();
        int count = 0;
        for(int i = 0; i < ca.length; i++)
        {
         int a=0;
            a = ca[i] + count;
            ca[i] = (char)a;
            if(ca[i] > 'z')
                ca[i] -= '\032';
            count = ++count % MAX_COUNT;
        }

        StringBuffer sb = new StringBuffer();
        sb.append(ca);
        return sb.toString();
    }

    private Codecs()
    {
    }

    public static final byte[] base64Encode(byte abyte0[])
    {
        if(abyte0 == null)
            return null;
        byte abyte1[] = new byte[((abyte0.length + 2) / 3) * 4];
        int i = 0;
        int j = 0;
        for(; i < abyte0.length - 2; i += 3)
        {
            abyte1[j++] = Base64EncMap[abyte0[i] >>> 2 & 0x3f];
            abyte1[j++] = Base64EncMap[abyte0[i + 1] >>> 4 & 0xf | abyte0[i] << 4 & 0x3f];
            abyte1[j++] = Base64EncMap[abyte0[i + 2] >>> 6 & 3 | abyte0[i + 1] << 2 & 0x3f];
            abyte1[j++] = Base64EncMap[abyte0[i + 2] & 0x3f];
        }

        if(i < abyte0.length)
        {
            abyte1[j++] = Base64EncMap[abyte0[i] >>> 2 & 0x3f];
            if(i < abyte0.length - 1)
            {
                abyte1[j++] = Base64EncMap[abyte0[i + 1] >>> 4 & 0xf | abyte0[i] << 4 & 0x3f];
                abyte1[j++] = Base64EncMap[abyte0[i + 1] << 2 & 0x3f];
            } else
            {
                abyte1[j++] = Base64EncMap[abyte0[i] << 4 & 0x3f];
            }
        }
        for(; j < abyte1.length; j++)
            abyte1[j] = 61;

        return abyte1;
    }

    public static final byte[] base64Decode(byte abyte0[])
    {
        if(abyte0 == null)
            return null;
        int i;
        for(i = abyte0.length; abyte0[i - 1] == 61; i--);
        byte abyte1[] = new byte[i - abyte0.length / 4];
        for(int j = 0; j < abyte0.length; j++)
            abyte0[j] = Base64DecMap[abyte0[j]];

        int k = 0;
        int l;
        for(l = 0; l < abyte1.length - 2; l += 3)
        {
            abyte1[l] = (byte)(abyte0[k] << 2 & 0xff | abyte0[k + 1] >>> 4 & 3);
            abyte1[l + 1] = (byte)(abyte0[k + 1] << 4 & 0xff | abyte0[k + 2] >>> 2 & 0xf);
            abyte1[l + 2] = (byte)(abyte0[k + 2] << 6 & 0xff | abyte0[k + 3] & 0x3f);
            k += 4;
        }

        if(l < abyte1.length)
            abyte1[l] = (byte)(abyte0[k] << 2 & 0xff | abyte0[k + 1] >>> 4 & 3);
        if(++l < abyte1.length)
            abyte1[l] = (byte)(abyte0[k + 1] << 4 & 0xff | abyte0[k + 2] >>> 2 & 0xf);
        return abyte1;
    }

    private static byte Base64EncMap[];
    private static byte Base64DecMap[];

    static
    {
        byte abyte0[] = {
            65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
            75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
            85, 86, 87, 88, 89, 90, 97, 98, 99, 100,
            101, 102, 103, 104, 105, 106, 107, 108, 109, 110,
            111, 112, 113, 114, 115, 116, 117, 118, 119, 120,
            121, 122, 48, 49, 50, 51, 52, 53, 54, 55,
            56, 57, 43, 47
        };
        Base64EncMap = abyte0;
        Base64DecMap = new byte[128];
        for(int i = 0; i < Base64EncMap.length; i++)
            Base64DecMap[Base64EncMap[i]] = (byte)i;

    }
}

import java.io.UnsupportedEncodingException;

public final class SignableBlock
{

    private SignableBlock()
    {
    }

    public static byte[] createSignableBlock(String as[])
        throws UnsupportedEncodingException
    {
        StringBuffer stringbuffer = new StringBuffer(256);
        for(int i = 0; i < as.length; i++)
            stringbuffer.append(as[i]);

        return stringbuffer.toString().getBytes("UTF-8");
    }
}

import java.io.UnsupportedEncodingException;
import java.security.*;

final class ValidateSignature
{

    private ValidateSignature()
    {
    }
   
    public static void main(String[] args)
    {
     String[] as = {"qq:8117892","www.blogjava.net/galaxyp","DSA数字签名"};
     String s = "MCwCFFSpNp/n4Mq24FDXyVkk/kr815yHAhQO0TLslIJOqUes4OFn0ARvFaAVOw==";
     try{
      System.out.println(validateSignature(as,s));
     }catch(Exception e){}
    }

    private static boolean validate(byte abyte0[], byte abyte1[])
    {
        Signature signature = null;
        boolean flag = false;
        try
        {
         java.io.ObjectInputStream in=new java.io.ObjectInputStream(new java.io.FileInputStream("myprikey.dat"));
            PrivateKey prikey=(PrivateKey)in.readObject();
            in.close();
           
            java.io.ObjectInputStream in2=new java.io.ObjectInputStream(new java.io.FileInputStream("mypubkey.dat"));
            PublicKey pubkey=(PublicKey)in2.readObject();
            in2.close();
           
            signature = Signature.getInstance("SHA/DSA");
           
            signature.initSign(prikey);
            signature.update(abyte0);
            byte[] bt = signature.sign();
            String encode =new String(Codecs.base64Encode(bt),"UTF-8");
            System.out.println(encode);
           
            signature.initVerify(pubkey);
            signature.update(abyte0);
           
            flag = signature.verify(abyte1);
        }
        catch(Exception e)
        { 
            return false;
        }
        return flag;
    }

    private static boolean validateSignatureBytes(String as[], byte abyte0[])
        throws UnsupportedEncodingException
    {
        byte abyte1[] = SignableBlock.createSignableBlock(as);
        return validate(abyte1, abyte0);
    }

    public static boolean validateSignature(String as[], String s)
        throws UnsupportedEncodingException
    {
        byte abyte0[];
        try
        {
            abyte0 = Codecs.base64Decode(s.getBytes("UTF-8"));
        }
        catch(ArrayIndexOutOfBoundsException arrayindexoutofboundsexception)
        {
            return false;
        }
        return validateSignatureBytes(as, abyte0);
    }
}

       ASA 是 Sybase 的一个本地数据库，但它也可以发布为 Open Server 模式，这样客户端就可以通过网络访问安装在不同机器上的 ASA 数据库。当然，服务端也不一定要安装 ASA 数据库，你可以拷贝一些必要的动态库和 EXE 文件，再写一些注册表信息，这样，一样精简的 ASA 数据库就可以远行起来。

       默认情况下，客户端连接处在网络中的 ASA 数据库会以广播包形式查找和连接数据库。因此，如果客户端和服务端不在同一网段，即跨越路由设备，客户端将无法连接到数据库。这时我们需要配置连接参数，让数据库连接以单播方式进行。

服务端的启动参数配置：

dbsrv7.exe Datafile -n Servername -x TCPIP{host=ServerIP} –Q

客户端连接参数配置

CommLinks TCPIP{host=ServerIP,DOBROADCAST=NO}

       Datafile ——数据库文件名，可以包函路径

       Servername ——数据库服务发布名称

       ServerIP ——数据库服务器所在机器的 IP

       通过上面的配置，客户端和服务端可以处在不同的网段。但服务器同一子网只能发布一个数据库服务器，当有多个数据库要发布时，要通过其它一些参数方能发布。具体可以参数 ASA 的管理手册