发表于 | 阅读次数

十一匆匆的就过去了，OneCoder过的也是有点恍惚。不知道都做了什么，心却有点散。做一篇翻译，权当收收心，找找感觉吧。

 
在之前发布的博文里我提到，我最近正在把一些neo4j数据加载的代码从Ruby迁移到Java，因此作为这个过程中的一步，我需要解析一些CSV文件。
 
在Ruby中，我使用FasterCSV进行解析。FasterCSV已经是Ruby1.9中的标准的CSV库。但是，我必须用Java代码去解析CSV文件，所以我不知道该用什么库。
 
我需要一个可以解析用逗号分割的文件内容的库，这里逗号还有可能是其中某部分的一个值。我认为这是任何CSV解析库的最普通标准的特性，不过通过google，我找到了OpenCSV。
 
在这里可以下载到OpenCSV，到目前为止它做的还不错。
 
下面是我使用的一个例子：
String filePath = "/Users/mneedham/data/awesome-csv-file.csv";
CSVReader reader = new CSVReader(new FileReader(filePath), ',');

List<String[]> csvEntries = reader.readAll();
Iterator<String[]> iterator = csvEntries.iterator();

while (iterator.hasNext()) {
    String[] row = iterator.next();
    System.out.println("field 1: " + row[0]);
}

在它的项目主页中有更多使用场景的莉子。

阅读全文 »

发表于 | 阅读次数

OneCoder最近一直在使用Restful API，最近正好看到一篇自定义restful接口规范的“抛砖引玉”得的文章，索性翻译一下，与大家分享。 原文地址：http://java.dzone.com/articles/restful-standard-resolved

最近，我正在使用RESTfull的方式构建一个web服务。尽管现在有很多的一般的指导和提示告诉你如何定义restful接口，但是却没有一个明确的标准或大家都接受的schema定义去遵循。

在网上获取了一些信息后，我打算打破这一局面：）我打算分享一下我定义的规则和结构，并且很希望能得到一些反馈来帮助我完善这个规则，所以，不要犹豫，请毫无留情给我指出错误和毛病吧。</div>

高级别的模式是：
http(s)://server.com/app-name/{version}/{domain}/{rest-convention}

这里，{version}代表api的版本信息。{domain}是一个你可以用来定义任何技术的区域(例如：安全-允许指定的用户可以访问这个区域。)或者业务上的原因。(例如：同样的功能在同一个前缀之下。)

{rest-convention} 代表这个域(domain)下，约定的rest接口集合。
单资源( singular-resourceX )
url样例：order/  (order即指那个单独的资源X)
  • GET - 返回一个新的order
  • POST- 创建一个新的order，从post请求携带的内容获取值。
单资源带id(singular-resourceX/{id} )
URL样例：order/1 ( order即指那个单独的资源X )
  • GET - 返回id是1的order
  • DELETE - 删除id是1的order
  • PUT - 更新id是1的order，order的值从请求的内容体中获取。
复数资源(plural-resourceX/)
URL样例:orders/
  • GET - 返回所有orders
复数资源查找(plural-resourceX/search)
URL样例：orders/search?name=123
  • GET - 返回所有满足查询条件的order资源。(实例查询，无关联) - order名字等于123的。
复数资源查找(plural-resourceX/searchByXXX)
URL样例：orders/searchByItems?name=ipad
  • GET - 将返回所有满足自定义查询的orders - 获取所有与items名字是ipad相关联的orders。
单数资源(singular-resourceX/{id}/pluralY)
URL样例：order/1/items/ (这里order即为资源X，items是复数资源Y)
  • GET - 将返回所有与order id 是1关联的items。
singular-resourceX/{id}/singular-resourceY/
URL样例：order/1/item/
  • GET - 返回一个瞬时的新的与order id是1关联的item实例。
  • POST - 创建一个与order id 是1关联的item实例。Item的值从post请求体中获取。
singular-resourceX/{id}/singular-resourceY/{id}/singular-resourceZ/
URL样例：order/1/item/2/package/
  • GET - 返回一个瞬时的新的与item2和order1关联的package实例。
  • POST - 创建一个新的与item 2和order1关联的package实例，package的值从post请求体中获得。
上面的规则可以在继续递归下去，并且复数资源后面永远不会再跟随负数资源。
总结几个关键点，来更清晰的表述规则。
  • 在使用复数资源的时候，返回的是最后一个复数资源使用的实例。
  • 在使用单个资源的时候，返回的是最后一个但是资源使用的实例。
  • 查询的时候，返回的是最后一个复数实体使用的实例(们)。
希望你的关注能帮助我完整这个结构并解决你可能偶然遇到的问题。
在下一篇文章里，在这个结构完善之后，我将会一些技术上的样例如何在Spring MVC3.1中，使用它。
OneCoder注：OneCoder只做翻译，不代表统一文中观点，Rest URL的定义本来也算是一个仁者见仁智者见智的事情。该文下面的评论中，就有人发表的不同的观点。
阅读全文 »

发表于 | 阅读次数

OneCoder准备自己慢慢写点东西，把离散的知识点汇总一下。给出的版本没什么特别的含义，只是OneCoder目前使用的环境而已。 <ul> <li> IDE:Eclipse4.2 JUNO。</li> <li> 应用服务器：Tomcat7.0.30（Servlet3.0）</li> <li> 项目构建工具： Maven 3.0.4</li> <li> JDK版本：1.7.07</li> <li> 日志组件：logback最新版</li> <li> 单元测试框架：Junit</li> </ul> <div> 为什么都用最新版本？因为OneCoder是个新版控呵呵。</div> <div> 为了以后管理方便，先建一个全局的parent工程，统一控制jar包依赖的版本。然后新建一个Maven管理的Web工程，parent指定为onecoder-parent工程。</div>

Parent pom.xml配置样例：(主要是版本变量定义，依赖包设置和编译级别设置)

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>onecoder-parent</groupId>
	<artifactId>onecoder-parent</artifactId>
	<version>0.1</version>
	<packaging>pom</packaging>
	<properties>
		<logback.version>1.0.7</logback.version>
		<slf4j.version>1.7.1</slf4j.version>
		<junit.version>4.10</junit.version>
	</properties>
	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>junit</groupId>
				<artifactId>junit</artifactId>
				<version>${junit.version}</version>
				<scope>test</scope>
			</dependency>
			<dependency>
				<groupId>org.slf4j</groupId>
				<artifactId>slf4j-api</artifactId>
				<version>${slf4j.version}</version>
			</dependency>
			<dependency>
				<groupId>ch.qos.logback</groupId>
				<artifactId>logback-core</artifactId>
				<version>${logback.version}</version>
			</dependency>
			<dependency>
				<groupId>ch.qos.logback</groupId>
				<artifactId>logback-classic</artifactId>
				<version>${logback.version}</version>
			</dependency>
		</dependencies>
	</dependencyManagement>
	<build>
		<pluginManagement>
			<plugins>
				<plugin>
					<groupId>org.apache.maven.plugins</groupId>
					<artifactId>maven-compiler-plugin</artifactId>
					<version>2.3.2</version>
					<configuration>
						<verbose>true</verbose>
						<fork>true</fork>
						<executable>${JAVA_HOME}/bin/javac</executable>
						<compilerVersion>1.7</compilerVersion>
						<source>1.7</source>
						<target>1.7</target>
					</configuration>
				</plugin>

				<plugin>
					<groupId>org.apache.maven.plugins</groupId>
					<artifactId>maven-surefire-plugin</artifactId>
					<version>2.7.2</version>
				</plugin>
			</plugins>
		</pluginManagement>
	</build>
</project>

logback的简要配置：

<configuration>  
  <appender name="console" class="ch.qos.logback.core.ConsoleAppender">  
    <encoder  class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">  
      <pattern>%d{yyyy/MM/dd-HH:mm:ss} %level [%thread] %C - %msg%n</pattern>  
    </encoder >  
  </appender>  
  
  <root level="INFO">  
    <appender-ref ref="console" />  
  </root>  
</configuration>

扔到src/main/resources下。

 

如果你此时不知所措，不放直接扔到Tomcat下启动一下，看报什么错，就知道缺什么了。解决错误的过程，可以学到很多东西。

接下来应该写Servlet了。Servlet3.0的一大亮点就是支持注解配置。所以你会发现没有了web.xml配置文件。Servlet写起来也很简单。

/**
 * Servlet3.0 Servlet使用样例
 * @author lihzh
 * @alia OneCoder
 * @blog http://www.coderli.com
 */
@WebServlet(name = "FirstServlet", urlPatterns = { "/firstservlet"})
public class FirstServlet extends HttpServlet {

	private static final long serialVersionUID = 3038754482452604279L;
	private static final Logger log = LoggerFactory.getLogger(FirstServlet.class);

        @Override
	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		PrintWriter out = response.getWriter();
		log.info("This is log");
		out.println("hello,world...");
		out.close();
	}
}
一个简单的Servlet就写好了。

运行一下？等等。我们知道一个web工程运行时依赖的jar包是需要放到WEB-INF/lib下的，这里明显看到lib下空的，并且我们的jar包是通过Maven管理的，难道要手动拷贝过去吗？OneCoder以前还真干过这样的啥事，甚至还自己开发了脚本，做所谓的“一键自动化”工作。其实Eclipse里已经帮你做好了。在工程的Properties配置项里的Deployment Assembly配置里，配好Maven的依赖和部署即可，如图：

此时再运行一下，log正常输出，说明jar依赖过来了，一切都ok了。
剩下的就是你想用什么框架就引入什么了。OneCoder会一遍配置，一遍简要的说明一下。
阅读全文 »

发表于 | 阅读次数

本来OneCoder是在一遍搭建一个J2EE的开发环境，一遍记录过程以跟大家分享。没想到这个过程中，遇到了很多细节的错误，考虑到如果和原来的主线任务文章混在一起，有点让人不知所措的感觉，所以OneCoder决定把这些问题的解决过程单独记录下来，以跟大家分享。

在Eclipse中启动Tomcat，启动开始有如下信息提示。

九月 28, 2012 10:18:12 上午 org.apache.catalina.core.AprLifecycleListener init
SEVERE: An incompatible version 1.1.20 of the APR based Apache Tomcat Native library is installed, while Tomcat requires version 1.1.24

先是一堆这样的错误。意思很明显，APR的版本不够。去http://archive.apache.org/dist/tomcat/tomcat-connectors/native/1.1.24/binaries

下载 一个1.1.24版。网上有人说扔到Java的bin下就好用，那我想扔到System32下也一定可以了，呵呵，一试果然奏效。其实OneCoder猜测，有这个问题主要还是因为Eclipse自带的wtp的插件没支持到最新的tomcat7导致的。貌似只支持到7.0.12。OneCoder肯定不会满足于就这样不明不白的好用了，tomcat/bin下明明有个文件，并且已经是最新的，为什么还要在别的地方乱扔一个。</div>

看一下tomcat的源码，发现在原来是从

String path = System.getProperty("java.library.path")

配置中读取dll文件的位置。这就简单了，给tomcat增加一个启动参数即可：

-Djava.library.path=”D:\Develop Software\apache-tomcat-7.0.30\bin”

再启动，果然好用了。

阅读全文 »

发表于 | 阅读次数

看到一篇通过模拟Runnable和Callable对话的方式，形象的讲述Java中Runnable和Callable区别的文章，遂决定翻译过来加深印象与大家分享。

英文原文地址：http://java.dzone.com/articles/callable-vs-runnable-brawl

Runnable: 我是多线程里的Yoda大师。(OneCoder注：I am the Yoda of multithreading. )。一段时间以来，我是Java中开发并行程序的唯一手段。（不算lang.Thread）记得我拥有的酷酷的方法run吧。不幸的是，他没有返回值。

Callable: 我一个Runnable, 更好更酷一点。我有一个令人惊叹的方法，叫做call。它能返回我工作的结果。call方法的返回类型是泛型的并且返回结果可以通过Future取到。现在，我已经超越了你，Runnable。

Runnable：好吧好吧。不过，事实上是，你的存在仅仅是为了填补我设计上的空白而已。比方说，我的run方法不会抛出Exception异常，如果你的任务想要抛出一个异常的话，你仅仅可以抛出Runtime异常。

Callable：我同意。我确实是站在你的肩膀上。毫无疑问，call方法抛出一个Exception异常，使得一个任务抛出一个校验过的异常给调用者。

Runnable API：

void    run() d

Callable API:

V     call() throws Exception

差异中的统一

FutureTask是一个有意思的类，它的构造函数既可以接受Runnable也可以接受Callable。因为FutureTask实现了Runnable接口，它可以确保的通过Exexutor.execute方法调用。要记住，Executor.executer方法仅仅接受Runnable类型的参数。我仍然需要特别的指出为什么某些人本想以为executer方法没有返回值不能返回结果。

厚脸皮从Javadoc中拷贝如下：

Executor executor= &hellip;

FutureTask<String> future =

   new FutureTask<String>(new Callable<String>() {
     public String call() {
       &hellip; do your thing&hellip;

    }});

executor.execute(future);
阅读全文 »

发表于 | 阅读次数

有一段事件没有更新文章了，各种原因都有吧。搬家的琐事，搬家后的安逸呵呵。不过，OneCoder明白，绝不能放松。对于Netty的学习，也该稍微深入一点了。

所以，这次OneCoder花了几天时间，仔细梳理了一下Netty的源码，总结了一下ServerBootStrap的启动和任务处理流程，基本涵盖了Netty的关键架构。OneCoder总结了一张流程图：

该图是OneCoder通过阅读Netty源码，逐渐记录下来的。基本可以说明Netty服务的启动流程。这里在具体讲解一下。

首先说明，我们这次顺利的流程是基于NioSocketServer的。也就是基于Java NIO Selector的实现方式。在第六讲《Java NIO框架Netty教程(六)-Java NIO Selector模式》中，我们已经知道使用Selector的几个关键点，所以这里我们也重点关注一下，这些点在Netty中是如何使用的。

很多看过Netty源码的人都说Netty源码写的很漂亮。可漂亮在哪呢？Netty通过一个ChannelFactory决定了你当前使用的协议类型(Nio/oio等)，比如，OneCoder这里使用的是NioServerSocket，那么需要声明的Factory即为NioServerSocketChannelFactory，声明了这个Factory，就决定了你使用的Channel，pipeline以及pipeline中，具体处理业务的sink的类型。这种使用方式十分简洁的，学习曲线很低，切换实现十分容易。

Netty采用的是基于事件的管道式架构设计，事件(Event)在管道(Pipeline)中流转，交由(通过pipelinesink)相应的处理器(Handler)。这些关键元素类型的匹配都是由开始声明的ChannelFactory决定的。

Netty框架内部的业务也遵循这个流程，Server端绑定端口的binder其实也是一个Handler，在构造完Binder后，便要声明一个Pipeline管道，并赋给新建一个Channel。Netty在newChannel的过程中，相应调用了Java中的ServerSocketChannel.open方法，打开一个channel。然后触发fireChannelOpen事件。这个事件的接受是可以复写的。Binder自身接收了这个事件。在事件的处理中，继续向下完成具体的端口的绑定。对应Selector中的 socketChannel.socket().bind()。然后触发fireChannelBound事件。默认情况下，该事件无人接受，继续向下开始构造Boss线程池。我们知道在Netty中Boss线程池是用来接受和分发请求的核心线程池。所以在channel绑定后，必然要启动Boss线城池，随时准备接受client发来的请求。在Boss构造函数中，第一次注册了selector感兴趣的事件类型,SelectionKey.OP_ACCEPT。至此，在第六讲中介绍的使用Selector的几个关键步骤都体现在Netty中了。在Boss中回启动一个死循环来查询是否有感兴趣的事件发生，对于第一次的客户端的注册事件，Boss会将Channel注册给worker保存。

这里补充一下，也是图中忽略的部分，就是关于worker线程池的初始化时机问题。worker池的构造，在最开始构造ChannelFactory的时候就已经准备好了。在NioServerSocketChannelFactory的构造函数里，会new一个NioWorkerPool。在NioWorkerPool的基类AbstractNioWorkerPool的构造函数中，会调用OpenSelector方法，其中也打开了一个selector，并且启动了worker线程池。<

private void openSelector() {
        try {
            selector = Selector.open();
        } catch (Throwable t) {
            throw new ChannelException(&quot;Failed to create a selector.&quot;, t);
        }

        // Start the worker thread with the new Selector.
        boolean success = false;
        try {
            DeadLockProofWorker.start(executor, new ThreadRenamingRunnable(this, &quot;New I/O  worker #&quot; + id));
            success = true;
        } finally {
            if (!success) {
                // Release the Selector if the execution fails.
                try {
                    selector.close();
                } catch (Throwable t) {
                    logger.warn(&quot;Failed to close a selector.&quot;, t);
                }
                selector = null;
                // The method will return to the caller at this point.
            }
        }
        assert selector != null &amp;&amp; selector.isOpen();
    }

至此，会分线程启动AbstractNioWorker中run逻辑。同样是循环处理任务队列。

processRegisterTaskQueue();
processEventQueue();
processWriteTaskQueue();
processSelectedKeys(selector.selectedKeys());

这样，设计使事件的接收和处理模块完全解耦。

由此可见，如果你想从nio切换到oio，只需要构造不同的ChannelFacotry即可。果然简洁优雅。

阅读全文 »

发表于 | 阅读次数

今天OneCoder遇到一个不大不小的问题。用Restlet开启了一个rest服务，并且在这个服务内部还会访问其他的rest服务，结果遇到404的错误。但是通过浏览器直接访问却可以访问，通过测试用例直接访问也可以，只有在间接通过restlet访问的时候出现这个问题。仔细观察控制台信息，发现如下信息：

WARNING: The protocol used by this request is not declared in the list of client connectors. (HTTP/1.1)

掏出翻墙的Google查询，在restlet项目的讨论区果然发现了相同的提问，也有人给出了很好的解答。概括起来就是需要在component内添加一行代码：

component.getClients​().add(Protocol.HTTP​);

重新启动，问题解决。</p>

讨论帖地址：http://restlet.tigris.org/ds/viewMessage.do?dsForumId=4447&dsMessageId=2638482

阅读全文 »

发表于 | 阅读次数

如果您持续关注OneCoder，您可能会问，在《Java NIO框架Netty教程(十四)- Netty中OIO模型(对比NIO)》中不是说下节介绍的是，NIO和OIO中的worker处理方式吗。这个一定会有的，只是在研究的过程中，OneCoder发现了之前遗留的文件传输的代码，所以决定先完成它。

其实，Netty的样例代码中也提供了文件上传下载的代码样例，不过太过复杂，还包括了Http请求的解析等，对OneCoder来说，容易迷惑那些才是文件传输的关键部分。所以OneCoder决定根据自己去写一个样例，这个理解就是在最开始提到的，Netty的传输是基于流的，我们把文件流化应该就可以传递了。于是有了以下的代码：

/**
 * 文件传输接收端，没有处理文件发送结束关闭流的情景
 * 
 * @author lihzh
 * @alia OneCoder
 * @blog http://www.coderli.com
 */
public class FileServerHandler extends SimpleChannelHandler {

	private File file = new File(&quot;F:/2.txt&quot;);
	private FileOutputStream fos;

	public FileServerHandler() {
		try {
			if (!file.exists()) {
				file.createNewFile();
			} else {
				file.delete();
				file.createNewFile();
			}
			fos = new FileOutputStream(file);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	@Override
	public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
			throws Exception {
		ChannelBuffer buffer = (ChannelBuffer) e.getMessage();
		int length = buffer.readableBytes();
		buffer.readBytes(fos, length);
		fos.flush();
		buffer.clear();
	}

}

/**
 * 文件发送客户端，通过字节流来发送文件，仅实现文件传输部分，<br>
 * 没有对文件传输结束进行处理<br>
 * 应该发送文件发送结束标识，供接受端关闭流。
 * 
 * @author lihzh
 * @alia OneCoder
 * @blog http://www.coderli.com
 */
public class FileClientHandler extends SimpleChannelHandler {

        // 每次处理的字节数
	private int readLength = 8;

	@Override
	public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e)
			throws Exception {
		// 发送文件
		sendFile(e.getChannel());
	}

	private void sendFile(Channel channel) throws IOException {
		File file = new File(&quot;E:/1.txt&quot;);
		FileInputStream fis = new FileInputStream(file);
		int count = 0;
                BufferedInputStream bis = new BufferedInputStream(fis);
		for (;;) {
			byte[] bytes = new byte[readLength];
			int readNum = bis.read(bytes, 0, readLength);
			if (readNum == -1) {
				return;
			}
			sendToServer(bytes, channel, readNum);
			System.out.println(&quot;Send count: &quot; + ++count);
		}

	}

	private void sendToServer(byte[] bytes, Channel channel, int length)
			throws IOException {
		ChannelBuffer buffer = ChannelBuffers.copiedBuffer(bytes, 0, length);
		channel.write(buffer);
	}

}

待发送的文件1.txt内容如下：

运行上述代码，接受到的文件2.txt结果：

完全一模一样。成功！

这只是一个简单的文件传输的例子，可以做为样例借鉴。对于大文件传输的情景，本样例并不支持，会出现内存溢出的情景，OneCoder准备另外单独介绍一下。

阅读全文 »

发表于 | 阅读次数

OneCoder这个周末搬家，并且新家目前还没有网络，本周的翻译的任务尚未完成，下周一起补上，先上一篇OIO和NIO对比的小研究。

Netty中不光支持了Java中NIO模型，同时也提供了对OIO模型的支持。（New IO vs Old IO）。

首先，在Netty中，切换OIO和NIO两种模式是非常方便的，只需要初始化不同的Channel工程即可。

ServerBootstrap bootstrap = new ServerBootstrap(
				new OioServerSocketChannelFactory(
						Executors.newCachedThreadPool(),
						Executors.newFixedThreadPool(4)));

ServerBootstrap bootstrap = new ServerBootstrap(
				new NioServerSocketChannelFactory(
						Executors.newCachedThreadPool(),
						Executors.newFixedThreadPool(4)));

这就是Netty框架为我们做的贡献。

再说说，这两种情况的区别。OneCoder根据网上的资料和自己的理解，总结了一下：在Netty中，是通过worker执行任务的。也就是我们在构造bootstrap时传入的worker线程池。对于传统OIO来说，一个worker对应的channel，从读到操作到再到回写，只要是这个channel的操作都通过这个worker来完成，对于NIO来说，到MessageRecieved之后，该worker的任务就完成了。所以，从这个角度来说，非常建议你在Recieve之后，立即启动线程去执行耗时逻辑，以释放worker。

基于这个分析，你可能也发现了，上面的代码中我们用的是FiexedThreadPool。固定大小为4，从理论上来说，OIO支持的client数应该是4。而NIO应该不受此影响。测试效果如下图：

8个Client连接：

NIOServer的线程情况：

并且8个Client的请求都正常处理了。

对于OIO来说，如果你对worker池没有控制，那么支持8个client需要8个worker，8个线程，这也就是传统OIO并发数受限的原因，如图：

当OIO使用FixedThreadPool的时候：

只能处理头四个client的请求，他的被堵塞了。

Hello action.: 32
Hello action.: 33
Hello action.: 34
Hello action.: 35
Hello action.: 36
Hello action.: 37
Hello action.: 38
Hello action.: 39
Hello action.: 40

但是，在Netty框架中，不论是OIO和NIO模型，读写端都不会堵塞。客户端写后立即返回，不管服务端是否接收到，接收后是否处理完成。下一章，我们将会从代码的角度来研究一下Netty中对OIO和NIO这两种模式下worker的处理方式。

阅读全文 »

发表于 | 阅读次数

其实是一个很简单的技巧，就是利用Maven的appassembler-maven-plugin插件，就可以实现自动打包可运行的脚本，还可以跨平台。（Windows/linux）

首先在pom.xml文件的build节点下配置插件：

<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>appassembler-maven-plugin</artifactId>
    <version>1.1.1</version>
	<configuration>
	<repositoryLayout>flat</repositoryLayout>
	<repositoryName>lib</repositoryName>
	<configurationSourceDirectory>src/main/resources/conf</configurationSourceDirectory>
	<!-- Set the target configuration directory to be used in the bin scripts -->
	<configurationDirectory>conf</configurationDirectory>
	<!-- Copy the contents from &quot;/src/main/config&quot; to the target configuration 
	directory in the assembled application -->
	<copyConfigurationDirectory>true</copyConfigurationDirectory>
	<!-- Include the target configuration directory in the beginning of 
		the classpath declaration in the bin scripts -->
	<includeConfigurationDirectoryInClasspath>true</includeConfigurationDirectoryInClasspath>
	<!-- prefix all bin files with &quot;mycompany&quot; -->
	<binPrefix>startup</binPrefix>
	<!-- set alternative assemble directory -->
	<assembleDirectory>${project.build.directory}/server</assembleDirectory>
	<!-- Extra JVM arguments that will be included in the bin scripts -->
	<extraJvmArguments>-Xms768m -Xmx768m -XX:PermSize=128m
						-XX:MaxPermSize=256m -XX:NewSize=192m -XX:MaxNewSize=384m
	</extraJvmArguments>
	<!-- Generate bin scripts for windows and unix pr default -->
	<platforms>
	<platform>windows</platform>
	<platform>unix</platform>
	</platforms>
	<programs>
	<program>
	<mainClass>com.coderli.onecoder.server.HypervisorServer</mainClass>
	<name>startup</name>
	</program>
	</programs>
	</configuration>
</plugin>

然后选择你要编译的工程，右键->maven build… 命令如下图：

然后Run一下：

一个可执行的脚本文件就生成好了。startup.bat是windows下的，startup.sh是linux下的。具体参数，可以参考我上面给出的配置，也可以自己研究一下插件的配置。

阅读全文 »