Nodyn：让Node.js应用运行于JVM - 企业架构 - ITeye资讯
相关知识库：
Nodyn是一个兼容Node.js的开源框架，由红帽公司的团队开发，其主要作用是可以让Node.js应用运行于JVM上。
Nodyn主要依赖于两个项目：
：为JVM提供了实际的JavaScript（ECMAScript）运行时
：用于开发异步、可伸缩、高并发Web应用的框架，目的是为JVM提供一个Node.js替代方案，跨多种语言
通过Nodyn，你可以直接在JVM上运行Node.js应用，并且可以通过JavaScript直接访问Java程序。由于DynJS兼容多种语言，因此你也可以使用JRuby或Clojure来开发应用程序，然后与Node.js应用进行交互。通过Vert.x来构建，可以使得应用之间的互操作更加便捷。
第1种：作为一个单独的REPL（Read-Eval-Print-Loop），并嵌入Vert.x
第2种：作为Vert.x的一个
Nodyn是一个开源项目，采用Apache 2.0许可协议。
Nodyn官网：
源码：
真不明白JavaScript有什么好的！可见未来，跨前后端和多平台的语言。
houzhanshanlinzhou 写道为什么这个网站整天把node.js放在头条，我做开发几年，实在没发现这个有什么好？动态脚本语言发展到一定程序，超高并发下，性能是硬伤，还java,c++伸缩性好。
为什么这个网站整天把node.js放在头条，我做开发几年，实在没发现这个有什么好？
witcheryne 写道xpf7622 写道真不明白JavaScript有什么好的！console.log('真应该去明白明白'); 不需要明白
xpf7622 写道真不明白JavaScript有什么好的！console.log('真应该去明白明白');
真不明白JavaScript有什么好的！
这是要来砸java饭碗的吗Java开发者结合Node.js编程入门教程
投稿：junjie
字体：[ ] 类型：转载 时间：
这篇文章主要介绍了Java开发者结合Node.js编程入门教程,我将先向您展示如何使用Java EE创建一个简单的Rest服务来读取 MongoDB数据库。然后我会用node.js来实现相同的功能,需要的朋友可以参考下
首先， 我必须得承认，作为一个有着十多年开发经验的java开发者，我已经形成了解决绝大部分问题的固有套路，尽管它们很多时候显得笨重和繁琐。 比如说如果要读取一个文件，那应该就是初始化一个BufferedReader 实例并传入一个FileReader，这几乎是顺理成章的，我在很多自认为算得上“企业级”的项目中编写这样的代码并且很享受这个过程，可以说我就是一个对其他语言不屑一顾的java脑残粉。&&&&&
　　如果你正在阅读这篇博文，你可能已经陷入了我多年前早就陷入的一个误区，作为一名合格的开发人员应该不断地学习新的技术并且根据实际工作需求选用适 当的技术。尽管我一直在变老并且有朝一日可能会厌烦了java。但是我现在真的发现了一个激动人心的新东西，node.js对于我就像一个儿童得到一个新 奇的玩具，在这篇博文中，我将先向您展示如何使用Java EE创建一个简单的Rest服务来读取 MongoDB数据库。然后我会用node.js来实现相同的功能，你会更容易了解到这种新的开发语言的激动人心之处。
从基础开始——什么是Node.js?
　　首先，我要说明一点，Node.js不是那种“新潮时尚”，只有“潮人”才使用的语言。虽然它是本着这种认知开始，但是我很高兴的报告给大 家，Node.js是一种成熟的语言——并且在当下这个互联网时代，它已经找到了其自己的方式进入大型企业，支撑起一些最高流量的网站。Node.js是 你技能储备当中的一个非常实用的工具，在构建稳定、安全和高性能的代码上，其便捷度会令你大吃一惊。
　　言而总之，Node是一种针对服务器端活动的语言。它使用了Javascript语言，并且有非常多的库可用，比如npm模型。你可以把那些npm 模型比作Java中的.jar包。当你需要一部分功能，并且不喜欢自己全部编写这部分代码，极有可能在npm模型中已经提供了你正在寻找的特性。
　　Node应用程序通常执行时需要实现效率最大化利用非阻塞 I/O 和异步事件。对于Java开发者来讲需要知道的一点是Node应用运行单线程中。然而，后端节点代码使用多个线程进行操作，如网络和文件访问。鉴于此，Node对于那些需要实时经验的应用是完美的选择。
继续——IDE支持
　　你可能会像我一样，在IDE中“生存”和“呼吸”，这可能源于Java实在是太罗嗦了，需要我们在软件开发过程中编写恒定的代码来完成功能。一旦我们找到 了代码完成的好处，我们慢慢学会了使用 IDE 进行文件管理、 调试和其他非常有用的功能。可以这样说，我喜欢使用一款IDE并且在使用Nodeb工作时继续使用它。下面是当前最为第一批支持Node的IDE：
1.Eclipse——这应该很容易上手当你在Java中已经使用它。仅需要安装Node.js插件即可。
2.JetBrains IntelliJ IDEA——一款非常流行的商业化的IDE。目前为止，这是我最喜欢的IDE。
3.Microsoft Visual Studio——是的，你没看错。Node已经成长到微软在Visual Studio添加了对其的原生支持。这个实现非常稳定，并且VS是我第二喜欢的IDE。说来也怪，我使用VS仅仅用作一些基础的Node项目。
4.CodeEnvy——一款基于web的IDE
5.Cloud9——一款基于web的IDE
6.SublimeText 2——没有多余装饰的文本编辑器，由于其轻量级，在开发者中的知名度越来越高。
这是我工作在Node基础项目上的最喜欢的几款IDE。仅仅做个举例。
从一个范例开始
　　在这篇博文的剩下部分里，我们将要用Java EE和Node.js结合起来创建一个简单的REST服务。这个REST服务将会简单的从MongoDB数据库里面读取信息并且返回这些结果给请求者。而 关于Java应用服务器和MongoDB数据库的安装和配置则不在本文的讨论范围之中。
创建我们的Java应用
　　第一步：配置pom.xml文件
　　我们把这个范例叫做restexample ,我将会使用JBoss EAP应用服务器。第一件我们要做的事情就是为使用Maven构建系统的依赖管理来配置我们的pom.xml文件。下面就是包含了我们这个restexample 应用里面所需要的依赖的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/maven-v4_0_0.xsd"&
&modelVersion&4.0.0&/modelVersion&
&groupId&restexample&/groupId&
&artifactId&restexample&/artifactId&
&packaging&war&/packaging&
&version&1.0&/version&
&name&restexample&/name&
&repositories&
&repository&
&id&eap&/id&
&url&http://maven./techpreview/all&/url&
&releases&
&enabled&true&/enabled&
&/releases&
&snapshots&
&enabled&true&/enabled&
&/snapshots&
&/repository&
&/repositories&
&pluginRepositories&
&pluginRepository&
&id&eap&/id&
&url&http://maven./techpreview/all&/url&
&releases&
&enabled&true&/enabled&
&/releases&
&snapshots&
&enabled&true&/enabled&
&/snapshots&
&/pluginRepository&
&/pluginRepositories&
&properties&
&project.build.sourceEncoding&UTF-8&/project.build.sourceEncoding&
&piler.source&1.6&/piler.source&
&piler.target&1.6&/piler.target&
&/properties&
&dependencies&
&dependency&
&groupId&org.jboss.spec&/groupId&
&artifactId&jboss-javaee-6.0&/artifactId&
&version&3.0.2.Final-redhat-4&/version&
&type&pom&/type&
&scope&provided&/scope&
&/dependency&
&dependency&
&groupId&org.mongodb&/groupId&
&artifactId&mongo-java-driver&/artifactId&
&version&2.9.1&/version&
&/dependency&
&/dependencies&
&/project&
　酷，相当的详细，但是我希望你们能够理解里面的代码，在这篇博文中我假设读者都已经了解Java，因此我不准备解释里面的细节了。
第二步：创建beans.xml文件并且设置我们的servlet映射
　　作为范例的一部分，我们将会对我们的数据库访问类使用CDI(上下文依赖注入)。根据官方的CDI配置说明，一个应用要使用CDI的话就要在该应用的 WEB-INF 目录里面包含一个beans.xml文件。因此我们就来创建这个文件并且按照我们所需的信息来配置它。进入到你的 /src/main/webapp/WEB-INF 目录然后创建一个 beans.xml文件，加入下面的代码：
&?xml version="1.0"?&
&beans xmlns="/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="/xml/ns/javaee
http://jboss.org/schema/cdi/beans_1_0.xsd"/&
　　我们也需要在 web.xml 文件里面为我们的RESI API设置servlet映射。在 /src/main/webapp/WEB-INF 目录的文件里面加入下面的servlet映射元素：
&servlet-mapping&
&servlet-name&javax.ws.rs.core.Application&/servlet-name&
&url-pattern&/ws/*&/url-pattern&
&/servlet-mapping&
第三步：创建DBConnection类
　　到这一步，我们已经建立好项目并且我们的pom.xml文件已经包含了MongoDB数据库的驱动依赖，记得要确保所需要的驱动已经被打包好在我们的应用里面。下一件事我们就要创建一个类用来管理数据库的连接。创建一个新的文件命名为 DBConneection.java，把这个文件放置到 /src/main/java/com/strongloop/data 目录里面，然后再这个文件里面加入下面的代码：
　　注意：要确保你安装MongoDB数据库配置好适当的连接授权细节信息!
package com.strongloop.
import java.net.UnknownHostE
import javax.annotation.PostC
import javax.enterprise.context.ApplicationS
import javax.inject.N
import com.mongodb.DB;
import com.mongodb.M
@ApplicationScoped
public class DBConnection {
private DB mongoDB;
public DBConnection() {
@PostConstruct
public void afterCreate() {
String mongoHost = "127.0.0.1"
String mongoPort = "27001"
String mongoUser = "
String mongoPassword = "rocks";
String mongoDBName = "restexample";
int port = Integer.decode(mongoPort);
Mongo mongo =
mongo = new Mongo(mongoHost, port);
} catch (UnknownHostException e) {
System.out.println("Couldn't connect to MongoDB: " + e.getMessage()
+ " :: " + e.getClass());
mongoDB = mongo.getDB(mongoDBName);
if (mongoDB.authenticate(mongoUser, mongoPassword.toCharArray()) == false) {
System.out.println("Failed to authenticate DB ");
public DB getDB() {
return mongoDB;
第四步：把数据导入到MongoDB中（mmmm啤酒）
在我们的项目中，我们想要加载所有名称为Pabst的啤酒列表。如果你不熟悉啤酒行业，你可以试下Pabst Brewing公司生产的美式淡啤。这些啤酒上面带有蓝绶带和柯尔特{敏感词}图案，他们包含所有的麦芽糖饮料种类。
首先你需要下载一个json文件，里面包含需要返回的所有数据。你可以用下面的URL来实现这点：
下载结束后，使用mongoimport命令把它导入到数据库中，命令如下：
$ mongoimport --jsonArray -d yourDBName -c beers --type json --file /tmp/beers.json -h yourMongoHost --port yourMongoPort -u yourMongoUsername -p yourMongoPassword
你可以看到如下结果：
connected to: 127.0.0.1:27017
Tue Jun 10 20:09:55.436 check 9 24
Tue Jun 10 20:09:55.437 imported 24 objects
第5步: 创建Beer模型对象
　　我们已经创建了一个数据库连接类并且已经把啤酒信息载入到MongoDB数据库里了，是时候创建一个模型对象来控制我们的啤酒信息了。创建一个新文件，名为Beer.java并把它放到/src/main/java/com/strongloop/data目录下。创建好该文件后，在其中添加如下代码:
package com.strongloop.
public class Beer {
public String getId() {
public void setId(String id) {
public String getName() {
public void setName(String name) {
this.name =
public String getDescription() {
public void setDescription(String description) {
this.description =
　注意: 提供好的JSON文件中包含了更多我们将会使用到的信息，所以可以找出来看看，并向其中添加一些额外的功能来拓宽你的学习经验。
第6步: 创建REST服务
　　猜猜看该干什么了？不错，我们终于准备好要创建基于REST的web服务了，它使我们可以获取到上一个步骤当中载入进来的啤酒信息。为此，我们需要创建一个新的名为BeerWS.java的文件，并把它放到/src/main/java/com/strongloop/webservice目录下。创建好之后，添加下列代码:
package com.strongloop.
import java.util.ArrayL
import java.util.L
import javax.enterprise.context.RequestS
import javax.inject.I
import javax.ws.rs.GET;
import javax.ws.rs.P
import javax.ws.rs.P
import javax.ws.rs.QueryP
import com.strongloop.data.DBC
import com.strongloop.data.B
import com.mongodb.BasicDBO
import com.mongodb.DB;
import com.mongodb.DBC
import com.mongodb.DBC
import com.mongodb.DBO
@RequestScoped
@Path("/beers")
public class BeerWS {
private DBConnection dbC
private DBCollection getBeerCollection() {
DB db = dbConnection.getDB();
DBCollection beerCollection = db.getCollection("beers");
return beerC
private Beer populateBeerInformation(DBObject dataValue) {
Beer theBeer = new Beer();
theBeer.setName(dataValue.get("name"));
theBeer.setDescription(dataValue.get("name"));
theBeer.setId(dataValue.get("_id").toString());
return theB
// 获取所有啤酒
@Produces("application/json")
public List&Beer& getAllBeers() {
ArrayList&Beer& allBeersList = new ArrayList&Beer&();
DBCollection beers = this.getBeerCollection();
DBCursor cursor = beers.find();
while (cursor.hasNext()) {
allBeersList.add(this.populateBeerInformation(cursor.next()));
} finally {
cursor.close();
return allBeersL
第7步: 浏览着啤酒信息傻乐
　　喔，搞定。我们已经写好了一个REST服务，可以从数据库中获取所有的啤酒信息。现在把你的代码部署到你的应用服务器吧， 在浏览器中打开下列地址看看它是否工作正常:
http://yourserverlocation/ws/beers
　　如果所有东西都正常，你将会看到所有的啤酒信息列表，如下图所示:
创建 Node 应用
　　如果你按照上面的步骤使用java进行编程，你会意识到使用javaEE创建应用尽管进展很快，但是创建一个类似REST服务的简单应用还是很麻烦。不要误解，我仍然很喜欢用javaEE，但是发现对于很多场景，比如创建返回json数据的REST服务，Node更适用。接下来，我们将要使用StrongLoop的LoopBack API创建一个简单的web服务。另外，我会向你展示如何在苹果OSX系统上安装Node。
步骤1：安装 Node
　　最简单的安装Node的方式是通过一个兼容大部分操作系统的二进制包。打开浏览器访问下面的网页，根据你的操作系统下载适用的版本：
　　下载完成后，你会看到下面的内容：
如果你用的是Mac OSX，点击通用的.pkg文件。这会把安装程序保存到你本机中。下载了该文件之后，双击它就可以启动安装程序，你会看到下列安装对话框:
一路默认的安装下去，成功安装之后，点击close按钮来退出安装程序。
相当简单，是吧?
步骤2：使用NPM安装LoopBack
　　现在本地系统中已经安装了Node，接下来要安装StroopLoop公司提供的LoopBack包。LoopBack是一个开放的API源码包，当你学习使用Node开发、部署软件时，LoopBack可以使编程更简单。
　　为了安装LoopBack，我们要使用npm命令行，它是Node语言核心的一部分。NPM是一个官方的包管理工具，用于安装应用程序依赖的类库或模版。如果你是一名java程序员，你可以把NPM比作Maven。使用Maven构建项目，开发人员可以在pom.xml中配置项目依赖的jar包或模版。当项目开始编译时，Maven会下载所有依赖的文件，并将jar包引入到项目中。NPM工作原理和Maven相同，对于一些特殊的项目，它使用package.json文件来配置项目依赖的文件。你也可以使用命令行方式将依赖的文件下载到本地系统中。如果这些内容你不理解，不要担心，在接下来的步骤里我们会详细描述package.json文件。
　　为了安装LoopBack, 我们使用一个简单的命令行来下载和安装所有依赖的文件。打开你的window命令行窗口，输入下面命令：
$ npm install -g strongloop
提示：安装时，你可能需要使用其它用户帐号来执行这个命令。
　　这个命令行是什么含义呢？-g参数表示告诉npm我们想要安装strong-cli包。-g参数使这个包对任何系统和应用程序都兼容。一旦你运行了上面的命令，NPM会下载所有依赖的文件。下载的时间视网速而定，可能需要几分钟。
步骤3：创建应用程序
　　使用LoopBack API创建一个应用程序很简单。 打开你的window命令行窗口，使用下面的命令来创建一个新的应用程序restexample.
$ slc loopback
接下来它会提示输入项目根路径的名称。 在这个示例中，使用restexample。 接下来它会提示输入应用程序名称。 使用默认值restexample。
slc命令现在已经创建一个名称为restexample的LoopBack应用程序，并且已经配置了这个应用程序。 如果再次执行上面的命令，仍然使用restexample命名，LoopBack会创建一个新的目录。 可以使用cd命令来修改应用程序的根路径。
$ cd restexample
现在我们已经创建完一个应用程序，接下来我们将MongoDB配置为程序的数据源。
步骤4:定义数据源
为了连通MongoDB,我们需要给应用程序增加一个数据源,运行以下命令即可:
$ slc loopback:datasource
在弹出的提示符下,可以输入任意自定义的数据源名称,这里选择myMongo
[?] Enter the data-source name: myMongo
这样我们就将后端的数据源定义附加到由StrongLoop支持的真实连接器上面.这里我们从列表选择MongoDB连接器.
[?] Select the connector for myMongo:
PostgreSQL (supported by StrongLoop)
Oracle (supported by StrongLoop)
Microsoft SQL (supported by StrongLoop)
MongoDB (supported by StrongLoop)
SOAP webservices (supported by StrongLoop)
REST services (supported by StrongLoop)
Neo4j (provided by community)
(Move up and down to reveal more choices)
步骤5:指向真实的数据源
　　为了连通MongoDB,我们需要指向真实际的MongoDB实例.LoopBack在datasource.json文件中定义了所有的数据源配置信息.这个文件位于应用程序的root/server目录.打开这个文件,按照如下的方式,为MongoDB增加一个数据源:
"name": "db",
"connector": "memory"
"myMongo": {
"name": "myMongo",
"connector": "mongodb"
"url": "mongodb://localhost:27017/restexample"
注意:要保证为MongoDB数据库提供正确的 连接 URL.针对这个例子,我创建了一个名为 restexample 的数据库,它用来作为数据源.
步骤6:导入数据到MongoDB(mmmmm 啤酒)
　　就像本文Java部分说到的那样,我们需要加载数据集到MongoDB数据库中.如果你已经按照本文说到的方法完成了这个步骤,然后打算使用同一个数据库,你可以忽略步骤6,直接跳到步骤7.
　　首先,你需要下载一个包含所有要返回信息的JSON文件,可以从如下的URL获取:
　　数据集文件下载完毕后,直接使用如下的mongoimport命令将它加载到数据库:
$ mongoimport --jsonArray -d yourDBName -c beers --type json --file /tmp/beers.json -h yourMongoHost --port
　　你应该可以看到如下的结果:
connected to: 127.6.189.2:27017
Tue Jun 10 20:09:55.436 check 9 24
Tue Jun 10 20:09:55.437 imported 24 objects
步骤7:创造我们自己的啤酒模型
　　在Java世界里,由此可以想到对象模型.它代表这一个对象,只是在这里,这个对象是啤酒.LoopBack通过命令行,提供了一种创建模型对象的简便方式.打开终端窗口,进入到工程文件夹,输入如下命令:
$ slc loopback:model
这将会开启一个交互式的会话来定义模型.首先需要输入的是模型名称,这里输入"beer".接下来会提示,这个模型应该附加到的数据源,这里选择之前创建的myMongo数据源.
[?] Enter the model name: beer
[?] Select the data-source to attach beer to:
db (memory)
myMongo (mongodb)
接下来提示,是否通过REST将此API暴露出来.当然,这里希望这样.
[?] Expose beer via the REST API? Yes
最后,为模型选择网络复数名,这里模型名为beer,所以复数为beers(默认).敲击Enter键接受默认值.
[?] Custom plural form (used to build REST URL):
接下来会提示定义模型属性.对这个示例程序,我们关注名称和对啤酒的描述.
Enter an empty property name when done.
[?] Property name: name
只要敲击了Enter,就会提示输入各个指定属性的数据类型.第一个项是name,这里选择字符串类型.选择字符串类型,然后敲击
[?] Property type: (Use arrow keys)
接下来,按照同样的方式创建description属性,接着会要求输入数据类型.它同样是一个字符串类型,选择字符串选项,然后敲击
Let's add another beer property.
Enter an empty property name when done.
[?] Property name: description
invoke loopback:property
[?] Property type: string
[?] Required? Yes
　　祝贺!你已经使用LoopBack结合Node完成了模型对象的创建.如果想查看在这个过程中真正创建了什么,可以打开位于应用程序root/common/models目录的beer.json文件,滚动到这个文件的最后,将会看到如下模型:
"name": "beer",
"base": "PersistedModel",
"properties": {
"type": "string",
"required": true
"description": {
"type": "string",
"required": true
"validations": [],
"relations": {},
"acls": [],
"methods": []
这里可以看到,我们创建了一个模型,同时,name和description属性已经赋予了这个模型.
在/server/model-config.js文件中,可以注意到,文件中包含一些额外的字段,包括public和datasource.其中public域指定我们希望通过一个REST网络服务将此模型暴露给外部.datasource域则指定这个模型的CRUD操作将会用到的数据源.
"dataSource": "myMongo",
"public": true
步骤8:沉浸在看到beers的喜悦中
　　祝贺!你已经创建了第一个Node.js应用程序,其中包含可以获取beer信息的REST网络服务.最后,我们需要做的就是部署这个应用程序.
　　庆幸的是,部署是已经很容易的事情.可以通过在应用程序根目录执行如下命令来完成:
只要应用程序一运行,就可以通过浏览器转到如下的URL来确认部署是否成功:
相当酷,是不是?
LoopBack同时也包含了一个允许查看应用程序所有可用服务的页面,包括Beer模型和我们创建的REST服务,将浏览器指向如下的URL即可查看:
页面加载成功后，你会看到下面的界面，我们已经创建了beers节点作为博客的一部分，我把/beers端点进行高亮显示了:
你可以点击/beers来展开可供调用的API，你可以操作并测试一下，如下图所示:
　在这篇博文中，我展示了如何使用java EE 去创建一个rest服务，这个服务能够返回Pabst啤酒公司的啤酒产品清单数据。 之后我又使用node.js以及基于node.js的loopback框架使用很少的代码实现了相同功能的rest服务。 最重要的是，LoopBack API& 还对beer实体的增删查改提供了默认的实现，使得我们不用再写一行代码就得到了一个具有完整增删查改功能的rest服务。
下面的清单对博文中涉及的javaEE和node.js各自特性进行一个对比：
完善的IDE支持
Yes, 多种IDE供选择，包括 Eclipse, Sublime and Idea
Yes,&&多种IDE供选择，&Visual Studio, Eclipse, Sublime
有企业级项目采用
庞大的组件生态系统
通用开发框架
Spring, JEE
数据库支持
接下来的内容?
&即将发布的Node v0.12 将带来至少8个激动人心的新特性，它们会是什么呢？访问 “What's New in Node.js v0.12” 页面了解更多.
对Node相关的培训和认证感兴趣? StrongLoop 公司提供各种服务满足您的需求。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具在Java项目中拥抱Nodejs — 使用gruntjs编译typescript，并将生成的js合并 - 为程序员服务
在Java项目中拥抱Nodejs — 使用gruntjs编译typescript，并将生成的js合并
作为一个Java程序员，做的是Java项目，为什么需要了解Nodejs，并且还要拥抱它？
这里的Java项目，特指java web项目。如果是纯java项目，并不是很需要它，但如果是有很js/css/coffeescript/typescript/less/sass这样的文件的项目时，也许你就需要Nodejs了。
Nodejs是一个平台，可以让我们写服务器端的代码，它内部使用了google开发的v8引擎，执行js代码速度很快。我们学习它并不是为了写js代码，而是为了把它当工具使用，更好地处理我们的js/css等文件。
Nodejs的启动速度很快，并且第三方模块很多，而这些模块很多都跟js相关。其中有一些很好用的工具，可以简化我们的工作。虽然学习它需要花一些时间，但是带来的回报更大。
这里我将使用它来管理我的js代码，要求实现以下功能：
将我的typescript编译为js代码
将多个js文件合并为一个
将合并后的js文件进行精简操作(min)，减少文件体积
当我修改了typescript/js代码，自动重复以上操作
在Playframework中，可以内置或通过插件，将coffeescript自动转为javascript并精简压缩。但是当我们需要更多更灵活的功能时，就比较麻烦，因为play的插件不是那么好写的。我今天在play1中，编写java代码来处理typescript的编译操作，但是发现效率很低，当文件多的时候，修改typescript文件刷新后，需要好几秒才能编译成新的，难以接受。另外，由于typescript现在不支持将多个ts文件合并为一个js文件，我想去合并、精简时生成的多个js文件时，觉得太麻烦没做，只好将就着。
后来实在受不了了，发现了gruntjs这个工具，它是基于nodejs的。原来用它实现这些任务竟然如此简单，只需要简单的配置即可，编译速度还很快。另外，除了这些任务，我还发现了nodejs上的livereload插件，这样就可以替代以前使用的那个python的livereload了。
这些经验不仅仅对现在的项目有用，以后做其它涉及到js的项目时，也同样可用。所以学习它很值得。
Nodejs现在发展势头良好，正在紧张开发之中，每隔几天就看到一个新版本，让人眼花缭乱，当前最新版是v0.8.18。它的官方地址是，可以在windows/linux/unix上安装。
打开主页后，网站会根据操作系统自动提供相应的安装包，下载后安装即可。我是win7 x64，安装完成后，在cmd中输入：
C:\Users\Freewind&node -v
我是之前安装的，那时候的版本还是0.8.11
来个hello world。直接输入node，就会出现交互运行环境：
C:\Users\Freewind&node
& console.log('hello, world')
hello, world
如果想执行某个js文件，可以输入：
node test.js
npm是nodejs中内置的包管理系统，类似于ubuntu上的apt-get，或者centos上的yum，或者ruby上的gem。
我们安装完nodejs后，它就可以使用了。我们可在命令行中输入：
就可以看到一些提示信息。它提供的命令很多，可用来安装、卸载某些第三方的库。npm中的库有很多，可到这里查看：，当前显示有20000多个。
package.json
npm的配置放在名为package.json的文件中，它的内容是一个json字符串，基本内容如下：
"author": {
"name": "Freewind"
"name": "mytest",
"version":"0.0.1",
"dependencies": {
"grunt": "~0.3.17",
"grunt-typescript": "0.0.8"
其中name和version是基本信息，必须有。不过通常比较关注的是”dependencies”信息，它表示所在项目依赖于哪些第三方库。
首先要讲一下npm是怎么来查找路径的。当我们执行一个npm命令时，比如npm install typescript，它会首先查当前目录下有没有package.json文件或者node_modules目录。如果有则直接使用，没有的话，到上级目录中寻找，直到根目录。这个特性可以让我们在一个项目的子目录中执行npm命令，十分方便。如果所有的上级目录都没有的话，则会以当前目录作为工作目录，创建一个node_modules目录，把安装的库放到里面。
如果在当前或者上级某个目录中，有package.json文件，并且里面已经定义了一些依赖，我们可以直接使用这个命令，自动安装：
npm install
后面没有加参数，表示按package.json的要求来安装。
还有一个参数比较重要:
npm install somelib --save
后面的--save可用来告诉nodejs，安装完指定库后，把该依赖信息写到package.json文件中（如果有的话）。
更多的常用命令：
npm install somelib
将somelib这个库安装在当前或上级某目录下
npm install somelib -g
将somelib这个库安装为全局库，一些工具通常使用这种方式安装，比如typescript。安装完后就可以在命令行中直接使用库中的命令了，比如tsc（typescript的编译命令）
npm remove somelib
从当前或上级目录下移除somelib
npm remove somelib -g
从全局库中移除somelib
npm install somelib –save
在当前或上级目录中安装somelib，并将它添加到package.json中的依赖项里，十分方便
npm install
根据当前或上级目录中的package.json，自动安装缺失库
显示当前或上级目录中已经安装的nodejs库
Typescript
实际上此时并不需要安装typescript的编译器，但是由于肯定会用到，所以一起装了。
Typescript的编译器是以nodejs库的方式发布的。我们只需要使用该命令：
npm install typescript -g
即可。安装成功后，在命令行中输入：
它就会提示一些帮助信息。
常用用法如下
tsc test.ts
编译一个test.ts文件
tsc –declaration test.ts
为test.ts生成它对应的声明文件，产生的文件为test.d.ts
tsc –out dist.js test.ts
将test.ts编译为dist.js文件
tsc –out dist test.js
将test.ts编译成dist目录下，如果test.ts依赖其它文件，则把它们也编译到dist目录中
tsc –module commonjs
使用commonjs方式生成js（默认），还可以使用amd
关于typescript的更多内容，参看我另一篇博文。
gruntjs是一个构建系统，有点像java中的ant，但是感觉要简单很多，而且很多任务都是跟js相关的。它现在有380个插件，可在其主页上查询。
npm install -g grunt-cli
这里安装的是grunt-cli，它是一个全局的命令行工具，可以让不同的项目使用不同版本的grunt来编译，解决兼容问题。而grunt，则要以本地方式安装到我们的某个工作目录中。
进入某个工作目录，输入以下命令：
npm install grunt
则会在本地安装grunt，之后我们才能使用grunt命令来进行一些操作。
如果你是windows系统，一定要注意，安装完后，你有两个grunt命令可用，一个是grunt，一个是grunt.cmd，它们是两个不同的文件。其中前者是grunt库本身的命令，后者是用来执行你定义的任务的命令。请记住必须要用grunt.cmd，否则你会奇怪，为什么我的任务没执行等等。这个坑爹的问题花了我很多时间才解决。
要生成它的配置文件，需要安装grunt-init工具：
npm install grunt-init -g
git clone /gruntjs/grunt-init-gruntfile.git ~/.grunt-init/gruntfile
然后运行：
grunt-init gruntfile
它会问一些配置方面的问题，然后生成一个默认的Gruntfile.js文件。
将会在当前或上级目录（按nodejs的方式来定位工作目录），产生一个grunt.js文件，里面的内容如下：
/*global module:false*/
module.exports = function(grunt) {
// Project configuration.
grunt.initConfig({
// Metadata.
pkg: grunt.file.readJSON('package.json'),
banner: '/*! &%= pkg.title || pkg.name %& - v&%= pkg.version %& - ' +
'&%= grunt.template.today("yyyy-mm-dd") %&\n' +
'&%= pkg.homepage ? "* " + pkg.homepage + "\\n" : "" %&' +
'* Copyright (c) &%= grunt.template.today("yyyy") %& &%= pkg.author.name %&;' +
' Licensed &%= _.pluck(pkg.licenses, "type").join(", ") %& */\n',
// Task configuration.
options: {
banner: '&%= banner %&',
stripBanners: true
src: ['lib/&%= pkg.name %&.js'],
dest: 'dist/&%= pkg.name %&.js'
options: {
banner: '&%= banner %&'
src: '&%= concat.dist.dest %&',
dest: 'dist/&%= pkg.name %&.min.js'
options: {
curly: true,
eqeqeq: true,
immed: true,
latedef: true,
newcap: true,
noarg: true,
sub: true,
undef: true,
unused: true,
boss: true,
eqnull: true,
globals: {
jQuery: true
gruntfile: {
src: 'Gruntfile.js'
lib_test: {
src: ['lib/**/*.js', 'test/**/*.js']
nodeunit: {
files: ['test/**/*_test.js']
gruntfile: {
files: '&%= jshint.gruntfile.src %&',
tasks: ['jshint:gruntfile']
lib_test: {
files: '&%= jshint.lib_test.src %&',
tasks: ['jshint:lib_test', 'nodeunit']
// These plugins provide necessary tasks.
grunt.loadNpmTasks('grunt-contrib-concat');
grunt.loadNpmTasks('grunt-contrib-uglify');
grunt.loadNpmTasks('grunt-contrib-nodeunit');
grunt.loadNpmTasks('grunt-contrib-jshint');
grunt.loadNpmTasks('grunt-contrib-watch');
// Default task.
grunt.registerTask('default', ['jshint', 'nodeunit', 'concat', 'uglify']);
可以看到它里面定义了很多任务，比如使用jslint检查js文件，合并，压缩，执行单元测试，监视文件变化等。注意里面的文件路径都是空的，需要根据自己的情况添加。
要执行某个任务，可在命令行中输入：
grunt.cmd qunit
如果只输入：
则表示执行默认任务。此时表示’lint qunit concat min’。
其中的watch任务非常有用，它可以监视某些文件和目录，当它们发现变化时，自动执行指定的某些任务。我们将可以使用该功能监视typescript文件，当修改后，自动把它编译为js，浏览器那边就能看到最新的代码了。
注意，使用此任务时，最好在后面加上–force参数，即：
grunt.cmd watch --force
这样当构建过程中出现错误时，它会跳过并继续监视，否则就直接退出了。
grunt-typescript
最后是安装grunt-typescript插件，它可以在grunt中增加编译typescript的任务：
npm install grunt-typescript --save
然后往grunt.js里添加一些配置即可。我这里的成品是这样的：
/*global module:false*/
module.exports = function (grunt) {
grunt.loadNpmTasks('grunt-typescript');
// Project configuration.
grunt.initConfig({
WindBase: {
src: ['tmp/typescripts/controllers/**/*.js',
dest: 'public/javascripts/app.js'
wind_articles: {
src: ['../wind_articles/tmp/typescripts/**/*.js'],
dest: '../wind_articles/public/javascripts/module.js'
WindBase: {
src: ['public/javascripts/app.js'],
dest: 'public/javascripts/app.min.js'
wind_articles: {
src: ['../wind_articles/tmp/typescripts/module.js'],
dest: '../wind_articles/public/javascripts/module.min.js'
files: ['typescripts/**/*.ts', "../wind_articles/typescripts/src/**/*.ts"],
tasks: 'typescript concat min'
typescript: {
WindBase: {
src: ['typescripts/src/**/*.ts'],
dest: 'tmp/typescripts',
options: {
module: 'amd', //or commonjs
target: 'es5', //or es3
base_path: 'typescripts/src',
sourcemap: false,
declaration: false
wind_articles: {
src: ['../wind_articles/typescripts/src/**/*.ts'],
dest: '../wind_articles/tmp/typescripts',
options: {
module: 'amd', //or commonjs
target: 'es5', //or es3
base_path: '../wind_articles/typescripts/src',
sourcemap: false,
declaration: false
// Default task.
grunt.registerTask('default', 'typescript concat min');
注意其中的”typescript”和”concat”任务，可以设置多个子任务，名字（这里是WindBase和wind_articles）任选，只要里面的配置写对即可。你可以参照它修改。
另外把package.json也贴上：
"name": "mytest",
"version": "0.0.1",
"dependencies": {
"typescript": "~0.8.2"
原文地址：, 感谢原作者分享。
您可能感兴趣的代码