Google V8扩展利器发布：v8-native-binding-generator

用C++扩展Google V8很简单，但是类比较多时还是很烦的。前段时间开发cantk-runtime-v8时，我写了一个代码产生器v8-native-binding-generator，让扩展Google V8变得非常方便，甚至无需要了解V8本身。具体用法如下：

先写一个JSON的类描述文件，下面这段JSON是我用来模拟XMLHttpRequest的：

{
    "className":"HttpClient",
    "functions":[
        {
            "name":"send",
            "returnType" : "bool",
            "args"   : [
                {"name":"onProgress", "type":"function"},
                {"name":"onDone", "type":"function"}
            ]
        }
    ],
    "attributes" : [
        {"name":"url", "type":"string"},
        {"name":"returnType", "type":"string"},
        {"name":"method", "type":"string"},
        {"name":"requestHeaders", "type":"string"},
        {"name":"requestData", "type":"string"},
        {"name":"status", "type":"int32_t"},
        {"name":"statusText", "type":"string"},
        {"name":"responseHeaders", "type":"string"},
        {"name":"responseText", "type":"string"}
    ]
}

运行代码产生器：

node gen-v8-binding.js idl/http_client.json

生成4个文件，依次是HttpClient类的头文件和CPP文件，HttpClientBinding类的头文件和CPP文件：

HttpClient.h

#ifndef _HTTPCLIENT_H
#define _HTTPCLIENT_H

#include <assert.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <v8.h>
#include <nan/nan.h>

using namespace std;
using namespace v8;

class HttpClient: public ObjectWrap {
public:
    HttpClient();
    ~HttpClient();

    bool send(NanCallback*  onProgress, NanCallback*  onDone);

    string getUrl() const;
    void setUrl(string url);

    string getReturnType() const;
    void setReturnType(string returnType);

    string getMethod() const;
    void setMethod(string method);

    string getRequestHeaders() const;
    void setRequestHeaders(string requestHeaders);

    string getRequestData() const;
    void setRequestData(string requestData);

    int32_t getStatus() const;
    void setStatus(int32_t status);

    string getStatusText() const;
    void setStatusText(string statusText);

    string getResponseHeaders() const;
    void setResponseHeaders(string responseHeaders);

    string getResponseText() const;
    void setResponseText(string responseText);

private:
    string _url;
    string _returnType;
    string _method;
    string _requestHeaders;
    string _requestData;
    int32_t _status;
    string _statusText;
    string _responseHeaders;
    string _responseText;
};

#endif

HttpClient.cpp

#include "HttpClient.h"
HttpClient::HttpClient(){
}

HttpClient::~HttpClient(){
}

bool HttpClient::send(NanCallback*  onProgress, NanCallback*  onDone) {
}

string HttpClient::getUrl() const {
    return this->_url;
}

void HttpClient::setUrl(string url) {
    this->_url = url;
}

string HttpClient::getReturnType() const {
    return this->_returnType;
}

void HttpClient::setReturnType(string returnType) {
    this->_returnType = returnType;
}

string HttpClient::getMethod() const {
    return this->_method;
}

void HttpClient::setMethod(string method) {
    this->_method = method;
}

string HttpClient::getRequestHeaders() const {
    return this->_requestHeaders;
}

void HttpClient::setRequestHeaders(string requestHeaders) {
    this->_requestHeaders = requestHeaders;
}

string HttpClient::getRequestData() const {
    return this->_requestData;
}

void HttpClient::setRequestData(string requestData) {
    this->_requestData = requestData;
}

int32_t HttpClient::getStatus() const {
    return this->_status;
}

void HttpClient::setStatus(int32_t status) {
    this->_status = status;
}

string HttpClient::getStatusText() const {
    return this->_statusText;
}

void HttpClient::setStatusText(string statusText) {
    this->_statusText = statusText;
}

string HttpClient::getResponseHeaders() const {
    return this->_responseHeaders;
}

void HttpClient::setResponseHeaders(string responseHeaders) {
    this->_responseHeaders = responseHeaders;
}

string HttpClient::getResponseText() const {
    return this->_responseText;
}

void HttpClient::setResponseText(string responseText) {
    this->_responseText = responseText;
}

HttpClientBinding.h

#ifndef _HTTPCLIENTBINDING_H
#define _HTTPCLIENTBINDING_H

#include <assert.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>

#include <string.h>

#include <v8.h>
#include <nan/nan.h>

using namespace v8;
void HttpClientInitBinding(Handle<Object> target);

#endif

HttpClientBinding.cpp

#include "HttpClient.h"

#include "HttpClientBinding.h"

NAN_METHOD(newHttpClient) {
    NanScope();

    HttpClient* obj = new HttpClient();
    obj->Wrap(args.This());

    NanReturnValue(args.This());
}

NAN_METHOD(HttpClientSend) {
    NanScope();
    HttpClient* obj = ObjectWrap::Unwrap<HttpClient>(args.This());

    if(args.Length() == 2) {
        NanCallback* onProgress = new NanCallback(args[0].As<Function>());
        NanCallback* onDone = new NanCallback(args[1].As<Function>());

        bool retVal = obj->send(onProgress, onDone);
        NanReturnValue(NanNew<Boolean>(retVal));
        return;
    }

}

NAN_GETTER(HttpClientGetUrl) {
    NanScope();
    HttpClient* obj = ObjectWrap::Unwrap<HttpClient>(args.This());
    NanReturnValue(NanNew<String>(obj->getUrl()));
}

NAN_SETTER(HttpClientSetUrl) {
    NanScope();
    HttpClient* obj = ObjectWrap::Unwrap<HttpClient>(args.This());
    if (value->IsString()) {
        v8::String::Utf8Value nativeValue(value);
        obj->setUrl(*nativeValue);
    }else{
        printf("invalid data type for HttpClient.url\n");
    }
}

NAN_GETTER(HttpClientGetReturnType) {
    NanScope();
    HttpClient* obj = ObjectWrap::Unwrap<HttpClient>(args.This());
    NanReturnValue(NanNew<String>(obj->getReturnType()));
}

NAN_SETTER(HttpClientSetReturnType) {
    NanScope();
    HttpClient* obj = ObjectWrap::Unwrap<HttpClient>(args.This());
    if (value->IsString()) {
        v8::String::Utf8Value nativeValue(value);
        obj->setReturnType(*nativeValue);
    }else{
        printf("invalid data type for HttpClient.returnType\n");
    }
}

NAN_GETTER(HttpClientGetMethod) {
    NanScope();
    HttpClient* obj = ObjectWrap::Unwrap<HttpClient>(args.This());
    NanReturnValue(NanNew<String>(obj->getMethod()));
}

NAN_SETTER(HttpClientSetMethod) {
    NanScope();
    HttpClient* obj = ObjectWrap::Unwrap<HttpClient>(args.This());
    if (value->IsString()) {
        v8::String::Utf8Value nativeValue(value);
        obj->setMethod(*nativeValue);
    }else{
        printf("invalid data type for HttpClient.method\n");
    }
}

NAN_GETTER(HttpClientGetRequestHeaders) {
    NanScope();
    HttpClient* obj = ObjectWrap::Unwrap<HttpClient>(args.This());
    NanReturnValue(NanNew<String>(obj->getRequestHeaders()));
}

NAN_SETTER(HttpClientSetRequestHeaders) {
    NanScope();
    HttpClient* obj = ObjectWrap::Unwrap<HttpClient>(args.This());
    if (value->IsString()) {
        v8::String::Utf8Value nativeValue(value);
        obj->setRequestHeaders(*nativeValue);
    }else{
        printf("invalid data type for HttpClient.requestHeaders\n");
    }
}

NAN_GETTER(HttpClientGetRequestData) {
    NanScope();
    HttpClient* obj = ObjectWrap::Unwrap<HttpClient>(args.This());
    NanReturnValue(NanNew<String>(obj->getRequestData()));
}

NAN_SETTER(HttpClientSetRequestData) {
    NanScope();
    HttpClient* obj = ObjectWrap::Unwrap<HttpClient>(args.This());
    if (value->IsString()) {
        v8::String::Utf8Value nativeValue(value);
        obj->setRequestData(*nativeValue);
    }else{
        printf("invalid data type for HttpClient.requestData\n");
    }
}

NAN_GETTER(HttpClientGetStatus) {
    NanScope();
    HttpClient* obj = ObjectWrap::Unwrap<HttpClient>(args.This());
    NanReturnValue(NanNew<Int32>(obj->getStatus()));
}

NAN_SETTER(HttpClientSetStatus) {
    NanScope();
    HttpClient* obj = ObjectWrap::Unwrap<HttpClient>(args.This());
    if (value->IsInt32()) {
        int32_t nativeValue = value->Int32Value();
        obj->setStatus(nativeValue);
    }else{
        printf("invalid data type for HttpClient.status\n");
    }
}

NAN_GETTER(HttpClientGetStatusText) {
    NanScope();
    HttpClient* obj = ObjectWrap::Unwrap<HttpClient>(args.This());
    NanReturnValue(NanNew<String>(obj->getStatusText()));
}

NAN_SETTER(HttpClientSetStatusText) {
    NanScope();
    HttpClient* obj = ObjectWrap::Unwrap<HttpClient>(args.This());
    if (value->IsString()) {
        v8::String::Utf8Value nativeValue(value);
        obj->setStatusText(*nativeValue);
    }else{
        printf("invalid data type for HttpClient.statusText\n");
    }
}

NAN_GETTER(HttpClientGetResponseHeaders) {
    NanScope();
    HttpClient* obj = ObjectWrap::Unwrap<HttpClient>(args.This());
    NanReturnValue(NanNew<String>(obj->getResponseHeaders()));
}

NAN_SETTER(HttpClientSetResponseHeaders) {
    NanScope();
    HttpClient* obj = ObjectWrap::Unwrap<HttpClient>(args.This());
    if (value->IsString()) {
        v8::String::Utf8Value nativeValue(value);
        obj->setResponseHeaders(*nativeValue);
    }else{
        printf("invalid data type for HttpClient.responseHeaders\n");
    }
}

NAN_GETTER(HttpClientGetResponseText) {
    NanScope();
    HttpClient* obj = ObjectWrap::Unwrap<HttpClient>(args.This());
    NanReturnValue(NanNew<String>(obj->getResponseText()));
}

NAN_SETTER(HttpClientSetResponseText) {
    NanScope();
    HttpClient* obj = ObjectWrap::Unwrap<HttpClient>(args.This());
    if (value->IsString()) {
        v8::String::Utf8Value nativeValue(value);
        obj->setResponseText(*nativeValue);
    }else{
        printf("invalid data type for HttpClient.responseText\n");
    }
}

static Persistent<FunctionTemplate> constructor;
void HttpClientInitBinding(Handle<Object> target) {
    NanScope();
    Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(newHttpClient);
    NanAssignPersistent(constructor, ctor);
    ctor->InstanceTemplate()->SetInternalFieldCount(1);
    ctor->SetClassName(NanNew("HttpClient"));
    Local<ObjectTemplate> proto = ctor->PrototypeTemplate();

    proto->SetAccessor(NanNew("url"), HttpClientGetUrl, HttpClientSetUrl);
    proto->SetAccessor(NanNew("returnType"), HttpClientGetReturnType, HttpClientSetReturnType);
    proto->SetAccessor(NanNew("method"), HttpClientGetMethod, HttpClientSetMethod);
    proto->SetAccessor(NanNew("requestHeaders"), HttpClientGetRequestHeaders, HttpClientSetRequestHeaders);
    proto->SetAccessor(NanNew("requestData"), HttpClientGetRequestData, HttpClientSetRequestData);
    proto->SetAccessor(NanNew("status"), HttpClientGetStatus, HttpClientSetStatus);
    proto->SetAccessor(NanNew("statusText"), HttpClientGetStatusText, HttpClientSetStatusText);
    proto->SetAccessor(NanNew("responseHeaders"), HttpClientGetResponseHeaders, HttpClientSetResponseHeaders);
    proto->SetAccessor(NanNew("responseText"), HttpClientGetResponseText, HttpClientSetResponseText);

    NAN_SET_PROTOTYPE_METHOD(ctor, "send", HttpClientSend);

    target->Set(NanNew("HttpClient"), ctor->GetFunction());

}

目前支持的数据类型有：

* 1.string 字符串

* 2.int32_t 整数

* 3.int64_t 整数

* 4.double 浮点数

* 5.bool 布尔变量

* 6.function 回调函数（目前只能用于参数）

* 7.其它对象指针(如Image*)，要求对象的类也是用本工具产生出来的。

更多例子请参考：https://github.com/drawapp8/cantk-runtime-v8

1.v8-native-binding-generator源码