node.js java 連用(g8 王)

const http = require("http");
const net = require("net");

const host = '127.0.0.1';
const port = 8082;

let count = 0;

http.createServer(function (req, res) {
    debugger;
    count++;

    req.on('data', function(){
        debugger;
    });

    req.on('end', async function () {
        debugger;

        console.log('count(%d)', count);
        let data;
        data = await getJavaData(count);

        res.writeHead(200, { 'Content-Type': 'text/html' });

        let content = `<p>${data}</p>`;
        res.end(content);
    });

}).listen(3000);

//======================================
function getJavaData(count) {
    return new Promise(function (res, rej) {
        let data = '';
        let time = 0;

        const client = net.connect(port, host, function () {
            console.log('java connect...');
        });

        client.on('data', function (_data) {
            if (time++ == 0) {
                data = _data.toString();
                console.log('java count(%s) data(%s) data.length', count, data, data.length);
            }
        });

        client.on('end', function () {
            console.log('java end...');
            res(data);
        });
    });
}
//////////////////////////////////////////////////////////////////////////////////////
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package test_5;

import java.io.IOException;
import java.io.PrintStream;
import java.net.*;
import static java.lang.System.out;

/**
 *
 * @author xman
 */
public class Socket_1 {
   
    ServerSocket ss;
    Socket socket;
   
    static int port = 8082;
   
    public Socket_1() throws Exception {
       
            ss = new ServerSocket(port);
            while(true){
                socket = ss.accept();
                out.println("connect");
                PrintStream ps = new PrintStream(socket.getOutputStream());
                ps.println("i am java");
                ps.close();
                socket.close();
                out.println("disconnect");
            }
    }
   
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
       
        try{
        new Socket_1();           
        }catch(Exception e){
            out.println(e.toString());
        }
    }   
}

JSON.stringify 各種數據的顯示

--------------
// Int8Array
'{"0":1,"1":2,"2":3}'
[object Int8Array]
Int8Array
--------------
// Symbol
undefined
[object Symbol]
Symbol
--------------
// Map
'{}'
[object Map]
Map
--------------
// Set
'{}'
[object Set]
Set
--------------
// RegExp
'{}'
[object RegExp]
RegExp
--------------
// Date
'"2018-12-26T07:26:30.486Z"'
[object Date]
Date
--------------
// NaN
'null'
[object Number]
Number
--------------
// Infinity
'null'
[object Number]
Number
--------------
// null
'null'
[object Null]
Null
--------------
// undefined
undefined
[object Undefined]
Undefined
--------------
// {}
'{}'
[object Object]
Object

java promise

https://my.oschina.net/andylucc/blog/608499

http://ifeve.com/promise-future-callback/

https://github.com/hprose/hprose-java/wiki/%E5%BC%82%E6%AD%A5%E7%BC%96%E7%A8%8B%E2%80%94%E2%80%94Promise

https://juejin.im/post/5b126065e51d4506bd72b7cc

https://www.infoq.cn/article/design-patterns-promise https://www.cnkirito.moe/future-and-promise/


interface Closure<E, T> {
    public T callback(E in);
  
    public void error(Error err);
}


public class Promise<E> {
       
    protected int status = 0;   
    protected ArrayList<Closure> jobList = new ArrayList<>();
    protected Closure<Promise, Void> job;
    protected E data;
   
    public Promise(Closure job){
        this.job = job;

        // 暴露 resolve, reject
        this.job.callback(this);
    }

    private Promise() {
       
    }
   
    public void resolve(E e){
       
    }
   
    public void reject(String err){
       
    }
   
    protected void reject(Error err){
       
    }
   
    public Promise done(Closure c){
       
        return (new Promise<E>());
    }
   
    public Promise error(Closure c){
       
        return (new Promise<E>());
    }   
}

java 非同步做法

public interface Callback<T, E> {

    // in: 回傳的資料
    public void back(T in);
  
    // 錯誤時要做的事
    // err 錯誤訊息
    public void error(E err);
}
//----------------------------------------

public class Server_1 {

    public Thread asyncGetData(Callback callback) {
        out.println("server start");
        Thread th_1 = new Thread(() -> {
            int time = (int) (Math.random() * 5000);
          
            out.printf("server thread start(%s)\n", time);
            try {
                Thread.sleep(time);
              
                // 回傳資料
                callback.back(time);
                out.printf("server thread end(%s)\n", time);
            } catch (InterruptedException ex) {
                callback.error(ex);
            }
        });
      
        th_1.start();

        return th_1;
    }
}
//----------------------------------------
public class Client_1 {

    // 資料交換用
    int switchData_int;

    public void getData(){
        out.println("client.getData()");
        Server_1 server_1 = new Server_1();
        int gg;
        Thread th_1 = server_1.asyncGetData(new Callback<Integer, Error>() {
            @Override
            public void back(Integer in) {
                out.println("callback.back");

                // 閉包只適用於套嵌的 class
                Client_1.this.switchData_int = in;
            }

            @Override
            public void error(Error err) {

            }
        });
        try {
            th_1.join();
        } catch (InterruptedException ex) {
            out.println(ex);
        }
        out.printf("result(%s)\n------------\n", this.switchData_int);

    }

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Client_1 cl = new Client_1();
        cl.getData();
        cl.getData();
    }

}

promise 時序性問題

let p = new Promise((res)=>{
    console.log('a');
    res();
});

p.then(()=>{
    // 非同步
    console.log('b');
})

console.log('c');

=> a, c, b

javascript 另一種模板編組

function compile(template) {
    const evalExpr = /<%=(.+?)%>/g;
    const expr = /<%([\s\S]+?)%>/g;
    template = template.replace(evalExpr, '`); \n echo( $1 ); \n echo(`');
    template = template.replace(expr, '`); \n $1 \n echo(`');
    template = 'echo(`' + template + '`);';

    console.log(template);

    let script =
        `let output = "";
            function echo(html){
            output += html;
            }       
        ${template}
        return output;`;
    return new Function(script);
}


let content = "<ul>\
    <% for(let i=0; i < 4; i++){ %>\
        <li><%= i %>--${i*2}</li>\
    <% } %>\
</ul>";

let res = compile(content);
console.log(res());
console.log('--------------------');
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
https://johnresig.com/blog/javascript-micro-templating/

function compile(template) {
    let functionStr = compile_1(template);

    functionStr = "data = data || {};\n\
        for(let k in data){\n\
            let command = 'var '+ k + '= data[\"'+k+'\"];';\n\
            eval(command);\n\
        }\n\
    " + functionStr;

    console.log(functionStr);
    let fun = new Function('print', 'data', functionStr);

    function print(html) {
        return html;
    }

    return (fun).bind(null, print);
}

function compile_1(template) {
    const expr = /([\s\S]*?)<%([\s\S]+?)%>/g;
    const evalExpr = /([\s\S]*?)<%=([\s\S]+?)%>/g;

    reg_1 = /<%[^=-][\s\S]+?%>/;
    reg_2 = /<%=[\s\S]+?%>/;
    reg_3 = /<%-[^-][\s\S]+?%>/;

    let reg = [];
    reg.push("(" + reg_1.source + ")");
    reg.push("(" + reg_2.source + ")");
    reg.push("(" + reg_3.source + ")");
    reg = reg.join("|");
    reg = `([\\s\\S]*?)(?:${reg})`;
    console.log(reg);
    reg = RegExp(reg, 'g');

    let source = "let source = [];\n";
    template = template.replace(reg, function (m, g1, g2, g3, g4) {
        debugger;
        if (g1) {
            source += `source.push(\`${g1}\`);\n`;
        }

        if (g2) {
            // <% %>
            g2 = g2.replace(/%>$/, '').replace(/^<%/, '');
            source += `\n${g2}\n`;
        } else if (g3) {
            // <%= %>
            g3 = g3.replace(/%>$/, '').replace(/^<%=/, '');
            source += `source.push(print(${g3}));\n`;
        } else if (g4) {
            // <%- %>
            g4 = g4.replace(/%>$/, '').replace(/^<%-/, '');
            source += `source.push(print(${g4}));\n`;
        }

        return '';
    });

    if (template) {
        source += `source.push(\`${template}\`);\n`;
    }

    source += 'return (source.join(""));\n';

    return source;
}


let content = "<ul>\
    <% for(let i=0; i < a.length; i++){ %>\
        <li><%= i*2 %>--${a[i]*2}</li>\
    <% } %>\
</ul>";


let res = compile(content);

console.dir(res);

about vue

https://ustbhuangyi.github.io/vue-analysis/