[转贴自yesky]
一、J2ME中需要的Java基础知识
　　现在有大部分人，都是从零开始学J2ME的，学习J2ME的时候，总是从Java基础开始学习，而且现在讲Java基础的书籍中都是以J2SE来讲基础，这就给学习造成了一些不必要的麻烦，下面将J2ME中用到的和不需要的Java基础知识做一个简单的说明。
　　J2ME中使用到的Java基础知识：
　　 1、Java语法基础：包括基本数据类型、关键字、运算符等等
　　 2、面向对象的思想：类和对象的概念，继承和多态等等。
　　 3、异常处理
　　 4、多线程
　　J2ME中没有用到的Java基础知识：
　　 1、JDK中javac和java命令的使用

JAVA手机网[www.cnjm.net]

　　 2、Java基础中的很多类在J2ME中没有，或者类中的方法做了大量的精简。所以建议在J2ME中熟悉类库。

JAVA手机网[www.cnjm.net]

　　 3、Applet、AWT、Swing这些知识在J2ME中根本使用不到。

JAVA手机网[www.cnjm.net]

　　简单说这么多，希望学J2ME的朋友们能少走一些弯路，不足之处希望大家积极指正和补充。
　　二、J2ME中暂时无法完成的功能
　　列一些J2ME中暂时无法完成的功能，希望大家能积极补充：

JAVA手机网[www.cnjm.net]

　　 1、在手机中不更改代码实现移植，主要指游戏。
　　 2、动态修改按钮文字。

JAVA手机网[www.cnjm.net]

　　 3、在Canvas上接受中文输入。

JAVA手机网[www.cnjm.net]

　　 4、操作本地资源、例如地址本、已收短信息等。

JAVA手机网[www.cnjm.net]

　　 5、制作破坏性的手机病毒。
　　 6、其他等待大家来补充。
　　三、J2ME的跨平台性
　　J2ME技术源于Java，所以也具有JVM的优势，可以在支持Java的平台上进行移植，但是现在的J2ME技术在跨平台上却做的很糟糕，我们来简单看一下原因：
　　1、手机的屏幕尺寸不一：
　　这个主要在界面制作上。如果你使用的是高级用户界面，比如你做的是应用开发或者用户登陆、用户注册这样的通用功能时，一般没有什么问题。
　　如果你使用的是低级用户界面，比如你做的是游戏，那么你就需要考虑这个问题了。

JAVA手机网[www.cnjm.net]

JAVA手机网[www.cnjm.net]

　　2、厂商的扩展API不统一：

JAVA手机网[www.cnjm.net]

　　例如Nokia的扩展API类库UI系列，在别的手机上或者没有实现，或者包名不同等等。
　　3、手机平台上实现的bug：
　　例如Nokia的7650在实现双缓冲上有bug，那么在这种机型上运行的软件就不能使用双缓冲。其他NOKIA上的一些bug，可以参看：http://www.cnjm.net/resfetch/EKayXl5MlY2NaSIHXDqIdRYYOhhiXo2ZYQgiaQcmaY1ha4iyCKZijcsVFcqNFWSNy6SNZMvczstkOmF1THk_
　　4、手机性能问题。
　　不同手机的可用内存、最大jar文件都有要求，例如Nokia S40的大部分手机支持的最大jar文件为64K，最大可用内容为210K。
　　所以现在的手机软件，特别是游戏都提供支持的机型列表，也才有了手机游戏移植人员的存在。
　　四、学习J2ME可以从事的工作种类
　　现在J2ME技术可以说相当的火暴，这里介绍一些学好了J2ME之后可以从事的工作的种类：
　　1、J2ME游戏开发人员
　　根据游戏策划或者文档要求，在某种特定的机型(以Nokia S40或S60居多)开发游戏程序。这是现在大部分J2ME程序员从事的工作。
　　需要熟练掌握：高级用户界面、低级用户界面、线程，如果是网络游戏，还需要熟练网络编程。
　　2、J2ME应用开发人员

JAVA手机网[www.cnjm.net]

　　现在的移动应用还不是很多，但是还是出现了一些，特别是移动定位以及移动商务相关的内容。需要熟练掌握：高级用户界面、线程和网络编程。
　　3、J2ME游戏移植人员
　　参照源代码，将可以在一个平台上可以运行的游戏移植到其他平台上去。例如将Nokia S40的游戏移植到S60上，或者索爱的T618等等。主要是控制屏幕坐标，有些可能需要替换一些API。
　　需要熟悉各平台之间的差异以及相关的技术参数，比如屏幕大小、最大jar文件尺寸等等。
　　五、J2ME程序设计的几个原则
　　1、使用面向对象编程。
　　虽然使用面向过程编程可以减小文件的尺寸，但是为了以后维护的方便和利于扩展，还是要使用面向对象编程。
　　2、使用MVC模式
　　将模型、界面和控制分离。现在很多的程序将三者合一，但是如果你做的程序比较大的话，还是建议你进行分离。

JAVA手机网[www.cnjm.net]

　　3、自动存储用户设定
　　使用RMS来存储用户的信息，例如存储用户上次输入的用户名、密码、用户对于系统的设定等，这样不仅可以减少用户的输入，而且对用户友好。很多程序甚至做了自动登陆等。
　　4、一些系统设置允许用户关闭。如背景音乐、背景灯显示等。

JAVA手机网[www.cnjm.net]

　　5、将低级用户界面的绘制动作放在一个独立的线程里面去。
　　6、在需要大量时间才能完成的工作时，给用户一个等待界面。

JAVA手机网[www.cnjm.net]

　　六、从模拟器到真机测试
　　对于J2ME开发者来说，模拟器给我们带来了很多方便，比如可以在模拟器中调试程序以及很方便的察看程序的效果，但是模拟器也给我们带来了一些问题，比如模拟器实现的bug等等，所以进行真机测试是必须的。
　　1、为什么要进行真机测试？

JAVA手机网[www.cnjm.net]

　　因为模拟器程序可能存在bug，以及真机的性能有限，所以必须进行真机测试。
　　2、如何将程序传输到机器中？
　　将程序传输到机器中有如下方式：
　　 a)　OTA下载
　　 b)　使用数据线传输

JAVA手机网[www.cnjm.net]

　　 c)　红外传输

JAVA手机网[www.cnjm.net]

　　 d)　蓝牙
　　你可以根据条件，选择合适的方式。
　　3、 真机测试主要测什么？

JAVA手机网[www.cnjm.net]

　　真机测试的内容很多，主要测试以下几个方面：
　　 a)　程序的功能
　　 b)　程序的操作性，是否易操作

JAVA手机网[www.cnjm.net]

JAVA手机网[www.cnjm.net]

　　 c)　程序的大小,比如Nokia S40系列的手机大部分接受的最大文件尺寸为64K
　　 d)　程序运行速度，速度是否可以忍受。

JAVA手机网[www.cnjm.net]

　　七、从WTK到厂商SDK
　　对于J2ME爱好者来说，基本上大家都是从SUN的WTK(J2ME Wireless Toolkit)开始的，但是对于实际应用来说，仅仅使用WTK是远远不够的，所以在学习过程中，必须完成从WTK到SDK的跨越。
　　1、厂商SDK的下载地址？
　　·Nokia
　　Nokia不愧为手机行业的老大，对于j2me的支持也是一流的，有专门的网站提供SDK和各种文档说明。
　　网址是：http://www.cnjm.net/resfetch/Dbvxamo8cwoKpIh4z44.G4iEykM.MYiOPzEbCpMx8QrKGwv7TD.xao4N
　　·Siemens

JAVA手机网[www.cnjm.net]

　　Siemens对于J2ME的支持也不错，它提供了SDK，模拟器需要独立安装。下载地址如下：
http://www.cnjm.net/resfetch/BVBDcHC9yrySkj0S7e24pIs9PnCLEqR77T4GZi5wS8qLLu0upMpLjS6SvRIGcD7qku0-i6RLPsq9OjfEPqTCQkUOt6kgPoukIC6kuEJFDnqpxC59cEJFDnqpvYuNDhSpPYuNDrepcIuNDuu3t7epOouNDrc_
　　·SonyEricsson

JAVA手机网[www.cnjm.net]

　　SonyEricsson SDK以及自己的模拟器，下载地址为：
　[url]http://developer.sonyericsson.com/site/global/docstools/java/p_java.jsp/url]
http://www.cnjm.net/resfetch/BEe.ZGSB34qK5B9NqS2pZHWSH9stlFti26l4xsYfsFt4H-RbeLCKlGLEYi0fgeRisGSKlB-SsC0fQ5RFv6lkW0PGgQ__
　　·Motorola
　　Motorola提供了专门的SDK，内部包含模拟器，下载地址为：
http://www.cnjm.net/resfetch/EKayXl5MlY2NPj4-OiYHXgeIBxZiazqIByaNJgdeB2sHImGNTIh1gAcmYjrBdUw_

JAVA手机网[www.cnjm.net]

　　·SamSung

JAVA手机网[www.cnjm.net]

　　SamSung也提供了专门的SDK和模拟器，下载地址为：
http://www.cnjm.net/resfetch/CnUnZGQjjsPDP7oJunRUI7phlNiAL9hs4OwvVP9FdLqUb1Qvw7rg7MOjYVTgZPn9VOC6w...2MP..9j5L4BF4JRL2CPfI.kvuuBs-UU.BC4p.v4_
　　·NEC：
　　NEC也提供了集成模拟器的SDK，下载地址为：

JAVA手机网[www.cnjm.net]

http://www.cnjm.net/resfetch/Ig9UMDBaS5eXGxsbLMm43HD4NMZquMmDLNzh-JfcyQ__
　　2、厂商SDK和WTK有什么不同？

JAVA手机网[www.cnjm.net]

　　厂商SDK最简单的理解就是在WTK的基础上增加了自己的模拟器和自己的扩展API。也就是说，你在使用厂商的SDK时，可以使用厂商的扩展类库，例如Nokia的UI类库，和厂商自己的模拟器而已。每个厂商的扩展API都不多，而且不尽相同。
　　3、如何使用？
　　有些厂商SDK的使用都和WTK相同，例如SamSung。Nokia提供了独立的界面来开发，但是这个界面在实际开发中使用不多。

JAVA手机网[www.cnjm.net]

　　4、厂商SDK的问题

JAVA手机网[www.cnjm.net]

　　厂商SDK实现过程中，有一些bug，而且和真机实现不一致。例如NOKIA的混音播放问题等等。
　　八、在J2ME中获得手机IMEI的方法
　　IMEI是Internation mobile entity identification的简称，在手机中输入*#06#可以显示该数字，长度为15位，全球唯一，永远不会冲突，所以可以作为识别用户的一个标志。

JAVA手机网[www.cnjm.net]

　　下面是在J2ME中获得IMEI的方法：
　　1、MOTO系列的手机可以通过读取系统的IMEI属性获得，代码如下：

JAVA手机网[www.cnjm.net]

　　 String imei = System.getProperty("IMEI");
　　2、SIEMENS系列的手机可以通过读取系统的com.siemens.IMEI属性获得，代码如下：
　　 String imei = System.getProperty("com.siemens.IMEI");
　　九、J2ME网络连接中显示问题的解决办法

JAVA手机网[www.cnjm.net]

JAVA手机网[www.cnjm.net]

　　在网络编程中，有些时候会出现一些在没有接收到网络数据就显示界面的，造成界面显示不符合要求（例如公告显示，会先显示公告的背景图片再显示公告信息），这里提一个简单的解决办法给大家：

JAVA手机网[www.cnjm.net]

　　解决这种情况的方法分成三个步骤：
　　1、在需要显示的界面中，调用发送网络数据的方法。每次显示时调用该构造方法，不调用Display的setCurrent方法显示。

JAVA手机网[www.cnjm.net]

　　2、显示等待界面(例如进度条等)，给用户提示，在进行网络连接。
　　3、在处理网络反馈的数据完以后，调用Display的setCurrent方法显示显示当前界面。

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

本文转自解正宇朋友的《手机Java之怪现象》，个人感觉对我等初学者帮助非常大，故此转贴，由于不知道原文所出网址，这里表示歉意。

下面记载的都是手机java实现中各种奇怪的毛病，bug，或者……特性，是根据某项目的开发经验总结出来的。但是涵盖的手机型号还是有限。因此很有可能某些“特性”会存在于更多的采用了相同JVM（比如平台相同、生产厂商）的手机上。
                                                                                  == 早期S60的内存泄漏 ==
这个bug可以上溯至2003年，甚至更早。表现为java应用中如果使用了Class.getResourceAsStream("本地文件")无法释放其占用的内存，是的，没有任何办法，无论是调用获得的的InputStream实例的close()或将其设为null，甚至显式强制System.gc()，都没有效果。结果就是至少和本地文件同尺寸的内存成为了无法回收的垃圾。这个问题还影响到以Class.getResourceAsStream()为基础的Image.createImage()（这个是最要命的，如何能够不使用图片资源呢！）。
这个bug据说在新的S60上已经解决了。但是Nokia3230（4.0526.2ch）、Nokia7610（6.0525.0ch）都存在这个问题。对于这些个有问题的机型，在java程序中是无法完美解决这个问题的，只能尽量避免。比如集中、统一载入资源，永不释放（也就是说，尽量控制泄漏的次数）。当然，这会对已有代码造成很大影响。毕竟手机java应用是内存受限系统的典型，大多数情况下，珍贵的内存中只保留需要的资源。
                                                                                  == 键盘响应事件 ==
在MIDP1中，获取键盘事件只能自己实现Canvas.keyPressed()。但是MotorolaE398和SonyEricssonK700c的实现却很奇怪。表现为左右软键有可能在这个方法中捕获不到。而是否能够成功捕获，取决于keyPressed()方法中代码的行数……
我承认我没彻底搞清楚这其中的玄机。鬼知道Motorola和SonyEricsson是怎么实现的JVM。我只知道把keyPressed中的所有代码提取到另外一个函数中，在keyPressed只把参数传递给新函数，问题就消失了……
                                                                                  == 超慢的drawRegion ==
除了N-Gage QD，几乎所有的NokiaS60手机都实现了MIDP2的支持。MIDP2中，最为重要的几个特性之一就是Graphics.drawRegion。这个API可以方便的将图片旋转、剪切之后画到画布上。
但是，这个API在Nokia3230、Nokia7610等手机上的实际性能表现让人实在不敢恭维。于是，这个最重要的API成了摆设……没什么怎么办，只能急需延用MIDP1的做法，自己实现剪切和旋转，或者像我一样懒，直接要求美工把旋转之后的图片全都做出来……
                                                                                  == 诡异的内存容量 ==
按照官方Spec，Java在Nokia3125上的可用内存（即Java Heap Size）为512k。但是实际测试的结果是，Nokia3125只有412k左右的实际内存，相差整整100k。不过好在Nokia3125并不是种市场保有量很高的型号。但是它是我正在使用的型号……
                                                                                  == 无法repaint ==
这个问题只存在于SonyEricssonK700c。表现为在keyPressed()中调用repaint()进行屏幕重画没有任何反映。
解决办法是，在keyReleased()中补一个repaint()……
                                                                                  == UTF8 ==
还是SonyEricssonK700c的问题。问题存在于new String(byte[], charset)上。也就是说，当获得了某个byte[]，并希望用UTF8作为字符集将其转换为字符串的时候，使用上述方法在SonyEricssonK700c上会出现丢失字符的现象。这个现象很诡异，以至于我目前没有搞清楚什么情况下会丢失字符（我甚至专门写了个测试程序在真机上跑，得出的结论是丢失字符的原因可能会很复杂，简单的拿被丢掉字符附近的一个子串来测没有任何问题）。
幸亏还是有解决办法的。不用new String就完了，而要用更加麻烦的办法，比如像我一样，用ByteArrayInputStream，外面套InputStreamReader(bais, "UTF8")，然后用StringBuffer一个一个char读进来，最后再toString()……
                                                                                  == 不可靠的copyArea ==
这是Motorola机器上的问题，V3和E398都有。copyArea是Graphics的作整块屏幕像素copy的常用API（2D动态背景的游戏几乎是必不可少）。按照Sun官方的Spec，手机厂商有义务来保证其API实现不存在覆盖冲突问题。但是Motorola显然做得不够好。在Motorola手机上使用这个API会随机产生贴图混乱的情况……
解决办法是自己实现另外一套机制。比如使用另外一张至少和屏幕同样大小的Image作为缓冲，用两次drawImage来替代copyArea……不过这个方法显而易见的缺点是消耗了更多的内存（那可是不小于屏幕尺寸的Image啊！）。如果内存实在吃紧，只能退而再求其次，作为缓冲的Image继续缩水，drawImage的次数继续增加……不过这个时候需要自己手工解决覆盖冲突……
                                                                                  == 无法安静下来的3220 ==
不知道这个问题是不是在S40平台上都有，手里S40又支持MIDI的手机实在是太少了……
3220的一个很明显的特征就是声音大。以至调用了VolumeControl.setLevel(0)之后还是有声音，和Sun官方的Spec完全不符……没办法，只能在需要静音的时候，再补一个VolumeControl.setMute(true)。
                                                                                  == 永不ready ==
这是一段手机java获取网络数据的常用代码：while(InputStream.ready()) { InputStream.read() }。
但是经测试，在Nokia3230上，这个ready永远返回false……没办法，如果不改上述代码的话，就自己实现一个继承类吧。

来自：J2MEDev yefeng17

本文主要讲述J2ME新手最常使用的开发工具Wireless Toolkit（WTK）。从WTK的安装、到MIDlet项目的创建、以及最后的打包发布，一步步带领读者进入MIDlet的开发世界!

1 什么是J2ME Wireless Toolkit
WTK 的全称是Sun J2ME Wireless Toolkit ―― Sun的无线开发工具包。这一工具包的设计目的是为了帮助开发人员简化j2me的开发过程。使用其中的工具可以开发与 Java Technology for the Wireless Industry (JTWI, JSR 185) 规范兼容的设备上运行的j2me 应用程序。该工具箱包含了完整的生成工具、实用程序以及设备仿真器。到本文写作时为止可以获取有四个版本，分别是1.0.4, 2.0, 2.1和2.2。每个版本都包括英语，日语，简体中文，繁体中文4个语种包。

1.0.4版只能够开发MIDP1.0 应用程序。
2.0版只能够开发MIDP2.0 应用程序。
2.1版则可以同时开发MIDP1.0、 JTWI(CLDC 1.0, MIDP2.0, WMA1.1)可改用CLDC1.1或加入MMAPI1.1)，自定义(自己随机组合Configuration, Profile以及Optional Package)三种环境下的应用程序。
2.2版中，WTK全面的支持JTWI规范。具体的说，即MIDP 2.0, CLDC 1.1, WMA 2.0, MMAPI 1.1, Web Services (JSR 172), File and PIM APIs (JSR 75), Bluetooth and OBEX APIs (JSR 82), and 3D Graphics (JSR 184)；同时您也可以使用该版本开发面向CLDC1.0 和MIDP1.0的应用程序。


系统要求上，WTK2.2至少需要50MB可用硬盘，128MB系统RAM和800MHZ Pentium III CPU。

你可以在sun的官方网站免费下载。

WTK2.2 下载链接：http://java.sun.com

WTK是Sun提供的一个开发工具包。目前各大手机厂商往往把WTK经过自身的简化与改装，推出适合自身产品，如SonyEricsson，Nokia Developer’s suit等，都属于此种类型；而通过JBuilder, Eclipse等IDE，J2ME开发包工具可以被绑定在这些集成开发环境中，进一步提高开发效率。

2 J2ME WTK的内容和目录结构

2.1 安装过程
在说明WTK文件结构之前，让我们首先把它安装起来。

WTK的安装程序与普通程序一样简单，只有一点需要注意，由于WTK自身并没有附带Java的运行环境JDK，所以，在WTK安装之前你需要安装自己的JDK（我们这里选用的是JDK1.4.2）。

WTK会首先自动检测当前系统已有的Java虚拟机：



然后显示出当前虚拟机所在路径




您在确定无误后，就可以继续了，最后安装成功后，您将得到一个包括多种实用工具的开发包。以下是安装显示的菜单项。




2.2 目录结构
无论哪个版本的WTK都会包括以下几个目录：

appdb目录： RMS数据库信息

apps目录： WTK自带的demo程序

bin目录： J2ME开发工具执行文件

docs目录： 各种帮助与说明文件

lib目录： J2ME程序库，Jar包与控制文件

session目录：性能监控保存信息

wtklib目录： JWTK主程序与模拟器外观



WTK是用来开发MIDP的，为了让MIDlet可以顺利编译和执行，WTK必须具有CLDC和MIDP的类库，WTK可以帮助我们省去额外安装调试这些类库的时间。而不同版本的WTK包含的程序库内容是不一样的，比如说2.0中包含了midpapi.jar, wma.jar, mmapi.jar，而在2.1中则变为了cldcapi10. jar, cldcapi11.jar, midpapi10.jar, midpapi20.jar, wma.jar以及mmapi.jar；在2.2中，wma.jar又细分为wma11.jar, wma20.jar。如果您在开发中需要某个特定的jar包而当前的WTK版本又没有时，您可以简单把这个jar包拷贝如当前WTK的lib文件夹即可。

apps目录中包括了许多Demo程序，为我们演示了J2ME的一些技术实例，这些往往是很好的学习材料。


3 使用J2ME WTK创建工程
3.1 建立新项目
下面让我们用WTK来创建一个经典的Hello World程序，看看这水有多深。

在WTK的程序列表中运行KToolbar，打开WTK主界面。WTK的标题菜单简单明了的列出了这个工具包的可选功能。

单击新建项目，键入新建的项目名和启动MIDlet名，这里的项目是一个MIDlet套件，而MIDlet类名则是这个套件的入口，MIDlet文件名(也是Java文件的名字)。




产生项目以后，会出现项目的设置表，您可以选择当前目标平台，CLDC配置，以及要采用的MIDP可选包。再不需要某个库文件时，请不要选中它，以减少最后程序大小。

另外，您还可以指定MIDlet的属性，这些设置将成为JAD，即J2ME程序的描述信息文档。我们的Hello World目前不需要其它的附加设置，于是采用默认，确定之后，控制台信息提示建立成功。







WTK产生项目后，不同类型的资源有着相对固定的存放位置。Java源文件被放在apps目录下\Hello World\src下，相关程序资源文件（图片，音频）放在\Hello World\res下，应用程序库文件放在\Hello World\lib下，这在WTK中是必须注意的，即便是相对路径，也必须是在该类型目录下建立。

项目创建成功后，我们来创建一个MIDlet文件，MIDlet是J2ME项目文件的入口文件，也是必须的。在\Hello World\src目录下创建HelloWorld.java，采用默认包，注意，此时创建的java程序必须是与我们在创建项目时键入的MIDlet类名一致。

在新创建的java文件中输入代码，下文是一个简单的Form程序。

HelloWorld.java

import javax.microedition.lcdui.*;

import javax.microedition.midlet.MIDlet;



public class HelloWorld extends MIDlet {



Display display;



public HelloWorld() {

super();

display = Display.getDisplay(this);

}



protected void startApp(){

Form form = new Form("Hello World!");

form.append("Welcome to J2ME world!");

display.setCurrent(form);

}



protected void pauseApp() {



}



protected void destroyApp(boolean arg0){



}

}



完成后保存java文件，单击“生成”按钮，由WTK为您进行编译，如果有错误生成，则会在控制台中提示。




根据提示信息对MIDlet文件进行修改，再重新生成，直到编译成功。对编译成功的程序，你可以从“设备”选项中选择DefaultColorPhone，DefaultGrayPhone或者其它WTK自带的设备模拟器，单击按钮可以看到弹出一个手机模拟器，显示出我们的第一个Hello World程序，如果执行有错，依然会在控制台中给出提示信息。




运行成功以后，在HelloWorld/bin目录下，将会产生一个程序描述文档JAD，它清楚的描述了当前MIDlet的名称与版本，发行人，指定的JAR包名称与大小，支持CLDC与MIDP版本等信息。在进阶开发中，默认的联网字符串，签名私钥等信息也可以保存在这个描述文档中。


3.2 开启旧项目
当我们下一次重新启动WTK的时候，选择打开项目，WTK会把自身apps目录下的应用项目全部显示出来，包括我们刚刚建立的Hello World，选择“打开项目”后，就能够对apps目录下的MIDlet项目进行开发更改了。




4 执行MIDlet、打包和混淆
4.1 执行MIDlet
除了我们刚刚介绍的在KToolbar中执行一个程序，我们还可以在程序组中直接选择Run MIDP Application…, 这是就可以在弹出的对话框中选择其它路径中的JAD程序运行了







当我们直接选择运行时，需要注意两个问题：

1. JAD描述文件与其指定的JAR文件在同一个目录下。

2. 运行目录路径中不要包含中文。

4.2 打包成JAR
KToolbar的生成功能只能帮我们将源代码编译并预先审核，并不会帮我们产生JAR文件，而我们如果要发布MIDP程序，除了JAD描述文件，JAR是必须的，这就需要打包。

在KToolbar选中项目 ―― 包 ―― 产生包，可以把整个程序，包括资源文件打包成JAR文件。形成的JAR保存在apps\HelloWorld\bin目录下。





4.3 包混淆
在上面的操作中，我们看到，除了“产生包”，另外还有一个“产生混淆包”选项。所谓混淆，是为了防止别人反编译后读取源代码，将程序(.class文件)进行混淆，经过混淆的Java Byte Code可以增加别人反编译的时间。

这里我们使用开源的ProGuard，关于混淆的详细介绍和混淆工具的下载，见本教程的前面的章节。

把刚刚获取的ProGuard解压，在解压目录的lib子目录中找到proguard.jar文件，将其拷贝到WTK安装目录的bin下，再执行混淆包。这是我们将会发现apps\HelloWorld\bin下的JAR大小变小了，反编译后的各个名称也变得毫无意义了。





5 WTK中其它值得关注的功能
到这里，我们就如何用WTK创建，执行，打包，混淆一个MIDP项目做了比较详细的介绍。除了以上所说各点，WTK(2.2版)还提供诸多实用功能。这些都可以在编辑 ―― 偏好中找到。





例如，当我们需要监视程序性能的时候，可以选中“启用内存监视器”，在下一次模拟器执行的时候，我们就可读出程序运行时的内存消耗均值，消耗峰值以及具体产生对象的个数和使用情况。

除了内存监视，我们还可以执行网络监视，设定存储区大小和堆栈大小，设定安全签名和蓝牙操作属性，以尽可能模拟手机实际运行环境，这些功能在进阶开发中都是非常实用的。

注意：
虽然WTK为我们提供了各种工具来模拟手机运行环境，但在实际开发中，由于受到手机硬件，网络条件等诸多限制，MIDP的真实性能在不同机器上会出现不同的反应，与WTK中的表现可能差别更大。

从菜单中选择“工具集”可以看到更多的实用工具，这些都是开发实用的j2me程序时会频繁使用到的。介于本教程面向入门级读者，所以这部分内容请读者自行研究.

Eclipse安装与配置

A.安装：
1．安装JDK1.4.2 (WTK2.2要求1.4.2以上)
2．安装WTK
3．安装Eclipes
4．解压缩Eclipseme到Eclipse的plugin目录。Eclipseme0.5.5之后的版本则不适用该方法，具体配置方法会在后面描述。
    EclipseMe作为Eclipse一个插件，致力于帮助开发者开发J2ME应用程序。EclipseMe并不为开发者提供无线设备模拟装置，而将各手机厂商的实用模拟器紧密连接到Eclipse开发环境中，为开发者提供一种无缝统一的集成开发环境。你可以在http://www.eclipseme.org/上得到免费下载的EclipseMe，本文写作时的最新版本是1.5.0，出于稳定的考虑，在这里选用eclipseme.feature_1.2.3_site.zip来为大家演示。
    除了Eclipse与EclipseMe之外，还需要java运行环境和一些手机模拟器来完成安装。以下列出了完成本文的工具列表：
   （1．JDK 1.4.2            
   （2．Eclipse 3.1.2        
   （3．Eclipse 3.1.1 语言包 NLpack1_FeatureOverlay-eclipse-SDK-3.1.1.zip和NLpack1-eclipse-SDK-3.1.1a-win32.zip
   （4．EclipseMe 1.2.3    eclipseme.feature_1.2.3_site.zip
   （5．Sun WTK 2.2 (sun的通用模拟器)
   （6. Nokia Developer's Suite 2.2 (Nokia开发者套件，包括几款比较典型机型的模拟器)

A-1 Eclipse安装与汉化
    Eclipse的安装过程更加简单，事实上，这仅仅是一个解压缩的过程。将你下载的Eclipse SDK压缩包eclipse-SDK-3.1.2-win32拷贝在你的目标目录下，我们这里以D盘根目录为例，然后解压到当前文件夹。
    Eclipse3.1.2汉化link方法归纳：
(1.下载语言包：NLpack1_FeatureOverlay-eclipse-SDK-3.1.1.zip
NLpack1-eclipse-SDK-3.1.1a-win32.zip
(2.解压缩两个语言包，并将二者合并，即相同文件夹名的文件夹合并成一个，最后得到一个eclipse文件夹。
(3.在Eclipse安装目录下创建language和links这两个文件夹。并将第2步合并后的文件夹拷贝到language文件夹下（注意：拷贝整个解压后得到的eclipse文件夹）。
(4.在links文件夹下创建一个文本文件：links.txt。内容为language文件夹路径，例如：path=d:\\eclipse\\language
(5.重新启动Eclipse。
    注意：如果出现有些英文单词没汉化时，可以把\eclipse\configuration目录下的.settings文件夹删掉，重启eclipse就完全汉化了。

A-2 EclipseMe插件安装
    在Eclipse中选择“帮助/软件更新/查找并更新”，在弹出对话框中选择“搜索要安装的新功能部件”，在“新建已归档站点”的弹出框中，指定EclipseMe压缩文件eclipseme.feature_1.2.3_site.zip。点击确定后可以看到Eclipse已经搜索到了相应的插件。选中EclipseMe的复选框，接受协议，忽略功能部件验证，最后重新启动控制台，EclipseMe插件就已经顺利的安装好了。
    为了验证EclipseMe确实已经安装上了，我们在工作台重启之后，打开“窗口/首选项”中，我们可以看到一个J2ME选项，这时，Eclipse移动开发的第一步，我们已经成功的迈出了！
    注意：安装好EclipseMe之后，我们要对原有的Eclipse配置做一点小小的改动。由于移动开发时我们需要首先启动手机模拟器，那么在Debug模式的Eclipse默认设置不等到模拟器启动就会失败。修改这点很简单，在首选项的“java/调试”中，把默认设置更改为选窗口--首选项 --JAVA --调试--把第1、2个钩去掉，并把最下面调试延时设置15000。调试模式就可以顺利的启动了。

A-3 加载厂商模拟器
    EclipseMe为我们提供了一个集成开发环境，但仅仅这些是不够的，我们还需要一种或多种手机模拟器作为程序运行的实际载体。目前，各大手机厂商都拥有多种型号的手机模拟器，Sun也提供了一种通用模拟器。这里采用Sun WTK和Nokia Developer's Suite 两种来演示。
   下面将WTK绑定到Eclipse。找到路径“窗口/首选项/ J2ME/ Platform Component”，右键单击对话框右侧的wireless toolkit，我们可以添加当前系统已有模拟器。在单击“浏览”按钮之后，我们选定WTK的安装目录。EclipseMe会自动分析出当前模拟器类型，并显示出来。确认之后，我们发现Platform Component一栏上添加了关于WTK的许多配置信息，此时，WTK已经被我们集成到EclipseMe上了。
    Nokia拥有多种型号的手机模拟器，为了统一管理，它推出了用于集中管理这些模拟器的管理软件Developer's Suite。Developer's Suite本身是一个可以独立运行的工具包，它同样可以被EclipseMe绑定，使开发者在一个相同的工作环境下高效率的工作。这里，我们采用了Nokia Developer's Suite 2.2，这个版本甚至在安装的时候就可以绑定Eclipse了！
    首先，从Nokia论坛上下载安装文件，如果电脑中有旧版本的Developer's Suite，需要首先卸载旧版本。Nokia的开发包是提供给Nokia论坛的开发者使用的，所以，在接受安装协议之后，你需要提供在Nokia论坛的用户名和安装序列号。第一次安装没有序列号也不用担心，输入一栏中什么都不用填直接忽略过去，Developer's Suite会让你选择一种代理联网模式(如果没有用代理服务器上网就选择no proxy)，然后要求你输入在Nokia论坛的用户名和密码进行注册。注册成功之后，用户名对应的序列号就会被发送到你的邮箱中，查收一下，就可以继续了！(有的时候Nokia发送序列号的行为会很慢，没办法，只有等等了)。
    当完成认证之后，会发现Developer's Suite 2.2提供了多种安装方式，包括独立安装或者直接与Eclipse集成。如果选择了与Eclipse集成，那就要提供当前Eclipse的安装目录。如果选择了独立安装，在重启系统之后，以与添加Sun WTK相同的方法，在“首选项/J2ME/Platform Components”中选中Developer's Suite的安装目录，确定之后可以看到，Wireless Toolkits中除了WTK，Nokia Developer Suit也被列在其中了！

NetBeans刚出来时还只有英文版，后台在大家努力下终于有了中文版，但是在中英文版本中进行切换却是一件难事，经过苦心查找资料和多次的 尝试，终于成功了，现与大家分享：

既然要进行语言切换，那自然需要你安装的是多国语言版本或者中文版的，

在安装成功后会在桌面生成一个快捷方式，名位“NetBeans 5.5”，在属性中可以看到“目标”为"C:\Program Files\netbeans-5.5\bin\netbeans.exe"，当然安装目录不定，大家得改成自己的，现在到了关键时刻了，

在安装成功后NB使用操作系统默认的语言的，如果是中文版的操作系统，则使用中文版。

如果你想使用英文版的NB，那么只需要在那个"C:\Program Files\netbeans-5.5\bin\netbeans.exe" 后面加一个
-locale en，即快捷方式的属性中的目标栏为
"C:\Program Files\netbeans-5.5\bin\netbeans.exe" -locale en

就OK了。我一般是把默认的快捷方式复制一份，再改那么，这样就有中文，英文两个版本的快捷方式了.

import java.io.*;


/**//*5.5.x GA算号源代码*/

public class Crack {

    public static String convert(String s) {

        if (s == null || s.length() == 0)

            return s;

        byte abyte0[] = s.getBytes();

        char ac[] = new char[s.length()];

        int i = 0;

        for (int k = abyte0.length; i < k; i++) {

            int j = abyte0[i];

            if (j >= 48 && j <= 57)

                j = ((j - 48) + 5) % 10 + 48;

            else if (j >= 65 && j <= 90)

                j = ((j - 65) + 13) % 26 + 65;

            else if (j >= 97 && j <= 122)

                j = ((j - 97) + 13) % 26 + 97;

            ac[i] = (char) j;

        }

        return String.valueOf(ac);

    }



    private static int hash(String s) {

        int i = 0;

        char ac[] = s.toCharArray();

        int j = 0;

        for (int k = ac.length; j < k; j++)

            i = 31 * i + ac[j];

        return Math.abs(i);

    }



    private static String inputString() {

        BufferedReader bufferedreader = new BufferedReader(

                new InputStreamReader(System.in));

        String s = null;

        try {

            s = bufferedreader.readLine();

        } catch (IOException ioexception) {

            ioexception.printStackTrace();

        }

        return s;

    }



    public static void main(String args[]) {

        try {

            System.out.println("My Eclipse IDE vxx.xx Keygen");

            System.out.print("License Name : ");

            String s = inputString();



           // 程序关键代码：
            String licStr = "YE3MP-100000-0912310";

            String h = s.substring(0, 1)

                    + licStr

                    + "Decompiling this copyrighted software is a violation of both your license agreement and the Digital Millenium Copyright Act of 1998 (http://www.loc.gov/copyright/legislation/dmca.pdf). Under section 1204 of the DMCA, penalties range up to a $500,000 fine or up to five years imprisonment for a first offense. Think about it; pay for a license, avoid prosecution, and feel better about yourself."

                    + s;

            int j = hash(h);



            String lic = s.substring(0, 1) + licStr + Integer.toString(j);

            System.out.println("License Key : " + convert(lic));

        } catch (Exception exception) {

            exception.printStackTrace();

        }

    }

}

看看代码，其实只有licStr这部分变了：

5.5.x GA版的：

5.1.x 以前的：

看出来了吧，只是很小的改动！

这段代码的解释：（5.5.x GA）

E3MP  表示pro版，E2MY 表示standard版；

100000 前面100表示版本号，后面000为使用人数，可以随便填，默认000为Ultimate；

091231 表示使用到期时间为：2009-12-31，这个已经是最大期限了，不能再改大了！

来自:http://www.jieesoft.com/modules.php?name=News&file=article&sid=155

Maven和ANT是Apache 推出的大名鼎鼎的Build和工程管理工具，国内有人将他做了汉化工作，并推出了maven手册汉化工作，其中手册已经完工，对广大程序员可是一大帮助。进入该网站
用户手册

1. 关于手册
   
2. 简介
   
3. 项目对象模型
   
4. POM 处理机制
   1. POM 插值机制
   2. POM 继承机制
   
   
5. 使用插件
   
6. maven.xml文件
   
   
   
   1. 简单的maven.xml例子
      
   2. project节点
      
   3. 目标
      
   4. Jelly编程
   
   
7. Maven 配置
   
   
   
   1. 属性的处理机制
      
   2. 插件的属性
      
   3. 行为属性
      
   4. 使用代理
      
   5. 使用多个远程Repositories
   
   
8. 项目设置
   
   
   
   1. 开始一个新项目
   
   
9. 构建
   
   
   
   1. 构建生命周期
      
   2. 在CVS中存放jar文件
      
   3. 重载已声明的依赖包
      
   4. 使用SNAPSHOT依赖
      
   5. 多项目构建和Reactor
      
   6. 离线构建
      
   7. 命令行选项介绍
   
   
10. 测试
    
    
    
    
    
    1. 测试资源
       
    2. 运行一个单独的测试
    
    
11. 打包
    
    
    
    
    
    1. JAR 资源
    
    
12. 部署
    
    
    
    
    
    1. 固化SNAPSHOT依赖
       
    2. 拷贝依赖JAR包
    
    
13. 命名约定
    
    
    
    1. 规则和指南
       
    2. 项目
       
    3. 依赖
       
    4. 发布多个包的项目
    
    
14. 远程Repository布局
    
15. 本地Repository布局
    
16. 生成项目站点
    
    
    
    1. 颜色
       
    2. 风格
       
    3. 报告

关于手册
这篇Maven使用手册意在通过提供完整的描述和例子，帮助开发人员了解Maven。 如果你有任何建议或者意见请在 Maven使用者邮件列表上发表.
感谢选择Maven!

简介
Maven最早始于Jarkarta Turbine项目，目的是为了简化构建过程。这个项目下面有 几个子项目，每个子项目都有自己的Ant文件，但是区别很小，而且生成的JAR 文件都要check in到CVS中。我们希望有一种标准的方式来构建这些项目，一种可以 清晰描述项目的方式，一种易于发布项目信息的方式，一种在多个项目之间共享JARs 的方式。
这个结果就是产生了一个可以用于构建、管理任何基于java的项目。我们希望我们创造 的这个工具可以让Java开发者的日常工作更加轻松，并有助于理解基于java的项目.

项目对象模型
Maven是基于项目对象模型(POM)的概念而创建的。在这个模型中，所有由Maven产生的 artifact都是清晰定义的项目模型的结果。构建，文档，源码度量，源码交叉引用和其他 任何由Maven plug-in提供的东西都是由POM来控制的。

POM 处理机制
这篇文档简单的描述了Maven执行过程中是如何处理POM的。这里有一些简单的POM例子 来展示继承机制和插值机制。

POM 插值机制
POM(通常以project.xml的名字出现)现在已经被当作Jelly脚本来处理了。大部分时 候，用户无须关心project.xml文件是不是真正的Jelly脚本，但是，如果需要的话， 也可以使用内置值。我也不愿看到逻辑控制语句出现在project.xml中，但是由于 project.xml实际上已经是一个隐含的jelly的脚本，所以它会有足够的灵活性:-)。 下面是一个简单的例子。
3
maven
maven
Maven
1.0-b5-dev

Apache Software Foundation
http://jakarta.apache.org/
/images/jakarta-logo-blue.gif

2001
org.apache.${pom.artifactId}
/images/${pom.artifactId}.jpg

Maven is a project that was created in ${pom.inceptionYear}.
${pom.name} is a Java Project Management Tool

POM 继承机制
现在有一种简单方式可以用于在POM中进行继承，下面是一个简单的例子：
project.xml
super-extendo
super-extendo
Super Extendo

**/*Test*.java

**/TestAll.java
**/*Abstract*.java

目前对POM父对象的解析还相对较弱，现在对一层以上的继承还没有做过任何测试。尽管如此， 单层继承加上插值机制已经能够给带来很多好处。这些机制的意图在于简化构建的共用问题。
你可以这样定义主模板：

3
commons
commons-master
Commons Master Maven POM

Apache Software Foundation
http://www.apache.org

jakarta
http://jakarta.apache.org/commons/${pom.artifactId}.html
http://nagoya.apache.org/
jakarta.apache.org
/www/jakarta.apache.org/commons/${pom.artifactId}/
/www/jakarta.apache.org/builds/jakarta-commons/${pom.artifactId}/

scm:cvs:pserver:anoncvs@cvs.apache.org:/home/cvspublic:jakarta-commons/${pom.artifactId}
http://cvs.apache.org/viewcvs/jakarta-commons/${pom.artifactId}/
...

子POM对象可以这样定义：
commons-betwixt
commons-betwixt
Betwixt
...

这样你就可以在父POM对象中，将子POM对象的${pom.artifactId}替换进去。有许多项目的 构建都以相似的方式进行构建，这样一来，对于项目的公共部分，你就可以使用一个主模板， 然后在子POM对象project.xml中定义有区别的部分，而这部分内容通常很少。
这种机制确实还可以简化那些需要产生多个JAR包的项目。由于project.xml和标准Ant构建 不会相互干扰，我计划在公共部分测试继承机制。
如果你对使用这种机制，DVSL报告会变成什么样感到疑惑，我要说，你很上路。我已经修改 了DVSL报告来适应POM本身，这就是说DVSL转换是基于java对象的。在使用继承和插值机制的 时候，为了正确的产生DVSL报告，这是很有必要的。象上面列出的子模板是无法工作的，我们 需要全面的解析POM。我能说的是，它可以工作了！我所使用的处理方式可能不是最有效率的 方式，但仍有提升的空间。因为POM只会被处理一次(不管怎么说，这就它的原理，我可能漏了 某些东西)，然后到处使用，至少这就是我以前试图做的事情，所以我们很有可能会取得平衡。
如果你不使用继承和插值，那么一切照常工作。maven站点本身一切ok，有几个刚部署的站点 已经使用了我昨晚提交的东西了。

使用插件
Maven是一个很紧凑的内核，围绕着它的是许许多多的插件。Maven所有的功能都是由插件来提供 的。

maven.xml文件
项目中的maven.xml文件是Maven在执行过程中要使用的“定制”文件。
在这个文件中，你可以加入Maven构建中需要的额外处理。或者在Maven的“目标”前后附加自己 的代码，如jar 或 test。
Maven使用Jelly 脚本语言, 任何合法的jelly标签都可以在maven.xml中使用。
Maven所采用的goal功能是由werkz标签库提供。更多的信息请看 wiki页面.

简单的maven.xml例子
注意由于Maven并未缺省的定义'compile'目标，下面这个例子没法运行。
这是一个简单的maven.xml例子

${goals}
Now attaining goal number ${goalNumber}, which is ${goal}

你可能会注意到这里一些有意思的东西，下面我们将逐一解释。

project节点
project节点, , 是任何 maven.xml 文件的根节点。
项目节点有一个缺省的属性：default="nightly-build"，如果用户只是简单键入 没有参数的maven命令，Maven就会用nightly-build 目标作为缺省目标。
接下来是几个名字空间的声明，如：

1. xmlns:j="jelly:core"
   所有以j:作为前缀的节点，Jelly都会把它视为在core标识下 预定义的标签库。
2. xmlns:u="jelly:util"
   所有以u:作为前缀的节点，Jelly都会把它视为在标识下 预定义的标签库。
   
   所有在maven.xml文件使用的Jelly标签库，都必须在project节点中定义，并且 分配一个名称空间前缀。
   Maven已经预先包含了jeez标签库作为空前缀。这个标签库在一个名称空间内包含了 ant 和 werkz 标签库。这样，任何werkz或ant标签都无须名称空间 即可使用，同时也简化了ant的迁移过程。
   
   目标
   goal是一个 werkz 标签，类似于Ant的target；它是包含了一系列可执行标签的容器。
   由于jeez 标签库已经由maven预先注册了，一个目标(goal)可以包含任何合法的 Ant 标签。
   为了执行在maven.xml中定义的目标，你只需要在命令行中为Maven指定目标名即可。要执行例子中定 义的nightly-build你只需执行命令:
   maven nightly-build
   
   Maven插件定义的目标需要在目标前加上插件名，这样一来，就不会和你自己的goal冲突，如 jar:jar就是 jar 插件定义的目标，用于创建项目的jar包。
   
   Jelly编程
   在每个目标里，由Jelly标签提供功能，让我们来看看例子里的这些代码。
   set
   
   这行就是一个jelly的core标签set，它使用了project节点中定义的前缀 j:
   set标签设置了一个由var属性定义的Jelly变量，值由 value 指定。和Ant的proerties不一样，Jelly变量在被赋值后仍可以改变。
   mkdir
   
   等同于Ant任务 mkdir, 用于创建目录，目录名由变量 ${maven.build.dir}指定。
   tokenize
   ${goals}
   这行执行的是Jelly tokenize 标签。这是Jelly util 标签库中标签， 这个标签库已经在项目节点中预先定义：u:
   tokenize标签在将节点中的内容分离成一个list，用于后续的处理。
   

• var 属性就是将被于新list的变量。
• delim 属性是用于分割字符串中的分隔符。
  
• 在这个例子中，tokenize 标签中节点值是一个变量：goals, 在前几行中，这是一个由逗号分隔、compile 与 test 的字符串。

forEach

Now attaining goal number ${goalNumber}, which is ${goal}


forEach标签提供简单循环功能，节点值就是循环体。

• items 属性是一个表达式，是在循环过程中需要遍历的值集合。
  
• 集合中的值被逐个取出，存放在var 属性指定的变量中。你可以在 forEach 循环体访问这个变量。
  
• indexVar 属性指定了一个计数器(起始基数为0)变量，用于在处理 过程中计数。

forEach 标签的节点值输出了一些在处理过程中的关于目标的文本，并使用 attainGoal werkz 标签来获得(执行?)这些目标。

Maven 配置

属性的处理机制
Maven按下面的顺序依次读入properties文件：

• ${project.home}/project.properties
• ${project.home}/build.properties
• ${user.home}/build.properties

读入的属性遵循“最后的定义有效”原则。也就是说，Maven依次读入properties文件，以新的定义 覆盖旧的定义。${user.home}/build.properties是Maven最后处理的文件。我们把 这些文件称为Maven处理的标准属性文件集。
另外，上述properties文件处理完毕后，Maven才会开始处理系统属性。所以，如果在命令行中使用 象-Dproperty=value这样的形式来指定的属性，它会覆盖先前定义的同名属性。

插件的属性
上述属性文件处理完后，Maven才会开始调用插件，但是 PluginManager 会禁止插件 覆盖已经设置的属性值。这和Maven一般的属性处理方式是相反的，这是因为插件只能在Maven内部的 其他部分初始化完毕后才能处理，但是我们又希望以这样顺序去处理属性：

• 处理Plug-in 缺省属性
• 处理${project.home}/project.properties
• 处理${project.home}/build.properties
• 处理${user.home}/build.properties

这样一来，即使插件处于属性处理链的后端，也能覆盖插件的任何缺省属性。例如，Checkstyle插件 就定义了如下缺省属性：
maven.checkstyle.format = sun

你可能已经猜出来了，Checksytle插件把Sun的编码规范作为缺省的格式。但是我们仍然可以在标准属性 文件集的任何一个文件中覆盖这个属性。所以如果在${project.home}/project.properties 文件定义了如下属性值：
maven.checkstyle.format = turbine

Checkstyle就会使用Turbine的编码规范。

行为属性
下面的这些属性可以改变Maven的“行为方式”。

属性
描述
缺省值

maven.build.dest
目录名，存放编译生成的类
${maven.build.dir}/classes

maven.build.dir
存放构建结果的目录，如类文件，文档，单元测试报告等等。
注意： 在${user.home}/build.properties文件中改变maven.build.dir 的缺省值或许会得到一个 较为个性化的目录布局。但是，这会干扰Maven由从源码开始的编译工作，因为它假设jar包 会被创建到${basedir}/target/目录中。
${basedir}/target

maven.build.src
源码目录
${maven.build.dir}/src

maven.conf.dir
配置文件目录
${basedir}/conf

maven.docs.dest
html格式报告的输出目录
${maven.build.dir}/docs

maven.docs.omitXmlDeclaration
产生的文档所应包含的xml声明头，如：

false

maven.docs.outputencoding
生成文档的缺省编码
ISO-8859-1

maven.docs.src
用户提供的文档目录
${basedir}/xdocs

maven.gen.docs
xdocs文档转换成html后的输出目录
${maven.build.dir}/generated-xdocs

maven.home.local
maven用于写入用户信息的本机目录，如解开插件包、缓冲数据。
${user.home}/.maven

maven.mode.online
是否连接internet
true

maven.plugin.dir
插件的存放目录
${maven.home}/plugins

maven.plugin.unpacked.dir
用于展开安装插件的目录
${maven.home.local}/plugins

maven.repo.central
在进行dist:deploy处理的时候，发行包所要部署的目标机器
login.ibiblio.org

maven.repo.central.directory
在进行dist:deploy处理的时候，发行包所要部署的目标目录。
/public/html/maven

maven.repo.local
本机repository，用于存储下载的jar包。
${maven.home.local}/repository

maven.repo.remote
远程repository，如果本机repository没有的jar包，maven会从这里下载。
http://www.ibiblio.org/maven

maven.repo.remote.enabled
是否使用远程repository。
true

maven.scp.executable
用于安全拷贝的可执行程序
scp

maven.src.dir
基础源代码目录
${basedir}/src

maven.ssh.executable
远程命令可执行程序
scp

使用代理
如果你只能通过代理访问，不要紧，Maven为你提供了下列属性：

代理属性
描述

maven.proxy.host
代理的IP地址

maven.proxy.port
代理端口

maven.proxy.username
如果代理需要认证的话，在这里填写用户名。 User name if your proxy requires authentication.

maven.proxy.password
如果代理需要认证的话，在这里填写密码。
如果你实在需要代理，最好在${user.home}/build.properties文件中指定。
## ----------------------------------------------------------
## ${user.home}/build.properties
## ----------------------------------------------------------
.
.
maven.proxy.host = my.proxyserver.com
maven.proxy.port = 8080
maven.proxy.username = username
maven.proxy.password = password
.
.

使用多个远程Repositories
你可以在任何Maven可以处理的属性文件中指定使用多个远程Repositories，如：
maven.repo.remote = http://www.ibiblio.org/maven/,http://www.mycompany.com/maven/

项目设置

开始一个新项目
如果你是第一次使用Maven，或者开始一个新的项目，你可以使用GenApp来自动创建Maven项目树。
maven -Dpackage=com.mycompany.app genapp

执行该命令后，屏幕显示如下：
__ __
| / |__ Jakarta _ ___
| |/| / _ V / -_) ' ~ intelligent projects ~
|_| |___,_|_/___|_||_| v. 1.0-beta-9

[mkdir] Created dir: /genapp/src/java/com/mycompany/app
[copy] Copying 1 file to /genapp/src/java/com/mycompany/app
[mkdir] Created dir: /genapp/src/test/com/mycompany/app
[copy] Copying 3 files to /genapp/src/test/com/mycompany/app
[copy] Copying 2 files to /genapp
[copy] Copying 1 file to /genapp/src/conf
BUILD SUCCESSFUL
Total time: 3 seconds

执行完毕，即生成下面的完整项目目录树：
.
|-- project.properties
|-- project.xml
`-- src
|-- conf
| `-- app.properties
|-- java
| `-- com
| `-- mycompany
| `-- app
| `-- App.java
`-- test
`-- com
`-- mycompany
`-- app
|-- AbstractTestCase.java
|-- AppTest.java
`-- NaughtyTest.java

构建
Maven采用了集中管理库的理念。所有用于构建的jar包都是从集中管理的中心库上取出。目前， 我们的中心库放在这儿Ibiblio. 在一个典型的Maven项目中，构建所需的 jar包会从中心库下载。Maven只会取回依赖链条上缺失的包。如果你使用Maven来构建几个项目， 这些项目可能会共享一些依赖包：Maven可以在任意个项目中共享同一个包，而无须在同一系统 中保持一个jar包的多个拷贝。

构建生命周期

在CVS中存放jar文件
我们不推荐你在CVS中存放jar包。Maven提倡在本机repository中存放用于构建共享的jar包或 和其他项目包。许多项目都依赖于诸如XML解析器、标准例程，这在Ant构建中，经常会被复制 多份。在Maven中，这些标准例程就存放在本地repository中，供任何项目构建使用。
重载已声明的依赖包
你可能会发现，在某些情况下允许重载POM中已经声明的依赖包会很方便，甚至很有必要。 你可能会希望使用文件系统中的某个JAR包，或者你希望简单重新指定某个包的版本。对于 这样的情况，Maven提供了一种简单的方式，允许你选择构建所需的jar包。我们严重建议;) 你设置本机repository，但是在简单至上，或在由ant构建迁移的情况下，JAR包重载特性 会显得非常方便。
为了使用JAR包重载特性，你必须将maven.jar.override 属性设置为 on。 只要设置了这个属性，就可以在任何maven处理的属性文件中重载JAR包。
关于JAR重载的指令有两种。第一种允许你指定某个特定的包的路径，作为JAR包；的二种 允许你指定某个特定的JAR包（这个jar包必须已经存在于本机repository）。下面是这两 种方式：
maven.jar.artifactId = [path]
maven.jar.artifactId = [version]

下面是一个使用JAR重载指令的属性文件例子：
# ------------------------------------------------------------------------
# M A V E N J A R O V E R R I D E
# ------------------------------------------------------------------------
maven.jar.override = on
# ------------------------------------------------------------------------
# Jars set explicity by path.
# ------------------------------------------------------------------------
maven.jar.a = ${basedir}/lib/a.jar
maven.jar.b = ${basedir}/lib/b.jar

# ------------------------------------------------------------------------
# Jars set explicity by version.
# ------------------------------------------------------------------------
maven.jar.classworlds = 1.0-beta-1

使用SNAPSHOT依赖
在Maven中，SNAPSHOP是某个特定项目的最新构建的jar包。如果你的项目依赖于另一个频繁变更 的项目，你可以在你的POM中声明SNAPSHOP依赖，以保持与那个项目的同步。例如，在你的POM中 这样写，你可以与Jelly保持 同步更新。
...
commons-jelly
commons-jelly
SNAPSHOT
...

上述语句的含义是：总是使用Maven repository中最新的Jelly构建包。SNAPSHOT依赖 总会导致依赖失败。在这种情况下，Maven就会去Maven repository取得一个SNAPSHOT 依赖包的拷贝。如果你正在离线工作，Maven就会发出警告：“SNAPSHO依赖包可能已经 过期”。

多项目构建和Reactor
在Maven中，Reactor是一个用于控制多项目构建的工具。Reactor用Werkz包,并根据每个项目 各自定义的依赖关系来安排构建顺序。Reactor的意图在于：鼓励创建/重构具有更小、更松散、 更有一致性单元的项目。r源于面向组件编程，在向组件编程中，整个系统由许多松散的个体 构成，这些个体需要聚合起来作为一个整体进行部署。
Reactor可以为某个项目集执行一个任意编排的目标列表。所以，如果使用Reactor的话，它 可以用来做项目站点生成，任意jar包生成这样的事情。
目前 db.apache.org 站点就是收集了其子项目的 丰富信息、并与一系列的Velocity 模板合成的。这一过程是由 Jelly Velocity 标签库来完成的。 这里是其中的机制，有兴趣可以看看。
Plexus(一个基于Avalon的容器)组件的manifest是遍历所有Plexus组件、并聚合而成的。这里 使用的还是Velocity模板和Jelly Volocity标签库。 这里是其中的机制，有兴趣可以看看。
这里是一个使用Reactor标签，遍历一系列组件，最后产生项目站点的例子：
... Do whatever you want with the harvested information ...

如果你需要聚合N个项目的文档，形成一个统一的视图，你可以参考 db.apache.org站点，它从所有的子项目中收集 信息，最终形成一个有导航条，邮件列表，开发者列表和源码repository统一的站点。这解决 了在收集子项目信息过程中的冗余、易于产生错误的问题。db.apache.org的子项目只需关注 自身的信息，却可以自动的集成到高层的项目站点中。

离线构建
如果你需要离线构建，你得在命令行中使用离线选项：
maven -o jar:jar

这等同于：
maven -Dmaven.mode.online=false jar:jar

或者你可以在属性文件中设置 maven.mode.online 属性为false。
在联机模式下，maven总是下载 SNAPSHOT 依赖包, 请参考 使用SNAPSHOT依赖。如果本机repository 上的当前版本比服务器上的还要新，你也许不想maven覆盖你的当前版本。如果不想下载，你可以 设置属性：
maven.repo.remote.enabled=false

在maven beta 9版本中，这个属性并没有起作用(新版本已经解决了这个问题)。可以这样来清空 maven.repo.remote 属性：
maven.repo.remote.enabled=

在命令行或属性文件中设置都一样。
在下面的情形中，你需要同时设置maven.repo.remote.enabled=false maven.mode.online=true：希望javadoc插件的"-link"选项起作用，而又不希望 下载任何(包括snapshot)包。

命令行选项介绍
如果你用命令行来构建，这里提供了一个关于命令行选项的快速参考。
Options:
-D,--define arg 定义一个系统属性
-E,--emacs 输出简洁的日志信息
-X,--debug 输出debug信息
-b,--nobanner 禁止 logo banner
-d,--dir arg 设置指定的工作目录
-e,--exception 输出异常堆栈信息
-f,--find arg 通过搜寻项目文件来确定执行的项目文件及其工作目录
-g,--goals 显示可用的目标
-h,--help 显示帮助信息
-i,--info 显示系统信息
-o,--offline 离线构建
-p,--pom arg 指定项目文件
-v,--version 显示版本号

测试

测试资源
通常情况下，你需要在测试类路径上为测试指定某些资源。你可以在POM中使用
下面的例子说明了如何递归的包含在${basedir}/src/test目录中所有以.xml和.properties为扩展名 的文件：
...
...
...

${basedir}/src/test
**/*.xml
**/*.properties

下面的例子说明了如何递归的包含在${basedir}/src/test目录中所有以.xml和.properties为扩展名 的文件，但naughty.properties文件除外。请注意增加的project/build/unitTest/resources/excludes 节点：
...
...
...

${basedir}/src/test
**/*.xml
**/*.properties

naughty.properties

运行一个单独的测试
下面的命令运行了一个单独的测试：
maven -Dtestcase=org.foo.bar.MyTest test:single-test

打包
JAR 资源
...

${basedir}/src/conf

*.xml
*.properties

${basedir}/src/messages
org/apache/maven/messages
messages*.properties

部署

固化SNAPSHOT依赖
在开发时使用SNAPSHOT依赖包非常方便，但是在部署的时候，你需要把所有的SNAPSHOT依赖包 固定下来，以便发布一个包含固定jar的版本。如果你发布了一个含SNAPSHOT依赖包的项目，而 这些SNAPSHOT在项目发布后发生了变更，你可能很快就会发现这个版本没法儿工作。
当SNAPSHOT以时间戳为版本号部署到Maven上时，Maven可以识别foo-SNAPSHOT.jar实际上相当 于foo-20030101.010101.jar。当部署的时刻来临，你可以用下面的命令，让Maven把SNAPSHOT 版本号变为时间戳版本号。
maven convert-snapshots

Maven会提供交互的方式让你选择哪个SNAPSHOPT依赖包应该固化下来。这一过程结束后，Maven 就会把刚才你的选择写会你的POM。
如果你希望Maven简单的、尽可能最好的固化SNAPSHOT依赖包，你可以用下面的命令：
maven convert-snapshots-auto

拷贝依赖JAR包
在maven.xml这样写下面的语句是最简单的拷贝依赖包的方法。
...
...

用deploy:copy-deps标签你就可以简单的把项目所有的依赖包拷贝到任何 目录，如果希望排除某个依赖包，需要给出一个依赖包的id列表，列表中依赖包就不会被拷贝。

...
...

命名约定
这部分将简要的描述项目对象模型(POM)中命名约定。本篇文档希望可以统一各式各样jar包命名 方法，这些jar包一般为java开发者社区广泛使用。

规则和指南
项目
一个项目必须由一个唯一的的标识，标识由a-z小写字母和连线号构成，其首字母必须以小写字母 开头。

bar
foo
...

所有项目间的引用都由组id和包id构成。到现在为止，在POM与此相关的是下面将要（上面提到的？）谈到的项目的 依赖声明。
项目的名称应该易于阅读，可用于文档。

bar
foo
The Grand Master Foo
...

项目应该有一个组标识，组标识是名称的基础部分。
bar
foo
The Grand Master Foo

...

所有项目发布的包都应基于项目唯一的标识，并且放在基于项目的组id的目录中。对于上面的 项目来说，假定发布的包是jar类型的包，我们就会有如下目录结构：
repository
|
+-- bar
|-- distribution
`-- jar
|-- foo-1.0.jar
`-- foo-2.0.jar


依赖
一个理想的典型依赖声明的例子可能会象这样：

yourProject
yourArtifact
Your Groovey Machine
...

bar
foo
1.0

这样一来，依赖于id为foo1.0 版本的bar项目 属于org.foo.bar组。这个依赖会被解析为本地repository中jar文件。上面 的情形假定发布的包是基于包id命名的。因此对于上述依赖，Maven就会采用 foo-1.0.jar作为jar名。
就像用户反映的那样，这种理想的方式并不能适应所有的项目。有几种情形我们必须考虑调整 理想的依赖机制：

• 发布的jar包的并未使用项目作为基础名，如xercesImpl就是所有发布的jar包的基础名 它与gump id和maven中的id都不一样。
  
• 发布的jar包没有使用任何版本声明，如许多commons组件并没有把版本号作为包名的一部分。
  
• 有些项目即没有使用项目id作为基础名也没有版本声明。例如，最坏的情形是Java Activation Framework 的jar包，它没有遵循其他Sun的命名规则，也没有在jar包中声明 版本号，甚至在manifest中都没有任何版本信息。
  
  在多数情形下，任何例外的情况都可以用 (可选节点)、或者是重命名来解决。 现在，许多Jarkata的产品在repository已经被重命名，因为在不久的未来，绝大多数的Jarkarta的 项目将用maven进行构建。但这不是公司政策，我们不需要解决所有情况的问题。
  
  发布多个包的项目
  Maven的依赖机制完全支持任何形式的多项目包。 Maven's dependency mechanism completely supports multiple project artifacts of any given type.
  下面的代码包含了ant的主jar包和optional包加上hypothetical包。
  ant
  ant
  1.4.1

ant
ant-optional
1.4.1
ant
poorly-named
1.4.1

所以A), B) 和 C)实际上是指向属于同一组的单个包的指针，这就是说，一个单独的依赖就是对某个组中的某个 包的引用。目前artifact如果没有特别说明的话，一般指的是jar包。但是依赖也可能是一个war文件或一个 发行包。我们试图在提供多数情况下(构建大多需要jar包)使用的缺省方式的同时，也顾及灵活性。

远程Repository布局
这部分文档将对Maven的远程repositories做一个概要的说明。目前，主repository位于 Ibiblio，但是你也可以自己创建一 个远程repositories，其结果描述可以在这部分文档中找到。
任何独立的项目在repository都有自己的目录。每个项目有一个唯一的项目id和同名目录， 项目的发行包就放在这个目录中。
项目的目录中可以存放各种各样的artifacts，目前最为广泛使用的两种类型是jar包和发行包 下面是一个远程repository快照：
repository
|
|-- ant
| |-- distribution
| `-- jars
| |-- ant-1.4.1.jar
| `-- ant-optional-1.4.1.jar
+-- jsse
|-- distribution
`-- jars
|-- jsse.jar
|-- jcert.jar
`-- jnet.jar

本地Repository布局
应该有一个接口集合的紧凑实现使本地repository目录结构更加随意一些。现在我只使用 了一个类来实现，显得有些臃肿。我还是认为本地和远程repositories应保持相同的结构 但是为了使用更乐于使用，我开始设计一些接口，用于满足用户自己安排自己本地Repository 布局，相似的远程Repositor也在设计中。尽管目前本地repository仍与远程repository 完全一致，我希望听到更多的用户反馈，以促进这些接口的开发，或者完全抛弃它。

生成项目站点
Maven可以为项目产生一个完成的web站点。这个web站点将包含各种各样、由许多Maven插件 产生的报告，如javadocs，代码度量，单元测试，changlog，及其它... 本节文档接下来的 部分将阐述Maven支持的站点定制选项。

颜色
考虑到一致性，缺省情况下，所有Maven产生的站点都使用相似的外观。这使用户一眼就能 认出由Maven产生的站点，产生熟悉的感觉，更加方便信息的获取。当然，Maven开发组也 考虑到用户可能会希望定制他们的站点。修改Maven产生的站点，最简单的方法是指定你要 使用的颜色搭配。这只需要在project.properties简单的设置适当的属性 即可。下面是所有可用的属性描述在 xdoc plugin。

风格
如果你感觉颜色太过于简单，无法满足你的要求，你可以用自己的stylesheet。为了重载 在${basedir}/xdocs/stylesheets/中的maven.css stylesheet，你可以通过设置maven.javadoc.stylesheet 属性来指定你的 javadoc风格。

报告
最后，如果你希望定制哪些报告需要自动产生，你需要在你的项目描述中包含 reports 标签库。 到目前为止，如果没有reports标签指定，所有插件报告都会产生。这个标签 允许你选择产生哪些报告而排斥另外一些报告，而且允许你安排顺序。
目前的标准 报告集在xdoc中是硬编码实现的，它们是：
maven-changelog-plugin
maven-changes-plugin
maven-checkstyle-plugin
maven-developer-activity-plugin
maven-file-activity-plugin
maven-javadoc-plugin
maven-jdepend-plugin
maven-junit-report-plugin
maven-jxr-plugin
maven-license-plugin
maven-linkcheck-plugin
maven-pmd-plugin
maven-tasklist-plugin

如果你希望产生缺省的报告，但是还想增加或删除一两个，最好的方法是：给 xdoc:register-reports目标写一个前置目标(postGoal)。

排除所有Maven产生的内容
某些情况下，用户需要构建只有文档的站点，或是构建聚合许多子项目的站点，但不希望 在站点上有个整体“项目文档”导航条。设置 maven.xdoc.includeProjectDocumentation属性值为no 即可解决这一问题。缺省的，Maven会包含“项目文档”导航条，下面挂的是许多Maven 生成的报告。 "

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=79196

Maven起步-教你开始使用Maven

Maven起步
作者：Timothy M.O'Brien, Vincent Massol
翻译：Revenger

版权声明：可以任意转载，转载时请务必以超链接形式标明文章原始出处和作者信息及本声明
英文原文地址:
http://www.onjava.com/pub/a/onjava/excerpt/mavenadn_ch01/index.html
中文地址:
http://www.matrix.org.cn/resource/article/43/43661_Maven.html
关键词： Maven Ant Java




编者注：

如果你已经有十次输入同样的Ant targets来编译你的代码、jar或者war、生成javadocs，你一定会自问，是否有有一个重复性更少却能同样完成该工作的方法。Maven便提供了这样一种选择，将你的注意力从作业层转移到项目管理层。Maven项目已经能够知道如何构建和捆绑代码，运行测试，生成文档并宿主项目网页。

O'Reilly's的新书Maven:A Developer's Notebook帮你提升你的项目、使其尽快的运行起来，同时也提供了对Maven插件及其团队协作等高级特性的深度考察。在“Maven Jump-Start” (656K PDF)的示范章节中，作者Vincent Massol和Timothy M.O'Brien向你展示了如何安装Maven，如何开始你初次的构建，研究如何使其与IDEs集成极其资源管等特性。

Vincent Massol是Jakarta Catus framework（框架）的创建者。其后他花费4年的时间在几个大项目（主要是J2EE）的架构技术上。他现在是Pivolis的创办人和CTO,这是一家专注于应用敏捷方法进行软件开发的公司。他现在居住在法国的首都City of Light（巴黎）。

Timothy M. O'Brien作为一个专业的歌手/程序员现正在芝加哥地区工作和生活。




让我们开始使用Maven。在本章结束时，你应该能够从头建立一个Maven的项目，使用Maven进行相关管理，创建基于某些感兴趣报告的简单的web站点。

安装Maven
开始本书以前，你有一些必备的安装工作。本书中的例子用Java1.4.2编写，Maven能够兼容Java1.4.2和Java1.5.0。本书中所写Maven的最新版本是在编写本书时发布的—Maven 1.0.2。除JDK和Maven1.0.2之外，你还需要连接到Internet，Maven将通过公网站点下载相关其需要的。那么，前进，安装Maven吧。

我该如何做？
从Apache Software Foundation(ASF)下载Maven。进入http://maven.apache.org/从左侧的导航菜单中的Getting Maven菜单选择下载。它将带你进入一个让你选择Windows 安装包、zip文件、tar'd.bzip文件或者tar'd.gzip文件。下载适合你平台的分类。

我该如何做？
从Apache Software Foundation(ASF)下载Maven。进入http://maven.apache.org/从左侧的导航菜单中的Getting Maven菜单选择下载。它将带你进入一个让你选择Windows 安装包、zip文件、tar'd.bzip文件或者tar'd.gzip文件。下载适合你平台的分类。

提示
某些Developer's Notebook中涉及的插件未与Maven1.0.2
绑定。请参考第6章并且附录A有安装Maven所需插件的全部
列表以及详细说明。


在Microsoft Windows平台，下载Windows安装包（maven-1.0.2.exe），跟随自动安装过程中的提示。在使用Maven Windows 安装器进行安装后，你应该定义一个用户环境变量，MAVEN_HOME，指向你本地的Maven安装。你此时需要进入控制面版→系统→高级选择环境变量按钮，添加%MAVEN_HOME%\bin到你的PATH环境变量。进入命令提示行运行cmd.exe，如果Maven安装成功，你将能够看到命令行有下面的输出：
C:\dev\mavenbook\code>maven -v
__  __
|  \/  |__ _Apache__ ___
| |\/| / _` \ V / -_) ' \  ~ intelligent projects ~
|_|  |_\__,_|\_/\___|_||_|  v. 1.0.2

如果你愿意安装Maven到一个除了C:\Program Files\Apache Software Foundation\Maven 1.0.2的目录，你也可以下载Maven1.0.2.zip文件，解压缩到任何目录。设置MAVEN_HOME指 向到Maven解压缩的目录，并且添加%MAVEN_HOME%\Bin到你的PATH环境变量。

在Unix平台，下载tar'd.zip文件（Maven-1.0.2.tar.gz）并接压缩tar xvzf maven-1.0.2.tar.gz到你选择的目录。本试验假设你解压Maven到/usr/local/maven-1.0.2目录下。你此时需要设置两个环境变量，MAVEN_HOME和PATH。下面的命令为这两个变量设置适当的值：
[tobrien@mavenbook tobrien]$ export MAVEN_HOME=/usr/local/maven-1.0.2
[tobrien@mavenbook tobrien]$ export PATH=${PATH}:${MAVEN_HOME}/bin
如果Maven被成功安装到你的机器，你能够看到与Windows系统同样的输出。恭喜！你已经成安装了Maven。

提示
有些人喜欢保存本地应用程序在Unix下的/opt目录或
Windows下的c:\apps。你可以根据个人喜好安装Maven。

刚刚发生了什么？
你刚刚安装了Maven1.0.2并且配置了一些环境变量。是的！一旦你对MAVEN_HOME进行了有效的设置或是maven.bat或maven.sh已经存在，你已经能够完成Developer's Notebook本次的实验。

关于....
          ..Maven 2?
是时机提及Maven 2（有时也被称为“m2”）。Maven 2完成了对Maven 1的重写。重写的首要目的是要提供了强大的Jave构建和包含API的项目，允许Maven被植入任何地方，尤其是高级别的产品如IDEs、质量工具、报告工具等这些。Maven 2构建生命周期的概念正式话，其比Maven更易扩展。

Maven 1和Maven 2有许多共同点，但它们还有几个主要的不同之处。在书中的各个部分我们尽可能提示你所希望了解的那些不同之处。更多关于Maven 2的信息，请转到http://maven.apache.org/下载Maven 2的体验版本，并加入Maven用户或开发者邮件列表。如果你听过Continuous Integration，你可能也想看一看命名为Continuum的Maven子项目，地址在http://maven.apache.org/continuum。

开始一个新的项目
创建新项目的争论一部分在于有很大部分的工作努力被用到在“发展基础设施”上—自动构建、单元测试、文档、项目报告等。使用Maven你可以加速这个过程，生成项目的框架使其作为新应用的种子。


我该如何做？
Maven拥有一个应用程序生成插件（Genapp）你能通过其创建一个新项目。首先创建一个空的目录c:\dev\mavenbook\code\genapp\test-application这将成为应用程序生成后的处所。通过执行genapp这个目标来运行Genapp插件，选择默认的模版并且提供一些你的新项目的相关信息。
C:\dev\mavenbook\code\genapp\test-application>maven genapp

__ __
| \/ |__ _Apache__ ___
| |\/| / _` \ V / -_) ' \ ~ intelligent projects ~
|_| |_\__,_|\_/\___|_||_| v. 1.0.2
Attempting to download commons-jelly-tags-interaction-20030211.143817.jar.
4K downloaded
Enter a project template to use: [default]
Enter
Please specify an id for your application: [app]
test-application
Please specify a name for your application:  Example Application
Test Application
Please specify the package for your application: [example.app]
mdn.testapp
build:start:
genapp:
[copy] Copying 1 file to C:\dev\mavenbook\code\genapp\test-application\
src\java\mdn\testapp
[copy] Copying 3 files to C:\dev\mavenbook\code\genapp\test-application\
src\test\mdn\testapp
[copy] Copying 1 file to C:\dev\mavenbook\code\genapp\test-application\
[copy] Copying 2 files to C:\dev\mavenbook\code\genapp\test-application\
BUILD SUCCESSFUL

本插件会要求用户一些输入，从这个输出内容你可以看到你使用了默认的（defalut）应用程序模板，并且你提供了新项目的应用程序ID、name，和包名。默认的（default）应用程序模板创建了一个单独的类，mdn.testapp.app，和一个静态main函数和两个JUnit测试。

Maven的应用程序生成插件生成了下面的目录和文件：

test-application/
project.properties
project.xml
src/
conf/
app.properties
java/mdn/testapp/
App.java
test/mdn/testapp/
AbstractTestCase.java
AppTest.java
NaughtyTest.java

所有Maven项目有一个参考了项目对象模型（POM）的标准目录结构, （as described shortly）。如果你有一些现存的类你想添加到一个项目，添加它们到src/java，如果你有一些单元测试将它们添加到src/test。如果这些已有的类和单元测试依赖一些外部的苦，你将在随后的章节看到如何添加一个附属。xdos目录包含了格式为XDoc的项目文档。

提示
请注意Maven1.0.2装载的Genapp插件版本创建了非标准
的布局。在Maven项目中src/java和src/test不再出现
在固有的源代码和单元测试位置。取而代之的是你可
以使用src/main/java和src/test/java。为了改变这些，
修改你项目的xml文件，改变src/java的引用为src/main-
/java，src/test的引用为src/test/java。更多的信息，
请参见“Maven Conventions”,地址在
http://maven.apache.org/-reference/conventions.html。

project.xml是项目的描述符；它是一个内容为POM的XML文件。让我们看看这个project.xml的拷贝，其已经定义了这个项目：

<project>
<pomVersion>3</pomVersion>
<artifactId>test-application</artifactId>
<name>Test Application</name>
<currentVersion>1.0</currentVersion>
<organization>
<name>Your Organization</name>
<url>http://www.someorganization.biz/</url>
<logo>http://www.someorganization.biz/logo.gif|jpg|...</logo>
</organization>
<inceptionYear>2005</inceptionYear>
<package>mdn.testapp</package>
<logo>http://yourproject/logo.jpg|gif|...</logo>
<description>
An example project
</description>
<shortDescription>
How to use maven in different situations
</shortDescription>
<!-- Many Elements Omitted (see generated POM) -->
<dependencies/>
<build>
<sourceDirectory>src/java</sourceDirectory>
<unitTestSourceDirectory>src/test</unitTestSourceDirectory>
<unitTest>
<includes>
<include>**/*Test.java</include>
</includes>
<excludes>
<exclude>**/NaughtyTest.java</exclude>
</excludes>
</unitTest>
<resources>
<resource>
<directory>src/conf</directory>
<includes>
<include>*.properties</include>
</includes>
</resource>
</resources>
</build>
</project>

该文件告诉Maven有关你项目的全部。build元素定位应用程序原码，单元测试和资源文件包的位置。name, artifactId, currentVersion, inceptionYear, description。
shortDescription标识该项目并且提供了该项目的信息被用作完成品的名字来创建项目。

提示
如果你工作在已有的Maven项目，你应该看到id元素在
artifactId的位置。该id元素已经不被赞成使用，
你可以用artifactId替代。

resources元素被用于JAR插件拷贝资源到JAR生成物。在该元素你指定一批资源到资源库。本例中，自src/conf的资源将被复制到classpath的根目录。换言之，app.properties资源将被复制到所生成的JAR生成物的根目录。如果你想所有位于src/conf的*.properties资源和*.xml资源在mdn.testapp包中生成的JAR有效，你可以按照以下来指定targetPath：

<resource>
<directory>src/conf</directory>
<targetPath>mdn/testapp</targetPath>
<includes>
<include>*.properties</include>
<include>*.xml</include>
</includes>
</resource>

project.properties让你能够定制Maven及其插件在本项目中的行为。你将在看过本书之后使用该文件定制所生成web站点的品质和JAR文件的内容。

提示
关于在没有Genapp插件来生成新Maven项目的快速入
门指导，参见BrettPorter的“The Ten Minute Test”，
地址在http://maven.apache.org/start/ten-minute-
test.html。

关于...
... Maven在有关协作项目中跟踪信息的能力？
为简化本例，我们从project.xml文件中去掉了一些初期显示的描
述项目邮件列表、知识库、开发者和web站点的元素。第4、5章深
入更多有关使用Maven发布web站点和在现有源码库中工作的细节。


在代理服务器下使用Maven
Maven依赖于Internet连接，其通过HTTP下载相关的插件。如果你工作在公共环境，你可能需要配置Maven来与工作代理服务器系统。


我该如何做？
你可能需要设置你项目中project.properties文件的一些属性。project.properties文件允许你通过设置命名的属性来定制Maven的行为。配置代理服务器，放置下面的project.properties到与你项目中project.xml文件同样的位置：
maven.proxy.host = proxy.company.com
maven.proxy.port = 80
并且，如果你需要连接到一个代理服务器必须有NTLM的授
权，设置以下属性：
maven.proxy.ntlm.username = tobrien
maven.proxy.ntlm.password = myp@ssw0rd

提示
在第二章，你将学到user-specific属性将被定义在
~/build.properties或%USERPROFILE%\build.properties 文件。现在，如果你需要完成本试验，在 project.properties里定义这些属性。

编译和测试一个项目
你拥有了一个包含一个类文件和单元测试文件的项目。下
面，让我们够见这个项目和运行应用程序类吧。

我该如果做？
通过执行jar:jar goal来创建一个包含应用程序的类的jar
文件。JAR插件定义了一个速记目标命名为jar其依赖之前的jar:jar goal。执行任何一个目标将得到相同的结果。所有的插件都定义了一条这样的捷径；例如，测试目标执行的是Test插件里的test:test goal。执行jar goal和maven jar：

C:\dev\mavenbook\code\genapp\test-application>maven jar
__ __
| \/ |__ _Apache__ ___
| |\/| / _` \ V / -_) ' \ ~ intelligent projects ~
|_| |_\__,_|\_/\___|_||_| v. 1.0.2
Attempting to download junit-3.8.1.jar.
118K downloaded
build:start:
java:prepare-filesystem:
[mkdir] Created dir: C:\dev\mavenbook\code\genapp\test-application\
target\classes
java:compile:
[echo] Compiling to C:\dev\mavenbook\code\genapp\test-application/
target/classes
[echo]
[javac] Compiling 1 source file to C:\dev\mavenbook\code\genapp\testapplication\
target\classes
java:jar-resources:
Copying 1 file to C:\dev\mavenbook\code\genapp\test-application\target\
classes
test:prepare-filesystem:
Compiling and Testing a Project 9
[mkdir] Created dir: C:\dev\mavenbook\code\genapp\test-application\
target\test-classes
[mkdir] Created dir: C:\dev\mavenbook\code\genapp\test-application\
target\test-reports
test:test-resources:
test:compile:
[javac] Compiling 3 source files to C:\dev\mavenbook\code\genapp\testapplication\
target\test-classes
test:test:
[junit] Running mdn.testapp.AppTest
[junit] Tests run: 1, Failures: 0, Errors: 0, Time elapsed: 0.078 sec
jar:jar:
[jar] Building jar: C:\dev\mavenbook\code\genapp\test-application\
target\test-application-1.0.jar
BUILD SUCCESSFUL
Total time: 9 seconds

Maven创建一个target（目标）目录来保存中间文件和JAR文件。在JAR首次被建立后，按照下面执行App类。

C:\dev\mavenbook\code\genapp\test-application> java ^
More? target\test-application-1.0.jar mdn.testapp.App
Hello World!

如果你想重复此项工作，运行maven clean来移除target目录重新构建。

刚刚发生了什么？
当你运行jar目标时，Maven使用JAR插件来创建了一个JAR生成物。首先，Maven找到一系列的目标以便能够创建这个应用程序的JAR文件；JAR插件有一个其它目标所依赖于目标的jar:jar goal，反过来，它也依赖于其他的目标。Maven找出下列需要的目标来执行：java:prepare-filesystem，java:compile，java:jarresources，
test:prepare-filesystem，test:test-resources，test:compile，and test:test。

Maven查看其需要执行目标中的Test插件来执行单元测试，并且检查本地Maven库中的JUnit JAR文件。因为你还没有使用过Maven，所以它将从位于http://www.ibiblio.org/
maven/的Maven默认库中下载junit-3.8.1.jar。你将在本章后学习到有关Maven本地库和Maven强大的相关管理能力的内容。


与项目对象模型一同工作
Project Object Model（POM）是Maven的重要部分，你将与其一同工作贯穿本书。


我该如何做？
POM同样涉及到项目的描述。project.xml描述了项目的源代码、开发者、源控制，许可和标示信息譬如项目名称和发起组织。Maven打破了过去传统的构建系统；取而代之的是为每个构建提供了外在说明，Maven使用声名的方法管理构建。换句话说，你不用过多的告诉Maven做什么，Maven知道去查找基于project.xml中的内容。另一方面，Ant以命令方式进行项目构建；你最终要告诉Ant编译这个文件，建立这个目录，绑定这些文件到WAR等等。Maven维护一个插件的分类来与标准的POM—一个结构声明、标示和内容工作。

如果你看了上次练习所生成的project.xml文件，你将注意到许多元素都在上次讨论中被忽略。下面的XML列出了POM中顶级的元素，（in the order in which they are expected:
）：

<project>
<extend/>
<pomVersion/>
<id/>
<name/>
<groupId/>
<currentVersion/>
<organization/>
<inceptionYear/>
<package/>
<logo/>
<gumpRepositoryId/>
<description/>
<shortDescription/>
<url/>
<issueTrackingUrl/>
<siteAddress/>
<siteDirectory/>
<distributionSite/>
<distributionDirectory/>
<repository/>
<versions/>
<branches/>
<mailingLists/>
<developers/>
<contributors/>
<licenses/>
<dependencies/>
<build/>
<reports/>
<properties/>
</project>

本章探究更多以上XML列出的元素，包括contributors，developers，dependencies，reports和repository。本章的式样将提供这些细节，但你应该使用上面XML的摘录来以适当的顺序放置这些元素到你的project.xml中。

列出有效的Goals
当你使用Maven时，你将执行目标。Maven插件是一组相关的插件。例如，要为一个项目创建JAR文件，你将如下所示执行JAR插件中的jar:jar goal。
C:\dev\mavenbook\code\genapp> maven jar:jar
冒号之前的jar分类这个目标属于JAR插件。查看全部的JAR插件列表，键入以下命令：
C:\dev\mavenbook\code\genapp> maven -P jar
__ __
| \/ |__ _Apache__ ___
| |\/| / _` \ V / -_) ' \ ~ intelligent projects ~
|_| |_\__,_|\_/\___|_||_| v. 1.0.2
Goals in jar
============
[jar] Create the deliverable jar file.
deploy ......................... Deploy a jar to the remote repository
deploy-snapshot ................ Deploy a snapshot jar to the remote
repository
install ........................ Install the jar in the local repository
install-snapshot ............... Install a snapshot jar in the local
repository
jar ............................ Create the deliverable jar file.
snapshot ....................... Create a snapshot jar, ie '
id-YYYYMMDD.hhmmss.jar'
Plugin for creating JAR files. Requires Maven 1.0 RC2.

如果你需要查看每个有效的插件和目标，输入下面内容：
C:\dev\mavenbook\code\genapp\test-application> maven -g | more
全部的插件可能使人有些畏惧，Maven有关于一切的插件，从生成项目文件到IDEs到生成WAR文件以及开始和停止应用服务器。你将在下面的实验中学习到一些更有用的插件。

生成调试信息
现在，你可能已经注意到Maven执行了许多繁重的工作。如果你使用Ant，你可能已经开始编写Ant的build.xml文件并且添加编译.jar任务和单元测试。Maven隐藏了许多复杂性，但当调试问题时，它也能够查看“幕后”。这个能力运行于Maven的调试模式并且这个工具打印输出每个构建的细节重要的是你可以根据需要来验证构建是否正确执行。


我该如何做？
本次实验，参考上一个测试应用程序。当你运行maven test，你将收到如下信息：

java:compile:
[echo] Compiling to 
C:\dev\mavenbook\code\genapp\test-application/
target/classes
[echo]
java:jar-resources:
[...]

在执行java:comile或java:jar-resources目标时到底发生了什么？执行构建项目中运行maven -x test将显示全部目标的调试信息。让我们来是一下，把注意力放在最早的第三个目标上。运行maven -x test生成下面的输出：

[...]
java:compile:
[echo] Compiling to C:\dev\mavenbook\code\genapp\test-application/
target/classes
[javac]  DEBUG  fileset: Setup scanner in dir
C:\dev\mavenbook\code\genapp\test-application\src\java with
patternSet{ includes: [ ] excludes: [**/package.html] }
[javac]  VERBOSE  mdn\testapp\App.java omitted as mdn/testapp/App.class
is up to date.
java:jar-resources:
DEBUG  FileSet: Setup scanner in dir
C:\dev\mavenbook\code\genapp\test-application\src\conf with
patternSet{ includes: [*.properties] excludes: [ ] }
VERBOSE  app.properties omitted as app.properties is up to date.
[...]

java:compile的打印输出任务可能看起来很熟悉。它是Ant的echo和javac任务的输出。Maven常常使用Ant的进程来执行常用操作如：拷贝、删除、编译和创建JAR文件。

刚刚发生了什么？
这两个目标执行的都是非常简单的调试输出。java:compile目标简单的扫描源目录中java源码中较新的相关类文件。java:jar-resources目标寻找资源中包含的JAR文件。更复杂的如test:test将产生有关虚拟机和类加载器的调试信息。

当Maven有问题或某个目标抛出异常，Maven将简单打印较少的错误信息来告诉你有错误发生。如果你需要等多信息，并且看到堆栈跟踪，添加-e标志到命令行。与-e标志一起，Maven将打印完整的堆栈信息当其遇到错误时。

添加依赖关系
你有了一个拥有单个类文件并且已经成功编译执行的项目。下面，你将添加一个依赖关系到项目描述器并且开始使用Maven管理项目依赖关系。本次实验的目的是，假设你需要工作在Spring框架中。添加Spring框架-spring-core-1.1.4.jar和spring-web-1.1.4.jar的依赖关系。


我该如何做？
首先，你需要根据需要定位Maven默认中心源码库中的JAR文件。ibiblio.org在http://www.ibiblio.org/maven/提供了这些。在Web浏览器中加载这个URL你将看到一系列的目录；我们关心的是springframework的目录，springframework下子目录的结构如下所示：
http://www.ibiblio.org/maven
/springframework
/jars
spring-core-1.1.4.jar
spring-dao-1.1.4.jar
spring-web-1.1.4.jar

依照人造物，你使用dependency—groupId, artifactId和version三个元素。你能够添加两个依赖关系的完成品以替代test-application/project.xml中的dependencies元素如下所示：

<dependencies>
<dependency>
<groupId>springframework</groupId>
<artifactId>spring-core</artifactId>
<version>1.1.4</version>
</dependency>
<dependency>
<groupId>springframework</groupId>
<artifactId>spring-web</artifactId>
<version>1.1.4</version>
</dependency>
</dependencies>

现在，运行jar目标并且看看Maven的输出吧；它将包含下面如下这些。

Attempting to download spring-core-1.1.4.jar.
266K downloaded
Attempting to download spring-web-1.1.4.jar.
111K downloaded

图1-1显示了jar目标触发的一系列事件：
1.Maven查看POM,依据project.xml的定义，看到在springframework组中的两个人造物的依赖关系。它将载你本地Maven的资源库中检查spring-core-1.1.4.jar和spring-web-1.1.4.jar。
2.当Maven找不到这些文件，它将到http://www.ibiblio.org/maven/springframework/jars/寻找JAR文件。这些JAR文件会被下载并放置于你本地Maven的资源库中。它们也被添加到你项目的classpath中。下次在你的项目查询这些文件时，Maven将在你本地的资源库中提供它们。


图1-1.Maven本地和远程资源库为test application项目提供的spring Jar。

刚刚发生了什么？
Maven为你节省了相当的时间和不必要的麻烦。Maven到来之前，依赖关系常常被捆绑到一个项目的目录或者项目应该指向到添加正确的JAR到你的classpath。使用Maven管理依赖关系显然有着明显的优势；作为初学者，如果你的项目依赖30个外部的JAR文件，这就不需要在你的资源库中存储成兆的JAR文件。这意味着当你在项目的外部检查资源控制的时候更少的存储空间和更快的下载时间。另外，如果你有多个项目依赖相同的外部依赖，Maven仅需要下载一次依赖关系，并且每个项目引用一个单独的副本在你本地的资源库中。当依赖关系能够从Maven资源库远程下载的时候，没有强制的原因让你存储你项目的依赖关系的版本。

当Maven下载依赖关系，其在你本地的机器上从远程的Maven资源库拷贝一个文件到你本地的Maven资源库。Maven如何定位依赖关系的？它使用project.xml中dependency元素的信息，如图1-2所示。


图1-2.POM和Maven资源库的映射。

指定的groupId告诉Maven查看特定的目录-springframework。指定type告诉Maven查找特定的子目录如jar和war（注意s是Maven附加到type元素上的）；本例中，type是被忽略的，JAR类型是默认类型。当你指定了artifactId，你正告诉Maven哪个文件将从jar目录下载。顶级目录表现为组标示符，JAR文件名的第一部分表现为artifact标示符，文件名最后的部分，包括扩展名表现为version标示符。Maven使用下面的公式来决定一个来自于资源库中的依赖关系。[REPO_ROOT]参考你远程的资源库：

[REPO_ROOT]/<groupId>/<type>s/<artifactId>-<currentVersion>.<type>

提示
Maven2.0的说明中，资源库可能开始于类似Java包的
结构。作为springframework的替代，groupId被提议
的结构为org.springframework。另外，每个版本将有
一个分隔目录用以增加Maven资源库的效率。更多有关
改变的提交建议，参见http://docs.codehaus.org/display/
MAVEN/Repository+Layout+-+Final。

一个本地的资源库来处理依赖关系。在Unix机器上，你的Maven资源库能在~/.maven/repository目录找到，在Windows机器上，你的Maven的资源库在你的%USERPROFILE%目录。如果你看一看本地Maven的资源库，你将会注意到它正包含一个springframework的目录。%USERPROFILE%\.maven\repository\springframework\jars目录包含spring-core依赖关系的两个：spring-core-1.1.4.jar文件和spring-core-1.1.4.jar.md5文件,其包含MD5文件用于验证sprint-core JAR文件的完整性。Maven 1当前并没有使用MD5来验证完成品的完整性，但在将来的版本可能会用其来验证完成品的完整性。

提示
在Windows机器上，%USERPROFILE%通常决定于C:\D-
ocuments and Settings\vmassol这种目录。%USERPR-
OFILE%被用在Unix的主目录。（%USERPROFILE% is
used in the spirit of the abbreviation for a Unix home directory。）

关于...
...使用id元素?

如果你工作在现存的Maven项目，你可能有依赖关系使用id元素。下面的dependencies元素示范了使用单独id元素来附加Jakarta Commons Math的1.0版本：

<dependencies>
<dependency>
<id>commons-math</id>
<version>1.0</version>
</dependency>
</dependencies>

单独使用id元素工作仅在groupId和artifactId匹配时，如果你浏览Maven资源库，你将看到下面的目录结构：
/commons-math
/jars
commons-math-1.0.jar
commons-math-1.1.jar

使用id元素工作，单独的id标记已经不被赞成使用并在Maven 2中消失。当你看到别的Maven项目中使用dependencies的速记符号时，请尝试使用groupId和artifactId来标识你的依赖关系。

依赖快照
如果你开发的程序依赖的依赖关系经常改变，你可能想将依赖的每个依赖关系替代为最近构件的硬编码的版本。在一个项目依赖的依赖关系还处在beta的版本，或你正开发一系列项目依赖的Maven项目时时特别有用，这将在第3章论述。本实验，你将学习到如何依靠快照。


我该如何做？
在你的依赖关系块儿中指定一个明确的版本，使用SNAPSHOT关键字作为版本名称的一部分。每次你执行Maven目标时，Maven将从远程资源库中检查较新的依赖关系。如果远程资源库的版本较新Maven将下载其到本地资源库。例如：下面的依赖关系将一直下载spring的新版JAR文件。

<dependency>
<groupId>springframework</groupId>
<artifactId>spring</artifactId>
<version>1.2-SNAPSHOT</version>
</dependency>

刚刚发生了什么？
当你使用SNAPSHOT依赖关系，你正告诉Maven使用远程资源库的最新版本。在你使用多项目插件或者当你依赖的一个完成品尚处于开发阶段这将得心应手。在你工作的团队仅有较少的开发者组成时，最好也常这么做。你将使用SNAPSHOT依赖关系当你的项目依赖一个最近的开发或者非正式版本的特别组件。SNAPSHOT依赖关系应该在开发阶段被保留，并且，概括说，你不用改发布一个依赖于SNAPSHOT依赖关系的项目。

执行脱机构建
如果你需要在一个离线的情况下使用Maven，你可能需要知道如何确使Maven不检查最新的SNAPSHOT依赖关系。本实验将向你展示如何用Maven执行脱机构建。


我该如何做？
这个方法很简单：仅仅使用-o命令行选项。例如，如果你没有网络连接，但又想执行测试目标，运行Maven -o test。Maven将执行这个test目标而不检查依赖关系。如果你的项目没有依赖SNAPSHOT构建，你也可以断看你的环境来添加-o标志。如果你依赖SNAPSHOT构建，你将需要使用-o标志，Maven将在每次执行目标时尝试检查最新的SNAPSHOT。在这种情况下不使用-o标志本项目将不会构建成功。


关于...
... 执行离线构建如果你不想下载任何完成品？
当然，这将不会工作。离线构建的工作，你必须已经有必需的依赖关系在你本地的资源库。项目最简单的获得Maven下载依赖
关系的方法是在每个Maven项目实例简单的运行“noop”目标，build:start。这个目标执行之前任何其它的目标并不执行任何动作。如果你运行build:start，Maven将从project.xml获得获取任何依赖关系。


使用Maven控制台
如果你再三的从命令行运行Maven，你可以通过Maven控制台来节省时间。Maven控制台提供一个“外壳”，在这你可以键入目标的名称来执行Maven。通过使用Maven可以避免每次载你想运行一个Maven目标时Java Virtual Machine（JVM）启动的等待。


我该如何做？
Maven Console是一个插件，你可以通过键入maven console在命令提示符。这将产生下面的输出：

__ __
| \/ |__ _Apache__ ___
| |\/| / _` \ V / -_) ' \ ~ intelligent projects ~
|_| |_\__,_|\_/\___|_||_| v. 1.0.2
The following commands are available:
list - list all available goals
help - this message
<goalname> - attain a goal
quit - quits the console
test-application 1.0 >

目前，你可以在命令行执行任何你能执行的目标。开始是一下；键入 java:compile。Maven将执行 java:compile目标并返回提示符其它的目标。在一个序列中运行两个目标，你可以在提示符处输入它们，通过“空格”-例如， clean test。众所周知作为“goal chaining”这是你想通过Maven获得指定一系列目标的方法。退出Maven Console，键入quit，查看有效目标列表，键入list。

刚刚发生了什么？
在Maven Console下Maven执行java:compile目标非常之快，不信么？当你使用Maven Console时你所执行的目标是在一个现成的JVM下。当你从命令行运行Maven时，你每次运行一个目标都不得不等待JVM的启动。如果你不确信其对性能的提升，自己试试看。在命令行下运行java:complie 10次，再在Maven Console下同样运行java:compile 10次。注意时间的差别，你将发现JVM启动的时间开始增加。如果你找到你自己常用的Maven目标，Maven Console将通过启动JVM一次为来节省时间。


生成Eclipse项目
我打赌你一定想在IDE下工作。Maven通过插件来与Eclipse,InelliJ,IDEA,JBuilder,JDeveloper以及Emacs集成。Maven很好的与全部这些工作集成，本实验关注其在Eclipse上的集成，一个开源的IDE。


我该如何做？
这个过程很简单；仅仅执行eclipse插件：

C:\dev\mavenbook\code\genapp\test-application> maven eclipse
build:start:
eclipse:generate-project:
[echo] Creating C:\dev\mavenbook\code\genapp\test-application/.project ...
eclipse:generate-classpath:
[echo] Creating C:\dev\mavenbook\code\genapp\test-application/.classpath ...
[echo] Contains JUnit tests
[echo] Setting compile of src/test to target/test-classes
Plugin 'cactus-maven' in project 'Test Application' is not available
[echo] Setting default output directory to target/classes
eclipse:
[echo] Now refresh your project in Eclipse (right click on the project
and select "Refresh")
BUILD SUCCESSFUL
Total time: 2 seconds

Maven创建两个文件以识别Eclipse的项目：.project和.classpath。在Eclipse中，你就可以通过下面的步骤导入这个工程了：
1.启动Eclipse。
2.从菜单栏选择File→Import...&#61472;
3.选择现存项目放入Workspace并单击Next按钮。
4.在Import对话框选择C:\dev\mavenbook\code\genapp\test-application目录，并单击Finish按钮。

你稍候将执行更多步来指向Eclipse到本地Maven资源库。Eclipse使用一个名叫MAVEN_REPO来指向到本地Maven资源库。你能通过在命令行执行下面的操作设置MAVEN_REPO来使用Maven:
maven -Dmaven.eclipse.workspace=c:\eclipse\workspace eclipse:add-maven-repo
执行这个目标可以设置位于目录c:\eclipse\workspace的全局变量MAVEN_REPO。
作为选择，你可以按照这些步骤手工配置该变量：
1.从菜单栏中选择Window→打开Eclipse Preferences选择preferences。
2.在树型菜单左手边的Preferences对话框，选择Java→Build Path→Classpath变量。
3.单击New按钮来创建一个新的变量；这可以带入到新变量对话框。
4.输入MAVEN_REPR到Name域。
5.单击Folder按钮选择你本地的Maven资源库。
6.单击OK并重新构建你的项目。

你可能需要配置MAVEN_REPO仅一次；该变量是全局的它可以与全部Eclipse项目共享。

关于...
... JBuilder, JDeveloper, and IntelliJ IDEA？
所有这些IDE有着Eclipse一样简单的插件。为JBuilder 项目生成必需的文件，运行mave jbuilder，对于JDeveloper运行mave jdeveloper，为IntelliJ IDEA项目运行mave idea。


使用Maven的Eclipse插件
是的，这是一个你可以使用的高品质的Maven插件。它提供了许多有趣的特性，如编辑project.xml文件的能力，支持Maven自定义，Maven资源库浏览等其他功能。


我该如何做？
Mevenide (http://mevenide.codehaus.org/mevenide-ui-eclipse/update/index.html) 是一个Eclipse插件其允许你使用Maven在Eclipse中工作。你能够按照如下指导从Eclipse更新站点上下载它：
1.启动Eclipse。
2.从菜单中选择Help→Software Updates→Find and Install。
3.在Install/Update和更新的对话框中，选择“Search for new feature to install,”并单击下一步。
4.在Install对话框中，单击New Remote Site。
5.在New Update Site对话框中，键入Mevenide在Name域，其位置在Eclipse Updates站点的URL区域。Mavenid在Eclipse Update站点中的位置是http://mevenide.codehaus.org/release/eclipse/update/site.xml。
6.当单词Mevenide出现在Install对话框中，选择两个子目标，Maven和Mevenide并单击Next。
7.直到Maven和Mevenide被下载和安装，重起Eclipse。

首先你会注意到Mevenide标注所有project.xml文件为绿色图标。在Project Object Model编辑器中打开project.xml，右击任何project.xml文件并选择Open With...→Project Object Model编辑器。该编辑器如下图1-3所显示。



Mevenide在Eclipse中提供了一系列tab让你编辑不同的project.xml片断。如果你学到了很多的project.xml语法，就知道Mevenide的Project Object Model编辑器提供了GUI接口来维护这个XML文件。如果你仍然希望直接编辑这个XML，你能够选择最右边的Source tab。
除POM编辑器之外，Mevenide也为你提供了Eclipse以外执行Maven目标的方法。要在Eclipse中执行一个Maven目标，选择Run→External Tools…→External Tools…你就能够创建一个Maven的配置并从全部有效的目标中选择你希望执行的目标。当目标在Eclipse中被执行，通过Console视图有效得显示它的输出。

Mevenide提供的另一个有趣的功能是Repository Browser。这个工具允许你检查许多远程资源库的内容。打开Repository Browser，选择Window→Show View…→Other…，此时在Maven目录的结果对话框中选择Repository Browser。Repository Browser简单的以树型显示了资源库中的全部依赖关系（dependency），如图1-4所示，其显示了HTTPClient和abbot group的依赖关系。


图1-4.Mevenide Repository Browser view

如果你想搜索资源库中完成品的细节，Mevenide同样提供了资源库搜索功能。这将是得心应手的因为为了某个依赖关系的细节搜索http://www.ibiblio.org/maven是非常恼人的。检查Mevenide；它将为你节省时间。

关于...
... NetBeans和JBuilder？
Mevenide当前的版本支持这两个IDE的表现。更多详情参见http://mevenide.codehaus.org/。
... IntelliJ？
IDEA插件维持了一些目标如同你在Eclipse中使用的目标。更多详情参见位于http://maven.apache.org/reference/plugins/idea/goals.html的IDEA插件的联机文档。


生成Ant构建文件
当你想用Apache的Ant构建的某些时候。可能你的项目使用自动化处理正依赖于Ant，又可能你有一些团队成员没有完成到Maven的转换并且他们希望继续使用Ant。目前为止许多IDE提供通过Ant构建项目文件，你能够使用Maven生成build.xml文件这样你的项目就能够被Apache的Ant所构建。


我该如何做？
运行Ant插件。运行maven ant将创建build.xml文件其包含到聚合的依赖关系的目标，build和test你的应用程序。看看运行默认的jar目标的输出：

C:\dev\mavenbook\code\genapp\test-application>ant
Buildfile: build.xml
init:
[mkdir] Created dir: C:\dev\mavenbook\code\genapp\target\lib
get-deps:
[get] Getting: http://www.ibiblio.org/maven/springframework/jars/
spring-core-1.1.4.jar
[get] Getting: http://www.ibiblio.org/maven/springframework/jars/
spring-web-1.1.4.jar
compile:
[copy] Copying 1 file to C:\dev\mavenbook\code\genapp\target\classes
junit-present:
[echo] = = = = = = ============ WARNING = = = == = = = = = = = = = = = = = = = = = = =
[echo] Junit isn't present in your ${ANT_HOME}/lib directory. Tests not
executed.
[echo] = = ==============================================
compile-tests:
internal-test:
test:
jar:
[jar] Building jar: C:\dev\mavenbook\code\genapp\test-application\
target\test-application-1.0.jar
BUILD SUCCESSFUL
Total time: 2 seconds

你可能注意到这里存在一个问题，这是个说明性的问题。Apache Ant没有自动管理依赖关系用于可选的Ant任务。如果你向运行JUnit单元测试，你就需要从本地Maven资源库拷贝junit-3.8.1.jar到${ANT_HOME}/lib下。这个构建文件包含了一个get-deps的目标其从位于http://www.ibiblio.org/maven的远程Maven资源库为所有的项目依赖关系执行Ant获得任务到gran。

关于...
... 试图离开Ant?Maven是Ant的替代者么？
是或不是。Ant并不“差”，并且多数工具仍然同Ant工作。没有理由不提供与Apache Ant的交互，一旦你学到更多关于第2章的Jelly，你将发现Ant工作在Maven里应用的更广泛。许多项目使用持续集成的系统如其期望的Ant构建文件。运行maven ant provides很容易找到继续支持这些工具。


移植一个Ant项目到Maven
一定数量的项目使用Ant作为构建系统，你可能打算移植到Maven上来。


我该如何做？
从头开始。创建一个默认的Maven模版，并且移动你的代码到适当的位置。不要设法使Maven适合你项目的目录和构建位置。Maven强过一个构建工具；它是一个标准方式考虑到项目的布局和管理。如果你试图使Maven适应你项目的想法来构建，你将结束使用Maven。如果你的项目由一个复杂的buil.xml文件组成其产生许多不同的交付结果，你将需要“组件化”你的项目请跟随第3章的多项目描述。你可能要开始移动你项目的目录结构转向标准的Maven项目目录结构。换而言之，不要试图生搬硬套你的项目到Maven。
如果你对迁移到Ant感兴趣，但你没有时间停止开发，你可以使用Maven调用你现存的Ant目标。如果你这么做，你将错失使用Maven的大部分益处，但仅仅是可能。更多信息参见位于http://maven.apache.org/using/migrating.html的“Migrating from Ant”。

关于...
... 灵活性和选择？
灵活性和选择是个比较老的问题了。我们保证Maven将改变你构建和维护项目的方式方法，重要的是应该有意的使用Maven。Ant和Maven间的差别是什么呢？Ant提供块构建的可重用任务如copy,move,delete和junit，Maven提供了可重用的任务构建。Maven是一个“构建容器”，其允许你在一系列项目上重用任务构建。以单元测试为例，使用Ant，你将通过在你项目的build.xml文件里包含下面来执行JUnit测试。

<junit printsummary="yes" haltonfailure="yes">
<classpath>
<pathelement location="${build.tests}"/>
<pathelement path="${java.class.path}"/>
</classpath>
<formatter type="plain"/>
<test name="my.test.TestCase" haltonfailure="no" outfile="result">
<formatter type="xml"/>
</test>
<batchtest fork="yes" todir="${reports.tests}">
<fileset dir="${src.tests}">
<include name="**/*Test*.java"/>
<exclude name="**/AllTests.java"/>
</fileset>
</batchtest>
</junit>

该片断省略的不同路经和变量的定义如build.tests和java.class.path，同时也省略的Ant目标的定义。另外一些单元测试类，你也需要定义一个标以目标在源文件和单元测试中，并且一个目标对应创建一个目录。每个项目需要定义同样的逻辑以执行单元测试。最后，大多数的Ant项目使用了相似的目录结构，并且构建逻辑重用是通过拷贝和粘贴到build.xml文件。时间推移，项目将变的更复杂和用户化，目录标准增加并且每个项目趋于不同的编译、测试方法和包；久而久之，build.xml变成项目中的一部分了。你定制的Ant构建文件越大，越多的(entropy creeps)会进入到你的构建工作。Ant作为一个构建工具的能力要少于其作为语言提供构特性的API。1.6的Ant，含有了Ant库和宏。在完成全局可重用的表现上与Maven相比Ant还有一段很长的路要走。

利用Maven的Test插件为所有项目定义通用逻辑其需要编译和执行单元测试。单元测试插件为编译和执行单元测试获得了最好的实践，并且它为所有项目达成了最有效的实践。当你运行maven test，Maven从POM传递信息到Test插件，Test插件则依赖于Java插件来执行编译。在Maven中没有一处你明确的告诉构建容器如何执行JUnit单元测试。如果你这么做了，在Ant中你将会面对同样的问题。正如你不用告诉你的Servlet容器如何解压WAR文件一样，你不用告诉Maven如何构建你的项目。Maven是一个构建容器。许多人最初被Maven吸引是因为它提供了依赖关系管理，但Maven最大的好处是它提供了标准的开发结构来访问多个项目。依赖关系管理仅仅是标准开发结构的一个简单的副产品。

提示
Maven提供了开发结构，统一了项目布局，在最后你可
以尝试让Maven照管许多构建任务的细节。与其花费你
重要的时间来写构建脚本，不如使用Maven插件来把焦
点放到编写你应用程序上来。

下面的章节将向你展示如何调整和定制Maven，但你需要确定你并不要求Maven成为另一个Ant。很有可能你有一个巨大的重建于Ant的build.xml文件充满了Jelly脚本（见第2章）并且的Maven项目和一个大的maven.xml文件。但如果这么做你则失去了所有Maven的指向。如果你发想自己包含了很多构建相关的逻辑在你的Maven构建，你需要慎重考虑使用Maven。高定制化的Maven构建是矛盾的；你的Maven项目应该对现存插件起到杠杆作用。例如，如果你的项目需要编译Jave源文件，创建JAR文件，使用Jave插件和JAR插件。如果你忽略重用Maven插件使用Maven的Ant集成则是重复制造轮子，你最好不要使用Maven。不要滥用Maven；合理使用Maven，省省你的火气。

生成项目文档
如果你正开发Java应用程序或者库，你可能想生成JavaDoc。

我该如何做？
简单的执行javadoc目标，Maven将生成项目的文档。下面是执行javadoc目标的输出：

C:\dev\mavenbook\code\genapp\test-application>maven javadoc
__ __
| \/ |__ _Apache__ ___
| |\/| / _` \ V / -_) ' \ ~ intelligent projects ~
|_| |_\__,_|\_/\___|_||_| v. 1.0.2
build:start:
xdoc:init:
maven-javadoc-plugin:report:
[mkdir] Created dir: C:\dev\mavenbook\code\genapp\test-application\
target\javadoc\src
[javadoc] Generating Javadoc
[javadoc] Javadoc execution
[javadoc] Loading source files for package mdn.testapp...
[javadoc] Constructing Javadoc information...
[javadoc] Standard Doclet version 1.5.0_01
[javadoc] Building tree for all the packages and classes...
[javadoc] Generating C:\dev\mavenbook\code\genapp\test-application\
target\docs\apidocs\constant-values.html...
[javadoc] Copying file C:\Documents and Settings\tobrien\.maven\cache\
maven-javadoc-plugin-1.7\plugin-resources\stylesheet.css to file C:\dev\
mavenbook\code\genapp\test-application\target\docs\apidocs\stylesheet.css...
[javadoc] Building index for all the packages and classes...
[javadoc] Building index for all classes...
[delete] Deleting directory C:\dev\mavenbook\code\genapp\testapplication\
target\javadoc\src
BUILD SUCCESSFUL
Total time: 7 seconds
Once this goal has been executed, JavaDoc is available in testapplication/
target/javadoc/src.

刚刚发生了什么？
再次，Maven作了全部繁重的工作。你想要JaveDoc，你告诉Maven生成JaveDoc，故事结束。注意你不用告诉Maven任何你项目的情况；它“知道”如何做，Maven这很多这样的事都是直截了当的；在你告诉Maven有关你的项目后你就不用做什么了。Maven操作细节。



介绍Maven给你的团队
Maven是一个伟大的协作工具，你能够使用它生成开发者活动报告，项目捐赠者和邮件列表。


我该如何做？
许多项目有一个邮件列表其被用于讨论架构和实现。并且，通过透视图，如Tomcat，Maven和Ant等项目，并不仅仅是一个开发者社区来共享捐赠到同样的邮件列表。邮件列表不仅用于开源项目；许多组织开始使用同样的协作模型用于开启，发布开发。因为邮件列表是协作的关键部分，Maven提供了在一个项目的project.xml中指定邮件列表的途径。下面引用project.xml添加邮件列表的元素：

<mailingLists>
<mailingList>
<name>Maven User List</name>
<subscribe>users-subscribe@maven.apache.org</subscribe>
<unsubscribe>users-unsubscribe@maven.apache.org</unsubscribe>
<archive>http://marc.theaimsgroup.com/?l=turbine-maven-user</archive>
</mailingList>
<mailingList>
<name>Maven Developer List</name>
<subscribe>dev-subscribe@maven.apache.org</subscribe>
<unsubscribe>dev-unsubscribe@maven.apache.org</unsubscribe>
<archive>http://marc.theaimsgroup.com/?l=turbine-maven-dev</archive>
</mailingList>
</mailingLists>

有两种类型的团队成员位于Maven项目中：捐赠者和开发者。这种定义可能改变你的项目，捐赠者通常被认为是开源社区中捐赠过补丁或文档者，开发者是一个项目的核心成员。在ASF，提交者和捐献者可以一同捐献一个项目，但捐献者既不写资源库代码又不提交大的项目决定。下面引用了project.xml添加contributor和developer元素到project.xml文件：

<developers>
<developer>
<name>Vincent Massol</name>
<id>vmassol</id>
<email>vmassol@apache.org</email>
<organization>Apache Software Foundation</organization>
<roles>
<role>Author</role>
<role>Developer</role>
</roles>
<url>http://www.massol.net</url>
<timezone>+1</timezone>
</developer>
</developers>
<contributors>
<contributor>
<name>Tim OBrien</name>
<email>tobrien@apache.org</email>
<organization>Apache Software Foundation</organization>
<roles>
<role>Author</role>
<role>Developer</role>
</roles>
<url>http://www.oreillynet.com/pub/au/1738</url>
<timezone>-6</timezone>
</contributor>
</contributors>

刚刚发生了什么？
你告诉Maven谁在这个项目工作，对于今后你生成项目的web站点很有用。开发者和捐赠者的信息在POM中以列表的通过站点生成插件，很多插件为资源控制生成报告。跟资源控制对话...。


向Maven到资源控制
你使用资源控制么？把它告诉给Maven，在本书的下面你将能够生成一些有兴趣的描述报告。一旦你关联了源代码资源库到你的项目，你将能够是用Maven的Source Control Management(SCM)插件，其提供了许多目标（goal）用于从诸如CVS和其子版本的版本控制系统更新和发布。


我该如何做？
你需要添加一个respository元素到你项目的project.xml文件。下面的respository元素来自于Apache Struts项目，并且它指向到位于有效的子版本资源库http://svn.apache.org/repos/asf/struts/core/trunk：

<repository>
<connection>
scm:svn:http://svn.apache.org/repos/asf/struts/core/trunk
</connection>
<developerConnection>
scm:svn:https://svn.apache.org/repos/asf/struts/core/trunk
</developerConnection>
<url>http://svn.apache.org/repos/asf/struts/core/trunk</url>
</repository>

connection元素告诉Maven有关SCM只读的位置。scm标识该URL起始于SCM位置，svn告诉Maven该URL将是资源库的子项目，并且最终的片断定位于项目的trunk。你可能也指定了developerConnection，你使用该元素在你需要分隔观众人群的不可写访问和一般人群的可写访问源代码。url元素提供了能够被浏览的资源库的URL。在Struts的案例中，他们选择了指向资源库到它自己，它能够被一个正常的浏览器所浏览。Struts团队也可以指向到ViewCVS实例配置指向到ASF的资源库的子版本，它能够在http://cvs.apache.org/viewcvs.cgi/struts/core/trunk/?root=Apache-SVN的位置找到。

当你在一个详细的资源控制系统指定了project.xml，你也可以指向到一个详细项目的不同版本和分之。下面的XML展示了简化版的Apache Struts项目的version和branche元素。

<versions>
<version>
<id>1.2.0</id>
<name>1.2.0</name>
<tag>STRUTS_1_2_0</tag>
</version>
<version>
<id>1.2.6</id>
<name>1.2.6</name>
<tag>STRUTS_1_2_6</tag>
</version>
</versions>
<branches>
<branch>
<tag>STRUTS_1_1_BRANCH</tag>
</branch>
<branch>
<tag>STRUTS_1_2_BRANCH</tag>
</branch>
</branches>

Version被用于几个插件，如Announcements插件，其用于为每个版本创建发布纪录。

关于...
... CVS？
如果你的项目使用CVS，在Jakatta Catus项目中你将需要添加一个如repository元素的资源库元素如下所示：

<repository>
<connection>
scm:cvs:pserver:anoncvs@cvs.apache.org:/home/cvspublic:jakarta-cactus
</connection>
<url>http://cvs.apache.org/viewcvs.cgi/jakarta-cactus/</url>
</repository>

在使用CVS paserver如果你暴露你的资源库上面的引用是合适的。如果你在SSH之上访问CVS，你就需要按照下面的语法设置你的CVS_RSH环境变量。

<repository>
<connection>
scm:cvs:pserver:anoncvs@cvs.apache.org:/home/cvspublic:jakarta-cactus
</connection>
<url>http://cvs.apache.org/viewcvs.cgi/jakarta-cactus/</url>
<developerConnection>
scm:cvs:ext:tobrien@somehost:/home/cvs/repository:modulename
</developerConnection>
</repository>

创建项目Web站点
Maven能够创建项目web页，包含项目的有关信息。


我该如何做？
创建一个Maven项目web站点，使用Site插件运行下面的Maven目标：
C:\dev\mavenbook\code\genapp\test-application> maven site
运行Site插件将在test-application/target/docs/index.html目录创建默认的项目站点。如果你加载这个HTML，你将发现这个站点与众不同的Maven感观。图1-5展示了一个轻量的定制web站点，包含定制的组织logo和项目logo。作为替换向你展示了人工的web站点，你能够看出这个站点的项目当前正使用Maven的构建系统-Jaxen。


图1-5.简单的Maven项目站点。

许多Maven站点有一个项目导航部分用于提供链接系统向所有的Maven项目。项目信息包含项目的有关信息，项目的邮件列表，项目的资源控制及问题跟踪（你将在第4章找到所有的这些）。通过在xdocs目录里创建和修改XML标记生成Maven web站点的目录。在图5，项目包含5个项目细节文档：Overview,FAQ,Releases,CVS Access和Status。这些文档因为被包括在xdocs/navigation.xml文件中所以他们被包含在左边的导航栏。xdocs目录是Maven存放XML XDoc格式的项目细节文档的地方。下面是Jaxen的navigation.xml文档的内容：

<?xml version="1.0" encoding="ISO-8859-1"?>
<project name="jaxen" repository="jaxen" href="http://jaxen.org">
<title>jaxen: universal java xpath engine</title>
<body>
<links>
<item name="The Werken Company" href="http://www.werken.com/"/>
</links>
<menu name="jaxen">
<item name="Overview" href="/index.html"/>
<item name="FAQ" href="/faq.html"/>
<item name="Releases" href="/releases.html"/>
<item name="CVS Access" href="/cvs-usage.html"/>
<item name="Status" href="/status.html"/>
</menu>
</body>
</project>

link元素放置一个链接http://www.werken.com到页面的右手边，项目的logo之下，menu元素包含了用以显示的左右边的导航区域。菜单中的一个文件是xdocs/index.xml。下面是Jaxen的xdocs/index.xml文件的简短目录：

<?xml version="1.0"?>
<document url="http://jaxen.org/index.xml">
<properties>
<author email="bob@eng.werken.com">bob mcwhirter</author>
<title>jaxen</title>
</properties>
<body>
<section name="News">
<p>
Added the slidedeck from my
<a href="/pdf/intro-slides.pdf">SD-West presentation</a>.
</p>
<p>
Check out these
<a href="http://dom4j.org/benchmarks/xpath/index.html">Performance
Benchmarks</a> comparing dom4j and Jaxen against Xerces and Xalan.
</p>
</section>
[...]
</document>

一旦你生成了你的项目站点，加载target/docs/index.html到一个浏览器来查看你项目的web站点。

关于...
... 这些文件的语法？
你能在Maven XDoc插件的FAQ（http://maven.apache.org/reference/plugins/xdoc/faq.html）找到navigation.xml文件的更多相关语法和格式信息。并且你也能在Maven XDoc Plug-in page（http://maven.apache.org/reference/plugins/xdoc/index.html）上找到更多有关individual pages格式的信息。这个插件也面也包含更多定制站点生成插件的输出和行为的说明。
看第4章有关多样化报告的更深的分析，这样你句能够把项目活动和结构搞清楚了。


定制站点报告
站点生成创建了许多有用的报告，但依照你的风格，你可能想取出其中的某些报告。


我该如何做？
修改project.xml中的reports元素内容来改变Maven站点生成对报告的生成。下面是reports元素中的几个有效的报告活动：

<reports>
<report>maven-changelog-plugin</report>
<report>maven-changes-plugin</report>
<report>maven-checkstyle-plugin</report>
<report>maven-clover-plugin</report>
<report>maven-cruisecontrol-plugin</report>
<report>maven-developer-activity-plugin</report>
<report>maven-faq-plugin</report>
<report>maven-file-activity-plugin</report>
<report>maven-license-plugin</report>
<report>maven-linkcheck-plugin</report>
Customizing Site Reports 37
<report>maven-javadoc-plugin</report>
<report>maven-jdepend-plugin</report>
<report>maven-jira-plugin</report>
<report>maven-junit-report-plugin</report>
<report>maven-jxr-plugin</report>
<report>maven-pmd-plugin</report>
<report>maven-simian-plugin</report>
<report>maven-tasklist-plugin</report>
</reports>

从Maven的站点生成中排除一个报告，仅需要移除reports元素中的report的插件元素。Maven项目并未指定reports元素生成一套默认的报告：jdepend，Checkstyle，changes，changelog，developer-activity，file-activity，license，javadoc，jxr，junit，linkcheck和tacklist。当你添加一个reports元素到你项目的project.xml文件，你必须列出所有你希望获得的报告。

刚刚发生了什么？
reports元素列出了所有这些多样的reports，但你可能想了解报告提供的全部这些。表1-1提供了报告的一些摘要描述。


更多全面的插件和报告列表，参见：
Maven插件: http://maven.apache.org/reference/plugins/index.html
Maven插件沙箱: http://maven.apache.org/plugins-sandbox/index.html
Maven 在SourceForge上的插件: http://maven-plugins.sourceforge.net/
第三方Maven插件: http://maven.apache.org/reference/3rdparty.html

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=470107

1、下载安装最新的windows版的Subversion服务器端安装文件：svn-1.3.0-setup.exe，我安装在C:\svn

2、创建项目数据仓库：命令行下执行：E:\>svnadmin create e:/svntest/repository

3、导入项目文件：命令行下执行：E:\>svn import e:\tmp\project file:///e:/svntest/repository -m "initial import"

4、基本操作导出：E:\>svn checkout file:///e:/svntest/repository/trunk WorkDir

5、启动SVN服务（缺省端口：3690）：svnserver -d -r e:\svntest\repository 现在可以通过svn://localhost/来访问我们的测试项目了。

6、简单配置：conf\svnserve.conf 和conf\passwd需要修改，以增加相应的用户验证id和密码，其中realm的值将作为客户端程序登陆输入用户名密码时看到提示信息。注意：一定要将每一非注释行顶格，否则用svn访问时会出错。

7、关于SVN协议用户密码验证：

• 密码缓存，保存在auth目录内，类似于下面的地址，系统不同稍有变化
   C:\Documents and Settings\bruce\Application Data\Subversion\auth
• 用户配置保存在
   C:\Documents and Settings\bruce\Application Data\Subversion\config
• 配置文件格式说明：
   C:\Documents and Settings\bruce\Application Data\Subversion\README.txt
• 说明文档提到svn密码验证是通过MD5加密传递

二、客户端安装

1、下载安装TortoisSVN安装文件：TortoiseSVN-1.3.2.5840-svn-1.3.0.msi ，在Win2k的虚拟机上安装的时候还提示我安装新版本的WindowsInstaller，下了一个3.1版的装上后就可以装TortoiseSVN了。可以下载中文语言包：（http://nchc.dl.sourceforge.net/sourceforge/tortoisesvn/LanguagePack_1.3.2_zh_CN.exe），安装语言包后，在TortoiseSVN的设置菜单里面可以选择中文界面。

2、基本操作：资源管理器内，删除上面命令行下导出的e:\tmp\WorkDir，用TortoiseSVN来导出.

新建一个目录WorkDir，在该目录上右键选择SVN checkout，Url填：file:///e:/svntest/repository 也可以试试svn://localhost/

3、访问开源subversion项目。测试项目：https://svn.sourceforge.net/svnroot/svntest3 ，提示：TotoiseSVN可以设置代理服务器。

by islq 2006-3-20

参考资料：

SUBVERSION系统学习笔记

svn-book.pdf

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=630553

SVN的安装

rpm -ivh apr-0.9.5-0.2.i386.rpmrpm -ivh apr-util-0.9.5-0.1.i386.rpmrpm -ivh neon-0.24.7-1.i386.rpmrpm -ivh subversion-1.1.1-1.rh80.i386.rpm

SVN安装包的基本命令

配置本地访问的SVN

[root@localhost local]# svn --version* ra_dav : Module for accessing a repository via WebDAV (DeltaV) protocol.* ra_local : Module for accessing a repository on local disk.* ra_svn : Module for accessing a repository using the svn network protocol.

执行一下命令

$ svnadmin create /root/svnrepo$ ls /root/svnrepoconf/ dav/ db/ format hooks/ locks/ README.txt

接下来，我们建立一个本地工作目录/root/svnlocal，进入执行

//建立项目[root@localhost svnlocal]# mkdir project [root@localhost svnlocal]# mkdir project/trunk[root@localhost svnlocal]# mkdir project/branches[root@localhost svnlocal]# mkdir project/tags//建立一个模块exo[root@localhost svnlocal]# mkdir project/exo[root@localhost svnlocal]# vi project/exo/exo.conf[root@localhost svnlocal]# svn import . file:///root/svnrepo -m 'initial'[root@localhost svnlocal]# rm -rf project[root@localhost svnlocal]# svn checkout file://localhost/root/svnrepo/project //check整个项目[root@localhost svnlocal]# svn checkout file://localhost/root/svnrepo/project exo //check 其中一个模块

其他的命令有

• Enter your working copy and edit a file's contents.
• Run svn diff to see unified diff output of your changes.
• Run svn commit to commit the new version of your file to the repository.
• Run svn update to bring your working copy “up-to-date” with the repository.

SVN的访问地址

启动SVN的svnserve，这样你就可以通过svn://url的方式来访问。

[root@localhost svnlocal]# svnserve --helpUsage: svnserve [options]Valid options:  -d [--daemon]            : daemon mode  --listen-port arg        : listen port (for daemon mode)  --listen-host arg        : listen hostname or IP address (for daemon mode)  --foreground             : run in foreground (useful for debugging)  -h [--help]              : display this help  --version                : display version  -i [--inetd]             : inetd mode  -r [--root] arg          : root of directory to serve  -R [--read-only]         : deprecated; use repository config file  -t [--tunnel]            : tunnel mode  --tunnel-user arg        : tunnel username (default is current uid's name)  -T [--threads]           : use threads instead of fork  -X [--listen-once]       : listen once (useful for debugging)

我们执行svnserve -d -r /root/svnrepo

然后在刚才的svnlocal目录下，执行

[root@localhost svnlocal]# svn checkout svn://localhost/project exo

注意：如果我们启动时候，只是用svnserve -d而没有制定repo路径的话，那么你在checkout的时候就必须使用是svn checkout svn://localhost/root/svnrepo/project exo 来指明全路径。

接下来，我们随便修改一个文件，然后执行

[root@localhost exo-build]# svn commit -m "test"

权限配置

进入/root/svnrepo/conf/ 打开svnserve.conf，修改一下两行

[general]anon-access = noneauth-access = write password-db = passwd

在相同目录下建立一个passwd文件，使用vi passwd命令。在里面输入

[users]danny = dannybobo = bobo

好，接下来，我们执行

[root@localhost svnlocal]# svn checkout svn://localhost/project exo

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=202474

一下内容为转贴，忘记在哪里找的了：（

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

SVN安装日志
1,下载
(1) svn-1.0.9-setup.exe
(2) TortoiseSVN-1.1.2-UNICODE_svn-1.1.2.msi
(3) SVNService

2,安装SVN Server
(1) 安装svn-1.0.9-setup.exe,安装目录为D:\Program Files\Subversion.
(2) 安装TortoiseSVN-1.1.2-UNICODE_svn-1.1.2.msi.安装目录为D:\Program Files\TortoiseSVN.
安装后者需要重启计算机.
(3) 将SVNService压缩包中的SVNService.exe copy到D:\Program Files\Subversion\bin中.
(4) 建立新目录E:\SVNRepo,作为Repository的主目录.
(5) 将SVN Server包装成服务运行: 开始->运行. 输入"cmd",回车,进入命令行界面.
进入D:\Program Files\Subversion\bin. 运行 SVNService -install -d -r e:\SVNRepo .将SVN Server注册成后台服务,并将Repository主目录设置到E:\SVNRepo.
(6) 进入计算机管理->服务和服务程序->服务.可以看见SVNService服务,将其启动类型从手动改为自动.(7) 启动服务.
(8) 如果安装有防火墙,则需要打开3690端口.

3,Demo
(1) 在E:\SVNRepo下新建目录"Default",点右键,TortoiseSVN->Create Repository Here,选择BDB.
(2) 进入E:\SVNRepo\Default\conf

在E:\SVNRepo\Default\conf目录下,新建users.conf文件.users.conf保存用户名和密码.格式如下:
[users]
username = password

用文本编辑器打开svnserve.conf,向其中添加
[general]
anon-access = none
auth-access = write
password-db = users.conf

(3) 点右键,TortoiseSVN->RepoBrowse,输入svn://<serverip>/Default,回车.输入users.conf中存在的用户名和密码,就可以进入Repository啦!

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=627189

1. 软件下载
2. 服务器和客户端安装
   
3. 建立版本库（Repository）
4. 配置用户和权限
   
5. 运行独立服务器
6. 初始化导入
7. 基本客户端操作

• 下载Subversion服务器程序。

• 下载Subversion的Windows客户端TortoiseSVN。

• 服务器安装，直接运行svn-1.2.3-setup.exe，根据提示安装即可，这样我们就有了一套服务器可以运行的环境。
• 安装TortoiseSVN，同样直接运行TortoiseSVN-1.2.4.4479-svn-1.2.3.msi按照提示安装即可，不过最后完成后会提示是否重启，其实重启只是使svn工作拷贝在windows中的特殊样式生效，与所有的实际功能无关，这里为了立刻看到好的效果，还是重新启动机器。

svnadmin create E:\svndemo\repository

就会在目录E:\svndemo\repository下创建一个版本库。

我们也可以使用TortoiseSVN图形化的完成这一步：

# [general]
# password-db = passwd

[general]
password-db = passwd

# [users]
# harry = harryssecret
# sally = sallyssecret

[users]
harry = harryssecret
sally = sallyssecret

svnserve -d -r E:\svndemo\repository

1. 右键->TortoiseSVN->Import...
2. URL of repository输入“svn://localhost/trunk”
3. ok

来到任意空目录下，在本例中是E:\svndemo\wc1，运行右键->Checkout，在URL of repository中输入svn://localhost/trunk，这样我们就得到了一份工作拷贝。

打开readme.txt，作出修改，然后右键->Commit...，这样我们就把修改提交到了版本库，我们可以运行。

readme.txt上右键->TortoiseSVN->Show Log，这样我们就可以看到我们对这个文件所有的提交。在版本1上右键->Compare with working copy，我们可以比较工作拷贝的文件和版本1的区别。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=537628

STEP 1:下载和安装 
   首先在Subversion的官方网站去下载windows安装包，最新版是1.3.1。[http://subversion.tigris.org/servlets ... cumentList?folderID=91]
下载后安装在本地机器上，这里注意的是最好将安装目录指定为纯英文名目录，安装在中文目录下天知道哪天会冒出一个让你想破头也想不出的错误来。
下载TortoiseSVN进行本地安装，我安装的是最新的TortoiseSVN-1.3.3.6219[http://surfnet.dl.sourceforge.net/sourceforge/t ... SVN-1.3.3.6219-svn-1.3.1.msi]，这是一个将SVN集成到windows shell中的GUI管理工具，推荐使用。


STEP 2:创建储存库 
  安装完TortoiseSVN后提示要重启机器，其实启不启都可以正常使用了，首先创建SVN储存库(repository)，可以选择命令行方式或者通过TortoiseSVN插件进行GUI操作，命令行运行如下：

svnadmin create F:\_SubVersion



F:\_SubVersion就是我指定的储存库目录，如果用GUI方式，可以在这个目录下点击右键选择[TotoiseSVN]->[Create Repository href...]进行创建，版本库模式指定为默认的即可。
repository创建完毕后会在目录下生成若干个文件和文件夹，dav目录是提供给Apache与mod_dav_svn使用的目录，让它们存储内部 数据；db目录就是所有版本控制的数据文件；hooks目录放置hook脚本文件的目录；locks用来放置Subversion文件库锁定数据的目录， 用来追踪存取文件库的客户端；format文件是一个文本文件，里面只放了一个整数，表示当前文件库配置的版本号；


STEP 3:配置 
打开/conf/目录，打开svnserve.conf找到一下两句：


# [general]
# password-db = passwd

去之每行开头的#，其中第二行是指定身份验证的文件名，即passwd文件
同样打开passwd文件，将

# [users]
# harry = harryssecret
# sally = sallyssecret

这几行的开头#字符去掉，这是设置用户，一行一个，存储格式为“用户名 = 密码”，如可插入一行：admin = admin888，即为系统添加一个用户名为admin，密码为admin888的用户


STEP 4:运行SVN服务 
在命令行执行


svnserve --daemon --root F:\_SubVersion
服务启动，--daemon可简写为-d，--root可简写为-r，可以建立一个批处理文件并放在windows启动组中便于开机就运行SVN服务，或者在这个地址[http://maxwoods.cnblogs.com/Files/ ... loads/SVNService.rar]下载那个svnservice.exe文件，拷贝到E:\svn\bin目录下，再从命令行下执行：

svnservice -install --daemon --root "F:\_SubVersion"
sc config svnservice start= auto
net start svnservice

此文件会将SVN变成windows系统的一个服务，并默认为自启动，注意：执行第三句时确保前面以命令行方式运行的SVN服务已经停止，如果没停止可在其窗口中按Ctrl+C中止运行。


STEP 5:创建项目版本树 
确定SVN服务(命令行或windows服务)运行后，在你需要导入储存库的目录下单击右键选择[TortoiseSVN]-> [Import...]，在弹开的窗口的URL框中输入 "svn://localhost/myproject" 点击 "OK" 执行导入，如果没有报错，数 据就全部加入SVN储存库目录树上了。用命令行也可以完成这些操作，这需要你在系统变量中新建一个“SVN_EDITOR”的系统变量，变量值为本地的一 个文本编辑器执行文件路径，一般指到windows的记事本上就行了 "c:\windows\notepad.exe" ，然后新开一个CMD窗口，执行

svn mkdir svn://localhost/myproject
随即关闭记事本打开的log文件窗口后按"c"键继续后生成项目树。一般情况，我们在创建文件根路径后应该在创建三个目录：branches、tags、trunk，这三个目录是Subversion需要的三个目录。对于check out、commit、update等操作可以通过svn命令行方式执行，也可以用TortoiseSVN的windows菜单完成，非常简单咯。

 

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=816965

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=782731

java.net http://www.java.net

www.eclipse.org

www.opensource.org

Lomboz http://www.objectlearn.com/index.jsp (J2EE plugin for Eclipse)
htmlArea http://sourceforge.net/projects/itools-htmlarea/ (所见即所得的在线HTML编辑器)
XmlBuddy http://www.xmlbuddy.com/ (XML Editor plugin for Eclipse)
JFreeChart http://www.jfree.org/ (用于生成图表的项目)
EclipseME http://eclipseme.sourceforge.net/ (J2ME Developmnt Plugin for Eclipse)
mvnForum http://sourceforge.net/projects/mvnforum/ (论坛)
jChatBox http://www.javazoom.net/index.shtml (用servlet实现的WEB聊天引擎)
POI http://jakarta.apache.org/poi/index.html (用于处理Excel,WORD等文档的项目)
FileUpload http://jakarta.apache.org/commons/fileupload/ (用于处理HTTP文件上传得项目)
PDFBox http://sourceforge.net/projects/pdfbox/ (处理PDF文档的项目)
Lucene http://jakarta.apache.org/lucene/index.html (搜索引擎)
Digester http://jakarta.apache.org/commons/digester/ (处理XML信息的项目)
DBCP http://jakarta.apache.org/commons/dbcp/ (数据库连接池)
AXIS http://ws.apache.org/axis/ (WebService 的实现框架)
Jetspeed http://portals.apache.org/jetspeed-1/ (Portal)
HSQLDB http://sourceforge.net/projects/hsqldb/ (Im memory Database Engine)
CEWOLF http://sourceforge.net/projects/cewolf/ (一套标签库实现Web报表,使用的是jFreeChart引擎)
Struts Menu http://sourceforge.net/projects/struts-menu/ (基于Struts的Web菜单项目)
htmlparser http://sourceforge.net/projects/htmlparser/ (用于解析HTML信息的项目)
Mondrian http://sourceforge.net/projects/mondrian/(Open Source OLAP Database)
ProGuard http://sourceforge.net/projects/proguard/(Java的混淆器)
InfoGlue http://sourceforge.net/projects/infoglue/ (J2EE 内容管理系统)
JPivot http://sourceforge.net/projects/jpivot/ (基于WEB的OLAP 展现)
http://java-source.net/

(5)几个常用JAVA开源项目的地址荟萃:
Lomboz http://www.objectlearn.com/index.jsp (J2EE plugin for Eclipse)
htmlArea http://sourceforge.net/projects/itools-htmlarea/ (所见即所得的在线HTML

编辑器)
XmlBuddy http://www.xmlbuddy.com/ (XML Editor plugin for Eclipse)
JFreeChart http://www.jfree.org/ (用于生成图表的项目)
EclipseME http://eclipseme.sourceforge.net/ (J2ME Developmnt Plugin for Eclipse)
mvnForum http://sourceforge.net/projects/mvnforum/ (论坛)
jChatBox http://www.javazoom.net/index.shtml (用servlet实现的WEB聊天引擎)
POI http://jakarta.apache.org/poi/index.html (用于处理Excel,WORD等文档

的项目)
FileUpload http://jakarta.apache.org/commons/fileupload/ (用于处理HTTP文件上传得项

目)
PDFBox http://sourceforge.net/projects/pdfbox/ (处理PDF文档的项目)
Lucene http://jakarta.apache.org/lucene/index.html (搜索引擎)
Digester http://jakarta.apache.org/commons/digester/ (处理XML信息的项目)
DBCP http://jakarta.apache.org/commons/dbcp/ (数据库连接池)
AXIS http://ws.apache.org/axis/ (WebService 的实现框架)
Jetspeed http://portals.apache.org/jetspeed-1/ (Portal)
HSQLDB http://sourceforge.net/projects/hsqldb/ (Im memory Database Engine)
CEWOLF http://sourceforge.net/projects/cewolf/

(一套标签库实现Web报表,使用的是jFreeChart引擎)
Struts Menu http://sourceforge.net/projects/struts-menu/ (基于Struts的Web菜单项目

)
htmlparser http://sourceforge.net/projects/htmlparser/ (用于解析HTML信息的项目

)
Mondrian http://sourceforge.net/projects/mondrian/ (Open Source OLAP

Database)
ProGuard http://sourceforge.net/projects/proguard/ (Java的混淆器)
InfoGlue http://sourceforge.net/projects/infoglue/ (J2EE 内容管理系统)
JPivot http://sourceforge.net/projects/jpivot/ (基于WEB的OLAP 展现)
HttpClient http://jakarta.apache.org/commons/httpclient/处理http客户端的接口