MyEclipse5.5的破解方法

     MyEclipse5.5推出有一段时间了,但是网上一直都没有破解的文件,通过今天跟公司几个同事的努力尝试终于找到破解的方法了,说起来比较可笑,我们经过好多次的尝试,最后用MyEclipse4.1的破解文件就可以破解MyEclipse5.5了,我们用的MyEclipse5.5的版本是MyEclipse_5.5M2_E3.2.2,Eclipse的版本是eclipse3.2.2大家可以尝试一下.

在此特别要说明一下的是运行MyEclipse4.1的时候要选择MyEclipse4.1&4.2 GA这个选择才可以破解如图


MyEclipse_5.5M2_E3.2.2的官方下载地址 : http://www.myeclipseide.com/ContentExpress-display-ceid-110.html
MyEclipse4.1破解文件下载

posted @ 2007-04-17 18:11 nbt 阅读(9269) | 评论 (29) | 编辑 收藏

解决运行eclipse内存不足的问题

    最近在用eclipse的时候，过上一会老弹出一个对话框，提示内存不足（大意），找了好多资料都没有解决，最近在eclipse的官方网站上找到了其解决的办法，希望对像我一样的朋友有帮助，解决方法如下，
在桌面上建一个启动eclipse的快捷方式，在该快捷方式上单击右键，在常规标签的目标中加入下面的内容：

E:\eclipse\eclipse.exe -clean -vmargs -Xms128M -Xmx512M -XX:PermSize=64M -XX:MaxPermSize=128M，其中“E:\eclipse\eclipse.exe” 是我eclipse的路径。

然后重启你的eclipse试试！ 

posted @ 2007-03-02 12:08 nbt 阅读(6622) | 评论 (9) | 编辑 收藏

ASP.NET2.0的写访问权限

在IIS中 发布程序一个ASP.NET程序，通过IE访问报如下错误：

当前标识(NT AUTHORITY\NETWORK SERVICE)没有对“C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\Temporary ASP.NET Files”的写访问权限。
说明: 执行当前 Web 请求期间，出现未处理的异常。请检查堆栈跟踪信息，以了解有关该错误以及代码中导致错误的出处的详细信息。

异常详细信息: System.Web.HttpException: 当前标识(NT AUTHORITY\NETWORK SERVICE)没有对“C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\Temporary ASP.NET Files”的写访问权限。

翻阅了一些资料后发现是需要重新注册IIS服务扩展, 解决方法如下:

在“开始”-“运行”里输入如入命令，回车，搞定

C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\aspnet_regiis -i -enable

posted @ 2007-02-13 10:36 nbt 阅读(492) | 评论 (0) | 编辑 收藏

JSTL详解(九)

     摘要: 9.9  完整示例 ...  阅读全文

posted @ 2007-01-18 15:22 nbt 阅读(3705) | 评论 (1) | 编辑 收藏

JSTL详解(八)

     摘要: 9.8 Struts 与 ...  阅读全文

posted @ 2007-01-18 15:21 nbt 阅读(3959) | 评论 (1) | 编辑 收藏

JSTL详解(七)

9.7 Functions 标签库

称呼 Functions 标签库为标签库，倒不如称呼其为函数库来得更容易理解些。因为 Functions 标签库并没有提供传统的标签来为 JSP 页面的工作服务，而是被用于 EL 表达式语句中。在 JSP2.0 规范下出现的 Functions 标签库为 EL 表达式语句提供了许多更为有用的功能。 Functions 标签库分为两大类，共 16 个函数。

q         长度函数： fn:length

q         字符串处理函数： fn:contains 、 fn:containsIgnoreCase 、 fn:endsWith 、 fn:escapeXml 、 fn:indexOf 、 fn:join 、 fn:replace 、 fn:split 、 fn:startsWith 、 fn:substring 、 fn:substringAfter 、 fn:substringBefore 、 fn:toLowerCase 、 fn:toUpperCase 、 fn:trim

以下是各个函数的用途和属性以及简单示例。

9.7.1  长度函数 fn:length 函数

长度函数 fn:length 的出现有重要的意义。在 JSTL1.0 中，有一个功能被忽略了，那就是对集合的长度取值。虽然 java.util.Collection 接口定义了 size 方法，但是该方法不是一个标准的 JavaBean 属性方法（没有 get,set 方法），因此，无法通过 EL 表达式“ ${collection.size} ”来轻松取得。

fn:length 函数正是为了解决这个问题而被设计出来的。它的参数为 input ，将计算通过该属性传入的对象长度。该对象应该为集合类型或 String 类型。其返回结果是一个 int 类型的值。下面看一个示例。

<%ArrayList arrayList1 = new ArrayList();

                            arrayList1.add("aa");

                            arrayList1.add("bb");

                            arrayList1.add("cc");

%>

<%request.getSession().setAttribute("arrayList1", arrayList1);%>

${fn:length(sessionScope.arrayList1)}

假设一个 ArrayList 类型的实例“ arrayList1 ”，并为其添加三个字符串对象，使用 fn:length 函数后就可以取得返回结果为“ 3 ”。

9.7.2  判断函数 fn:contains 函数

fn:contains 函数用来判断源字符串是否包含子字符串。它包括 string 和 substring 两个参数，它们都是 String 类型，分布表示源字符串和子字符串。其返回结果为一个 boolean 类型的值。下面看一个示例。

${fn:contains("ABC", "a")}<br>

${fn:contains("ABC", "A")}<br>

前者返回“ false ”，后者返回“ true ”。

9.7.3 fn:containsIgnoreCase 函数

fn:containsIgnoreCase 函数与 fn:contains 函数的功能差不多，唯一的区别是 fn:containsIgnoreCase 函数对于子字符串的包含比较将忽略大小写。它与 fn:contains 函数相同，包括 string 和 substring 两个参数，并返回一个 boolean 类型的值。下面看一个示例。

${fn:containsIgnoreCase("ABC", "a")}<br>

${fn:containsIgnoreCase("ABC", "A")}<br>

前者和后者都会返回“ true ”。

9.7.4  词头判断函数 fn:startsWith 函数

fn:startsWith 函数用来判断源字符串是否符合一连串的特定词头。它除了包含一个 string 参数外，还包含一个 subffx 参数，表示词头字符串，同样是 String 类型。该函数返回一个 boolean 类型的值。下面看一个示例。

${fn:startsWith ("ABC", "ab")}<br>

${fn:startsWith ("ABC", "AB")}<br>

前者返回“ false ”，后者返回“ true ”。

9.7.5  词尾判断函数 fn:endsWith 函数

fn:endsWith 函数用来判断源字符串是否符合一连串的特定词尾。它与 fn:startsWith 函数相同，包括 string 和 subffx 两个参数，并返回一个 boolean 类型的值。下面看一个示例。

${fn:endsWith("ABC", "bc")}<br>

${fn:endsWith("ABC", "BC")}<br>

前者返回“ false ”，后者返回“ true ”。

9.7.6  字符实体转换函数 fn:escapeXml 函数

fn:escapeXml 函数用于将所有特殊字符转化为字符实体码。它只包含一个 string 参数，返回一个 String 类型的值。

9.7.8  字符匹配函数 fn:indexOf 函数

fn:indexOf 函数用于取得子字符串与源字符串匹配的开始位置，若子字符串与源字符串中的内容没有匹配成功将返回“ -1 ”。它包括 string 和 substring 两个参数，返回结果为 int 类型。下面看一个示例。

${fn:indexOf("ABCD","aBC")}<br>

${fn:indexOf("ABCD","BC")}<br>

前者由于没有匹配成功，所以返回 -1 ，后者匹配成功将返回位置的下标，为 1 。

9.7.9  分隔符函数 fn:join 函数

fn:join 函数允许为一个字符串数组中的每一个字符串加上分隔符，并连接起来。它的参数、返回结果和描述如表 9.25 所示：

表 9.25 　 fn:join 函数

下面看一个示例。

<% String[] stringArray = {"a","b","c"}; %>

<%request.getSession().setAttribute("stringArray", stringArray);%>

${fn:join(sessionScope.stringArray,";")}<br>

定义数组并放置到 Session 中，然后通过 Session 得到该字符串数组，使用 fn:join 函数并传入分隔符“ ; ”，得到的结果为“ a;b;c ”。

9.7.10  替换函数 fn:replace 函数

fn:replace 函数允许为源字符串做替换的工作。它的参数、返回结果和描述如表 9.26 所示：

表 9.26 　 fn:replace 函数

参数	描述
inputString	源字符串。其类型必须为 String 类型
beforeSubstring	指定被替换字符串。其类型必须为 String 类型
afterSubstring	指定替换字符串。其类型必须为 String 类型
返回结果	返回一个 String 类型的值

下面看一个示例。

${fn:replace("ABC","A","B")}<br>

将“ ABC ”字符串替换为“ BBC ”，在“ ABC ”字符串中用“ B ”替换了“ A ”。

9.7.11  分隔符转换数组函数 fn:split 函数

fn:split 函数用于将一组由分隔符分隔的字符串转换成字符串数组。它的参数、返回结果和描述如表 9.27 所示：

表 9.27 　 fn:split 函数

参数	描述
string	源字符串。其类型必须为 String 类型
delimiters	指定分隔符。其类型必须为 String 类型
返回结果	返回一个 String[] 类型的值

下面看一个示例。

${fn:split("A,B,C",",")}<br>

将“ A,B,C ”字符串转换为数组 {A,B,C} 。

9.7.12  字符串截取函数 fn:substring 函数

fn:substring 函数用于截取字符串。它的参数、返回结果和描述如表 9.28 所示：

表 9.28 　 fn:substring 函数

参数	描述
string	源字符串。其类型必须为 String 类型
beginIndex	指定起始下标（值从 0 开始）。其类型必须为 int 类型
endIndex	指定结束下标（值从 0 开始）。其类型必须为 int 类型
返回结果	返回一个 String 类型的值

下面看一个示例。

${fn:substring("ABC","1","2")}<br>

截取结果为“ B ”。

9.7.14  起始到定位截取字符串函数 fn:substringBefore 函数

fn:substringBefore 函数允许截取源字符从开始到某个字符串。它的参数和 fn:substringAfter 函数相同，不同的是 substring 表示的是结束字符串。下面看一个示例。

${fn:substringBefore("ABCD","BC")}<br>

截取的结果为“ A ”。

9.7.15  小写转换函数 fn:toLowerCase 函数

fn:toLowerCase 函数允许将源字符串中的字符全部转换成小写字符。它只有一个表示源字符串的参数 string ，函数返回一个 String 类型的值。下面看一个示例。

${fn:toLowerCase("ABCD")}<br>

转换的结果为“ abcd ”。

9.7.16 大写转换函数 fn:toUpperCase 函数

fn:toUpperCase 函数允许将源字符串中的字符全部转换成大写字符。它与 fn:toLowerCase 函数相同，也只有一个 String 参数，并返回一个 String 类型的值。下面看一个示例。

${fn:toUpperCase("abcd")}<br>

转换的结果为“ ABCD ”。

9.7.17 空格删除函数 fn:trim 函数

fn:trim 函数将删除源字符串中结尾部分的“空格”以产生一个新的字符串。它与 fn:toLowerCase 函数相同，只有一个 String 参数，并返回一个 String 类型的值。下面看一个示例。

${fn:trim("AB C ")}D<br>

转换的结果为“ AB CD ”，注意，它将只删除词尾的空格而不是全部，因此“ B ”和“ C ”之间仍然留有一个空格。

posted @ 2007-01-18 15:19 nbt 阅读(3195) | 评论 (1) | 编辑 收藏

JSTL详解(六)

9.6  Database access 标签库

Database access 标签库中的标签用来提供在 JSP 页面中可以与数据库进行交互的功能，虽然它的存在对于早期纯 JSP 开发的应用以及小型的开发有着意义重大的贡献，但是对于 MVC 模型来说，它却是违反规范的。因为与数据库交互的工作本身就属于业务逻辑层的工作，所以不应该在 JSP 页面中出现，而是应该在模型层中进行。

对于 Database access 标签库本书不作重点介绍，只给出几个简单示例让读者略微了解它们的功能。

Database access 标签库有以下 6 组标签来进行工作： <sql:setDataSource> 、 <sql:query> 、 <sql:update> 、 <sql:transaction> 、 <sql:setDataSource> 、 <sql:param> 、 <sql:dateParam> 。

9.6.1  用于设置数据源的 <sql:setDataSource> 标签

<sql:setDataSource> 标签用于设置数据源，下面看一个示例：

<sql:setDataSource

         var="dataSrc"

         url="jdbc:postgresql://localhost:5432/myDB"

         driver="org.postgresql.Driver"

         user="admin"

         password="1111"/>

该示例定义一个数据源并保存在“ dataSrc ”变量内。

9.6.2  用于查询的 <sql:query> 标签

<sql:query> 标签用于查询数据库，它标签体内可以是一句查询 SQL 。下面看一个示例：

<sql:query var="queryResults" dataSource="${dataSrc}">

      select * from table1

</sql:query>

该示例将返回查询的结果到变量“ queryResults ”中，保存的结果是 javax.servlet.jsp.jstl.sql.Result 类型的实例。要取得结果集中的数据可以使用 <c:forEach> 循环来进行。下面看一个示例。

<c:forEach var="row" items="${queryResults.rows}">

      <tr>

               <td>${row.userName}</td>

                   <td>${row.passWord}</td>

      </tr>

</c:forEach>

“ rows ”是 javax.servlet.jsp.jstl.sql.Result 实例的变量属性之一，用来表示数据库表中的“列”集合，循环时，通过“ ${row.XXX} ”表达式可以取得每一列的数据，“ XXX ”是表中的列名。

9.6.3  用于更新的 <sql:update> 标签

<sql:update> 标签用于更新数据库，它的标签体内可以是一句更新的 SQL 语句。其使用和 <sql:query> 标签没有什么不同。

9.6.4  用于事务处理的 <sql:transaction> 标签

<sql:transaction> 标签用于数据库的事务处理，在该标签体内可以使用 <sql:update> 标签和 <sql:query> 标签，而 <sql:transaction> 标签的事务管理将作用于它们之上。

<sql:transaction> 标签对于事务处理定义了 read_committed 、 read_uncommitted 、 repeatable_read 、 serializable4 个隔离级别。

9.6.5  用于事务处理的 <sql:param> 、 <sql:dateParam> 标签

posted @ 2007-01-18 15:18 nbt 阅读(2353) | 评论 (1) | 编辑 收藏

JSTL详解(五)

9.5  I18N formatting 标签库

看到 I18N 就应该想到知识“国际化”， I18N formatting 标签库就是用于在 JSP 页面中做国际化的动作。在该标签库中的标签一共有 12 个，被分为了两类，分别是：

q         国际化核心标签： <fmt:setLocale> 、 <fmt:bundle> 、 <fmt:setBundle> 、 <fmt:message> 、 <fmt:param> 、 <fmt:requestEncoding> 。

q         格式化标签： <fmt:timeZone> 、 <fmt:setTimeZone> 、 <fmt:formatNumber> 、 <fmt:parseNumber> 、 <fmt:formatDate> 、 <fmt:parseDate> 。

下面只选择其中常见的一些标签和属性进行介绍。

9.5.1  用于设置本地化环境的 <fmt:setLocale> 标签

<fmt:setLocale> 标签用于设置 Locale 环境。它的属性和描述如表 9.17 所示：

表 9.17 　 <fmt:setLocale> 标签属性和说明

下面看一个示例：

<fmt:setLocale value="zh_TW"/>

表示设置本地环境为繁体中文。

9.5.2  用于资源文件绑定的 <fmt:bundle> 、 <fmt:setBundle> 标签

这两组标签用于资源配置文件的绑定，唯一不同的是 <fmt:bundle> 标签将资源配置文件绑定于它标签体中的显示， <fmt:setBundle> 标签则允许将资源配置文件保存为一个变量，在之后的工作可以根据该变量来进行。

根据 Locale 环境的不同将查找不同后缀的资源配置文件，这点在国际化的任何技术上都是一致的，通常来说，这两种标签单独使用是没有意义的，它们都会与 I18N formatting 标签库中的其他标签配合使用。它们的属性和描述如表 9.18 所示：

表 9.18 　 <fmt:bundle> 、 <fmt:setBundle> 标签属性和说明

下面看一个示例

<fmt:setLocale value="zh_CN"/>

<fmt:setBundle basename="applicationMessage" var="applicationBundle"/>

该示例将会查找一个名为 applicationMessage_zh_CN.properties 的资源配置文件，来作为显示的 Resource 绑定。

9.5.3  用于显示资源配置文件信息的 <fmt:message> 标签

用于信息显示的标签，将显示资源配置文件中定义的信息。它的属性和描述如表 9.19 所示：

表 9.19 　 <fmt:message> 标签属性和说明

下面看一个示例：

<fmt:setBundle basename="applicationMessage" var="applicationBundle"/>

<fmt:bundle basename="applicationAllMessage">

         <fmt:message key="userName" />

         <p>

         <fmt:message key="passWord" bundle="${applicationBundle}" />

</fmt:bundle>

该示例使用了两种资源配置文件的绑定的做法，“ applicationMessage ”资源配置文件利用 <fmt:setBundle> 标签被赋于了变量“ applicationBundle ”，而作为 <fmt:bundle> 标签定义的“ applicationAllMessage ”资源配置文件作用于其标签体内的显示。

q         第一个 <fmt:message> 标签将使用“ applicationAllMessage ”资源配置文件中“键”为“ userName ”的信息显示。

q         第二个 <fmt:message> 标签虽然被定义在 <fmt:bundle> 标签体内，但是它使用了 bundle 属性，因此将指定之前由 <fmt:setBundle> 标签保存的“ applicationMessage ”资源配置文件，该“键”为“ passWord ”的信息显示。

9.5.4  用于参数传递的 <fmt:param> 标签

<fmt:param> 标签应该位于 <fmt:message> 标签内，将为该消息标签提供参数值。它只有一个属性 value 。

<fmt:param> 标签有两种使用版本，一种是直接将参数值写在 value 属性中，另一种是将参数值写在标签体内。

9.5.6  用于为请求设置字符编码的 <fmt:requestEncoding> 标签

<fmt:requestEncoding> 标签用于为请求设置字符编码。它只有一个属性 value ，在该属性中可以定义字符编码。

9.5.7  用于设定时区的 <fmt:timeZone> 、 <fmt:setTimeZone> 标签

这两组标签都用于设定一个时区。唯一不同的是 <fmt:timeZone> 标签将使得在其标签体内的工作可以使用该时区设置， <fmt:setBundle> 标签则允许将时区设置保存为一个变量，在之后的工作可以根据该变量来进行。它们的属性和描述如表 9.20 所示：

表 9.20 　 <fmt:timeZone> 、 <fmt:setTimeZone> 标签 属性和说明

9.5.8  用于格式化数字的 <fmt:formatNumber> 标签

<fmt: formatNumber > 标 签用于格式化数字。它的属性和描述如表 9.21 所示：

表 9.21 　 <fmt:formatNumber> 标签属性和说明

<fmt:formatNumber> 标签实际是对应 java.util.NumberFormat 类， type 属性的可能值包括 currency （货币）、 number （数字）和 percent （百分比）。

下面看一个示例。

<fmt:formatNumber value="1000.888" type="currency" var="money"/>

9.5.9  用于解析数字的 <fmt:parseNumber> 标签

<fmt:parseNumber> 标签用于解析一个数字，并将结果作为 java.lang.Number 类的实例返回。 <fmt:parseNumber> 标签看起来和 <fmt:formatNumber> 标签的作用正好相反。它的属性和描述如表 9.22 所示：

表 9.22 　 <fmt:parseNumber> 标签属性和说明

下面看一个示例。

<fmt:parseNumber value="15%" type="percent" var="num"/>

解析之后的结果为“ 0.15 ”。

9.5.10  用于格式化日期的 <fmt:formatDate> 标签

<fmt:formatDate> 标签用于格式化日期。它的属性和描述如表 9.23 所示：

表 9.23 　 <fmt:formatDate> 标签属性和说明

<fmt:formatDate> 标签与 <fmt:timeZone> 、 <fmt:setTimeZone> 两组标签的关系密切。若没有指定 timeZone属性， 也可以通过 <fmt:timeZone> 、 <fmt:setTimeZone> 两组标签设定的时区来格式化最后的结果。

9.5.11  用于解析日期的 <fmt:parseDate> 标签

<fmt:parseDate> 标签用于解析一个日期，并将结果作为 java.lang.Date 类型的实例返回。 <fmt:parseDate> 标签看起来和 <fmt:formatDate> 标签的作用正好相反。它的属性和描述如表 9.24 所示：

表 9.24 　 <fmt:parseDate> 标签属性和说明

<fmt:parseNumber> 和 <fmt:parseDate> 两组标签都实现解析字符串为一个具体对象实例的工作，因此，这两组解析标签对 var 属性的字符串参数要求非常严格。就 JSP 页面的表示层前段来说，处理这种解析本不属于份内之事，因此 <fmt:parseNumber> 和 <fmt:parseDate> 两组标签应该尽量少用，替代工作的地方应该在服务器端表示层的后段，比如在 Servlet 中。

posted @ 2007-01-18 15:17 nbt 阅读(3670) | 评论 (0) | 编辑 收藏

JSTL详解(四)

     摘要: 9.3.9  用于包含页面的 <c:import> ...  阅读全文

posted @ 2007-01-18 11:45 nbt 阅读(3706) | 评论 (0) | 编辑 收藏

JSTL详解(三)

     摘要: 9.3.2  用于赋值的 <c:set> ...  阅读全文

posted @ 2007-01-18 11:25 nbt 阅读(3360) | 评论 (0) | 编辑 收藏

JSTL详解(二)

     摘要: 9.2.3  EL 表达式的操作符 ...  阅读全文

posted @ 2007-01-18 10:02 nbt 阅读(5836) | 评论 (3) | 编辑 收藏

JSTL详解(一)

     摘要: 概述 ...  阅读全文

posted @ 2007-01-18 09:57 nbt 阅读(4250) | 评论 (1) | 编辑 收藏

jBPM3.12用户指南中文翻译----第五章 部署

 这是Jboss 的jBPM3.12框架的用户指南的中文翻译。我的翻译风格是中英文对照，只翻译部分我认为重要的，不翻译简单的英文，以免浪费你我的时间。 同时，对于其中的部分内容，我会在翻译中做出解释和写上我的理解。

Chapter 5. Deployment部署

jBPM is an embeddable BPM engine, which means that you can take jBPM and embed it into your own java project, rather then installing a separate product and integrate with it. One of the key aspects that make this possible is minimizing the dependencies. This chapter discusses the jbpm libraries and their dependencies.

   jBPM是一个嵌入式的BPM（业务程序管理）引擎。本章讨论jbpm库和它的依赖库。

5.1. Java runtime environment

jBPM 3 requires J2SE 1.4.2+

5.2. jBPM libraries

jbpm-[version].jar is the library with the core jbpm functionality.是jbpm的核心功能库。

jbpm-identity-[version].jar is the (optional) library containing an identity component as described in Section 11.11, “The identity component”.

可选的，这个库包含了身份验证组件。用于流程的参与者的管理。

5.3. Third party libraries第三方库

In a minimal deployment, you can create and run processes with jBPM by putting only the commons-logging and dom4j library in your classpath. Beware that persisting processes to a database is not supported. The dom4j library can be removed if you don't use the process xml parsing, but instead build your object graph programatically.

最小的jbpm部署，只需要核心jbpm库和commons-logging库，以及dom4j库到你的classpath中。此时，不支持持久化业务程序到数据库。

Table 5.1. 

Library库	Usage用途	Description描述	Directory目录
commons-logging.jar	logging in jbpm and hibernate	The jBPM code logs to commons logging. The commons logging library can be configured to dispatch the logs to e.g. java 1.4 logging, log4j, ... See the apache commons user guide for more information on how to configure commons logging. if you're used to log4j, the easiest way is to put the log4j lib and a log4j.properties in the classpath. commons logging will automatically detect this and use that configuration.	lib/jboss (from jboss 4.0.3)
dom4j-1.6.1.jar	process definitions and hibernate persistence	xml parsing	lib/dom4j

A typical deployment for jBPM will include persistent storage of process definitions and process executions. In that case, jBPM does not have any dependencies outside hibernate and its dependent libraries.

典型的jBPM部署包括持久化业务程序定义和执行的功能。 需要Hibernate

Of course, hibernate's required libraries depend on the environment and what features you use. For details refer to the hibernate documentation. The next table gives an indication for a plain standalone POJO development environment.

下面的表给出了简单的标准POJO部署环境需要的第三方库。

jBPM is distributed with hibernate 3.1 final. But it can also work with 3.0.x. In that case, you might have to update a few hibernate queries in the hibernate.queries.hbm.xml configuration file. For more info about customizing queries, see Section 7.6, “Customizing queries”

Table 5.2. 

Library库	Usage	Description	Directory
hibernate3.jar	hibernate persistence	the best O/R mapper	lib/hibernate (hibernate 3.1 final)
antlr-2.7.5H3.jar	used in query parsing by hibernate persistence	parser library	lib/jboss (from jboss 4.0.3)
cglib-2.1_2jboss.jar	hibernate persistence	reflection library used for hibernate proxies	lib/jboss (from jboss 4.0.3)
commons-collections.jar	hibernate persistence		lib/jboss (from jboss 4.0.3)
ehcache-1.1.jar	hibernate persistence (in the default configuration)	second level cache implementation.二级缓存实现。 When configuring a different cache provider for hibernate, this library is not required.	lib/hibernate
jaxen-1.1-beta-4.jar	process definitions and hibernate persistence	XPath library (used by dom4j)	lib/hibernate
jdbc2_0-stdext.jar	hibernate persistence		lib/hibernate
asm.jar	hibernate persistence	asm byte code library 二进制代码修改库	lib/hibernate
asm-attrs.jar	hibernate persistence	asm byte code library	lib/hibernate

The beanshell library is optional. If you don't include it, you won't be able to use the beanshell integration in the jbpm process language and you you'll get a log message saying that jbpm couldn't load the Script class and hence, the script element won't be available.

Beanshell库是可选的。

Table 5.3. 

Library	Usage	Description	Directory
bsh-1.3.0.jar	beanshell script interpreter	Only used in the script's and decision's. When you don't use these process elements, the beanshell lib can be removed, but then you have to comment out the Script.hbm.xml mapping line in the hibernate.cfg.xml	lib/jboss

posted @ 2006-10-08 18:25 nbt 阅读(1214) | 评论 (0) | 编辑 收藏

jBPM3.12用户指南中文翻译----第四章 面向图表编程

     摘要: 这是Jboss 的jBPM3.12框架的用户指南的中文翻译。我的翻译风格是中英文对照，只翻译部分我认为重要的，不翻译简单的英文，以免浪费你我的时间。 同时，对于其中的部分内容，我会在翻译中做出解释和写上我的理解。   Chapter 4. Graph Oriented Programming面向图表编程4.1. Introduction介绍This chapter can be conside...  阅读全文

posted @ 2006-10-08 18:22 nbt 阅读(1765) | 评论 (0) | 编辑 收藏

jBPM3.12用户指南中文翻译----第三章 指南

     摘要: 这是Jboss 的jBPM3.12框架的用户指南的中文翻译。我的翻译风格是中英文对照，只翻译部分我认为重要的，不翻译简单的英文，以免浪费你我的时间。       同时，对于其中的部分内容，我会在翻译中做出解释和写上我的理解。Chapter 3. Tutorial指南This tutorial will show you basic process constructs 过程建造in jpdl an...  阅读全文

posted @ 2006-10-08 18:19 nbt 阅读(1404) | 评论 (0) | 编辑 收藏

jBPM3.12用户指南中文翻译----第二章 起步

  这是Jboss 的jBPM3.12框架的用户指南的中文翻译。我的翻译风格是中英文对照，只翻译部分我认为重要的，不翻译简单的英文，以免浪费你我的时间。
       同时，对于其中的部分内容，我会在翻译中做出解释和写上我的理解。

Chapter 2. Getting started起步

This chapter takes you through the first steps of getting JBoss jBPM and provides the initial pointers to get up and running in no time.

初始化JBpm3.12

2.1. Downloadables Overview

Listed below are the different jBPM packages that are available today. Each of these packages contains one or more downloadable files. Along with each of these files goes a description of its contents and a pointer to any relevant installation instructions if they are available.

All downloads described below can be found on the sourceforge jbpm downloads page.

2.1.1. jBPM 3

Download JBoss jBPM 3 at sourceforge.net. This is the main distribution package containing the core engine and a number of additional modules that you may need to work with jBPM. 包括JBpm核心和其他包。

• The Starters Kit (jbpm-starters-kit-<version>.zip): If you want to get started with jBPM quickly, this is the file you want to download. It contains all the other modules of this package plus the graphical designer in one single download. Extract the zipped archive into a folder of your choice and read the file named 'readme.html' for more info and further installation instructions. With this starters kit you can immediately get started with the Chapter 3, Tutorial.

包含了包括图形化设计器在内的所有模块，能够帮助你快速启动。

• Core Engine and Identity Component (jbpm-<version>.zip): The download contains the jBPM core engine as well as the identity component for actor and group management. To start working with it, extract the archive into a folder of your choice. You will find pointers to the User's Guide and other important information resources in the 'readme.html' file in the 'jbpm-<version>' folder.

核心，包括核心引擎和身份组建，内有用户指南文档。

• Database Extensions (jbpm-db-<version>.zip):数据库扩展 The database extension pack contains the jBPM core engine as well as the identity component for actor and group management. To start working with it, extract the archive into a folder of your choice. You will find pointers to the User's Guide and other important information resources in the 'readme.html' file in the 'jbpm-<version>' folder.

2.1.2. jBPM Process Designer

jBPM过程设计器

Download JBoss jBPM Process Designer at sourceforge.net. The designer is an eclipse plugin and enables you to author 创作your process definitions过程定义 and to easily deploy them. The plug-in is available for download either as a zipped Eclipse feature or as a zipped Eclipse update site. There is no difference in content, the only difference is in the way you have to do the installation.

• Eclipse Update Site (jbpm-gpd-site-<version>.zip): If you want to be absolutely sure that the designer installation goes smoothly, we recommend to use the update site mechanism together with a new Eclipse installation. Of cource the Eclipse version should match the downloaded update site archive. To get started with the designer plugin, follow the instructions in the 'readme.html' file included in the archives root folder to succesfully install the GPD.

使用本地站点更新方式部署。

• Eclipse Feature (jbpm-gpd-feature-<version>.zip): If you are tired of each time having to do a fresh Eclipse installation and you are willing to cope with some possible issues, you can try the feature download. In this case installation is as easy as extracting the archive into your Eclipse installation (make sure the included 'plugins' and 'features' folders end up in the same location of your Eclipse installation) overwriting the files and folders with the same name that are possibly already present. This installation is very easy, but you could run into incompatibility issues when you overwrite plugins already present in your installation because of other features that you did install. Though they have the same name it could happen that the versions of these colliding plugins are not equal, hence the possible incompatibilities. The installation instructions are repeated in the 'readme.html' file.

这个是手工部署。

2.1.3. jBPM BPEL extension

Download JBoss jBPM BPEL extension at sourceforge.net. It contains only one file : jbpm-bpel-<version>.zip. To get started with the BPEL extensions, look in the User's Guide in the 'doc' subfolder of the toplevel folder.

jbpm-bpel：含有JBoss jBPM的BPEL扩展件方面的信息。

BPEL是一个规范的SOA组件。因为与JBoss jBPM使用的许可证不同，所以被独立了出来。

2.2. The JBoss jBPM project directory

• professional support: JBoss is the company that backs this project with professional support, training and consultancy services.
• user guide: is the document you're reading and serves as the main entry point into the project.
• forums: get in contact with the community, ask questions and discuss jBPM   论坛，社区。
• wiki: extra information, mostly provided by the community
• issue tracker: for submitting bugs and feature requests
• downloads: sourceforge download page for jBPM
• mailing lists: mailing lists are used for announcements
• javadocs: part of the download in the doc/javadoc directory.

2.3. CVS access

2.3.1. Anonymous CVS access

Alternatively, you can get JBoss jBPM from cvs with the following information:

• Connection type: pserver
• User: anonymous
• Host: anoncvs.forge.jboss.com
• Port: 2401 (which is the default)
• Repository path: /cvsroot/jbpm
• Label: :pserver:anonymous@anoncvs.forge.jboss.com:/cvsroot/jbpm

2.3.2. Developer CVS access

To get cvs developer access, you must sign contributors agreement and you need an ssh key. More information on both can be found on the JBoss cvs repository wiki page

• Connection type: ext over ssh (extssh in eclipse)
• User: sf.net username or jboss username
• Host: cvs.forge.jboss.com
• Port: 2401 (which is the default)
• Repository path: /cvsroot/jbpm
• Label: :pserver:anonymous@cvs.forge.jboss.com:/cvsroot/jbpm

posted @ 2006-10-08 18:16 nbt 阅读(2283) | 评论 (0) | 编辑 收藏

基于JBPM的工作流应用的开发

利用JBPM开发一个工作流应用，相对于使用shark是比较简单直观的。我们之前提到过，一个工作流管理系统最基本的组件包括流程定义组件，流程执行组件和流程客户端组件。下面从这三个方面看一下JBPM对开发工组流应用的支持。

1.   流程的定义

JBPM 没有采用WfMC提出的流程定义语言XPDL，而是自己开发了一种称为JPDL的语言来定义流程。因此，在开发一个应用时我们最终需要生成一个符合该XML schema的文件processdefinition.xml来表示定义好的流程。它可以manually获得，也可以使用可视化的定义工具自动生成。

JBPM 专门提供了一个开发流程的环境，称为process development environment(pde)。可以 在 jbpm 根目录下执行命令 ant create.pde 来生成 pde 工作目录 。生成的包结构如下所示：

         Build.xml 文件用于配置一个流程，即利 用 ant 工具解析 processdefinition.xml 文件，并将运行流程时所需的相关信息存储到数据库中。

Lib 存放了开发和配置流程所需的全部库文件，包括数据库的 jdbc 驱动。

Src 包括开发和配置流程的全部源文件和所需资源。

Src/config 只有两个文件， jbpm.properties 和 log4j.properties 。其中， jbpm.propertie 文件包含了数据库的配置信息。因此，更换数据库或数据库的 jdbc 驱动都需要修改这里。

Scr/java 存放 java 源文件。

Src/process 存放工作流定义文件 (processdefinition.xml) 和相关的资源文件，如图片和 form 文件。

Src/test 存放测试代码。

Target/classes 是 src/java 中源码的输出目录，存放编译后的 class 文件。

Target/par 存放用命令 ant build.process.archives 生成的 par 包。 Par 包实际上就是把 src/process 中的流程定义及相关文件打包成 zip 形式存储。

Target/test-classes 存放测试程序的编译结果。

Target/test-report 存放测试报告。

2.   流程的执行

JBPM 把负责执行流程的类库打包成jbpm.core.jar，它也是JBPM工作流引擎的核心。在开发一个工作流应用时，只需将该jar文件放到相应的lib目录下面。而开发人员就可以专注于开发一个流程模型，完成对流程的定义，而无需过多考虑流程执行的细节。

3.   流程的客户端

客户端组件的开发，需要一个应用服务器作为servlet container，我们这里选择了tomcat。JBPM将开发一个webapp所需的类打包成jbpm.web.jar，包括自定义的tag和Struts用到的类等等。开发应用时，将该jar放到WEB-INF\lib下面就可以了。

一个基于工作流的webapp应用的开发和普通webapp的开发方式很相似。包结构也保持一贯作风：

      
所以，我们需要做的主要工作是完成客户端应用所需的 jsp 页面的开发，可以选用 Struts 来进行开发。需要注意的是，我们要对 lib 目录下的 jbpm.properties 文件进行配置，主要是对数据库 jdbc 驱动的配置。

4.    系统数据库的创建

JBPM 可以支持多种数据库系统，包括MSSQL,，Mysql，Oracle，hdbsql等。它提供了很灵活的配置方式，只需要修改jbpm.properties文件，同时将相应的JDBC Driver拷贝到lib目录就可以了。利用ant的generate.ddl命令，JBPM还支持自动生成用于创建系统表的sql脚本，而且可以生成对应于各种数据库系统的脚本，非常便于数据库系统的更换和系统数据库的创建。

5.   开发过程

环境配置如下：

JBPM 2.0

Ant 1.6.2

Tomcat 5.0.27

SQL Server 2000

SQL Server 2000 Driver for JDBC

仍以之前演示过的request a payraise为例（见下图），介绍一下利用JBPM开发一个工作流应用需要完成的工作。

1)       首先，我们需要完成流程的定义。这不仅包括定义processdefinition.xml，还要对流程执行时使用到的其他资源进行定义。比如，在web应用中用到的图片，form等。还需要配置form.xml，该文件确定了流程中不同状态和form的关系，如request a payraise状态下，需要如下图所示的form：

 

补充Processdefinition.xml 示例：

 

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE process-definition PUBLIC "-//jBpm/jBpm Mapping DTD 2.0//EN" "http://jbpm.org/dtd/processdefinition-2.0.dtd">

<process-definition name="pay raise process">

<!-- SWIMLANES -->
<swimlane name="requester" />

    <swimlane name="boss">
    <delegation class="org.jbpm.delegation.assignment.ActorAssignmentHandler">cg</delegation>
</swimlane>

    <swimlane name="erp operator">
    <delegation class="org.jbpm.delegation.assignment.ActorAssignmentHandler">pf</delegation>
</swimlane>

<!-- START-STATE -->
  <start-state name="request a payraise" swimlane="requester">
    <transition to="evaluating"/>
  </start-state>

<!-- NODES -->
  <state name="evaluating">
    <assignment swimlane="boss" />
    <transition name="approve"     to="fork"/>
    <transition name="disapprove"  to="done"/>
  </state>
 
  <fork name="fork">
   <transition to="updating erp asynchronously" />
   <transition to="treating collegues on cake and pie" />
  </fork>

      <state name="updating erp asynchronously">
    <assignment swimlane="erp operator" />
    <transition to="join" />
  </state>

      <state name="treating collegues on cake and pie">
    <assignment swimlane="requester" />
    <transition to="join" />
  </state>
 
  <join name="join">
   <transition to="done" />
  </join>

<!-- END-STATE -->
  <end-state name="done" />

</process-definition>

 

2)       有了processdefinition.xml文件，我们就可以配置流程。即使用ant命令，解析这个文件并且将执行时需要的信息存储在数据库中。如下图：

3)       我们无需关心流程将怎么执行，完全交给jbpm.core.jar就好。

4)       剩下的另外一项比较繁重的工作就是开发一个用于该流程的客户端应用。前面已经提到过， 我们需要做的主要工作是完成客户端应用所需的 jsp 页面的开发。包括登录页面，查看自己的 tasklist 页面，执行 task 的页面等。除此之外，还可以通过日志来完成流程的监控和管理界面。这些都由应用的需求来决定。

posted @ 2006-10-08 18:14 nbt 阅读(1305) | 评论 (1) | 编辑 收藏

jBPM3.12用户指南中文翻译----第一章 绪论

       这是Jboss 的jBPM3.12框架的用户指南的中文翻译。其中第一章的译文，是我在网上找到的。其他几章都是我自己做的翻译。我的翻译是中英文对照，只翻译部分我认为重要的，不翻译简单的英文，以免浪费你我的时间。
       同时，对于其中的部分内容，我会在翻译中做出解释。
下面是从网络上找到的第一章，这是jBPM3.0的用户指南的译文。但是第一章，3.0和3.1内容相差不大，我就不做翻译了。直接使用这一篇。

目录

第一章绪论

 JBoss jBPM 是一个灵活的，易扩展的工作流管理系统。JBoss jBPM有一套直观的流程建模语言，这套语言能用任务（task），异步通信的等待状态（wait state ），定时器（timer），自动化的动作（automated action）等来图形化的表示业务流程。为了把这些操作集成在一

起，JBoss jBPM拥有强大的，易扩展的控制流程机制。

JBoss jBPM对外依赖程度很小，你完全可以像用java的类库一样用它。并且它也可以被部署在高性能的J2EE集群应用服务器上。

JBoss jBPM能配置在任何数据库上，并且能被部署在任何的应用服务器上。

1.1 总览

 工作流和业务流程处理功能的核心部分被打包成一个简单的java类库。这个类库包括了这样一个服务：流程信息的存储，更新，和从数据库中重新取回。

   

图1.1：JBoss jBPM组成模块的概略图

1.2 JBoss jBPM starter kit

starter kit是一个包含jbpm所有模块的下载包。这个下载包中包括以下模块：

·                                 jbpm-server, 一个预选配置好的jboss应用服务器。

·                                 jbpm-designer, 图形化定制流程的eclipse插件。

·                                 jbpm-db, jBPM的数据库兼容包 (见后边论述)。

·                                 jbpm, jbpm的核心模块，其中包括libs文件夹和这个用户说明。

·                                 jbpm-bpel, JBoss jBPM对BPEL扩展的一些参考资料

预先配置好的JBoss应用服务器具有如下组成部分：

jBPM核心模块，被打包成一个用于提供服务的存档文件

带有jbpm表的集成数据库：默认的hypersonic数据库拥有jbpm表，并且这个表已经拥有一个流程了。

Jbpm的web控制台，它既可以被Jbpm管理员用也可以被流程的参与者使用。

执行定时器的Jbpm的调度程序，这个调度程序在starter kit里边被配置成一个servlet。这个servlet会产生一个新的线程来监视和执行定时器。

一个具体流程的例子，它已经被部署在jbpm数据库中了。

1.3 JBoss jBPM 流程图形定制器

JBoss jBPM还拥有一套图形化的设计工具。这个设计器是一个图形化的业务流程定制工具。

JBoss jBPM流程图形定制器是eclipse的一个插件。单独安装这个定制器非常简单。

这个图形设计器最重要的特性是：业务分析人员也能像技术开发人员一样用它来完成任务。这使得业务流程建模能平滑的转换到具体技术实现。

这个插件可以利用eclipse的一般升级机制通过一个升级站点得到安装（zip文件格式）。也可以通过解压一个特定的包到eclipse的安装目录来安装此插件。

1.4 JBoss jBPM的核心模块

JBoss jBPM的核心模块是一个用来管理流程定义和流程实例的执行环境的普通java程序。

JBoss jBPM是一个java类库。所以它可以被用在任何java环境中，比如：web应用程序，swing应用程序，EJB，web service……。JBPM类库还可以被打包并被当成无状态会话EJB（stateless session EJB）使用。这样可使它被部署在集群上并且适应高性能应用。这些无状态会话EJB必须符合J2EE1.3规范这样才能使它可以被部署在任何应用服务器上。

JBoss jBPM的核心模块被打包成一个简单的java库文件。依你功能的需要，jbpm-3.0.jar这个库文件对一些第三方的类库比如hibernate, dom4j有所依赖。这些依赖在第五章（部署）中作了详细的说明。

至于持久化，JBPM在内部用了hibernate。除了传统的O/R映射功能，hibernate还解决了不同数据SQL dialect差异的问题，这使得JBPM能适应现在所有的数据库。

JBoss jBPM API可以被你工程中任何的java代码调用，比如，你的web应用程序，EJB，web service 模块，消息驱动bean或其它任何java模块。

1.5 JBoss jBPM web应用程序的控制台

jBPM web应用程序的控制台提供两种服务。首先，它被用来当作一个用来和流程执行过程中产生的任务进行交互的主要用户接口，其次，它还是一个用来检查和操作运行实例的管理和监控平台。

1.6 JBoss jBPM人员组织模块

JBoss jBPM可以和任何包括人员和其他组织信息的公司结构集成在一起。但是对那些组织结构信息模块很难获取的项目，JBoss jBPM提供了这个模块。这个模块使用的模型要比传统的servlet, ejb,portlet模型丰富的多。

更多信息，请参照第九章第九节人员组织模块

1.7 JBoss jBPM调度程序

JBoss jBPM调度程序是一个用来监测和执行在流程执行过程中设置的定时器的模块。

定时器模块被打包在jbpm的核心包中，但是它必须被部署在以下环境中：或者你必须订制一个调度servlet，它来产生一个监测线程，或者你必须启动一个单独的JVM来执行调度程序。

1.8 JBoss jBPM 数据库兼容包

JBoss jBPM 数据库兼容包是一个下载包，它包括所有的资料，drivers和scripts,用这些你可以使jbpm运行在你选择的数据库上。

1.9 JBoss jBPM BPE的扩展

JBoss jBPM BPE的扩展是一个为了支持BPEL独立的扩展包。BPEL的本质就是一组用来参照别的web service写web service的xml脚本语言。

posted @ 2006-10-08 18:11 nbt 阅读(1554) | 评论 (0) | 编辑 收藏

log4j的用法

posted @ 2006-10-07 13:53 nbt 阅读(714) | 评论 (0) | 编辑 收藏

C#导出Excel

     摘要: 网上反应比较强烈。本人也因为工作需要的原因，将其封装了成了ExcelManager。企业当中，做报表的数据来源肯定就是数据库了。该ExcelManager目前只提供Ms Sql Server的支持，因为我们公司使用的就是ms sql server 2000 了。封装后的ExcelManager，你只需传入你的报表表头（一级表头、二级表头。大部分有两级也就够了。如果你有多个，可自行修改该类.）,并将...  阅读全文

posted @ 2006-10-07 13:41 nbt 阅读(876) | 评论 (0) | 编辑 收藏

spring 生成Excel和PDF文件

posted @ 2006-10-07 13:29 nbt 阅读(625) | 评论 (0) | 编辑 收藏

Eclipse快速上手指南之使用Ant

                                    作者：佚名     来自：J2ME开发网

Ant是Java平台下非常棒的批处理命令执行程序，能自动完成编译，测试，打包，部署等等一系列任务。

　　Ant是Java平台下非常棒的批处理命令执行程序，能非常方便地自动完成编译，测试，打包，部署等等一系列任务，大大提高开发效率。如果你现在还没有开始使用Ant，那就要赶快开始学习使用，使自己的开发水平上一个新台阶。

　　Eclipse 中已经集成了Ant，我们可以直接在Eclipse中运行Ant。

　　以前面建立的Hello工程为例，创建以下目录结构：

　　新建一个build.xml，放在工程根目录下。build.xml定义了Ant要执行的批处理命令。虽然Ant也可以使用其它文件名，但是遵循标准能更使开发更规范，同时易于与别人交流。

　　通常，src存放Java源文件，classes存放编译后的class文件，lib存放编译和运行用到的所有jar文件，web存放JSP等web文件，dist存放打包后的jar文件，doc存放API文档。

　　然后在根目录下创建build.xml文件，输入以下内容：

<xml version="1.0"?>
<project name="Hello world" default="doc">

<-- properies -->
<property name="src.dir" value="src" />
<property name="report.dir" value="report" />
<property name="classes.dir" value="classes" />
<property name="lib.dir" value="lib" />
<property name="dist.dir" value="dist" />
<property name="doc.dir" value="doc"/>

<-- 定义classpath -->
<path id="master-classpath">
<fileset file="${lib.dir}/*.jar" />
<pathelement path="${classes.dir}"/>
<path>

<-- 初始化任务 -->
<target name="init">
<target>

<-- 编译 -->
<target name="compile" depends="init" description="compile the source files">
<mkdir dir="${classes.dir}"/>
<javac srcdir="${src.dir}" destdir="${classes.dir}" target="1.4">
<classpath refid="master-classpath"/>
<javac>
<target>

<-- 测试 -->
<target name="test" depends="compile" description="run junit test">
<mkdir dir="${report.dir}"/>
<junit printsummary="on"
haltonfailure="false"
failureproperty="tests.failed"
showoutput="true">
<classpath refid="master-classpath" />
<ormatter type="plain"/>
<batchtest todir="${report.dir}">
<fileset dir="${classes.dir}">
<include name="**/*Test.*"/>
<fileset>
<batchtest>
<junit>
<fail if="tests.failed">
***********************************************************
**** One or more tests failed! Check the output ... ****
***********************************************************
<fail/>
<target/>

<-- 打包成jar -->
<target name="pack" depends="test" description="make .jar file">
<mkdir dir="${dist.dir}" />
<jar destfile="${dist.dir}/hello.jar" basedir="${classes.dir}">
<xclude name="**/*Test.*" />
<xclude name="**/Test*.*" />
<jar/>
<targe/t>

<-- 输出api文档 -->
<target name="doc" depends="pack" description="create api doc">
<mkdir dir="${doc.dir}" />
<javadoc destdir="${doc.dir}"
author="true"
version="true"
use="true"
windowtitle="Test API">
<packageset dir="${src.dir}" defaultexcludes="yes">
<include name="example/**" />
<packageset/>
<doctitle>[CDATA[<1>ello, test<h1>]>doctitle>
<dottom>[CDATA[<>ll Rights Reserved.<i>]>bottom>
<tag name="todo" scope="all" description="To do:" />
<javadoc/>
<target/>
<project/>

　　以上xml依次定义了init（初始化），compile（编译），test（测试），doc（生成文档），pack（打包）任务，可以作为模板。

　　选中Hello工程，然后选择“Project”，“Properties”，“Builders”，“New…”，选择“Ant Build”：

　　填入Name：Ant_Builder；Buildfile：build.xml；Base Directory：${workspace_loc:/Hello}（按“Browse Workspace”选择工程根目录），由于用到了junit.jar包，搜索Eclipse目录，找到junit.jar，把它复制到Hello/lib目录下，并添加到Ant的Classpath中：

　　然后在Builder面板中钩上Ant_Build，去掉Java Builder：

　　再次编译，即可在控制台看到Ant的输出：

Buildfile: F:\eclipse-projects\Hello\build.xml

init:

compile:
[mkdir] Created dir: F:\eclipse-projects\Hello\classes
[javac] Compiling 2 source files to F:\eclipse-projects\Hello\classes

test:
[mkdir] Created dir: F:\eclipse-projects\Hello\report
[junit] Running example.HelloTest
[junit] Tests run: 1, Failures: 0, Errors: 0, Time elapsed: 0.02 sec

pack:
[mkdir] Created dir: F:\eclipse-projects\Hello\dist
[jar] Building jar: F:\eclipse-projects\Hello\dist\hello.jar

doc:
[mkdir] Created dir: F:\eclipse-projects\Hello\doc
[javadoc] Generating Javadoc
[javadoc] Javadoc execution
[javadoc] Loading source files for package example...
[javadoc] Constructing Javadoc information...
[javadoc] Standard Doclet version 1.4.2_04
[javadoc] Building tree for all the packages and classes...
[javadoc] Building index for all the packages and classes...
[javadoc] Building index for all classes...
[javadoc] Generating F:\eclipse-projects\Hello\doc\stylesheet.css...
[javadoc] Note: Custom tags that could override future standard tags: @todo. To avoid potential overrides, use at least one period character (.) in custom tag names.
[javadoc] Note: Custom tags that were not seen: @todo
BUILD SUCCESSFUL
Total time: 11 seconds

　　Ant依次执行初始化，编译，测试，打包，生成API文档一系列任务，极大地提高了开发效率。将来开发J2EE项目时，还可加入部署等任务。并且，即使脱离了Eclipse环境，只要正确安装了Ant，配置好环境变量ANT_HOME=<nt解压目录>Path=…;%ANT_HOME%\bin，在命令行提示符下切换到Hello目录，简单地键入ant即可。

posted @ 2006-08-14 09:34 nbt 阅读(529) | 评论 (1) | 编辑 收藏

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 文件更快地装载，因为在装载过程中要解压缩文件，但是未压缩的文件在网络上的下载时间可能更长。
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.security API 签名。一个签名的 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.security API 以编程方式签名 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 文件格式的能力简化和改进开发和部署过程。

posted @ 2006-08-09 16:26 nbt 阅读(1106) | 评论 (0) | 编辑 收藏

JAR文件包及jar命令详解

常常在网上看到有人询问：如何把 java 程序编译成 .exe 文件。通常回答只有两种，一种是制作一个可执行的 JAR 文件包，然后就可以像.chm 文档一样双击运行了；而另一种是使用 JET 来进行 编译。但是 JET 是要用钱买的，而且据说 JET 也不是能把所有的 Java 程序都编译成执行文件，性能也要打些折扣。所以，使用制作可执行 JAR 文件包的方法就是最佳选择了，何况它还能保持 Java 的跨平台特性。  　　下面就来看看什么是 JAR 文件包吧：  　　1. JAR 文件包  　　JAR 文件就是 Java Archive File，顾名思意，它的应用是与 Java 息息相关的，是 Java 的一种文档格式。JAR 文件非常类似 ZIP 文件??准确的说，它就是 ZIP 文件，所以叫它文件包。JAR 文件与 ZIP 文件唯一的区别就是在 JAR 文件的内容中，包含了一个 META-INF/MANIFEST.MF 文件，这个文件是在生成 JAR 文件的时候自动创建的。举个例子，如果我们具有如下目录结构的一些文件：  　　==  　　`-- test  　　　 `-- Test.class  　　把它压缩成 ZIP 文件 test.zip，则这个 ZIP 文件的内部目录结构为：  　　test.zip  　　`-- test  　　　 `-- Test.class  　　如果我们使用 JDK 的 jar 命令把它打成 JAR 文件包 test.jar，则这个 JAR 文件的内部目录结构为：  　　test.jar  　　|-- META-INF  　　|　 `-- MANIFEST.MF  　　`-- test  　　　　`--Test.class  　　2. 创建可执行的 JAR 文件包  　　制作一个可执行的 JAR 文件包来发布你的程序是 JAR 文件包最典型的用法。  　　Java 程序是由若干个 .class 文件组成的。这些 .class 文件必须根据它们所属的包不同而分级分目录存放；运行前需要把所有用到的包的根目录指定给 CLASSPATH 环境变量或者 java 命令的 -cp 参数；运行时还要到控制台下去使用 java 命令来运行，如果需要直接双击运行必须写 Windows 的批处理文件 (.bat) 或者 Linux 的 Shell 程序。因此，许多人说，Java 是一种方便开发者苦了用户的程序设计语言。  　　其实不然，如果开发者能够制作一个可执行的 JAR 文件包交给用户，那么用户使用起来就方便了。在 Windows 下安装 JRE (Java Runtime Environment) 的时候，安装文件会将 .jar 文件映射给 javaw.exe 打开。那么，对于一个可执行的 JAR 文件包，用户只需要双击它就可以运行程序了，和阅读 .chm 文档一样方便 (.chm 文档默认是由 hh.exe 打开的)。那么，现在的关键，就是如何来创建这个可执行的 JAR 文件包。  　　创建可执行的 JAR 文件包，需要使用带 cvfm 参数的 jar 命令，同样以上述 test 目录为例，命令如下：  jar cvfm test.jar manifest.mf test  　　这里 test.jar 和 manifest.mf 两个文件，分别是对应的参数 f 和 m，其重头戏在 manifest.mf。因为要创建可执行的 JAR 文件包，光靠指定一个 manifest.mf 文件是不够的，因为 MANIFEST 是 JAR 文件包的特征，可执行的 JAR 文件包和不可执行的 JAR 文件包都包含 MANIFEST。关键在于可执行 JAR 文件包的 MANIFEST，其内容包含了 Main-Class 一项。这在 MANIFEST 中书写格式如下：  　　Main-Class: 可执行主类全名(包含包名)  　　例如，假设上例中的 Test.class 是属于 test 包的，而且是可执行的类 (定义了 public static void main(String[]) 方法)，那么这个 manifest.mf 可以编辑如下：  Main-Class: test.Test <回车>  　　这个 manifest.mf 可以放在任何位置，也可以是其它的文件名，只需要有 Main-Class: test.Test 一行，且该行以一个回车符结束即可。创建了 manifest.mf 文件之后，我们的目录结构变为：  　　==  　　|-- test  　　|　 `-- Test.class  　　`-- manifest.mf  　　这时候，需要到 test 目录的上级目录中去使用 jar 命令来创建 JAR 文件包。也就是在目录树中使用“==”表示的那个目录中，使用如下命令：  jar cvfm test.jar manifest.mf test  　　之后在“==”目录中创建了 test.jar，这个 test.jar 就是执行的 JAR 文件包。运行时只需要使用 java -jar test.jar 命令即可。  　　需要注意的是，创建的 JAR 文件包中需要包含完整的、与 Java 程序的包结构对应的目录结构，就像上例一样。而 Main-Class 指定的类，也必须是完整的、包含包路径的类名，如上例的 test.Test；而且在没有打成 JAR 文件包之前可以使用 java <类名> 来运行这个类，即在上例中 java test.Test 是可以正确运行的 (当然要在 CLASSPATH 正确的情况下)。  　3. jar 命令详解  　　jar 是随 JDK 安装的，在 JDK 安装目录下的 bin 目录中，Windows 下文件名为 jar.exe，Linux 下文件名为 jar。它的运行需要用到 JDK 安装目录下 lib 目录中的 tools.jar 文件。不过我们除了安装 JDK 什么也不需要做，因为 SUN 已经帮我们做好了。我们甚至不需要将 tools.jar 放到 CLASSPATH 中。  　　使用不带任何的 jar 命令我们可以看到 jar 命令的用法如下：  　　jar {ctxu}[vfm0M] [jar-文件] [manifest-文件] [-C 目录] 文件名 ...  　　其中 {ctxu} 是 jar 命令的子命令，每次 jar 命令只能包含 ctxu 中的一个，它们分别表示：  　　　-c　创建新的 JAR 文件包  　　　-t　列出 JAR 文件包的内容列表  　　　-x　展开 JAR 文件包的指定文件或者所有文件  　　　-u　更新已存在的 JAR 文件包 (添加文件到 JAR 文件包中)  　　　　　[vfm0M] 中的选项可以任选，也可以不选，它们是 jar 命令的选项参数  　　　-v　生成详细报告并打印到标准输出  　　　-f　指定 JAR 文件名，通常这个参数是必须的  　　　-m　指定需要包含的 MANIFEST 清单文件  　　　-0　只存储，不压缩，这样产生的 JAR 文件包会比不用该参数产生的体积大，但速度更快  　　　-M　不产生所有项的清单（MANIFEST〕文件，此参数会忽略 -m 参数  　　　　　[jar-文件] 即需要生成、查看、更新或者解开的 JAR 文件包，它是 -f 参数的附属参数  　　　　　[manifest-文件] 即 MANIFEST 清单文件，它是 -m 参数的附属参数  　　　　　[-C 目录] 表示转到指定目录下去执行这个 jar 命令的操作。它相当于先使用 cd 命令转该目录下再执行不带 -C 参数的 jar 命令，它只能在创建和更新 JAR 文件包的时候可用。　　  　　文件名 ... 指定一个文件/目录列表，这些文件/目录就是要添加到 JAR 文件包中的文件/目录。如果指定了目录，那么 jar 命令打包的时候会自动把该目录中的所有文件和子目录打入包中。  　　下面举一些例子来说明 jar 命令的用法：  　　1) jar cf test.jar test  　　该命令没有执行过程的显示，执行结果是在当前目录生成了 test.jar 文件。如果当前目录已经存在 test.jar，那么该文件将被覆盖。  　　2) jar cvf test.jar test  　　该命令与上例中的结果相同，但是由于 v 参数的作用，显示出了打包过程，如下：  　　标明清单(manifest)  　　增加：test/(读入= 0) (写出= 0)(存储了 0%)  　　增加：test/Test.class(读入= 7) (写出= 6)(压缩了 14%)  　　3) jar cvfM test.jar test  　　该命令与 2) 结果类似，但在生成的 test.jar 中没有包含 META-INF/MANIFEST 文件，打包过程的信息也略有差别：  　　增加：test/(读入= 0) (写出= 0)(存储了 0%)  　　增加：test/Test.class(读入= 7) (写出= 6)(压缩了 14%)  　　4) jar cvfm test.jar manifest.mf test  　　运行结果与 2) 相似，显示信息也相同，只是生成 JAR 包中的 META-INF/MANIFEST 内容不同，是包含了 manifest.mf 的内容  　　5) jar tf test.jar  　　在 test.jar 已经存在的情况下，可以查看 test.jar 中的内容，如对于 2) 和 3) 生成的 test.jar 分别应该此命令，结果如下；  　　对于 2)  　　META-INF/  　　META-INF/MANIFEST.MF  　　test/  　　test/Test.class  　　对于 3)  　　test/  　　test/Test.class  　　6) jar tvf test.jar  　　除显示 5) 中显示的内容外，还包括包内文件的详细信息，如：  　　0 Wed Jun 19 15:39:06 GMT 2002 META-INF/  　　86 Wed Jun 19 15:39:06 GMT 2002 META-INF/MANIFEST.MF  　　0 Wed Jun 19 15:33:04 GMT 2002 test/  　　7 Wed Jun 19 15:33:04 GMT 2002 test/Test.class  　　7) jar xf test.jar  　　解开 test.jar 到当前目录，不显示任何信息，对于 2) 生成的 test.jar，解开后的目录结构如下：  　　==  　　|-- META-INF  　　|　 `-- MANIFEST  　　`-- test  　　　　`--Test.class  jar xvf test.jar  　　运行结果与 7) 相同，对于解压过程有详细信息显示，如：  　　创建：META-INF/  　　展开：META-INF/MANIFEST.MF  　　创建：test/  　　展开：test/Test.class  　　9) jar uf test.jar manifest.mf  　　在 test.jar 中添加了文件 manifest.mf，此使用 jar tf 来查看 test.jar 可以发现 test.jar 中比原来多了一个 manifest。这里顺便提一下，如果使用 -m 参数并指定 manifest.mf 文件，那么 manifest.mf 是作为清单文件 MANIFEST 来使用的，它的内容会被添加到 MANIFEST 中；但是，如果作为一般文件添加到 JAR 文件包中，它跟一般文件无异。  　　10) jar uvf test.jar manifest.mf  　　与 9) 结果相同，同时有详细信息显示，如：  　　增加：manifest.mf(读入= 17) (写出= 19)(压缩了 -11%)  　　4. 关于 JAR 文件包的一些技巧  　　1) 使用 unzip 来解压 JAR 文件  　　在介绍 JAR 文件的时候就已经说过了，JAR 文件实际上就是 ZIP 文件，所以可以使用常见的一些解压 ZIP 文件的工具来解压 JAR 文件，如 Windows 下的 WinZip、WinRAR 等和 Linux 下的 unzip 等。使用 WinZip 和 WinRAR 等来解压是因为它们解压比较直观，方便。而使用 unzip，则是因为它解压时可以使用 -d 参数指定目标目录。  　　在解压一个 JAR 文件的时候是不能使用 jar 的 -C 参数来指定解压的目标的，因为 -C 参数只在创建或者更新包的时候可用。那么需要将文件解压到某个指定目录下的时候就需要先将这具 JAR 文件拷贝到目标目录下，再进行解压，比较麻烦。如果使用 unzip，就不需要这么麻烦了，只需要指定一个 -d 参数即可。如：  　　unzip test.jar -d dest/  　　2) 使用 WinZip 或者 WinRAR 等工具创建 JAR 文件  　　上面提到 JAR 文件就是包含了 META-INF/MANIFEST 的 ZIP 文件，所以，只需要使用 WinZip、WinRAR 等工具创建所需要 ZIP 压缩包，再往这个 ZIP 压缩包中添加一个包含 MANIFEST 文件的 META-INF 目录即可。对于使用 jar 命令的 -m 参数指定清单文件的情况，只需要将这个 MANIFEST 按需要修改即可。  　　3) 使用 jar 命令创建 ZIP 文件  　　有些 Linux 下提供了 unzip 命令，但没有 zip 命令，所以需要可以对 ZIP 文件进行解压，即不能创建 ZIP 文件。如要创建一个 ZIP 文件，使用带 -M 参数的 jar 命令即可，因为 -M 参数表示制作 JAR 包的时候不添加 MANIFEST 清单，那么只需要在指定目标 JAR 文件的地方将 .jar 扩展名改为 .zip 扩展名，创建的就是一个不折不扣的 ZIP 文件了，如将上一节的第 3) 个例子略作改动：  　　jar cvfM test.zip test

posted @ 2006-08-09 16:23 nbt 阅读(258) | 评论 (0) | 编辑 收藏