分享下自己的自动打包小工具

月光魔力鸭

2018-12-14 08:40 阅读 1031 喜欢 3 自动打包 nodejs命令

在开发项目过程中，经常需要将开发的项目部署到服务器上，但是每个环境都有每个环境的配置等等，如果每次打包的时候都要去调整（可能删除、替换等），那就很烦人了,这里分享下自己实现的几个简单的小工具（当然这个工具可能只对我自己有用），希望能够帮到你。

其实，思路和实现都很简单，无非就是复制、删除、调用命令而已。

开发环境-tomcat

之前的项目是直接通过myeclipse来往tomcat发布，这样打包的话，只需要把tomcat下的相关文件进行处理并打包即可。

主要的流程就是：

将一些额外的或者其他名字的配置文件变更，比如：config.properties 这个文件,在我的项目中有不同环境的命名，需要做的就是把原本的删除掉，然后把对应环境的文件进行重命名即可。

config.properties

将一些准备好的文件放进去，在项目中，还需要一些环境的license，所以需要将这些文件放到对应的目录下。
调用命令进行打包（war）

根据流程，其实就可以抽离一些常用操作（比如：复制、重命名、删除等），然后通过json来配置要做的过程（这样能够适应同类的其他项目）。

代码: util.js 主要是用于抽取的一些操作，包括删除、复制、重命名等，具体的步骤请看下面的json文件。

let {join} = require('path');
let fs = require('fs');
class exeIssuse{
	constructor( json ){
		this.json = json ;
	}
	callisu () {
		if(this.json.length > 0){
			let isu = this.json[0];
			this.json = this.json.splice(1);
			this.name = isu.name;
			this.path = isu.path;
			this.actions = isu.actions;
			this.encodexml = isu.encodexml;
			let thiz = this;
			this.actions.forEach(function( info ){
				thiz.step(info);
			});
			this.packer();
		}else{
			console.log(`全部结束，已经没有需要打包的路径了。`);
			//打开文件夹
			require('child_process').exec('start '+__dirname);
		}
	}
	step ( info ){
		let type = info.key;
		let repath = info.repath || '/';
		let from = info.from || '';
		let to = info.to ||'';
		if(type === 'del'){
			this.del(repath,from);
		}else if( type === 'rename'){
			this.rename(repath,from,to);
		}else if(type === 'copy'){
			this.copy(repath,from,to);
		}
	}

	packer () {
		let name = this.name;
		let exec = require('child_process').exec;
		let topath = join(__dirname,this.name);
		let frompath = this.path;
		let cmd = 'jar cvf '+topath+' -C '+frompath+' .';
		var cp = exec(cmd);
		let thiz = this;
		cp.stdout.on('close',function(){
			console.log(`---${name}打包结束,等待10s后进行加密war包`)
		});
		cp.on('exit',function(){
			//10s后调用
			setTimeout(function(){
				thiz.encode();	
			},10000);
		})
	}

	//加密
	encode () {
		let thiz = this;
		let encodexml = this.encodexml;
		let exec = require('child_process').exec;
		let cmd = 'java -Xms128m -Xmx512m -jar allatori.jar '+encodexml;
		console.log(cmd);
		var cp = exec(cmd,function(err,stdout){
			console.log(err);
			console.log(stdout);
			console.log(`---war包加密结束，请查看`);
			thiz.callisu();
		});
		
		// cp.stdout.on('close',function(){
			
		// })
	}

	del ( repath , from ) {
		console.log(`删除文件:${from}`)
		let dir = join(this.path,repath);
		from = typeof from == 'string' ? [from] : from;

		from.forEach(function( item ){
			if(item !== ''){
				let filePath = join(dir,item);
				fs.unlinkSync(filePath);
			}
		});

	}

	copy ( repath, from , to){
		let topath = join(this.path,repath,to);
		console.log(`复制文件从${from}到${topath}`);
		var buffer = fs.readFileSync(from);
		fs.writeFileSync(topath,buffer);
	}
	rename ( repath, from ,to){
		
		let dir = join(this.path,repath);
		let fromPath = join(dir,from);
		let topath = join(dir,to);
		console.log(`重命名:${fromPath}——————${topath}`)
		fs.renameSync(fromPath,topath);
	}
}
module.exports = exeIssuse;

dev.json 开发环境的部署过程-操作步骤.定义一些操作类型以及相关的数据

[
{
	"name":"byyresource-dev.war",
	"path":"I:/tomcat7/webapps/byyresource/",
	"encodexml":"byyresource/config-war-dev.xml",
	"actions":[
		
		{
			"key":"del",
			"repath":"/WEB-INF/classes",
			"from":["config.properties","spring.xml","license.key","license.lic"]
		},{
			"key":"rename",
			"repath":"/WEB-INF/classes",
			"from":"config-dev.properties",
			"to":"config.properties"
		},
		{
			"key":"rename",
			"repath":"/WEB-INF/classes",
			"from":"spring-dev.xml",
			"to":"spring.xml"
		},{
			"key":"copy",
			"repath":"/WEB-INF/classes",
			"from":"e:/node/boyuyun/packer/dev/license.key",
			"to":"license.key"
		},{
			"key":"copy",
			"repath":"/WEB-INF/classes",
			"from":"e:/node/boyuyun/packer/dev/license.lic",
			"to":"license.lic"
		}
	]
}
]

app.js 该文件用于发起打包过程

/**删除文件、文件重命名，最后打包**/
let packer = require('./byyresource/dev.json');

let issue =require( './util');

if(packer.length == 0){
	console.log('no issuses');
	return;
}

let ins = new issue(packer);
ins.callisu();

剩下的，就是执行了。node app 然后等待结果就可以啦。

开发环境-springboot

后来，项目使用了spring-boot ，然后导致tomcat的一些东西没有了（可能我没找到），所以上面的打包过程就不适用了。

这个环境的大体流程是：

找到项目文件夹，然后把文件全部复制出来（不然的话，改动后会把代码改变，很麻烦）
复制出来后，进行删除、复制、替换等操作后
执行mvn package打包命令，剩下的就等结果啦。

代码: app.js 这个项目目前只做了一个简单版本的，还没有通用到其他项目。过程也比较简单（只是多了个babel编译）

//对spring-boot项目进行打包处理
let fs = require('fs');
let {join} = require('path');
let {spawn} = require('child_process');

let TARGET = 'i:/wp2018/ByyTeaching'
let CURRENT = __dirname;
let ENV = 'jiqun';
//1.配置文件替换或者某些项目替换

function exeCmd(cmd,dir){
	return new Promise((resolve,reject)=>{
		let ls = spawn('cmd.exe',['/c'].concat(cmd),{
			cwd : dir
		});
		ls.stdout.on('data',(data)=>{
			// console.log(`stdout: ${data}`);	
		});
		ls.stderr.on('data', (data) => {
		  // console.log(`stderr: ${data}`);
		  reject(false);
		});
		ls.on('close',function(){
			console.log(cmd.join(' ')+'命令执行结束.')
			resolve();
		});
	});
}
function copy(sourcePath,targetPath){
	console.log(sourcePath);
	console.log(targetPath);
	return new Promise((resolve,reject)=>{
		let rs = fs.createReadStream(sourcePath);
		let ws = fs.createWriteStream(targetPath);
		rs.on('data',function(data){
			ws.write(data);
		});
		rs.on('close',function(){
			rs.close();
			ws.close();
			console.log('复制结束:'+sourcePath+'---'+targetPath);
			resolve();//复制结束

		})
	});
}
//删除目录下的所有文件
function delFile(fileUrl,flag){
	if (!fs.existsSync(fileUrl)) return;
    // 当前文件为文件夹时
    if (fs.statSync(fileUrl).isDirectory()) {
        var files = fs.readdirSync(fileUrl);
        var len = files.length,
            removeNumber = 0;
        if (len > 0) {
            files.forEach(function(file) {
                removeNumber ++;
                var stats = fs.statSync(fileUrl+'/'+file);
                var url = fileUrl + '/' + file;
                if (fs.statSync(url).isDirectory()) {
                    delFile(url,true);
                } else {
                    fs.unlinkSync(url);
                }
            });
            if(len == removeNumber && flag){
            	fs.rmdirSync(fileUrl);
            }
        } else if(len == 0 && flag){
            fs.rmdirSync(fileUrl);
        }
    } else {
        // 当前文件为文件时
        fs.unlinkSync(fileUrl);
        console.log('删除文件' + fileUrl + '成功');
    }
}

//开始执行

exeCmd(['jar','-cvf','byyteaching.war','./'],TARGET)
.then(()=>{
	//复制
	return copy(join(TARGET,'byyteaching.war'),join(CURRENT,'source','base','byyteaching.war'));
})
.then(()=>{
	//执行解压命令
	return exeCmd(['jar','-xvf','byyteaching.war'],join(CURRENT,'source','base'));
})
.then(()=>{
	//删除war包
	delFile(join(CURRENT,'source','base','byyteaching.war'));
	delFile(join(TARGET,'byyteaching.war'));
})
.then(()=>{
	//替换application.yml 文件
	let applicationPath = join(CURRENT,'source','base','src','main','resources','application.yml');
	delFile(applicationPath);
	return copy(join(CURRENT,ENV,'application.yml'),applicationPath);
})
.then(()=>{
	//复制license
	let licensePath = join(CURRENT,'source','base','src','main','resources','license.key');
	return copy(join(CURRENT,ENV,'license.key'),licensePath);
})
.then(()=>{
	//复制license
	let licensePath = join(CURRENT,'source','base','src','main','resources','license.lic');
	return copy(join(CURRENT,ENV,'license.lic'),licensePath);
})
.then(()=>{
	//执行js编译
	return exeCmd(['node','index',join(CURRENT,'source','base','src','main','resources','static','js')],join(CURRENT,'babel'));
})
.then(()=>{
	//执行打包命令
	return exeCmd(['mvn','package'],join(CURRENT,'source','base'));
})
.then(()=>{
	//复制war包到目标地址
	return copy(join(CURRENT,'source','base','target','byyteaching.war'),join(CURRENT,'source',ENV,'byyteaching.war'));
})
.then(()=>{
	//打开文件夹
	exeCmd(['start',join(CURRENT,'source',ENV)],join(CURRENT,'source',ENV));
})
.then(()=>{
	//删除base下的源文件
	delFile(join(CURRENT,'source','base'));
})

啦啦啦，解放了双手（虽然只是一小会，但是能够通过简单的命令来实现也是很得意的../大神不要踩/）

可能我的代码只能我来用，但是如果能够给你提供一点点..哪怕一点点小小的灵感或思路，那我也很高兴啦。

转载请注明出处: https://chrunlee.cn/article/nodejs-package-tool.html

感谢支持!

赞赏支持

喜欢