Forem: HyperRedStart

Using Configurations and Options

HyperRedStart — Tue, 12 Apr 2022 08:14:29 +0000

這個章節會介紹到基本的 webpack config 設定的實際使用，透過設定的層層疊加，並討論組態設定、資源管理、輸出管理、對 webpack 的設定。

💈 基本 Webpack Config 設定指南 💈

1. 使用不同的設定檔

在 package.json 中指定 webpack config 的設定檔案名稱

"scripts": {"build": "webpack --config example.config.js" }

2. 設定模組選項

mode 可以針對不同的輸出模式進行優話
entry 預設為 src 底下目錄，代表開始封裝的起始目錄位置

const path = require('path');
module.exports = {
mode: "production", // "production" | "development" | "none"
entry: "./app/entry", // string | object | array

3. 輸出選項

設定輸出路徑，輸出檔案名稱，以及公共路徑位置，library 設定輸出給其他第三方的名稱，libraryTarget 可以指定引用語句類型

output: {
path: path.resolve(__dirname, "dist"), // string
filename: "bundle.js", // string
publicPath: "/assets/", // string
library: "MyLibrary", // string,
libraryTarget: "umd", // universal module definition
},

4. 引用檔案名稱規則

設定模組內需要引用的檔案規則，可以引入指定目錄，或是將其排除

module: {
  rules: [{
    test: /\.jsx?$/,
    include: [ path.resolve(__dirname, "app") ],
    exclude: [
      path.resolve(__dirname, "app/demo-files")
    ],

5. enforce / issuer

issuer 指定支援的使用，如 svg 檔案可讓 js 副檔名的檔案，進行加載

{
  test: /\.svg(\?.*)?$/,
  issuer: /\.js$/,
  loader: 'svg-inline-loader'
}

設定 enforce 指定載入順序

pre 優先
normal 正常
inline 其次
post 最後

enforce: "pre" | enforce: "post"

6. performance

限制效能警告
當檔案過大造成效能頻緊時，提出緊告

performance: {
hints: "warning", // enum
maxAssetSize: 200000, // int (in bytes),
maxEntrypointSize: 400000, // int (in bytes)
assetFilter: function(assetFilename) {
return assetFilename.endsWith('.css') || assetFilename.endsWith('.js');
}

7. devServer

設定啟動開發測試環境，實現 Live Reload

devServer: { 
  proxy: { '/api':'http://localhost:3000' },
  contentBase: path.join(__dirname, 'public'),
  compress: true,
  historyApiFallback: true,
  hot: true,
  https: false,
  noInfo: true,
},

運行 server

npx webpack serve

資源管理

CSS / Image / woff 資源檔案

安裝資源載入相應套件

npm install --save-dev style-loader css-loader file-loader

📚 設定資源載入套件

module: {
  rules: [{
    test: /\.css$/,
    use: ['style-loader', 'css-loader']
  }, {
    test: /\.(png|svg|jpg|gif)$/,
    use: ['file-loader']
  }, {
    test: /\.(woff|woff2|eot|ttf|otf)$/,
    use: ['file-loader']
  }
]}

載入後就可以在js中透過import 加載資源檔

import './style.css';
import Icon from './icon.png';

CSS 中加載字型

@font-face {
  font-family: 'SampleFont';
  src: url('./sample-font.woff2') format('woff2'),
  url('./sample-font.woff') format('woff');
}

JSON/ CSV / XML 資源檔案

除了一般的 CSS / 圖檔以外，也可以載入文字資源檔
安裝資源載入相應套件

npm install --save-dev csv-loader xml-loader

設定資源載入

{
  test: /\.(csv|tsv)$/,
  use: ['csv-loader']
},
{
  test: /\.xml$/,
  use: ['xml-loader']
}

載入資源

import Data from './data.xml';

HtmlWebpackPlugin

使用 html plugin 透過 webpack.config.js 來設定 html內容

npm install --save-dev html-webpack-plugin

ex: 設定網頁 title

const HtmlWebpackPlugin = require('html-webpack-plugin');

plugins: [
  new HtmlWebpackPlugin({
    title: 'Output Management'
  }
)]

清除發布目錄

在開發中我們輸出至dist的目錄內，可能會有很多殘留檔案，可以透過以下工具，清理目錄內容

npm install --save-dev clean-webpack-plugin

const CleanWebpackPlugin = require('clean-webpack-plugin');

plugins: [
  new CleanWebpackPlugin(),
],

Bail

Bail 參數設定為布林值，會強迫 Webpack 在編譯中發生錯誤問題後，立刻終止

module.exports = {bail: true};

其他介紹的屬性參數

profile : 布林屬性，提供分析資料，可使用 https://webpack.github.io/analyse/ 進行分析
parallelism : 正整數並行數量，透過並行的方式執行各個模組
recordsPath：字串路徑，紀錄code splitting 跨檔案之間的關聯，以便確保緩存(Cahching)行為能正常再分散的檔案中。

第三章節 Using Configurations and Options 結束 🎉
第四章會介紹更多的第三方 Webpack 套件，指導我們如何應用 Webpack 整合各式的開發工具，以及使用 Webpack 進行各種複雜的建置設定。

Working with Modules and Code Splitting

HyperRedStart — Fri, 08 Apr 2022 06:30:19 +0000

此章節會介紹 Webpack 中的模組 (Module) 以及程式碼分離 (Code Splitting) 兩個 Webpack 特色，透過以上特色使專案代碼分割並以最適合的方式分割代碼。

此章節包含內容：

解釋 Webpack 中的 Modules
了解 Code Splitting 機制
將所需要的模組預先載入
範例展示

Module

透過 Webpack 模組會將共用的方法集合在同一檔案內，並會依照不同類型進行分類，如下圖所釋：

Webpack 根據不同的模組標準有以下幾種語句：

ECMA 2015 : import
CommonJS : require
ASM(Asynchronous Module Definition) : define / require
CSS : @import stylesheet

模組支援語言

確保 Webpack 支援這些模組，必須要使用允許的程式語言，透過 Webpack 社群所建立的 Loaders 支援了大量的語言例如以下幾種。

TypeScript
SASS
LESS
C++
Babel
Bootstrap

載入模組路徑

絕對路徑
從根目錄開始定位到引用檔案
import 'C:\Users\project\file';
相對路徑
根據當前檔案定位到引用檔案
import '../src/file';
模組路徑
從模組中搜尋名稱，引用模組內的檔案
import 'module/sub-directory/file';

Code Splitting

允許使用者將片段的程式放入不同的套件中，並且可以按需求或是並行載入，被認為是 Webpack 最具矚目的功能。

達成方法

Entry Points: 可以手動設置片段程式進入點設定檔
SplitChunksPlugin: 並免相同程式載入，將片段的程式碼整合成群組這種群組稱為 "chunks"
Dynamic Imports: 透過程式來動態將片段程式碼載入

Entry Points

使用 Entry points 是最簡單可以達成 code splitting 的方法。

我們根據第一章範例的專案，增改以下內容

src/another-module.js

import _ from 'lodash';
console.log(_.join(['Another', 'module', 'loaded!'], ' '));

webpack.config.js

const path = require('path');
module.exports = {
  mode: 'development',
  entry: {
    index: './src/index.js',
    another: './src/another-module.js'
  },
  output: {
    filename: '[name].bundle.js',
    path: path.resolve(__dirname, 'dist')
  }
};

編譯專案

$ npm run build
Asset Size Chunks Chunk Names
another.bundle.js 550 KiB another [emitted] another
index.bundle.js 550 KiB index [emitted] index
Entrypoint index = index.bundle.js
Entrypoint another = another.bundle.js

編譯完成後再 dist 目錄下產生了 index.bundle.js/another.bundle.js 倆的檔案，但因為兩支js程式都有加載 lodash 導致兩支程式代碼重複。

SplitChunksPlugin

預防重複程式碼

從剛剛的 entrypoints 結果我們的程式碼重複了，為了避免這個狀況我們可以使用 SplitChunks 的 Webpack 套件

webpack.config.js
在 module 中增加 optimization 參數，再進行編譯

const path = require('path');
module.exports = {
  mode: 'development',
  entry: {
    index: './src/index.js',
    another: './src/another-module.js'
  },
  output: {
    filename: '[name].bundle.js',
    path: path.resolve(__dirname, 'dist')
  },
  optimization: {
    splitChunks: {
      chunks: 'all'
    }
  }
};

編譯專案

$npm run build

> 01-sample-app2@1.0.0 build
> webpack --config webpack.config.js
asset vendors-node_modules_lodash_lodash_js.bundle.js 550 KiB [emitted] (id hint: vendors)
asset index.bundle.js 8.83 KiB [emitted] (name: index)
asset another.bundle.js 8.75 KiB [emitted] (name: another)
Entrypoint index 559 KiB = vendors-node_modules_lodash_lodash_js.bundle.js 550 KiB index.bundle.js 8.83 KiB
Entrypoint another 559 KiB = vendors-node_modules_lodash_lodash_js.bundle.js 550 KiB another.bundle.js 8.75 KiB
runtime modules 7.3 KiB 16 modules
cacheable modules 532 KiB
  ./src/index.js 212 bytes [built] [code generated]
  ./src/another-module.js 83 bytes [built] [code generated]
  ./node_modules/lodash/lodash.js 531 KiB [built] [code generated]
webpack 5.69.1 compiled successfully in 326 ms

此時除了 anotherjs 與 indexjs 外多了一個檔案 "vendors-node_modules_lodash_lodash_js.bundle.js" lodash 的代碼就統一放在這個檔案，避免代碼重複

現在我們了解了如何避免重複代碼，接下來就要換到另一個更難的主題，Dynamic Imports。

Dynamic Imports

Dynamic Imports 是實現 on-demand imports 的必要方法。

webpack.config.js
output 中增加 chunkFilename 指定Dynamic Import Moudle 檔案名稱

const path = require('path');
module.exports = {
  mode: 'development',
  entry: {
    index: './src/index.js'
  },
  output: {
    filename: '[name].bundle.js',
    chunkFilename: '[name].bundle.js',
    path: path.resolve(__dirname, 'dist')
  },
};

index.js
透過在程式中 import 以動態的方式載入第三方模組，編譯過後就會產生相應檔案，並透過 webpackChunkName 指定產出名稱。

function getComponent() {
  return import(/* webpackChunkName: "lodash" */ 'lodash').then(({ default: _ }) => {
  var element = document.createElement('div');

  element.innerHTML = _.join(['Hello', 'Webpack'], ' ');

  return element;

  }).catch(error => 'An error occurred while loading the component');
}

getComponent().then(component => {
  document.body.appendChild(component);
});

編譯專案

$npm run build
> 01-sample-app2@1.0.0 build
> webpack --config webpack.config.js

asset another.bundle.js 554 KiB [emitted] (name: another)
asset lodash.bundle.js 550 KiB [emitted] (name: lodash) (id hint: vendors)
asset index.bundle.js 14.2 KiB [emitted] (name: index)
runtime modules 9.2 KiB 17 modules
cacheable modules 532 KiB
  ./src/index.js 390 bytes [built] [code generated]
  ./src/another-module.js 83 bytes [built] [code generated]
  ./node_modules/lodash/lodash.js 531 KiB [built] [code generated]
webpack 5.69.1 compiled successfully in 316 ms

透過這些方法可以改善瀏覽器的快取速度。

Caching

章節最後也介紹了其他的 Plugin 來協助我們來預先載入或是減少記憶體用量。

const path = require("path");
const { CleanWebpackPlugin } = require("clean-webpack-plugin");
const HtmlWebpackPlugin = require("html-webpack-plugin");
module.exports = {
  entry: "./src/index.js",
  plugins: [
    new CleanWebpackPlugin(),
    new HtmlWebpackPlugin({
      title: "Output Management",
      title: "Caching",
    }),
  ],
  output: {
    filename: "bundle.js",
    filename: "[name].[contenthash].js",
    path: path.resolve(__dirname, "dist"),
  },
};

好了我們的第二章節 Working with Modules and Code Splitting 結束 🎉
後面的章節會再介紹有關 Webpack 的強大功能！敬請期待！

Apache Airflow 初體驗

HyperRedStart — Fri, 11 Mar 2022 04:16:48 +0000

Airflow 是由 Airbnb 所貢獻的 Apache 頂級專案，用於流程控制，建立有向無環的工作流程(DAGs) ，以事件排程的方式部屬我們的 DAG Schedule 並可以部屬到各個雲端平台上， GCP / AWS / Azure，可透過網頁 UI 調配部屬排程，主打彈性、高擴充性、搭配Jinja Template Engine 優雅的設計 Workflow 工作流程！

1.建置 Airflow 環境 - 使用 Docker

下載官方提供 docker-compose 文件

curl -LfO 'https://airflow.apache.org/docs/apache-airflow/2.2.4/docker-compose.yaml'

產生相依目錄並設定 Airflow 使用者權限

mkdir -p ./dags ./logs ./plugins
echo -e "AIRFLOW_UID=$(id -u)" > .env

2.資料庫初始化

docker-compose up airflow-init

3.啟動 Airflow 服務

docker-compose up -d

確認我們的 Container 是否都健康！

4.下載 airflow 命令工具

curl -LfO 'https://airflow.apache.org/docs/apache-airflow/2.1.1/airflow.sh'
chmod +x airflow.sh

5.撰寫 Demo 程式

將我們第一隻 DAGs 程式放至於 Container掛載目錄 dags 下
dags/test_app_v1.py

import time
from datetime import datetime, timedelta
from airflow import DAG
from airflow.operators.python import PythonOperator

default_args = {
  'owner' : '',
  'start_date' : datetime(2022, 1, 1, 0, 0),
  'schedule_interval': '@daily',
  'retries':2,
  'retry_delay': timedelta(minutes = 1)

}


def fn_one(): 
  print('execute jobs')

with DAG('test_app_v1' ,default_args=default_args) as dag:
  tesk = PythonOperator(
    task_id = 'one',
    python_callable=fn_one
  )

6.透過 airflow.sh 將執行我們的 DAG 程式

# 建立運行 python container 
./airflow.sh bash
# 執行 python 檔案
python dags/test_app_v1.py

7.網頁中查看新建立的 test_app_v1 DAG

Airflow Web Server
http://localhost:8080
airflow/airflow

在執行py腳本後我們就可以在 Airflow 首頁中查找到我們的 DAG 排程！

查看執行狀態，使否有異常失敗等情況

8.REST API

使用 Airflow Rest Api 可以取代我們在 WebUI 上的工作，進行 DAG 的抓取執行刪除等工作。

https://airflow.apache.org/docs/apache-airflow/stable/stable-rest-api-ref.html

curl -X GET 'http://10.1.200.67:8080/api/v1/dags' --user "airflow:airflow"

{
  "dag_id": "test_app_v1",
  "description": null,
  "file_token": "",
  "fileloc": "/opt/airflow/dags/test_app_v1.py",
  "is_active": true,
  "is_paused": false,
  "is_subdag": false,
  "owners": [],
  "root_dag_id": null,
  "schedule_interval": {
    "__type": "TimeDelta",
    "days": 1,
    "microseconds": 0,
    "seconds": 0
  },
  "tags": []
}

Conclusion

很多需要進行排定的工作項目都可以在 Airflow 的幫助下進行運行，搭配 python的語法可以很快速的撰寫爬蟲、資料轉換、事件觸發等工作，Airflow 提供WebUI操作畫面可以讓我們更便利的去對我們的 DAGs 進行監控，解決了我們在設計排程上的諸多困難！

Dart - Mixin Vs Class

HyperRedStart — Tue, 08 Mar 2022 03:15:39 +0000

在 Dart 中有一較為特殊的關鍵字， Mixin 透過這個關鍵字可以讓我們實現多重繼承的關係，透過將關鍵字分離，可以更清楚在宣告時我們應該如何對此類別進行設計。

1.標準繼承

Class Child 繼承來至 Class A 在呼叫建構子的時候，進行呼叫 getMessage() ，沒意外的得到 A Construct -->A.getMessage() 的訊息。

abstract class A {
  A() {
    print('A Construct');
    getMessage();
  }

  getMessage() {
    print('-->A.getMessage()');
  }
}

class Child extends A {}

void main() {
    Child child = Child();
}

Output

A Construct
-->A.getMessage()

2.加入Mixin使用

增加 mixin MB 並於混合於 Child 當中，MB Mixin 也是基於 A Class 所建構的，並透過 super 呼叫父類別的 getMessage 方法，也就是 -->A.getMessage() 。

mixin MB on A {
  @override
  getMessage() {
    print('-->MixMB.getMessage()');
    super.getMessage();
    print('-->MixMB');
  }
}

class Child extends A with MB {}

Output

A Construct
-->MixMB.getMessage()
-->A.getMessage()
-->MixMB

製造錯誤 🪲

我們嘗試把 class Child ~~extends A~~ with MB {} 。

Error: 'Object' doesn't implement 'A' so it can't be used with 'MB'.

此時編譯器提示錯誤，物件尚未實現 A 所以不可以混合 MB Mixin ，因為 MB 依賴著 Class A 所以如果混合 MB 時，類別未繼承制 A Class 就會得到提示，在使用上不可不留意！

3.再來一個Mix!

我們在替 Child Class 混合多一個類別， MC Mixin 程式與 MB Mixin 相同只是訊息部份從 MixMB 換成 MixMC 方便我們了解流程。

在MixMC中呼叫super.getMessage() 會先執行 MixMB 這邊Dart 使用堆疊的先進後出的方式，根據 with 後面的順序依序進行 pop 處理，就會看到我們的顯示結果！

mixin MC on A {
  @override
  getMessage() {
    print('-->MixMC.getMessage()');
    super.getMessage();
    print('-->MixMC');
  }
}

class Child extends A with MB, MC {}

Output

A Construct
-->MixMC.getMessage()
-->MixMB.getMessage()
-->A.getMessage()
-->MixMB
-->MixMC

4.再來一個Class!?

接著我們在替程式加上一個 Class B 並讓 MB 基於 A,B ，此時我們的Child 需要把B也跟著繼承，但是 extends 只能繼承一個Class 所以我們就把 B Class 用在 with 一起混入，執行後發現我們的 A Class 的getMessage 就被 B Class override 了，消失在我們的結果當中！

abstract class B {
  getMessage() {
    print('-->B.getMessage()');
  }
}

mixin MB on A,B {
  @override
  getMessage() {
    print('-->MixMB.getMessage()');
    super.getMessage();
    print('-->MixMB');
  }
}

class Child extends A with B, MB, MC {}

Output

A Construct
-->MixMC.getMessage()
-->MixMB.getMessage()
-->B.getMessage()
-->MixMB
-->MixMC

Conclusion

Dart 中使用 Mixin 可以讓我們的物件重用性更高，更能減少我們程式碼重複部份，但邏輯上可能就會便得更加的複雜，使用上不可不謹慎！

後續會增加更多 Dart/Flutter 的開發介紹，歡迎大家持續關注！

OpenGL Programming Using VSCODE

HyperRedStart — Fri, 04 Mar 2022 07:31:51 +0000

這篇文章為一個簡單的開端，做為後續開發 OpenGL 的基礎教學，如何使用 VSCODE 來開發我們的 OpenGL 程式，這邊作業系統以 Ubuntu 為範例

首先第一步安裝我們的 OpenGL 開發工具 glfw3

透過 apt 安裝開發套件

sudo apt-get install libglfw3
sudo apt-get install libglfw3-dev

再來我們需要 GLAD 去管理 OpenGL 的各項功能，依照需要的功能去進行載入動作

GLAD

📁 透過網站產生檔案下載到本機中，並將檔案複製到 /usr/include 內

sudo cp -r * /usr/include

並將 glad.c 放入專案同目錄下
編寫 CMakeLists.txt

# cmake 版本
cmake_minimum_required(VERSION 3.9.1)
# 專案名稱
project(CMakeHello)
# 套件搜尋
find_package(glfw3 REQUIRED)
find_package(OpenGL REQUIRED)
find_package(Threads REQUIRED)
# 加入程式與連結函式庫
add_executable(hello_triangle hello_triangle.cpp glad.c)
TARGET_LINK_LIBRARIES(hello_triangle dl glfw3 pthread)

VSCODE

安裝 CMake Tools Extenstion

Hello Triangle

將撰寫範例程式 hello_triangle.cpp 這段範例程式在後面的章節中，會再做詳細的介紹！

#include <glad/glad.h>
#include <GLFW/glfw3.h>

#include <iostream>

void framebuffer_size_callback(GLFWwindow* window, int width, int height);
void processInput(GLFWwindow *window);

// settings
const unsigned int SCR_WIDTH = 800;
const unsigned int SCR_HEIGHT = 600;

const char *vertexShaderSource = "#version 330 core\n"
    "layout (location = 0) in vec3 aPos;\n"
    "void main()\n"
    "{\n"
    "   gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
    "}\0";
const char *fragmentShaderSource = "#version 330 core\n"
    "out vec4 FragColor;\n"
    "void main()\n"
    "{\n"
    "   FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n"
    "}\n\0";

int main()
{
    // glfw: initialize and configure
    // ------------------------------
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

#ifdef __APPLE__
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#endif

    // glfw window creation
    // --------------------
    GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
    if (window == NULL)
    {
        std::cout << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

    // glad: load all OpenGL function pointers
    // ---------------------------------------
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        std::cout << "Failed to initialize GLAD" << std::endl;
        return -1;
    }


    // build and compile our shader program
    // ------------------------------------
    // vertex shader
    unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
    glCompileShader(vertexShader);
    // check for shader compile errors
    int success;
    char infoLog[512];
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
        std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
    }
    // fragment shader
    unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
    glCompileShader(fragmentShader);
    // check for shader compile errors
    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
        std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;
    }
    // link shaders
    unsigned int shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    glLinkProgram(shaderProgram);
    // check for linking errors
    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
    if (!success) {
        glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
        std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
    }
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);

    // set up vertex data (and buffer(s)) and configure vertex attributes
    // ------------------------------------------------------------------
    float vertices[] = {
        -0.5f, -0.5f, 0.0f, // left  
         0.5f, -0.5f, 0.0f, // right 
         0.0f,  0.5f, 0.0f  // top   
    }; 

    unsigned int VBO, VAO;
    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);
    // bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
    glBindVertexArray(VAO);

    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);

    // note that this is allowed, the call to glVertexAttribPointer registered VBO as the vertex attribute's bound vertex buffer object so afterwards we can safely unbind
    glBindBuffer(GL_ARRAY_BUFFER, 0); 

    // You can unbind the VAO afterwards so other VAO calls won't accidentally modify this VAO, but this rarely happens. Modifying other
    // VAOs requires a call to glBindVertexArray anyways so we generally don't unbind VAOs (nor VBOs) when it's not directly necessary.
    glBindVertexArray(0); 


    // uncomment this call to draw in wireframe polygons.
    //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

    // render loop
    // -----------
    while (!glfwWindowShouldClose(window))
    {
        // input
        // -----
        processInput(window);

        // render
        // ------
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        // draw our first triangle
        glUseProgram(shaderProgram);
        glBindVertexArray(VAO); // seeing as we only have a single VAO there's no need to bind it every time, but we'll do so to keep things a bit more organized
        glDrawArrays(GL_TRIANGLES, 0, 3);
        // glBindVertexArray(0); // no need to unbind it every time 

        // glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.)
        // -------------------------------------------------------------------------------
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    // optional: de-allocate all resources once they've outlived their purpose:
    // ------------------------------------------------------------------------
    glDeleteVertexArrays(1, &VAO);
    glDeleteBuffers(1, &VBO);
    glDeleteProgram(shaderProgram);

    // glfw: terminate, clearing all previously allocated GLFW resources.
    // ------------------------------------------------------------------
    glfwTerminate();
    return 0;
}

// process all input: query GLFW whether relevant keys are pressed/released this frame and react accordingly
// ---------------------------------------------------------------------------------------------------------
void processInput(GLFWwindow *window)
{
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
        glfwSetWindowShouldClose(window, true);
}

// glfw: whenever the window size changed (by OS or user resize) this callback function executes
// ---------------------------------------------------------------------------------------------
void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
    // make sure the viewport matches the new window dimensions; note that width and 
    // height will be significantly larger than specified on retina displays.
    glViewport(0, 0, width, height);
}

Compile & Run

<Ctrl> + <SHIT> + P 開啟VSCODE命令工具，執行 CMake:Debug

Result

Debug

我們可以在 VSCODE 下中斷點，來監看我們的變數

Conclusion

完成我們的基本配置，接下來就可以更順利的開發我們的 OpenGL 程式 !

Reference

https://learnopengl.com/Getting-started/Hello-Triangle

Skia - First Look Part 1

HyperRedStart — Fri, 04 Mar 2022 03:37:51 +0000

Skia 是 Flutter 2D渲染引擎的底層框架，並應用於 Android、Google Chrome、Chrome OS、Chromium OS、Mozilla Firefox、Firefox OS以及Sublime Text、LibreOffice 。

✨ Feature

CPU 軟體點陣圖計算
GPU 加速渲染
透過 ANGLE 轉編譯 OpenGL 至 Native Api DirectX, Vulkan, Metal
PDF / XPS / SVG 格式輸出

可惜的是目前按照官網的方式嘗試多次都無法正常運行，~~所以原本寫的一篇文章就廢掉了😭~~

bin/gn gen out/Static
python2 tools/git-sync-deps
bin/gn gen out/Release  --args='is_debug=false'
ninja -C out/Release

-> failed!

其他苦主 ->
https://bugs.chromium.org/p/skia/issues/detail?id=12765&q=SkPDFSubsetFont&can=2

參考其他大多數的文章都已經過時老舊，索性有大神在去年分享了在Windows的做法，但使用 Skia 在 github上最新的版本編譯出的程式碼並無法正常在 VS 中運行，目前只能靠以下 github 中已經編譯好的 dll檔案進行測試。

https://github.com/nightelf3/FirstSkiaApp/tree/example

輕鬆點開我們的 Solution 就可以開始測試 Skia 的強大功能，

程式主要是 C++ WinApi 框架所開發的視窗程式範例，透過 Layer 將多個範例放入到我們的主程式中 !

透過 <Tab> 切換我們的範例

透過 <z> / <x> 可以切換 Raster 與 OpenGL

Raster

OpenGL

Conclusion

無法從原始碼編譯成功還是覺得有點小可惜，希望未來官方可以再補足文件，讓更多人有機會透過 Skia 進行開發。

未來的章結會再根據 Skia 開發進行更深入的說明，可能會搭配 OpenGL / Vulkan / Meta 等圖像庫一起進行研究 !

📣 大力祈求有其他先進好手能提供完整的 SKIA 建置教學 ! 📣

Reference

https://skia.org/docs/user/build/
https://chromium.googlesource.com/skia.git/+/chrome/m42/site/user/sample/hello.md
https://blog.csdn.net/yujunyu12/article/details/100859127
https://blog.csdn.net/var_Rain/article/details/79318208
https://github.com/cisen/blog/issues/464
https://kyamagu.github.io/skia-python/install.html
https://www.youtube.com/watch?v=lEj_GfH8is8&ab_channel=EngineeringCommunity

Introduction to Webpack 5

HyperRedStart — Thu, 03 Mar 2022 01:23:06 +0000

Webpack 是一個帶有豐富多樣功能的前端網站包裝工具，將我們網站的各項資產 HTML, CSS, images, JS 進行包裝/壓縮/相容性排除/效能提昇等工作，這次就讓我們透過 Webpack 5 Up and Running 這本書一一剖析 Webpack 的各種強大功能吧！

1. Without Webpack or Other Module Bundler Library

首先先來測試看看，我們在沒有 Webpack 的情境下，應該如何進行作業。

Let's Do This Now 🔥

專案初始化

# 初始化專案
mkdir 01-sample-app && cd 01-sample-app
npm init -y

自動產生 package.json

{
  "name": "01-sample-app",
  "version": "1.0.0",
  "description": "",
  "private": true,
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

撰寫 JS Component

Dir: src/index.js

function component() {
  let element = document.createElement('div');
  // _ 使用 lodash 第三方 Lib
  element.innerHTML = _.join(['Testing', 'without', 'webpack'], ' ');
  return element;
}

document.body.appendChild(component());

撰寫 HTML

Dir: index.html

<!doctype html>
<html>
  <head>
    <title>Webpack - Test</title>
    <!-- 引用 lodash Lib -->
    <script src="https://unpkg.com/lodash@4.16.6"></script>
  </head>
  <body>
    <!-- 載入 index Component -->
    <script src="./src/index.js"></script>
  </body>
</html>

結果預覽

完成我們的第一步驟! 實做如何在沒有 Webpack 的狀況下完成我們的網站！

2. With Webpack

專案初始化

# 初始化專案
mkdir 01-sample-app && cd 01-sample-app
npm init -y
# 安裝 webpack lib
npm install webpack webpack-cli --save-dev
# 安裝 lodash lib
npm install lodash

自動產生 package.json 看到多增加了 webpack / lodash 🌈

{
  "name": "01-sample-app2",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "build": "webpack --config webpack.config.js"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "webpack": "^5.69.1",
    "webpack-cli": "^4.9.2"
  },
  "dependencies": {
    "lodash": "^4.17.21"
  }
}

撰寫 JS Component

Dir: src/index.js

// 透過 webpack 的封裝我們可以直接使用 import 來引用我們所需要的 lib
import _ from 'lodash';
function component() {
  let element = document.createElement('div');
  element.innerHTML = _.join(['Hello', 'Webpack'], ' ');
  return element;
}

document.body.appendChild(component());

撰寫 HTML

Dir: dist/index.html

不需要在引用我們的lib webpack 會自動幫我們進行包裝

<meta charset="utf-8"/> ⬅️ 缺少這句在 Webpack5 production mode 狀況下會發生錯誤

<!doctype html>
<html>
  <head>
    <!-- webpack mode=production -->
    <meta charset="utf-8"/>
    <title>Getting Started</title>
  </head>
  <body>
    <script src="main.js"></script>
  </body>
</html>

使用 Webpack 進行編譯

npx webpack mode=development

開啟 index.html 預覽結果

好了我們的第一章節 Introduction to Webpack 5 結束 🎉
後面的章節會再介紹有關 Webpack 的強大功能！敬請期待！

Java Hot Reload Plan

HyperRedStart — Wed, 02 Mar 2022 08:18:26 +0000

Java Hot Reload Plan

透過 DCEVM 可以達到與 JRebel 相同的熱重載效果。 😂

進入 http://dcevm.github.io/ 下載 Dynamic Code Evolution Virtual Machine

開啟 DCEVM 工具開啟，並指定要安裝的 JDK 版本

安裝完成後開啟喜好的 IDE 並設定 Java Opt

JAVA_OPTS = -XXaltjvm=dcevm -javaagent:c:/hotswap-agent.jar

完成收工 🙌🙌🙌

Git Basic Tutorial

HyperRedStart — Tue, 01 Mar 2022 06:40:12 +0000

Git Tutorial

Git Command 影響範圍

Gitlab 專案初始化

Command line instructions

Git global setup

git config --global user.name "Corey Lai"
git config --global user.email "corey.lai@deanshoes.com"

Create a new repository

git clone http://gitlab/ws/wsrm-react-ide.git
cd wsrm-react-ide
touch README.md
git add README.md
git commit -m "add README"
git push -u origin master

Existing folder

cd existing_folder
git init
git remote add origin http://gitlab/ws/wsrm-react-ide.git
git add .
git commit -m "Initial commit"
git push -u origin master

Existing Git repository

cd existing_repo
git remote add origin http://gitlab/ws/wsrm-react-ide.git
git push -u origin --all
git push -u origin --tags

創建

在local端建立一個

$ git init

從gitlab內載入已經建立的庫

$ git clone http://gitlab/zk/deplm.git

Local 端操作

顯示目前已修改文件

$ git status

顯示與上次提交版本不同處

$ git diff

將修改檔案加入index

# 所有修改進行提交
$ git add .
# 指定特定文件進行提交
$ git add -p{patch 批次確認} <filename>
# 解決衝突後，將檔案標記為以解決
$ git add <resolved-filename>

提交更改

$ git commit -a{略過 git add 步驟}
$ git commit -m "comment"
$ git commit --amend {撤回提交}

git history

顯示歷程

$ git log
#顯示指定檔案所有修改
$ git log -p <filename>

分支

git branch

# 顯示所有分支
$ git branch -av
# 基於當前分支創建新分支
$ git branch <new-branch>
# 刪除本地分支
$ git branch -d <branch>
# 刪除遠端分支
$ git branch -dr <branch>

git tag
給當前提交設標籤

$ git tag <tag-name>

更新與發佈

git remote

# 列出遠端庫
$ git remote -v
# 新增遠端庫
$ git remote add <nickname> <url>

git fetch

# 取得遠端庫所有變動，不合併到local
$ git fetch <remote>
#

git pull

# 取得遠端庫所有變動，不合併到local
$ git pull <remote> <branch>
$ git pull origin development

合併

git merge

# 將當前分支合併到指定分支
$ git merge <branch>

git rebase

# 將當前分支重新接枝到指定分支
$ git rebase <branch>
# 終止rebase
$ git rebase --abort
# 解決衝突後繼續重新接枝
$ git rebase --continue

撤銷

git reset

# 放棄目前所有修改
$ git reset --hard HEAD
# 回到指定commit，並將之後修改標記
$ git reset <commit>
# 放棄目前所有修改，並回到指定commit
$ git reset --hard <commit>
# 回到指定commit，並保留local尚未提交的修改
$ git reset --keep <commit>
# 取消已 add file
$ git reset HEAD <filename>

git revert

# 回到前一次 commit 的狀態
$ git revert HEAD

本機憑證快取

記憶憑證

git config credential.helper store

清除憑證

git config --global --unset credential.helper
git config --system --unset credential.helper

Git checkout

Git 從特定 branch 取得特定檔案

$ git checkout <another-branch> <path-to-file> [<one-more-file> ...]
$ git status
$ git commit -m "'Merge' specific file from '<another-branch>'"

Git 標準流程

如專案已從 Gitlab 上下載並開發完成請從 Step 5. 開始

# Step 1. 
$ git clone http://gitlab/zk/<project>.git
# Step 2. 
$ git checkout development
# Step 3. 
$ git pull
# Step 4.
Coding ...
# Step 5.
$ git add <file> or . {all file that was changed}
# Step 6. check the files you add
$ git status
# Step 7.
$ git commit -m "comment"
# Step 8.
$ git push origin development
# Step 9. git conflict happen
Resolve... 
# Step 10. git conflict happen
$ git add <resolved-file>
# Step 11.
$ git push origin development

Git merge branch

$ git checkout release
$ git merge development
$ git add .
$ git push

### forced update
$ git checkout release
$ git reset --hard development
$ git push --force origin release

Git feature

1. merge origin/master branch to feature branch

# step1: change branch to master, and pull to update all commits
$ git checkout master
$ git pull

# step2: change branch to target, and pull to update commits
$ git checkout feature
$ git pull

# step3: merge master to feature(⚠️ current is feature branch)
$ git merge master

2. merge feature branch to origin/master branch

$ git checkout master
$ git pull origin master

$ git merge feature
$ git push origin master

gitignore file

git rm -r --cached .
git add .
git commit -m ".gitignore"

git branch

feature

# create feature
git checkout -b desc-feature master
git status
git add <some-file>
git commit

# finish dev
git push -u origin desc-feature
git push

# merge master
git checkout master
git pull
#git pull origin desc-feature
git merge desc-feature

git push

git branch -d desc-feature

Git module

git submodule add <repository> [<path>]</path></repository>

Mongodb + GraphQL + Django

HyperRedStart — Tue, 01 Mar 2022 06:27:43 +0000

Mongodb + GraphQL + Django

Mongodb installation

Mongodb Image

docker pull mongo
docker run --name mongodb mongo
docker ps
================================
CONTAINER ID        IMAGE               COMMAND                  CREATED      STATUS              PORTS                      NAMES
2fef936de7f9        mongo               "docker-entrypoint.s"    10 days ago  Up About an hour    0.0.0.0:27017->27017/tcp   mongodb

Mongodb Compass

Django Constructor

conda update conda
conda create --name NGDP python=3.6
activate NGDP
(NGDP) D:\NGDP>

conda install -y Django=3.1.2
conda install -y -c conda-forge django-cors-headers
conda install -y  -c conda-forge graphene-django
conda install -y  -c conda-forge graphene-mongo
conda install -y  -c conda-forge django-filter
conda install -y  -c conda-forge mongoengine
conda install -y  -c conda-forge mongomock
conda install -c conda-forge neo4jdjango
conda install pytest
conda install pytest-django

django-admin startproject ngdp
conda install pip

Start Project

django-admin startproject shoesstore
cd shoesstore
django-admin startapp store
django-admin startapp shoes

Start Programming (Backend)

Project Structure

shoesstore/settings.py

# 載入 mongodb 引擎
from mongoengine import connect

# 允許所有裝置連線
ALLOWED_HOSTS = ['*']

# Application definition
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    # 預載程式
    'graphene_django',
    'graphene_mongo',
    'store',
    'shoes'
]

# mongodb connection
_MONGODB_USER = ""
_MONGODB_PASSWD = ""
_MONGODB_HOST = "localhost"
_MONGODB_NAME = "shoesstore"
_MONGODB_PORT = 27017
_MONGODB_DATABASE_HOST = "mongodb://%s:%s@%s/%s" % (
    _MONGODB_USER,
    _MONGODB_PASSWD,
    _MONGODB_HOST,
    _MONGODB_NAME,
)

connect(_MONGODB_NAME, host=_MONGODB_HOST, port=_MONGODB_PORT)

# Graphql Schema
GRAPHENE = {"SCHEMA": "shoesstore.schema.schema"}

shoesstore/urls.py

# 增加 graphql 路徑，csrf_exempt 跨網站請求豁免
urlpatterns = [
    path('admin/', admin.site.urls),
    path("graphql", csrf_exempt(GraphQLView.as_view(graphiql=True)), name="graphql-query")
]

Graphql

query ($name: String) {
  bikes(first:1, name_Istartswith: $name) {
    totalCount
    pageInfo {
      hasPreviousPage
      hasNextPage
    }
    edges {
      node {
        name
        brand
        year
        size
        wheelSize
        type
      }
    }
  }
}

query {
  allCategories(first: 1, after: "opaqueCursor") {
    edges {
      node {
        name,
        ingredients {
          edges {
            node {
              name
            }
          }
        }
      }
    }
      pageInfo {
        hasNextPage
      }
  }
}

{
  shoes(first: 2) {
    totalCount
    pageInfo {
      startCursor
      hasNextPage
      hasPreviousPage
      endCursor
    }
    edges {
      cursor
      node {
        name
        brand
        model
        id
      }
    }
  }
}

query ($name: String) {
  bikes(first:2, name_Istartswith: $name, after: "YXJyYXljb25uZWN0aW9uOjE=") {
    totalCount
    pageInfo {
      endCursor
      hasPreviousPage
      hasNextPage
    }
    edges {
      node {
        id
        name
        brand
        year
        size
        wheelSize
        type
      }
      cursor
    }
  }
}

React Native App

expo init ShoesStoreProjectR

Modern Java Recipes

HyperRedStart — Tue, 01 Mar 2022 06:20:44 +0000

Java之所以被開發，是要達到以下五個目的：

應當使用物件導向程式設計方法學
應當允許同一程式在不同的電腦平台執行
應當包括內建的對電腦網路的支援
應當被設計成安全地執行遠端程式碼
應當易於使用，並借鑑以前那些物件導向語言（如C++）的長處。

Java 在各個版本的演進
1.0-1.4 中的 java.lang.Thread
5.0 中的 java.util.concurrent
6.0 中的 Phasers 等
7.0 中的 Fork/Join 框架
8.0 中的 Lambda、Stream
9.0 中的 Jigsaw 模組化

Developer Skills Tree
http://aliyunzixunbucket.oss-cn-beijing.aliyuncs.com/jpg/87a7e437be53abaa0761f7a462a7da69.jpg?x-oss-process=image/resize,p_100/auto-orient,1/quality,q_90/format,jpg/watermark,image_eXVuY2VzaGk=,t_100,g_se,x_0,y_0

CHAPTER 1 Basic

Anonymous inner - > Lambda

傳統匿名語法

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("inside runnable using an anonymous inner class");
    }
}).start();

lambda 於建構子中

new Thread(() -> System.out.println("inside Thread constructor using lambda")).start();

lambda 賦與變數

Runnable r = () -> System.out.println("lambda expression implementing the run method");

lambda 實做 FilenameFilter

String[] names = directory.list((dir, name) -> name.endsWith(".java"));
System.out.println(Arrays.asList(names));

lambda 區塊

String[] names = directory.list((File dir, String name) -> {
return name.endsWith(".java");
});

使用方法參考(method reference) 存取 print

// Consumer<Integer>  functional interface
Consumer<Integer> printer = System.out::println;
Stream.of(3, 1, 4, 1, 5, 9).forEach(printer);

語句
object::instanceMethod
物件實例方法 ex: System.out::println
Class::staticMethod
類別靜態方法 ex: Math::max
Class::instanceMethod
類別實例方法 ex: String::length

@FunctionalInterface

註釋該介面目標為 lambda expression or method reference.
只能有一個抽象成員

Default Methods

在介面中提供實做

public interface Collection<E> extends Iterable<E> {
    boolean isEmpty();
    default boolean removeIf(Predicate<? super E> filter) {  
        Objects.requireNonNull(filter);  
        boolean removed = false;  
         final Iterator<E> each = iterator();  
         while (each.hasNext()) {  
            if (filter.test(each.next())) {  
                each.remove();  
                removed = true;  
            }  
         }  
        return removed;  
    }
}

// usage 
boolean removed = Arrays.asList(3, 1, 4, 1, 5, 9).removeIf(n -> n <= 0);

CHAPTER 2 The java.util.function Package

p.s. ReferencePipeline內的 downstream 為 Consumer 類

Consumer

將欲使用方法傳入 Consumer 內

// implement
public interface Iterable<T> {  
    Iterator<T> iterator();  
    default void forEach(Consumer<? super T> action) {  
        Objects.requireNonNull(action);  
        for (T t : this) {  
            action.accept(t);  
        }  
    }
}

// usage
Arrays.asList("this", "is", "a", "list", "of", "strings").forEach(System.out::println);

Suppliers

將產生的值載入 supplier 內並透過 get 方法取得值

Supplier<T> sippiler = () -> T;
DoubleSupplier randomSupplier = Math::random;
// 此時才呼叫 Math.random()
System.out.println(randomSupplier.getDouble());

附加 Suppliers 介面

Interface	abstract method
Supplier	T get()
IntSupplier	int getAsInt()
DoubleSupplier	double getAsDouble()
LongSupplier	long getAsLong()
BooleanSupplier	boolean getAsBoolean()

Predicates

透過 Predicates 判斷是否有符合 filter

// implement
public static boolean predicateTest(int value, Predicate<Integer> predicate) {  
    return predicate.test(value);  
}
// usage
predicateTest(3, (x) -> x == 3);

// Stream implement
Stream<T> filter(Predicate<? super T> predicate);
abstract class IntPipeline<E_IN>  
    extends AbstractPipeline<E_IN, Integer, IntStream>  
    implements IntStream {
    @Override  
    public final IntStream filter(IntPredicate predicate) {  
        Objects.requireNonNull(predicate);  
        return new StatelessOp<Integer>(this, StreamShape.INT_VALUE,  
        StreamOpFlag.NOT_SIZED) {  
                @Override  
                Sink<Integer> opWrapSink(int flags, Sink<Integer> sink) {  
                return new Sink.ChainedInt<Integer>(sink) {  
                    @Override  
                    public void begin(long size) {  
                        downstream.begin(-1);  
                    }  

                    @Override  
                    public void accept(int t) {  
                        // 檢查是否通過測試
                        if (predicate.test(t))  
                            downstream.accept(t);  
                    }  
                };  
            }  
        };  
    }
}

// usage
Arrays.asList("this", "is", "a", "list", "of", "strings")
    .stream()
    .filter(s -> s.length() == 2)
    .collect(Collectors.joining(", "));

Functions

呼叫特定方法，並回傳所需內容

// implement
static int modifyTheValue(int valueToBeOperated, Function<Integer, Integer> function) {  
    return function.apply(valueToBeOperated);  
}
// usage
modifyTheValue(10, (x)-> x + 20);

// Stream implement
abstract class ReferencePipeline<P_IN, P_OUT>  
        extends AbstractPipeline<P_IN, P_OUT, Stream<P_OUT>>  
        implements Stream<P_OUT>  {
    @Override  
    @SuppressWarnings("unchecked")  
    public final <R> Stream<R> map(Function<? super P_OUT, ? extends R> mapper) {  
        Objects.requireNonNull(mapper);  
        return new StatelessOp<P_OUT, R>(this, StreamShape.REFERENCE,  
            StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {  
                @Override  
                Sink<P_OUT> opWrapSink(int flags, Sink<R> sink) {  
                return new Sink.ChainedReference<P_OUT, R>(sink) {  
                    @Override  
                    public void accept(P_OUT u) {  
                        downstream.accept(mapper.apply(u));  
                    }  
                };  
            }  
        };  
    }
}

// usage
Arrays.asList("this", "is", "a", "list", "of", "strings")
    .stream()
    .map(String::length)
    .collect(Collectors.toList());

附加 Functions 介面

Interface	abstract method
Function	R apply(t value)
IntFunction	R apply(int value)
DoubleFunction	R apply(double value)
LongFunction	R apply(long value)
ToIntFunction	int applyAsInt(T value)
ToDoubleFunction	double applyAsDouble(T value)
ToLongFunction	long applyAsLong(T value)
DoubleToIntFunction	int applyAsInt(double value)
DoubleToLongFunction	long applyAsLong(double value)
IntToDoubleFunction	double applyAsDouble(int value)
IntToLongFunction	long applyAsLong(int value)
LongToDoubleFunction	double applyAsDouble(long value)
LongToIntFunction	int applyAsInt(long value)
BiFunction	void accept(T t, U u)
ToIntBiFunction	int applyAsInt(T t, U u)
ToDoubleBiFunction	double applyAsDouble(T t, U u)
ToLongBiFunction	long applyAsLong(T t, U u)

CHAPTER 3 Streams

java 8 新串流 API 支援 functional programming，串流只能被使用一次，如需要再次處理數據必須再重新建立。

Stream 運行原理

// 呼叫流程
Arrays.stream -> StreamSupport.stream -> return ReferencePipeline.Head -> filter (or the method you need)

CHAPTER 4 Comparators and Collectors

java7 使用 collections

public List<String> defaultSort() {
    Collections.sort(list);
    return sampleStrings;
}

java8 透過 streams 使用 collections

public List<String> defaultSortUsingStreams() {
    return list.stream()
    .sorted()
    .collect(Collectors.toList());
}

collect 方法兩種實做

<R, A> R collect(Collector<? super T, A, R> collector);
<R> R collect(Supplier<R> supplier,  
  BiConsumer<R, ? super T> accumulator,  
  BiConsumer<R, R> combiner);

CHAPTER 5 Issues with Streams, Lambdas, and Method References

使用靜態方法確認空值與比較

// 去除空值資料
List<String> nonNullStrings = Arrays.asList(
"this", null, "is", "a", null, "list", "of", "strings", null)
.stream().filter(Objects::nonNull).collect(Collectors.toList());

在 lambdas 內存取在外 local 變數

int total = 0;
// 錯誤 lambdas 無法存取 local var
Arrays.asList(3, 1, 4, 1, 5, 9).forEach(n -> total += n);

// 使用 function 傳入屬性進行存取
Arrays.asList(3, 1, 4, 1, 5, 9)
.stream().mapToInt(Integer::valueOf).sum()

使用 forEach 來進行迭代

List<Integer> integers = Arrays.asList(3, 1, 4, 1, 5, 9);
// 匿名方法
integers.forEach(new Consumer<Integer>() {
    @Override
    public void accept(Integer integer) {
        System.out.println(integer);
    }
});
// 完整敘述式 lambda
integers.forEach((Integer n) -> {System.out.println(n);});
// 表達式 lambda
integers.forEach(n -> System.out.println(n));
// 方法參照
integers.forEach(System.out::println);

檢查 lambda 錯誤 exception

// 使用 encode 必須處理 UnsupportedEncodingException
Arrays.stream(values).map(s -> URLEncoder.encode(s, "UTF-8"))).collect(Collectors.toList());
// solution
Arrays.stream(values)
.map(s -> {
    try {
        return URLEncoder.encode(s, "UTF-8");
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
        return "";
    }
})
.collect(Collectors.toList());

透過 @FunctionalInterface 改寫

@FunctionalInterface
public interface FunctionWithException<T, R, E extends Exception> {
    R apply(T t) throws E;
}

private static <T, R, E extends Exception> Function<T, R> wrapper(FunctionWithException<T, R, E> fe) {
        return arg -> {
            try {
                return fe.apply(arg);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        };
}

Arrays.stream(values).map(wrapper(s -> URLEncoder.encode(s, "UTF-8"))).collect(Collectors.toList());

CHAPTER 6 The Optional Type

Java 8 新的 java.util.Optional<T> 類，目的是解決許多開發者困擾的 NullPointerExceptions，他被設計以溝通的方式告知回傳值為不合法的空值。

Optional 結合 AtomicInteger 範例

AtomicInteger counter = new AtomicInteger();
Optional<AtomicInteger> opt = Optional.ofNullable(counter);
System.out.println(optional); // Optional[0]
counter.incrementAndGet();
System.out.println(optional); // Optional[1]
optional.get().incrementAndGet();
// 重新指定內容
optional = Optional.ofNullable(new AtomicInteger());

Optional 例外範例

Optional<String> firstOdd =
Stream.of("five", "even", "length", "string", "values")
.filter(s -> s.length() % 2 != 0)
.findFirst();
// throws NoSuchElementException
System.out.println(firstOdd.get()); 
// 使用 isPresent 檢查空值
System.out.println(
firstOdd.isPresent() ? firstOdd.get() : "No even length strings");
// 如值為空回傳預設值
firstOdd.orElse("No even length strings");
// 如值為空執行Methods並回傳值
firstOdd.orElseGet(() -> new String());

CHAPTER 7 File I/O

使用 stream 處理檔案內文

找出檔案內最長的單字前10名

try (Stream<String> lines = Files.lines(Paths.get("/usr/share/dict/web2")) {
    lines.filter(s -> s.length() > 20)
    .sorted(Comparator.comparingInt(String::length).reversed()).limit(10)
    .forEach(w -> System.out.printf("%s (%d)%n", w, w.length()));
} catch (IOException e) {
    e.printStackTrace();
}

列出目錄檔案清單

try (Stream<Path> paths = Files.walk(Paths.get("src/main/java"))) {
    paths.forEach(System.out::println);
} catch (IOException e) {
    e.printStackTrace();
}

找出含有特定目錄的檔案

try (Stream<Path> paths =
Files.find(Paths.get("src/main/java"), Integer.MAX_VALUE, (path, attributes) -> !attributes.isDirectory() && path.toString().contains("fileio"))) {
    paths.forEach(System.out::println);
} catch (IOException e) {
    e.printStackTrace();
}

CHAPTER 8 The java.time Package

從 JDK1.0 開始就包含的程式庫，java.util.Date ，大多數 java.util.Date 方法都被棄用並使用 java.util.Calendar 來取代，但也並不是那麼方便取用。

終於在 Java 8 後導入了 Joda-Time library 並建議之後的使用者使用它做為開發。

基本使用

// Instant.now(): 2017-06-20T17:27:08.184Z
System.out.println("Instant.now(): " + Instant.now());
// LocalDate.now(): 2017-06-20
System.out.println("LocalDate.now(): " + LocalDate.now());
// LocalTime.now(): 13:27:08.318
System.out.println("LocalTime.now(): " + LocalTime.now());
// LocalDateTime.now(): 2017-06-20T13:27:08.319
System.out.println("LocalDateTime.now(): " + LocalDateTime.now());
// ZonedDateTime.now(): 2017-06-20T13:27:08.319-04:00[America/New_York]
System.out.println("ZonedDateTime.now(): " + ZonedDateTime.now());

util.Date, util.Calendar, java.sql.Date 與 util.time 互換

package datetime;
import java.sql.Timestamp;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Date;
public class ConvertDate {
    public LocalDate convertFromSqlDatetoLD(java.sql.Date sqlDate) {
        return sqlDate.toLocalDate();
    }
    public java.sql.Date convertToSqlDateFromLD(LocalDate localDate) {
        return java.sql.Date.valueOf(localDate);
    }
    public LocalDateTime convertFromTimestampToLDT(Timestamp timestamp) {
        return timestamp.toLocalDateTime();
    }
    public Timestamp convertToTimestampFromLDT(LocalDateTime localDateTime) {
        return Timestamp.valueOf(localDateTime);
    }
}

CHAPTER 9 Parallelism and Concurrency

parallelStream 是透過 ForkJoinPool Thread 來進行並發任務

並行範例

// 下列陣列將不會按順訊印出
Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9)
.parallelStream().forEach(out::println);  
// 使用 forEachOrdered 強制以順序印出
Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9)
.parallelStream().forEachOrdered(out::println);

Parallelism 與其他方式比較

class Person {
        int    id;
        String name;
        String sex;
        float  height;
}

// 傳統迴圈
public List<Person> constructPersons() {
    List<Person> persons = new ArrayList<Person>();
    for (int i = 0; i < 5; i++) {
        Person p = new Person(i, "name" + i, "sex" + i, i);
        persons.add(p);
    }
    return persons;
}

// 迴圈
public void doFor(List<Person> persons) {
    long start = System.currentTimeMillis();
    for (Person p : persons) {
        System.out.println(p.name);
    }
    long end = System.currentTimeMillis();
    System.out.println("doFor cost:" + (end - start));
}

// 串流
public void doStream(List<Person> persons) {
    long start = System.currentTimeMillis();

    persons.stream().forEach(x -> System.out.println(x.name));

    long end = System.currentTimeMillis();
    System.out.println("doStream cost:" + (end - start));
}

// 並行
public void doParallelStream(List<Person> persons) {
    long start = System.currentTimeMillis();
    persons.parallelStream().forEach(x -> System.out.println(x.name));
    long end = System.currentTimeMillis();
    System.out.println("doParallelStream cost:" + (end - start));
}

使用 openjdk (Java Micro-benchmark Harness) 計算效能

import org.openjdk.jmh.annotations.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@State(Scope.Thread)
@Fork(value = 2, jvmArgs = {"-Xms4G", "-Xmx4G"})
public class DoublingDemo {
    public int doubleIt(int n) {
        try {
            Thread.sleep(100);
        } catch (InterruptedException ignored) { }
        return n * 2;
    }

    @Benchmark
    public int doubleAndSumSequential() {
        return IntStream.of(3, 1, 4, 1, 5, 9).map(this::doubleIt).sum();
    }

    @Benchmark
    public int doubleAndSumParallel() {
        return IntStream.of(3, 1, 4, 1, 5, 9)
        .parallel().map(this::doubleIt).sum();
    }
}

ForkJoinPool

改變 ForkJoinPool 參數

// 改變 pool 大小
System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "20");
// 使用自定的 ForkJoinPool 執行 parallel
ForkJoinPool pool = new ForkJoinPool(15);
ForkJoinTask<Long> task = pool.submit(() -> LongStream.rangeClosed(1, 3_000_000).parallel().sum());

Future

等待未來的結果

public void getIfNotCancelled(Future<String> future) {
    if (!future.isCancelled()) {
        System.out.println(future.get());
    } else {
        System.out.println("Cancelled");
    }
}

ExecutorService service = Executors.newCachedThreadPool();
Future<String> future = service.submit(new Callable<String>() {
    @Override
    public String call() throws Exception {
        Thread.sleep(100);
        return "Hello, World!";
    }
});
// 取消 service submit
future.cancel(true);
System.out.println("Processing...");
getIfNotCancelled(future);

CHAPTER 10 Java 9 Additions

Java 9 新功能

Jigsaw

Suppliers Module

package com.oreilly.suppliers;
public class NamesSupplier implements Supplier<Stream<String>> {
    private Path namesPath = Paths.get("server/src/main/resources/names.txt");
    @Override
    public Stream<String> get() {
        try {
            return Files.lines(namesPath);
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }
}
// module-info.java
module com.oreilly.suppliers {
    exports com.oreilly.suppliers;
}

package com.kousenit.clients;
import com.oreilly.suppliers.NamesSupplier;
public class Main {
    public static void main(String[] args) throws IOException {
        NamesSupplier supplier = new NamesSupplier();
        try (Stream<String> lines = supplier.get()) {
            lines.forEach(line -> System.out.printf("Hello, %s!%n", line));
        }
    }
}
// module-info.java
module com.kousenit.clients {
    requires com.oreilly.suppliers;
}

介面私有成員

public interface SumNumbers {
    default int addEvens(int... nums) {
        return add(n -> n % 2 == 0, nums);
    }
    default int addOdds(int... nums) {
        return add(n -> n % 2 != 0, nums);
    }
    private int add(IntPredicate predicate, int... nums) {
        return IntStream.of(nums)
        .filter(predicate)
        .sum();
    }
}
class PrivateDemo implements SumNumbers {}
public class SumNumbersTest {
    private SumNumbers demo = new PrivateDemo();
    @Test
    public void addEvens() throws Exception {
        assertEquals(2 + 4 + 6, demo.addEvens(1, 2, 3, 4, 5, 6));
    }
    @Test
    public void addOdds() throws Exception {
        assertEquals(1 + 3 + 5, demo.addOdds(1, 2, 3, 4, 5, 6));
    }
}

不可變動集合

靜態工廠　
不可變動集合使用 add, addAll, clear, remove, removeAll, replaceAll, set 將會拋出 UnsupportedOperationException.

@Test(expected = UnsupportedOperationException.class)
public void showImmutabilityAdd() throws Exception {
    List<Integer> intList = List.of(1, 2, 3);
    intList.add(99);
}
@Test(expected = UnsupportedOperationException.class)
public void showImmutabilityClear() throws Exception {
    List<Integer> intList = List.of(1, 2, 3);
    intList.clear();
}
@Test(expected = UnsupportedOperationException.class)
public void showImmutabilityRemove() throws Exception {
    List<Integer> intList = List.of(1, 2, 3);
    intList.remove(0);
}
@Test(expected = UnsupportedOperationException.class)
public void showImmutabilityReplace() throws Exception {
    List<Integer> intList = List.of(1, 2, 3);
    intList.replaceAll(n -> -n);
}
@Test(expected = UnsupportedOperationException.class)
public void showImmutabilitySet() throws Exception {
    List<Integer> intList = List.of(1, 2, 3);
    intList.set(0, 99);
}

// 如果將不可變動集合塞入物件，將可改變物件內容
@Test
public void areWeImmutableOrArentWe() throws Exception {
    List<Holder> holders = List.of(new Holder(1), new Holder(2));
    assertEquals(1, holders.get(0).getX());
    holders.get(0).setX(4);
    assertEquals(4, holders.get(0).getX());
}

迭代使用Predicate

// Java8 方法
List<BigDecimal> bigDecimals =
Stream.iterate(BigDecimal.ZERO, bd -> bd.add(BigDecimal.ONE)).limit(10).collect(Collectors.toList());

// Java9 方法
bigDecimals = Stream.iterate(BigDecimal.ZERO,
bd -> bd.longValue() < 10L,
bd -> bd.add(BigDecimal.ONE))
.collect(Collectors.toList());

日期計算

// Java8 用法
public List<LocalDate> getDays_java8(LocalDate start, LocalDate end) {
    Period period = start.until(end);
    return LongStream.range(0, ChronoUnit.DAYS.between(start, end))
    .mapToObj(start:plusDays)
    .collect(Collectors.toList());
}
LocalDate start = LocalDate.of(2017, Month.JUNE, 10);
LocalDate end = LocalDate.of(2017, Month.JUNE, 17);
System.out.println(dateRange.getDays_java8(start, end));

// Java9 用法
public List<LocalDate> getDays_java9(LocalDate start, LocalDate end) {
    return start.datesUntil(end).collect(Collectors.toList());
}
public List<LocalDate> getMonths_java9(LocalDate start, LocalDate end) {
    return start.datesUntil(end, Period.ofMonths(1)).collect(Collectors.toList());
}

Extra Information

Try-With-Resources

Try with Resources 會自動幫開發者關閉 try(closeable; ... ) 內實做 java.lang.AutoCloseable 的物件

// Java8 用法
// inputstream
try(InputStream stream1 = new InputStream(....); InputStream stream2 = new InputStream(....)) { ... }
// connection
try (Connection con = DriverManager.getConnection(myConnectionURL);
      PreparedStatement ps = createPreparedStatement(con, userId); 
      ResultSet rs = ps.executeQuery()) {
      // process the resultset here, all resources will be cleaned up
 } catch (Exception e) {
     e.printStackTrace();
 }

// Java9 用法
InputStream stream1 =  new  InputStream(....);  InputStream stream2 =  new  InputStream(....);  ....  try(stream1;stream2){  ....  }

APPENDIX A Generics and Java 8

關於泛型的能力大多數的 Java 開發者都只認識到他們所需用於工作上的範圍，跟著 Java 8 的來到 javadoc 文件已經充斥著像是以下的代碼 :

// java.util.Map.Entry
static <K extends Comparable<? super K>,V> Comparator<Map.Entry<K,V>>
comparingByKey()
// or this one from java.util.Comparator:
static <T,U extends Comparable<? super U>> Comparator<T> comparing(
Function<? super T,? extends U> keyExtractor)
// or even this monster from java.util.stream.Collectors:
static <T,K,D,A,M extends Map<K, D>> Collector<T,?,M> groupingBy(
Function<? super T,? extends K> classifier, Supplier<M> mapFactory,
Collector<? super T,A,D> downstream)

理解基礎的泛型已不再夠用。

簡易泛型代碼

List<String> strings = new ArrayList<>();
strings.add("Hello");
strings.add("World");
// strings.add(new Date());
// Integer i = strings.get(0);  編譯不過
for (String s : strings) {
    System.out.printf("%s has length %d%n", s, s.length());
}

List 所定義的方法

boolean add(E e)
boolean addAll(Collection<? extends E> c)
void clear()
boolean contains(Object o)
boolean containsAll(Collection<?> c)
E get(int index)

有些開發者所不理解的

許多開發者對於 ArrayList<String> 跟 ArrayList<Object> 並沒有關連

List<String> strings = new ArrayList<>();
String s = "abc";
String s = "abc";
Object o = s;
// 這樣的代碼是不被允許的
strings.add(o);

未只定 List 的通配符

List<?> stuff = new ArrayList<>();
// 未指定泛型的 list 不能被寫入
stuff.add("abc");
stuff.add(new Object());
stuff.add(3);
// 但是能被讀取
int numElements = stuff.size();

Upper Bounded Wildcards

使用向上通配符一樣不能被寫入

List<? extends Number> numbers = new ArrayList<>();
// numbers.add(3);
// numbers.add(3.14159);
// numbers.add(new BigDecimal("3"));

使用 Upper Bounded

private static double sumList(List<? extends Number> list) {
    return list.stream().mapToDouble(Number::doubleValue).sum();
}

List<Integer> ints = Arrays.asList(1, 2, 3, 4, 5);
List<Double> doubles = Arrays.asList(1.0, 2.0, 3.0, 4.0, 5.0);
List<BigDecimal> bigDecimals = Arrays.asList(
new BigDecimal("1.0"),new BigDecimal("2.0"),new BigDecimal("3.0"),new BigDecimal("4.0"),new BigDecimal("5.0"));
System.out.printf("ints sum is %s%n", sumList(ints));
System.out.printf("doubles sum is %s%n", sumList(doubles));
System.out.printf("big decimals sum is %s%n", sumList(bigDecimals));

使用 Lower Bounded

向下通配符一樣不能被寫入

public void numsUpTo(Integer num, List<? super Integer> output) {
    IntStream.rangeClosed(1, num).forEach(output::add);
}

ArrayList<Integer> integerList = new ArrayList<>();
ArrayList<Number> numberList = new ArrayList<>();
ArrayList<Object> objectList = new ArrayList<>();
numsUpTo(5, integerList);
numsUpTo(5, numberList);
numsUpTo(5, objectList);

多重分配符

T extends Runnable & AutoCloseable

Java Spring VS Go gRPC

HyperRedStart — Tue, 01 Mar 2022 06:13:01 +0000

Spring boot

Client Side

以下 Entity 會以自動產生的方式給予 PR
EntityController 則是底層功能
Entity Model

@Entity  
@Table(name = "CAR")  
public class Car extends EntityContoller {  
    @Id  
    @Column(name = "ID")  
    @SerializedName("ID")  
    private Integer id;  

    @Column(name = "MODEL")  
    @SerializedName("MODEL")  
    private String model;  

    @Column(name = "MAKE")  
    @SerializedName("MAKE")  
    private String make;  

    @Column(name = "PREVIEW")  
    @SerializedName("PREVIEW")  
    private String preview;  

    @Column(name = "DESCRIPTION")  
    @SerializedName("DESCRIPTION")  
    private String description;  

    @Column(name = "PRICE")  
    @SerializedName("PRICE")  
    private Integer price;  

    public Car() {  
        super();  
    }  

    public Car(Integer id, String model, String make, String description, String preview, Integer price) {  
        super();  
        this.id = id;  
        this.model = model;  
        this.make = make;  
        this.preview = preview;  
        this.description = description;  
        this.price = price;  
    }  

    public Integer getId() {  
        return id;  
    }  

    public void setId(Integer id) {  
        this.id = id;  
    }  

    public String getMake() {  
        return make;  
    }  

    public void setMake(String make) {  
        this.make = make;  
    }  

    public String getPreview() {  
        return preview;  
    }  

    public void setPreview(String preview) {  
        this.preview = preview;  
    }  

    public String getDescription() {  
        return description;  
    }  

    public void setDescription(String description) {  
        this.description = description;  
    }  

    public Integer getPrice() {  
        return price;  
    }  

    public void setPrice(Integer price) {  
        this.price = price;  
    }  

    public String getModel() {  
        return model;  
    }  

    public void setModel(String model) {  
        this.model = model;  
    }  
}

@Entity  
@Table(name = "CAR_INFO")  
public class CarInfo extends EntityContoller {  

    @Id  
    @SerializedName("ID")  
    @Column(name = "ID")  
    private Integer id;  

    @Id  
    @SerializedName("CAR_OWNER")  
    @Column(name = "CAR_OWNER")  
    private String carOwner;  

    @Column(name = "CAR_TYPE")  
    @SerializedName("CAR_TYPE")  
    private String carType;  

    @Temporal(TemporalType.TIMESTAMP)  
    @Column(name = "DRIVE_DATE")  
    @SerializedName("DRIVE_DATE")  
    private Date driveDate;  

    @Column(name = "KM")  
    @SerializedName("KM")  
    private String km;  

    @Column(name = "TEST")  
    @SerializedName("TEST")  
    private String test;  

    @ManyToOne  
    @SerializedName("*CAR")  
    @JoinColumn(name = "ID", referencedColumnName = "ID", insertable = false, updatable = false)  
    private Car car = new Car();  

    public CarInfo() {  
        super();  
    }  

    public CarInfo(Integer id, String carOwner, String carType, Date driveDate, String km, String test, Car car) {  
        super();
        this.id = id;
        this.carOwner = carOwner;
        this.carType = carType;
        this.driveDate = driveDate;
        this.km = km;
        this.test = test;
        this.car = car;
    }  

    public Integer getId() {  
        return id;  
    }  
    public void setId(Integer value) {  
        id = value;  
    }  

    public String getCarOwner() {  
        return carOwner;  
    }  
    public void setCarOwner(String value) {  
        carOwner = value;  
    }  

    public Date getDriveDate() {  
        return driveDate;  
    }  
    public void setDriveDate(Date value) {  
        driveDate = value;  
    }  

    public String getKm() {  
        return km;  
    }  
    public void setKm(String value) {  
        km = value;  
    }  

    public String getTest() {  
        return test;  
    }  
    public void setTest(String value) {  
        test = value;  
    }  

    public String getCarType() {  
        return carType;  
    }  
    public void setCarType(String value) {  
        carType = value;  
    }  

    public Car getCar() {  
        return car;  
    }  
    public void setCar(Car value) {  
        car = value;  
    }  
}

ViewModel

public class CarInfoViewModel extends ServiceImpl {  

    private String keyword;  
    private List<CarInfo> list;  
    private CarInfo selectedCarInfo;  

    private CarService carService = new CarServiceImpl();  
    public CarInfoViewModel() {
        super(new CarInfo());  
    }

    public List<CarInfo> getList(){  
        return list;  
    }  

    public void setSelectedCarInfo(CarInfo selectedCarInfo) {  
        this.selectedCarInfo = selectedCarInfo;  
    }  

    public CarInfo getSelectedCarInfo() {  
        return selectedCarInfo;  
    }  

    @Command  
    @NotifyChange("list")  
    public void search(){  
        list = carService.search(keyword);  
    }  
    public List<CarInfo> get {
        RequestBody body = RequestBody.create(okhttp3.MediaType.parse("application/json; charset=utf-8"), gson.toJson(new CarInfo()));  
        retrofit2.Call<ResponseBody> call = entityServices.getNativeCarInfo(body);
        Type type = new TypeToken<List<CarInfo>>() {}.getType();  

        call.enqueue(new Callback<ResponseBody>() {  

            @Override  
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {  
                try {  
                    list = gson.fromJson(response.body().string(), type);  
                } catch (Exception e) {  
                    e.printStackTrace();  
                }  
            }  

            @Override  
            public void onFailure(Call<ResponseBody> call, Throwable t) {  
                System.out.println("Connection Failed");  
            }  
        });
    }

}

View

<window title="Search" width="600px" border="normal" apply="org.zkoss.bind.BindComposer"
        viewModel="@id('vm') @init('demo.getting_started.mvvm.SearchViewModel')">
    <hbox align="center">
        Keyword:
        <textbox value="@bind(vm.keyword)" />
        <button label="Search" iconSclass="z-icon-search" onClick="@command('search')" />
    </hbox>
    <listbox height="160px" model="@bind(vm.carInfoList)" emptyMessage="No car found in the result"
             selectedItem="@bind(vm.selectedCarInfo)" style="margin-top:10px">
        <listhead>
            <listheader label="ID" />
            <listheader label="Car Owner" />
            <listheader label="Car Type" />
            <listheader label="Drive Date" />
            <listheader label="KM" />
        </listhead>
        <template name="model">
            <listitem>
                <listcell label="@bind(each.id)"></listcell>
                <listcell label="@bind(each.carOwner)"></listcell>
                <listcell label="@bind(each.carType)"></listcell>
                <listcell label="@bind(each.driveDate) @converter('formatedDate',format='yyyy/MM/dd')"></listcell>
                <listcell label="@bind(each.km)"></listcell>
            </listitem>
        </template>
    </listbox>
    <hbox style="margin-top:20px" visible="@bind(not empty vm.selectedCarInfo)">
        <image src="@bind(vm.selectedCarInfo.car.preview)" style="padding:10px" />
        <vbox>
            <hlayout>
                Model : <label value="@bind(vm.selectedCarInfo.car.model)" style="font-weight:bold"/>
            </hlayout>
            <hlayout>
                Make : <label value="@bind(vm.selectedCarInfo.car.make)" style="font-weight:bold"/>
            </hlayout>
            <hlayout>
                Price :
                <span>$<label value="@bind(vm.selectedCarInfo.car.price)" style="font-weight:bold"/></span>
            </hlayout>
            <label value="@bind(vm.selectedCarInfo.car.description)" />
        </vbox>
    </hbox>
</window>

Server Side

PR 如需複雜方式必須去 Spring Boot 新增，並將 Entity Model 放入Spring Boot

CarInfoContoller

@RestController  
@RequestMapping("/carinfo")  
public class CarInfoContoller {  

    @Autowired  
    private CarInfoRepository carInfoRepository;  

    @Autowired  
    CarInfoService CarInfoService;  

    @GetMapping("/paging") // native sql  
    public List<CarInfo> getCarInfoByNativeSQL(@PageableDefault(size = 10) Pageable pageable) {  
        Page<CarInfo> contacts = this.carInfoRepository.findAllUsersWithPaginationByNativeSQL(pageable);  
        return contacts.getContent();  
    }
}

@Repository  
public interface CarInfoRepository extends JpaRepository<CarInfo, Long> {
    @Query(value = "SELECT * FROM CarInfo ORDERBY CAR_OWNER", countQuery = "SELECT count(*) FROM CarInfo", nativeQuery = true)  
    Page<CarInfo> findAllUsersWithPaginationByNativeSQL(Pageable pageable);
}

JpaRepository 支援關鍵字方法語法

Keyword	Sample	JPQL snippet
And	findByLastnameAndFirstname	… where x.lastname = ?1 and x.firstname = ?2
Or	findByLastnameOrFirstname	… where x.lastname = ?1 or x.firstname = ?2
Between	findByStartDateBetween	… where x.startDate between 1? and ?2
LessThan	findByAgeLessThan	… where x.age < ?1
GreaterThan	findByAgeGreaterThan	… where x.age > ?1
After	findByStartDateAfter	… where x.startDate > ?1
Before	findByStartDateBefore	… where x.startDate < ?1
IsNull	findByAgeIsNull	… where x.age is null
IsNotNull,NotNull	findByAge(Is)NotNull	… where x.age not null
Like	findByFirstnameLike	… where x.firstname like ?1
NotLike	findByFirstnameNotLike	… where x.firstname not like ?1
StartingWith	findByFirstnameStartingWith	… where x.firstname like ?1 (parameter bound with appended %)
EndingWith	findByFirstnameEndingWith	… where x.firstname like ?1 (parameter bound with prepended %)
Containing	findByFirstnameContaining	… where x.firstname like ?1 (parameter bound wrapped in %)
OrderBy	findByAgeOrderByLastnameDesc	… where x.age = ?1 order by x.lastname desc
Not	findByLastnameNot	… where x.lastname <> ?1
In	findByAgeIn(

gRPC

#透過 protoc tool 產生code
$ protoc -I car_info/ car_info/car_info.proto --go_out=plugins=grpc:car_info
#透過 maven plugin  產生code 
$ mvn protobuf:compile

Golang Service Side

syntax = "proto3";
// 生成的程式在 Golang 中將會屬於 `pb` 套件。
option java_multiple_files = true;
option java_package = "io.grpc.examples.car_info";
option java_outer_classname = "CarInfoProto";
option objc_class_prefix = "CARINFO";

package  car_info;
// CarInfo 定義了一個服務。
service  CarInfoService {
// GetList 會接收 CarInfoGetListRequest 資料，最終會回傳 CarInfoGetListResponse
rpc  GetList (CarInfoGetListRequest) returns (CarInfoGetListResponse) {}
rpc  InsertList (CarInfoInsertListRequest) returns (CarInfoInsertListResponse) {}
}

message  CarInfo {
    string  CarOwner = 1;
    string  CarType = 2;
    string  DriveDate = 3;
    string  km = 4;
    string  test = 5;
}

// Car Info Get List 需求 list
message  CarInfoGetListRequest { }
// Car Info Get List 回應 list
message  CarInfoGetListResponse {
    repeated  CarInfo  cars = 1;
}

// Car Info Get List 需求list
message  CarInfoInsertListRequest {
    repeated  CarInfo  cars = 1;
}
// Car Info Get List 回應 list
message  CarInfoInsertListResponse {
    repeated  CarInfo  cars = 1;
}

透過工具產生 code go 版本

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: car_info.proto
package car_info

import (
    context "context"
    fmt "fmt"
    math "math"

    proto "github.com/golang/protobuf/proto"
    grpc "google.golang.org/grpc"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type CarInfo struct {
    CarOwner             string   `protobuf:"bytes,1,opt,name=CarOwner,proto3" json:"CarOwner,omitempty"`
    CarType              string   `protobuf:"bytes,2,opt,name=CarType,proto3" json:"CarType,omitempty"`
    DriveDate            string   `protobuf:"bytes,3,opt,name=DriveDate,proto3" json:"DriveDate,omitempty"`
    Km                   string   `protobuf:"bytes,4,opt,name=km,proto3" json:"km,omitempty"`
    Test                 string   `protobuf:"bytes,5,opt,name=test,proto3" json:"test,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

func (m *CarInfo) Reset()         { *m = CarInfo{} }
func (m *CarInfo) String() string { return proto.CompactTextString(m) }
func (*CarInfo) ProtoMessage()    {}
func (*CarInfo) Descriptor() ([]byte, []int) {
    return fileDescriptor_6109e1b82e86989a, []int{0}
}

func (m *CarInfo) XXX_Unmarshal(b []byte) error {
    return xxx_messageInfo_CarInfo.Unmarshal(m, b)
}
func (m *CarInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    return xxx_messageInfo_CarInfo.Marshal(b, m, deterministic)
}
func (m *CarInfo) XXX_Merge(src proto.Message) {
    xxx_messageInfo_CarInfo.Merge(m, src)
}
func (m *CarInfo) XXX_Size() int {
    return xxx_messageInfo_CarInfo.Size(m)
}
func (m *CarInfo) XXX_DiscardUnknown() {
    xxx_messageInfo_CarInfo.DiscardUnknown(m)
}

var xxx_messageInfo_CarInfo proto.InternalMessageInfo

func (m *CarInfo) GetCarOwner() string {
    if m != nil {
        return m.CarOwner
    }
    return ""
}

func (m *CarInfo) GetCarType() string {
    if m != nil {
        return m.CarType
    }
    return ""
}

func (m *CarInfo) GetDriveDate() string {
    if m != nil {
        return m.DriveDate
    }
    return ""
}

func (m *CarInfo) GetKm() string {
    if m != nil {
        return m.Km
    }
    return ""
}

func (m *CarInfo) GetTest() string {
    if m != nil {
        return m.Test
    }
    return ""
}

// Car Info Get List 需求 list
type CarInfoGetListRequest struct {
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

func (m *CarInfoGetListRequest) Reset()         { *m = CarInfoGetListRequest{} }
func (m *CarInfoGetListRequest) String() string { return proto.CompactTextString(m) }
func (*CarInfoGetListRequest) ProtoMessage()    {}
func (*CarInfoGetListRequest) Descriptor() ([]byte, []int) {
    return fileDescriptor_6109e1b82e86989a, []int{1}
}

func (m *CarInfoGetListRequest) XXX_Unmarshal(b []byte) error {
    return xxx_messageInfo_CarInfoGetListRequest.Unmarshal(m, b)
}
func (m *CarInfoGetListRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    return xxx_messageInfo_CarInfoGetListRequest.Marshal(b, m, deterministic)
}
func (m *CarInfoGetListRequest) XXX_Merge(src proto.Message) {
    xxx_messageInfo_CarInfoGetListRequest.Merge(m, src)
}
func (m *CarInfoGetListRequest) XXX_Size() int {
    return xxx_messageInfo_CarInfoGetListRequest.Size(m)
}
func (m *CarInfoGetListRequest) XXX_DiscardUnknown() {
    xxx_messageInfo_CarInfoGetListRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CarInfoGetListRequest proto.InternalMessageInfo

// Car Info Get List 回應 list
type CarInfoGetListResponse struct {
    Cars                 []*CarInfo `protobuf:"bytes,1,rep,name=cars,proto3" json:"cars,omitempty"`
    XXX_NoUnkeyedLiteral struct{}   `json:"-"`
    XXX_unrecognized     []byte     `json:"-"`
    XXX_sizecache        int32      `json:"-"`
}

func (m *CarInfoGetListResponse) Reset()         { *m = CarInfoGetListResponse{} }
func (m *CarInfoGetListResponse) String() string { return proto.CompactTextString(m) }
func (*CarInfoGetListResponse) ProtoMessage()    {}
func (*CarInfoGetListResponse) Descriptor() ([]byte, []int) {
    return fileDescriptor_6109e1b82e86989a, []int{2}
}

func (m *CarInfoGetListResponse) XXX_Unmarshal(b []byte) error {
    return xxx_messageInfo_CarInfoGetListResponse.Unmarshal(m, b)
}
func (m *CarInfoGetListResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    return xxx_messageInfo_CarInfoGetListResponse.Marshal(b, m, deterministic)
}
func (m *CarInfoGetListResponse) XXX_Merge(src proto.Message) {
    xxx_messageInfo_CarInfoGetListResponse.Merge(m, src)
}
func (m *CarInfoGetListResponse) XXX_Size() int {
    return xxx_messageInfo_CarInfoGetListResponse.Size(m)
}
func (m *CarInfoGetListResponse) XXX_DiscardUnknown() {
    xxx_messageInfo_CarInfoGetListResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CarInfoGetListResponse proto.InternalMessageInfo

func (m *CarInfoGetListResponse) GetCars() []*CarInfo {
    if m != nil {
        return m.Cars
    }
    return nil
}

type CarInfoInsertListRequest struct {
    Cars                 []*CarInfo `protobuf:"bytes,1,rep,name=cars,proto3" json:"cars,omitempty"`
    XXX_NoUnkeyedLiteral struct{}   `json:"-"`
    XXX_unrecognized     []byte     `json:"-"`
    XXX_sizecache        int32      `json:"-"`
}

func (m *CarInfoInsertListRequest) Reset()         { *m = CarInfoInsertListRequest{} }
func (m *CarInfoInsertListRequest) String() string { return proto.CompactTextString(m) }
func (*CarInfoInsertListRequest) ProtoMessage()    {}
func (*CarInfoInsertListRequest) Descriptor() ([]byte, []int) {
    return fileDescriptor_6109e1b82e86989a, []int{3}
}

func (m *CarInfoInsertListRequest) XXX_Unmarshal(b []byte) error {
    return xxx_messageInfo_CarInfoInsertListRequest.Unmarshal(m, b)
}
func (m *CarInfoInsertListRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    return xxx_messageInfo_CarInfoInsertListRequest.Marshal(b, m, deterministic)
}
func (m *CarInfoInsertListRequest) XXX_Merge(src proto.Message) {
    xxx_messageInfo_CarInfoInsertListRequest.Merge(m, src)
}
func (m *CarInfoInsertListRequest) XXX_Size() int {
    return xxx_messageInfo_CarInfoInsertListRequest.Size(m)
}
func (m *CarInfoInsertListRequest) XXX_DiscardUnknown() {
    xxx_messageInfo_CarInfoInsertListRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CarInfoInsertListRequest proto.InternalMessageInfo

func (m *CarInfoInsertListRequest) GetCars() []*CarInfo {
    if m != nil {
        return m.Cars
    }
    return nil
}

// Car Info Get List 回應 list
type CarInfoInsertListResponse struct {
    Cars                 []*CarInfo `protobuf:"bytes,1,rep,name=cars,proto3" json:"cars,omitempty"`
    XXX_NoUnkeyedLiteral struct{}   `json:"-"`
    XXX_unrecognized     []byte     `json:"-"`
    XXX_sizecache        int32      `json:"-"`
}

func (m *CarInfoInsertListResponse) Reset()         { *m = CarInfoInsertListResponse{} }
func (m *CarInfoInsertListResponse) String() string { return proto.CompactTextString(m) }
func (*CarInfoInsertListResponse) ProtoMessage()    {}
func (*CarInfoInsertListResponse) Descriptor() ([]byte, []int) {
    return fileDescriptor_6109e1b82e86989a, []int{4}
}

func (m *CarInfoInsertListResponse) XXX_Unmarshal(b []byte) error {
    return xxx_messageInfo_CarInfoInsertListResponse.Unmarshal(m, b)
}
func (m *CarInfoInsertListResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    return xxx_messageInfo_CarInfoInsertListResponse.Marshal(b, m, deterministic)
}
func (m *CarInfoInsertListResponse) XXX_Merge(src proto.Message) {
    xxx_messageInfo_CarInfoInsertListResponse.Merge(m, src)
}
func (m *CarInfoInsertListResponse) XXX_Size() int {
    return xxx_messageInfo_CarInfoInsertListResponse.Size(m)
}
func (m *CarInfoInsertListResponse) XXX_DiscardUnknown() {
    xxx_messageInfo_CarInfoInsertListResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CarInfoInsertListResponse proto.InternalMessageInfo

func (m *CarInfoInsertListResponse) GetCars() []*CarInfo {
    if m != nil {
        return m.Cars
    }
    return nil
}

func init() {
    proto.RegisterType((*CarInfo)(nil), "car_info.CarInfo")
    proto.RegisterType((*CarInfoGetListRequest)(nil), "car_info.CarInfoGetListRequest")
    proto.RegisterType((*CarInfoGetListResponse)(nil), "car_info.CarInfoGetListResponse")
    proto.RegisterType((*CarInfoInsertListRequest)(nil), "car_info.CarInfoInsertListRequest")
    proto.RegisterType((*CarInfoInsertListResponse)(nil), "car_info.CarInfoInsertListResponse")
}

func init() { proto.RegisterFile("car_info.proto", fileDescriptor_6109e1b82e86989a) }

var fileDescriptor_6109e1b82e86989a = []byte{
    // 309 bytes of a gzipped FileDescriptorProto
    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x52, 0xdd, 0x4a, 0x02, 0x41,
    0x14, 0x6e, 0x56, 0x4b, 0x3d, 0x85, 0xd0, 0x81, 0x6a, 0x94, 0x20, 0xd9, 0x08, 0xbc, 0xda, 0x0b,
    0xa3, 0xeb, 0xf0, 0x87, 0x42, 0x08, 0x95, 0x2d, 0xe8, 0x32, 0xa6, 0xe5, 0x18, 0x8b, 0xb9, 0xb3,
    0xcd, 0x4c, 0x56, 0x97, 0xbd, 0x4a, 0x6f, 0xd1, 0xdb, 0x85, 0xd3, 0xb8, 0x56, 0x5b, 0x51, 0x77,
    0x73, 0xbe, 0x3f, 0xbe, 0x33, 0x1c, 0xa8, 0x46, 0x42, 0x5d, 0xc5, 0xc9, 0x58, 0x06, 0xa9, 0x92,
    0x46, 0x62, 0x79, 0x31, 0xfb, 0xcf, 0x0c, 0x4a, 0x5d, 0xa1, 0xfa, 0xc9, 0x58, 0x62, 0x1d, 0xca,
    0x5d, 0xa1, 0x86, 0x0f, 0x09, 0x29, 0xce, 0x1a, 0xac, 0x59, 0x09, 0xb3, 0x19, 0xb9, 0x95, 0x5d,
    0x3c, 0xa5, 0xc4, 0x3d, 0x4b, 0x2d, 0x46, 0xdc, 0x85, 0x4a, 0x4f, 0xc5, 0x33, 0xea, 0x09, 0x43,
    0xbc, 0x60, 0xb9, 0x25, 0x80, 0x55, 0xf0, 0x26, 0x53, 0x5e, 0xb4, 0xb0, 0x37, 0x99, 0x22, 0x42,
    0xd1, 0x90, 0x36, 0x7c, 0xd5, 0x22, 0xf6, 0xed, 0xef, 0xc0, 0x96, 0xab, 0x70, 0x4a, 0xe6, 0x2c,
    0xd6, 0x26, 0xa4, 0xbb, 0xfb, 0x39, 0x71, 0x0c, 0xdb, 0x5f, 0x09, 0x9d, 0xca, 0x44, 0x13, 0x1e,
    0x40, 0x31, 0x12, 0x4a, 0x73, 0xd6, 0x28, 0x34, 0xd7, 0x5b, 0x9b, 0x41, 0xb6, 0x9f, 0xd3, 0x87,
    0x96, 0xf6, 0xdb, 0xc0, 0x1d, 0xd0, 0x4f, 0x34, 0xa9, 0x8f, 0xe1, 0x7f, 0x8d, 0xe8, 0x40, 0xed,
    0x9b, 0x88, 0x7f, 0xd5, 0x68, 0xbd, 0x32, 0xa8, 0x3a, 0xe4, 0x9c, 0xd4, 0x2c, 0x8e, 0x08, 0x07,
    0x50, 0x72, 0x3b, 0xe1, 0x5e, 0xce, 0xf6, 0xf9, 0x1b, 0xea, 0x8d, 0x9f, 0x05, 0xef, 0x3d, 0xfc,
    0x15, 0xbc, 0x04, 0x58, 0xf6, 0x43, 0x3f, 0xe7, 0xc8, 0xed, 0x5f, 0xdf, 0xff, 0x55, 0xb3, 0x08,
    0xee, 0x1c, 0x41, 0x2d, 0x96, 0xc1, 0x8d, 0x4a, 0xa3, 0x80, 0x1e, 0xc5, 0x34, 0xbd, 0x25, 0x9d,
    0x19, 0x3b, 0x1b, 0xce, 0x39, 0x9a, 0x5f, 0xd5, 0x88, 0xbd, 0x78, 0xa5, 0x6e, 0x3b, 0xec, 0x0f,
    0x4e, 0x86, 0xd7, 0x6b, 0xf6, 0xd0, 0x0e, 0xdf, 0x02, 0x00, 0x00, 0xff, 0xff, 0x22, 0xe2, 0x10,
    0xb0, 0x7a, 0x02, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// CarInfoServiceClient is the client API for CarInfoService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type CarInfoServiceClient interface {
    // GetList 會接收 CarInfoGetListRequest 資料，最終會回傳 CarInfoGetListResponse
    GetList(ctx context.Context, in *CarInfoGetListRequest, opts ...grpc.CallOption) (*CarInfoGetListResponse, error)
    // rpc GetList (CarInfoGetListRequest) returns (stream CarInfo) {}
    InsertList(ctx context.Context, in *CarInfoInsertListRequest, opts ...grpc.CallOption) (*CarInfoInsertListResponse, error)
}

type carInfoServiceClient struct {
    cc *grpc.ClientConn
}

func NewCarInfoServiceClient(cc *grpc.ClientConn) CarInfoServiceClient {
    return &carInfoServiceClient{cc}
}

func (c *carInfoServiceClient) GetList(ctx context.Context, in *CarInfoGetListRequest, opts ...grpc.CallOption) (*CarInfoGetListResponse, error) {
    out := new(CarInfoGetListResponse)
    err := c.cc.Invoke(ctx, "/car_info.CarInfoService/GetList", in, out, opts...)
    if err != nil {
        return nil, err
    }
    return out, nil
}

func (c *carInfoServiceClient) InsertList(ctx context.Context, in *CarInfoInsertListRequest, opts ...grpc.CallOption) (*CarInfoInsertListResponse, error) {
    out := new(CarInfoInsertListResponse)
    err := c.cc.Invoke(ctx, "/car_info.CarInfoService/InsertList", in, out, opts...)
    if err != nil {
        return nil, err
    }
    return out, nil
}

// CarInfoServiceServer is the server API for CarInfoService service.
type CarInfoServiceServer interface {
    // GetList 會接收 CarInfoGetListRequest 資料，最終會回傳 CarInfoGetListResponse
    GetList(context.Context, *CarInfoGetListRequest) (*CarInfoGetListResponse, error)
    // rpc GetList (CarInfoGetListRequest) returns (stream CarInfo) {}
    InsertList(context.Context, *CarInfoInsertListRequest) (*CarInfoInsertListResponse, error)
}

func RegisterCarInfoServiceServer(s *grpc.Server, srv CarInfoServiceServer) {
    s.RegisterService(&_CarInfoService_serviceDesc, srv)
}

func _CarInfoService_GetList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
    in := new(CarInfoGetListRequest)
    if err := dec(in); err != nil {
        return nil, err
    }
    if interceptor == nil {
        return srv.(CarInfoServiceServer).GetList(ctx, in)
    }
    info := &grpc.UnaryServerInfo{
        Server:     srv,
        FullMethod: "/car_info.CarInfoService/GetList",
    }
    handler := func(ctx context.Context, req interface{}) (interface{}, error) {
        return srv.(CarInfoServiceServer).GetList(ctx, req.(*CarInfoGetListRequest))
    }
    return interceptor(ctx, in, info, handler)
}

func _CarInfoService_InsertList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
    in := new(CarInfoInsertListRequest)
    if err := dec(in); err != nil {
        return nil, err
    }
    if interceptor == nil {
        return srv.(CarInfoServiceServer).InsertList(ctx, in)
    }
    info := &grpc.UnaryServerInfo{
        Server:     srv,
        FullMethod: "/car_info.CarInfoService/InsertList",
    }
    handler := func(ctx context.Context, req interface{}) (interface{}, error) {
        return srv.(CarInfoServiceServer).InsertList(ctx, req.(*CarInfoInsertListRequest))
    }
    return interceptor(ctx, in, info, handler)
}

var _CarInfoService_serviceDesc = grpc.ServiceDesc{
    ServiceName: "car_info.CarInfoService",
    HandlerType: (*CarInfoServiceServer)(nil),
    Methods: []grpc.MethodDesc{
        {
            MethodName: "GetList",
            Handler:    _CarInfoService_GetList_Handler,
        },
        {
            MethodName: "InsertList",
            Handler:    _CarInfoService_InsertList_Handler,
        },
    },
    Streams:  []grpc.StreamDesc{},
    Metadata: "car_info.proto",
}

Entity 結構

type  CarInfo  struct {
    CarOwner string
    CarType string
    DriveDate time.Time
    Km string
    Test string
}

取得清單方法

func (s *server) GetList(ctx context.Context, in *car_info.CarInfoGetListRequest) (*car_info.CarInfoGetListResponse, error) {
    var list []CarInfo
    car_list := []*car_info.CarInfo{}

    engine.Limit(1000, 0).Find(&list)
    orm, _ := json.Marshal(list)
    json.Unmarshal(orm, &car_list)

    return &car_info.CarInfoGetListResponse{Cars: car_list}, nil
}

批次新增

func (s *server) InsertList(ctx context.Context, in *car_info.CarInfoInsertListRequest) (*car_info.CarInfoInsertListResponse, error) {
    var list []CarInfo

    orm, _ := json.Marshal(in.Cars)
    json.Unmarshal(orm, &list)
    for _, car := range list {
        engine.Insert(&car)
    }

    return &car_info.CarInfoInsertListResponse{Cars: in.Cars}, nil
}

Java Client Side

public class CarInfoClient {
    private static final Logger logger = Logger.getLogger(CarInfoClient.class.getName());

    private final ManagedChannel channel;
    private final ServiceGrpc.ServiceBlockingStub blockingStub;

    public CarInfoClient(String host, int port) {
        this(ManagedChannelBuilder.forAddress(host, port)
                .usePlaintext()
                .build());
    }

    CarInfoClient(ManagedChannel channel) {
        this.channel = channel;
        blockingStub = ServiceGrpc.newBlockingStub(channel);
    }

    public void getList() {
        CarInfoGetListRequest request = CarInfoGetListRequest.newBuilder().build();
        CarInfoGetListResponse response;
        try {
            response = blockingStub.getList(request);
        } catch (StatusRuntimeException e) {
            logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
            return;
        }
        logger.info("CarList: " + response.getCarsList());
    }


    public void shutdown() throws InterruptedException {
        channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
    }

    public static void main(String[] args) throws Exception {
        CarInfoClient client = new CarInfoClient("localhost", 50051);
        try {
            client.getList();
        } finally {
            client.shutdown();
        }
    }
}

Golang Client Side

func main() {
    runtime.GOMAXPROCS(runtime.NumCPU())
    conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure())
    if err != nil {
        log.Fatalf("連線失敗：＿%v", err)
    }
    defer conn.Close()
    car_service := car_info.NewCarInfoServiceClient(conn)

    // insert
    var list []*car_info.CarInfo
    for i := 1; i <= 10; i++ {
        list = append(list, &car_info.CarInfo{CarOwner: strconv.Itoa(counter) + ":" + strconv.Itoa(i), CarType: "n"})
    }
    car_service.InsertList(context.Background(), &car_info.CarInfoInsertListRequest{Cars: list})
}