how to install and use Jeddict AI Assistant on NetBeans IDE 23+

Jeddict AI Assistant 為適用於 NetBeans IDE 23 以上版本的插件，能夠連接大語言模型，協助編寫程式碼，大幅提升開發體驗，讓程式撰寫更輕鬆、更智慧。以下簡介其安裝方法及功能。

A.安裝與解除安裝

  • 安裝步驟：
    • 開啟 NetBeans IDE
    • 點選 Tools/Plugins/Available Plugins
    • 搜尋並安裝 Jeddict AI Assistant
    • 點選 Tools/Options/Jeddict AI Assistant
      Providers: OLLAMA,
      URL: http://localhost:11434,
      Model: qwen2.5-coder:7b
  • 解除安裝步驟：
    • 點選 Tools/Plugins/Installed
    • 在 User Installed Plugins 下，選擇 Jeddict AI Assistant
    • 點擊解除作用 (Deactivate) 或 解除安裝 (Uninstall)

B.主要功能與使用說明

Jeddict AI Assistant 提供了多種智慧功能，幫助提升程式碼品質與開發效率：

  1. 智慧程式碼補全

    (Smart Code Completion)
    • 用法： 在編輯程式碼時，按下 Ctrl+Space 或 Ctrl+Alt+Space 鍵，AI 會提供相關的程式碼建議。按下 Enter 鍵即可接受建議。
    • 說明： AI 會學習程式碼上下文，提供更精準的補全、變數和方法重命名，以及改進日誌訊息或註解的建議，大幅提高編碼效率。

  2. 行內提示

    (Inline Hint)
    • 用法： 在編輯程式碼行時，按下 Enter 鍵，AI Assistant 會直接在程式碼編輯器中顯示基於當前上下文的行內提示。再次按下 Enter 鍵即可確認並整合建議，或按下其他任意鍵取消。
    • 說明： 提供即時、上下文感知的建議，有效提升程式碼品質和效率，且不干擾開發流程。

  3. 為行內提示提供上下文

    (Providing Context to Inline Hint)
    • 用法：
      • 使用註解作為提示： 在程式碼中撰寫註解說明程式意圖，然後按 Enter 鍵。AI 會將註解和現有程式碼作為上下文。
      • 使用儲存的提示： 在設定中定義長提示，然後在編輯器中輸入 /prompt-id 並按 Enter 鍵來重複使用。
      • 即時擴展儲存的提示： 輸入 /{prompt-id} 加上額外上下文，AI 會同時處理儲存的提示和額外文字。
    • 說明： 可更精確地控制 AI 的建議，使其更符合當前的開發任務。

  4. 方法強化

    (Method Enhancement)
    • 用法： 反白顯示任何方法，然後點擊提示："AI: Enhance the method"。
    • 說明： AI 會根據專案需求，改進方法的邏輯、結構或效率。

  5. Javadoc 創建與改進

    (Javadoc Creation & Improvement)
    • Javadoc 創建用法： 反白顯示任何類別、方法或介面，然後點擊提示："AI: Create Javadoc using assistance"。
    • Javadoc 改進用法： 反白顯示任何類別、方法或介面中現有的 Javadoc 註解，然後點擊提示："AI: Enhance existing Javadoc"。
    • 說明： AI 會自動生成符合程式碼上下文的 Javadoc，並提升其清晰度、準確性和符合最佳實踐。

  6. 變數命名建議

    (Variable Naming Suggestions)
    • 用法： 反白顯示任何變數或參數，然後點擊提示："AI: Improve variable name using assistance"。
    • 說明： 自動建議更有意義且符合上下文的變數名稱，提升程式碼的可讀性和可維護性。

  7. 語法修正

    (Grammar Fixes)
    • 用法： 選擇任何字串文字 (例如註解、Javadoc 或其他文本)，然後點擊提示："AI: Fix grammar issues using assistance"。
    • 說明： 檢測並修正程式碼中註解、Javadoc 或其他文本內容的語法錯誤，確保文件專業且潤飾精良。

  8. 文本強化

    (Text Enhancement)
    • 用法： 選擇任何字串文字 (例如註解、文件或日誌訊息)，然後點擊提示："AI: Enhance text quality using assistance"。
    • 說明： 透過提供更簡潔、更有影響力的替代方案，提升文本內容的品質和可讀性。

  9. 程式碼行強化 (Code Line Enhancement)

    • 用法： 選擇任何單行程式碼片段，然後點擊提示："AI: Enhance a single line of code"。
    • 說明： 建議單行程式碼的強化或最佳化，確保表達簡潔、高效和可維護。

  10. 學習類別

    (Learn about Class)
    • 用法： 反白顯示類別名稱，然後點擊提示："AI: Learn about Class"。之後可以在聊天中繼續詢問特定問題。
    • 說明： 提供關於特定類別的深入見解和詳細解釋，包括其方法、屬性以及在專案中的用法。

  11. 生成測試案例

    (Generate Test Cases)
    • 用法： 反白顯示任何類別或方法，然後點擊提示："AI: Generate Test for Class or Method"。
    • 說明： 根據 AI Assistant 提供的上下文提示，自動為類別或方法生成測試案例，簡化測試寫作流程。

C.AI 聊天功能

Jeddict AI Assistant 提供了多種上下文感知的 AI 聊天模式，可有效解決開發問題：

  1. 感知專案上下文的 AI 聊天

    (Project Context-Aware AI Chat)
    • 用法： 在專案開啟時，右鍵點擊專案並選擇 "AI Assistant" 以啟動 AI 聊天。
    • 說明： AI 聊天會考量整個專案的上下文，提供針對專案結構和組件的全面見解和支援。

  2. 感知 Java 套件與類別上下文的 AI 聊天

    (Java Packages & Classes Context-Aware AI Chat)
    • 用法： 選擇所需的套件或類別，右鍵點擊並選擇 "AI Assistant" 以開始聊天。
    • 說明： 針對特定的 Java 套件或類別與 AI 互動，獲得反映該套件或類別上下文的見解和建議。

  3. 編輯器提供各 Java 類別專屬的 AI 聊天

    (Tailored AI Chat for Individual Java Classes from Editor)
    • 用法： 在編輯器中開啟所需的 Java 類別，右鍵點擊並選擇 "AI Assistant" 以啟動專注於該類別的對話。
    • 說明： 針對單個 Java 類別與 AI Assistant 進行有針對性的討論，接收專門針對該類別的詳細分析和改進建議。

  4. 網頁開發上下文感知的 AI 聊天

    (Web Development Context-Aware AI Chat (HTML, CSS, JS, JSF))
    • 用法： 選擇 webapp 目錄或其任何子目錄，右鍵點擊並選擇 "AI Assistant"。
    • 說明： 與 AI 針對 HTML, CSS, JavaScript 和 JSF 等網頁應用程式組件進行交流，獲得針對網頁開發的上下文感知支援和建議。

  5. 通用 AI 聊天

    (General AI Chat (No Context Required))
    • 用法： 點擊頂部工具列上的 Jeddict 按鈕。
    • 說明： 無需程式碼或專案上下文即可使用 AI 聊天功能，適用於一般查詢或不與特定程式碼元素相關的討論，更具成本效益且速度更快。

D.其他實用功能

  1. 國際化支援

    (Internationalization Support)
    • 可透過在設定面板中設定 系統訊息 (System Message) 來配置 AI 以特定語言回應，例如使用 "Respond in French"。
    • 對於某些語言，可能需要使用相容的字體來正確呈現聊天視窗和編輯器中的文本。

  2. 支援 PlantUML 和 Markdown 支援

    (PlantUML and Markdown Support in Chat)
    • 現在可以直接在聊天視窗中查看和編輯 PlantUML 圖表和 Markdown 內容。當要求圖表或格式化文本時，會即時顯示，可以在提交前預覽和進行更改。
    • 原地編輯 (Edit in-place)： 只需點擊圖表或 Markdown 區塊即可直接在聊天中編輯。
    • 請注意： 所做的任何更改不會發送給 AI，直到明確地複製並貼上更新的內容到輸入框並提交。

  3. AI 式提交訊息

    AI Commit Message
    • 用法： 右鍵點擊專案並選擇 "AI Commit Message" 以自動生成提交訊息。此選項僅在 Git 檢測到更改時可見。
    • 說明： 根據 Git 儲存庫中檢測到的差異生成有意義的提交訊息，簡化版本控制流程。

  4. AI式 SQL 聊天助理

    (SQL AI Chat Assistant)
    • 用法： 導航至 Services > Databases > Register DB in Apache NetBeans。右鍵點擊資料庫連接並選擇 "AI Assistant"。
    • 說明： 這將啟動 AI 聊天視窗，提供基於資料庫的上下文。AI 將在 SQL 編輯器中生成結果，能夠在同一個聊天視窗中利用 AI 進行 SQL 查詢的智慧行內補全。

  5. AI 式 SQL 行內補全

    (SQL Inline Completion with AI)
    • 用法： 在 Services > Databases > Register DB in Apache NetBeans 中，右鍵點擊資料庫連接並選擇 "Execute Command..."。在開啟的新視窗中撰寫 SQL 查詢，提供AI 驅動的行內補全建議。
    • 說明： 可以在同一個視窗中執行查詢並立即查看結果，簡化工作流程並減少查詢所花費的時間。
於 沒有留言:
Labels: ,

how to write Java HTTP client and server for RESTful web services

供程式串接用的網頁服務 (Web Service) 分成客戶端及服務端。以 Java RESTful Web Service 為例，假設服務端點規格如下:

    http://example.com:8080/api/v1/users/123?name=John 

其中，本體區皆以 JSON 物件字串為資料交換標準，輸入參數用到路徑123，查詢字串name=John，標頭區Area: Taipei，本體區phone: 123-4567。其 POST 請求 (Request) 及回應 (Response) 如下，

Request Header and Body
POST /api/users/123?name=John HTTP/1.1
Host: example.com:8080
Accept: application/json
Area: Taipei

{ "phone": "123-4567" }
Response Header and Body
HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 85

{
  "id": 123,
  "name": "John",
  "area": "Taipei",
  "phone": "123-4567"
}

以下介紹上述端點規格的服務端及客戶端寫法:

(一) 服務端寫法，將使用 JAX-RS Jersey 套件

A. Java EE 7 手動轉型寫法如下，須搭配 GlassFish 4.1.2 (Java EE 7) with JDK 8

// Old Version:
//  On NetBeans, use Tools/Server 
//    to install GlassFish 4.1.2 (Java EE 7) with JDK 8
//  Use New/RESTful Web Services from Patterns...
//    to set up ApplicationConfig.java and Resource.java
//
import javax.ws.rs.Consumes;
import javax.ws.rs.HeaderParam;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType;
//import javax.ws.rs.core.Response;
import com.goolge.gson.Gson;  // install gson-2.7.jar in library

@Path("/api/users")
public class UserResource {

    @POST
    @Path("{id}")
    @Consumes(MediaType.APPLICATION_JSON)
    @Produces(MediaType.APPLICATION_JSON)
    public String updateUser(      // 此方法名無關緊要，回傳型別建議用字串
            @PathParam("id") int id,
            @QueryParam("name") String name,
            @HeaderParam("Area") String area,
            String requestBody) {  // 請求本體區建議用字串接收，避免自動轉型出錯

        // 取出請求本體區物件
        PhoneRequest request = new Gson()
            .fromJson(requestBody, PhoneRequest.class); // 字串轉物件

        // 依據給定 id, name, area, request，執行運算邏輯

        // 建構回應物件，轉型成字串回應
        UserResponse response = new UserResponse();
        response.id = id;
        response.name = name;
        response.area = area;
        response.phone = request.phone;

        String jsonResponse = new Gson().toJson(response);  // 物件轉字串
        return jsonResponse;  // 回傳用字串

        //return Response.ok(response).build();  // 回傳用物件，可能報錯
    }

    // Request body class 請求本體物件
    public static class PhoneRequest {

        public String phone;
    }

    // Response body class 回應本體物件
    public static class UserResponse {

        public int id;
        public String name;
        public String area;
        public String phone;
    }
}

B. Jakarta EE 9.1 自動轉型寫法如下，須搭配 GlassFish 6.2.5 (Jakarta EE 9.1) with JDK 11

// New Version:
//  On NetBeans, use Tools/Server 
//    to install GlassFish 6.2.5 (Jakarta EE 9.1) with JDK 11
//  Use New/RESTful Web Services from Patterns...
//    to set up ApplicationConfig.java and Resource.java
//
import jakarta.ws.rs.Consumes;
import jakarta.ws.rs.HeaderParam;
import jakarta.ws.rs.POST;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.PathParam;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.QueryParam;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;

@Path("/api/users")
public class UserResource {

    @POST
    @Path("{id}")
    @Consumes(MediaType.APPLICATION_JSON)
    @Produces(MediaType.APPLICATION_JSON)
    public Response updateUser(      // 此方法名無關緊要，回傳型別 Response
            @PathParam("id") int id,
            @QueryParam("name") String name,
            @HeaderParam("Area") String area,
            PhoneRequest requestBody) {  // 請求本體區物件型別 PhoneRequest

        // 依據給定 id, name, area, requestBody，執行運算邏輯

        // 建構回應物件
        UserResponse response = new UserResponse();
        response.id = id;
        response.name = name;
        response.area = area;
        response.phone = requestBody.phone;

        return Response.ok(response).build();  // 回傳成功狀態 Response 物件
        // Response.status(Response.Status.BAD_REQUEST) // 其他錯誤狀態回傳法
        //       .entity("Invalid input")
        //       .build();
    }

    // Request body class 請求本體物件
    public static class PhoneRequest {

        public String phone;
    }

    // Response body class 回應本體物件
    public static class UserResponse {

        public int id;
        public String name;
        public String area;
        public String phone;
    }
}

(二) 至於客戶端有如下三種常用寫法，可供比較選用:

  • JAX-RS 適合用於 Java/Jakarta EE 或 Jersey 等 RESTful 應用。
  • HttpURLConnection 是最基本的方式，無需額外套件，但較繁瑣。
  • HttpClient (JDK 11+) 是現代化且功能強大的選擇，須 JDK11以上才支援。

 A.使用 JAX-RS Client API 

// On NetBeans, use New/RESTful Java Client... 
//   to add JAX-RS libraries which support javax/jakarta.ws.rs.* packages
//   and set up NewJerseyClient.java
import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.Entity;
import javax.ws.rs.client.Invocation;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;

public class JaxRsClientExample {
    public static void main(String[] args) {
        Client client = ClientBuilder.newClient();
        WebTarget target = client
            .target("http://example.com:8080/api/users/123")
            .queryParam("name", "John");

        Invocation.Builder builder = target
            .request(MediaType.APPLICATION_JSON)
            .header("Area", "Taipei");

        String jsonBody = "{ \"phone\": \"123-4567\" }";

        Response response = builder.post(
            Entity.entity(jsonBody, MediaType.APPLICATION_JSON));

        String responseBody = response.readEntity(String.class);
        System.out.println("Response: " + responseBody);
        response.close();
        client.close();
    }
}

B.使用 java.net.HttpURLConnection

import java.io.BufferedReader;
import java.io.IOException;  // thrown by httpURLConnection.openConnection()
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException; // thrown by URL()
import java.net.URL;

public class HttpURLConnectionExample {
    public static void main(String[] args) throws IOException, MalformedURLException {
        URL url = new URL("http://example.com:8080/api/users/123?name=John");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();

        conn.setRequestMethod("POST");
        conn.setRequestProperty("Accept", "application/json");
        conn.setRequestProperty("Area", "Taipei");
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setDoOutput(true);  // needed before writing the request body

        String jsonInput = "{ \"phone\": \"123-4567\" }";
        // use try with resource block without catch block
        //   output stream will be auto closed when leaving the block
        //   any exception in the block will be passed upward to the calling method
        try (OutputStream os = conn.getOutputStream()) {
            os.write(jsonInput.getBytes());
            os.flush();
        }

        BufferedReader br = new BufferedReader(
            new InputStreamReader(conn.getInputStream()));
        String line;
        StringBuilder response = new StringBuilder();
        while ((line = br.readLine()) != null) {
            response.append(line);
        }

        System.out.println("Response: " + response.toString());
        conn.disconnect();
    }
}

C.使用 java.net.http.HttpClient (JDK 11+)

// JDK 11 above is required
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpRequest.BodyPublishers;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;

public class HttpClientExample {
    public static void main(String[] args) throws IOException, InterruptedException {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("http://example.com:8080/api/users/123?name=John"))
            .header("Accept", "application/json")
            .header("Area", "Taipei")
            .header("Content-Type", "application/json")
            .POST(BodyPublishers.ofString("{ \"phone\": \"123-4567\" }"))
            .build();

        HttpResponse<String> response = client.send(request, BodyHandlers.ofString());

        System.out.println("Response: " + response.body());
    }
}
    參考資料
  1. 對應各 Java/Jakarta EE 版本，與其相容的 GlassFish, JDK 版本可參考下址
    Version history of Java EE, JSF, GlassFish, JDK, and NetBeans
於 沒有留言:
Labels: , , , ,

how the http protocol may support crud database operation

RESTful Web Service 為現在流行，用來存取資料庫記錄的 API 設計形式。以下以 JSON 資料交換格式為例，展示幾種對記錄進行增查改刪 (CRUD, Create, Read, Update, Delete) 運算時，常用的 HTTP 請求及回應範例。

設計 RESTful API 時，請求參數如果量小，可以利用 Path Parameter, Query String Parameter, Header Parameter, Body Parameter using application/json, Body Parameter using application/x-www-form-urlencoded 等參數傳遞法。如果參數量大，包含檔案，則可利用 Body Parameter using multipart/form-data 參數傳遞法。

同樣的，回應結果如果量小，可以利用 application/json 結果回傳法。如果量大，包含檔案，則可利用 multipart/mixed 結果回傳法。

以下透過 MS Copilot 生成幾種可能的 HTTP 請求及回應長相，如下。

(一) 利用 HTTP 進行新增及查詢記錄的幾種作法如下:
A. 請求(Request)訊息格式
A1: Path Parameter 由路徑上的id，查詢某人基本資料

GET /api/users/123 HTTP/1.1
Host: example.com
Accept: application/json

A2: Query String Parameter 由查詢字串上的id，查詢某人基本資料

GET /api/users?id=123 HTTP/1.1
Host: example.com
Accept: application/json

A3: Header Parameter 由標頭區的id，查詢某人基本資料

GET /api/users HTTP/1.1
Host: example.com
Accept: application/json
id: 123

A4: Body Parameter using application/json 由本體區的id，查詢某人基本資料

POST /api/users HTTP/1.1
Host: example.com
Accept: application/json
Content-Type: application/json
Content-Length: 18

{
  "id": 123
}

A5: Body Parameter using application/x-www-form-urlencoded 新增某人基本資料

POST /users/updateProfile HTTP/1.1
Host: example.com
Accept: application/json
Content-Type: application/x-www-form-urlencoded
Content-Length: 27

id=123&name=John+Doe&email=johndoe%40example.com

A6. Body Parameter using multipart/form-data 新增某人基本資料，含照片

POST /users/uploadProfile HTTP/1.1
Host: example.com
Accept: application/json
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Length: [length]

------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="metadata"
Content-Type: application/json

{
  "id": 123,
  "name": "John Doe",
  "email": "johndoe@example.com"
}
------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="profileImage"; filename="profile.jpg"
Content-Type: image/jpeg

[image data here]
------WebKitFormBoundary7MA4YWxkTrZu0gW--

B. 回應(Response)訊息格式
B1. application/json格式，回傳某人基本資料

HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 85

{
  "id": 123,
  "name": "John Doe",
  "email": "johndoe@example.com"
}

B2. multipart/mixed格式，回傳某人基本資料，含檔案

HTTP/1.1 200 OK
Content-Type: multipart/mixed; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Length: [total length]

------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Type: application/json

{
  "id": 123,
  "name": "John Doe",
  "email": "johndoe@example.com"
}
------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Type: application/octet-stream
Content-Disposition: attachment; filename="example.txt"

[file data here]
------WebKitFormBoundary7MA4YWxkTrZu0gW--

(二) 利用 HTTP 進行修改及刪除記錄的作法如下:
A. 修改記錄
Request:

PUT /api/users/123 HTTP/1.1
Host: example.com
Accept: application/json
Content-Type: application/json
Content-Length: 58

{
  "name": "Jane Doe",
  "email": "janedoe@example.com"
}

Response:

HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 85

{
  "id": 123,
  "name": "Jane Doe",
  "email": "janedoe@example.com",
  "status": "updated"
}

B.刪除記錄
Request:

DELETE /api/users/123 HTTP/1.1
Host: example.com
Accept: application/json

Response:

HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 45

{
  "id": 123,
  "status": "deleted"
}
於 沒有留言:
Labels: , , , ,

how to connect to Java DB from Java application or Java EE container

 假設 Java DB 已建好 db_name 資料庫，帳密為 user/password。

以下展示 Java EE 後台組件如何善用資料來源定義，注入資料來源，定義執行SQL指令，回傳結果集合給前台。


// 定義資料來源
@DataSourceDefinition(
   name = "java:global/jdbc/db_name",
   className = "org.apache.derby.jdbc.ClientDataSource",
   url = "jdbc:derby://localhost:1527/db_name",
   databaseName = "db_name",
   user = "user",
   password = "password")

@Named("bean")
@javax.faces.view.ViewScoped 
public class Bean implements Serializable
{
   // 定義每筆記錄的欄位屬性 f1, f2, f3

   // 要求伺服器注入資料來源成為 dataSource 物件
   @Resource(lookup="java:global/jdbc/db_name")
   DataSource dataSource;
  
   // 回傳查詢結果集合
   public ResultSet query() throws SQLException
   {
      // check whether dataSource was injected by the server
      if (dataSource == null)
      {
         throw new SQLException("Unable to obtain DataSource");
      }
      
      // 透過注入的資料來源，從連線池取得連線
      Connection connection = dataSource.getConnection();

      // check whether connection was successful
      if (connection == null)
      {
         throw new SQLException("Unable to connect to DataSource");
      }
      
      try
      {
         // 建立查詢指令
         PreparedStatement getRecords = connection.prepareStatement(
            "SELECT * FROM tbl");
   
         // 建立存放結果的快取列集合
         CachedRowSet rowSet = 
            RowSetProvider.newFactory().createCachedRowSet();
            
         // 執行查詢指令，將結果填入列集合
         rowSet.populate(getRecords.executeQuery());

         // 回傳列集合，供前台呈現
         return rowSet; 
      } 
      finally
      {
         connection.close(); // return this connection to pool
      } 
   } 
   
   // 新增一筆記錄，回傳去處網頁名稱
   public String insert() throws SQLException
   {
      // check whether dataSource was injected by the server
      if (dataSource == null)
      {
         throw new SQLException("Unable to obtain DataSource");
      }
      
      // 透過注入的資料來源，從連線池取得連線
      Connection connection = dataSource.getConnection();
      
      // check whether connection was successful
      if (connection == null)
      {
         throw new SQLException("Unable to connect to DataSource");
      }
      
      try
      {
         // 建立帶參數新增記錄指令
         PreparedStatement addEntry = 
            connection.prepareStatement("INSERT INTO tbl " +
               "(f1,f2,f3) VALUES (?, ?, ?)");

         // 指定欄位值
         addEntry.setString(1, getF1());
         addEntry.setString(2, getF2());
         addEntry.setString(3, getF3());

         addEntry.executeUpdate(); // insert the entry
         return ""; // 回傳空字串，停在原頁
      } 
      finally
      {
         connection.close(); // 不管發生例外或return，都會關閉連線，歸還給連線池
      } 
   } 
}
    利用 Java EE 後台注入資料來源的好處包括
  1. 連線池管理，可供連線重複使用，減少頻繁開關連線的成本。
  2. 資源管理，伺服器可管理連線生命週期，確保連線正常關閉，返回連線池。
  3. 組態管理，伺服器設定資料庫連線組態細節，程式只要呼叫資料來源即可。

如果願意喪失上述好處，也可採用

A. 單機版如DriverManager操作資料庫作法，一切自己管理，如下。


import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class JavaDBExample {
    private static final String DB_URL = "jdbc:derby:myDB;create=true";
    private static final String USER = "user";
    private static final String PASSWORD = "password";

    public static void main(String[] args) {
        try (Connection conn = DriverManager.getConnection(DB_URL, USER, PASSWORD);
             Statement stmt = conn.createStatement()) {

            // Create a table
            String createTableSQL = "CREATE TABLE addresses (" +
                                    "id INT PRIMARY KEY, " +
                                    "firstname VARCHAR(255), " +
                                    "lastname VARCHAR(255), " +
                                    "street VARCHAR(255), " +
                                    "city VARCHAR(255), " +
                                    "state VARCHAR(255), " +
                                    "zip VARCHAR(255))";
            stmt.execute(createTableSQL);

            // Insert data
            String insertSQL = 
               "INSERT INTO addresses VALUES " + 
               "(1, 'John', 'Doe', '123 Main St', 'Anytown', 'CA', '12345')";
            stmt.execute(insertSQL);

            // Query data
            String querySQL = "SELECT * FROM addresses";
            ResultSet rs = stmt.executeQuery(querySQL);

            while (rs.next()) {
                System.out.println("ID: " + rs.getInt("id"));
                System.out.println("First Name: " + rs.getString("firstname"));
                System.out.println("Last Name: " + rs.getString("lastname"));
                System.out.println("Street: " + rs.getString("street"));
                System.out.println("City: " + rs.getString("city"));
                System.out.println("State: " + rs.getString("state"));
                System.out.println("ZIP: " + rs.getString("zip"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

或者，
B. 採用單機版Java Persistence API (JPA) 操作資料庫作法，如下。

// Address.java 住址個體類別

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "addresses")
public class Address {
    @Id
    private int id;
    private String firstname;
    private String lastname;
    String city;
    private String state;
    private String zip;

    // Getters and setters
}

由如下個體管理員建立查詢，取用資料庫:

// JpaExample.java

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.TypedQuery;
import java.util.List;

public class JpaExample {
    private static final EntityManagerFactory ENTITY_MANAGER_FACTORY =
      Persistence.createEntityManagerFactory("myPersistenceUnit");

    public static void main(String[] args) {
        EntityManager entityManager = ENTITY_MANAGER_FACTORY.createEntityManager();

        try {
            // Create a query to fetch addresses
            TypedQuery<Address> query = 
              entityManager.createQuery("SELECT a FROM Address a", Address.class);
            List<Address> addresses = query.getResultList();

            // Process the result
            for (Address address : addresses) {
                System.out.println("ID: " + address.getId());
                System.out.println("First Name: " + address.getFirstname());
                System.out.println("Last Name: " + address.getLastname());
                System.out.println("Street: " + address.getStreet());
                System.out.println("City: " + address.getCity());
                System.out.println("State: " + address.getState());
               ();
            }
        } finally {
            entityManager.close();
            ENTITY_MANAGER_FACTORY.close();
        }
    }
}

其中，建立個體管理員時，須要參考如下 META-INF/persistence.xml 持續組態檔，

內含 myPersistenceUnit 持續單元的定義:

<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence" version="2.2">
  <persistence-unit name="myPersistenceUnit">
    <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
    <class>com.example.Address</class>
    <properties>
       <property name="javax.persistence.jdbc.url" value="jdbc:derby:myDB;create=true"/>
       <property name="javax.persistence.jdbc.user" value="user"/>
       <property name="javax.persistence.jdbc.password" value="password"/>
       <property name="javax.persistence.jdbc.driver" value="org.apache.derby.jdbc.EmbeddedDriver"/>
       <property name="hibernate.dialect" value="org.hibernate.dialect.DerbyDialect"/>
       <property name="hibernate.hbm2ddl.auto" value="update"/>
    </properties>
  </persistence-unit>
</persistence>
於 沒有留言:
Labels: , ,

a table summary of the javaserver faces 2.2 tag libraries defined in java ee 7

如 Java/Jarkarta EE 版本歷史所列，Java EE 7 標準發佈於 2013 年，伴隨的 JavaServer Faces 2.2 標準，已實作於 GlassFish 4.x 版本。其 .xhtml 網頁支援的標籤可參考 Oracle JavaEE 7 JSF 2.2 網站，共分成如下 6 種命名空間。

  • h: 為 JSF 超文字(html)標籤庫，提供標準 HTML 標籤的 JSF 版本，如 h:form、h:inputText 等，用於生成 HTML 表單元素。

  • f: 為 JSF 特殊功能(function)標籤庫，提供 JSF 的核心功能標籤，如 f:view、f:ajax、f:convertDateTime 等，用於處理事件、轉換器和 AJAX 功能。

  • ui: 為 JSF 配置用戶介面(user interface)標籤庫，提供模板和組合元件功能的標籤，如 ui:composition、ui:include、ui:repeat 等，用於定義和重複利用頁面結構。

  • c: 為 JSTL 核心(core)標籤庫，提供 JSTL的核心功能標籤，如 c:forEach、c:if、c:set 等，用於邏輯控制和迭代。

  • cc: 為 JSTL 組合元件(composite component)標籤庫，提供定義和使用組合元件的標籤，如 cc:interface、cc:implementation、cc:attribute 等，用於創建可重複利用的元件。

  • fn: 為 JSTL 函數(function)標籤庫，提供 JSTL 的函數標籤，如 fn:contains、fn:substring、fn:replace 等，用於字符串操作和其他常見功能。

其中，後面3種 JSTL (JavaServer Pages Standard Tag Library) 命名空間主要為了相容於早期發展的 JSP (JavaServer Pages) 網頁。以下針對 JSF (JavaServer Faces) 常見的前3種命名空間標籤，由 Miscosoft Copilot 摘要成表格如下。

h:命名空間標籤 描述
h:body 定義 HTML 文檔的主體。
h:button 渲染 HTML 按鈕。
h:column 定義數據表中的列。
h:commandButton 渲染可以提交表單的按鈕。
h:commandLink 渲染可以提交表單的鏈接。
h:dataTable 渲染數據表。
h:doctype 聲明文檔類型。
h:form 渲染 HTML 表單。
h:graphicImage 渲染圖像。
h:head 定義 HTML 文檔的頭部。
h:inputFile 渲染文件輸入字段。
h:inputHidden 渲染隱藏輸入字段。
h:inputSecret 渲染密碼輸入字段。
h:inputText 渲染文本輸入字段。
h:inputTextarea 渲染文本區輸入字段。
h:link 渲染超鏈接。
h:message 顯示單個驗證消息。
h:messages 顯示所有驗證消息。
h:outputFormat 渲染格式化文本。
h:outputLabel 為輸入字段渲染標籤。
h:outputLink 渲染超鏈接。
h:outputScript 渲染腳本。
h:outputStylesheet 渲染樣式表鏈接。
h:outputText 渲染文本。
h:panelGrid 渲染網格面板。
h:panelGroup 將組件分組在一起。
h:panelpassthrough.Element 渲染透傳元素。
h:selectBooleanCheckbox 渲染布爾值的複選框。
h:selectManyCheckbox 渲染多選複選框組。
h:selectManyListbox 渲染多選列表框。
h:selectManyMenu 渲染多選菜單。
h:selectOneListbox 渲染單選列表框。
h:selectOneMenu 渲染單選菜單。
h:selectOneRadio 渲染單選單選按鈕組。

f:命名空間標籤 描述
f:actionListener 為組件註冊一個動作監聽器。
f:ajax 為組件添加 Ajax 功能。
f:attribute 為組件添加一個屬性。
f:attributes 為組件添加多個屬性。
f:convertDateTime 將字符串轉換為日期/時間對象。
f:converter 為組件註冊一個轉換器。
f:convertNumber 將字符串轉換為數字。
f:event 為組件註冊一個事件監聽器。
f:facet 為組件聲明一個面。
f:loadBundle 加載資源包。
f:metadata 為視圖聲明元數據。
f:param 為組件添加一個參數。
f:passThroughAttribute 為組件添加一個透傳屬性。
f:passThroughAttributes 為組件添加多個透傳屬性。
f:phaseListener 為生命周期註冊一個階段監聽器。
f:resetValues 重置輸入組件的值。
f:selectItem 為選擇組件添加一個項目。
f:selectItems 為選擇組件添加多個項目。
f:setPropertyActionListener 當動作事件發生時設置屬性。
f:subview 在視圖中聲明一個子視圖。
f:validateBean 驗證一個 bean。
f:validateDoubleRange 驗證值是否在雙精度範圍內。
f:validateLength 驗證字符串的長度。
f:validateLongRange 驗證值是否在長整數範圍內。
f:validateRegex 根據正則表達式驗證字符串。
f:validateRequired 驗證值是否不為 null。
f:validator 為組件註冊一個驗證器。
f:valueChangeListener 為組件註冊一個值變更監聽器。
f:verbatim 渲染原始文本。
f:view 聲明一個視圖。
f:viewAction 聲明在視圖處理期間調用的動作。
f:viewParam 聲明一個視圖參數。

ui:命名空間標籤 描述
ui:component 定義可重用的組件，可以包含在其他頁面中。
ui:composition 定義頁面的模板，允許包含其他組件。
ui:debug 提供 JSF 頁面的調試信息。
ui:decorate 類似於 `ui:include`，但允許插入用戶定義的模板。
ui:define 定義模板的一部分，可以填充內容。
ui:fragment 定義頁面的一部分，可以包含在其他頁面中。
ui:include 包含另一個頁面或模板的內容。
ui:insert 將內容插入到模板的定義部分。
ui:param 將參數傳遞給包含的頁面或模板。
ui:remove 從渲染輸出中移除內容。
ui:repeat 對集合中的每個項目重複頁面的一部分。
於 沒有留言:
Labels: , ,

Version history of Java EE, JPA, Java DB, JavaFX, and JDK

下表為 Java 平台企業版 (EE, Enterprise Edition) 各種開發工具的版本歷史。資料來自網路，可看出從昇陽公司的 J2EE、甲骨文公司的 Java EE，到 Eclipse基金會的 Jakarta EE，EE 標準的主導權不斷異動。 如果有機會拿到依據各代 Java 平台 EE 標準開發的舊程式碼，建議查找下表找出最合適的相關開發工具，以免無法進行測試。

例如，拿到使用 JavaFX 視窗介面程式，若查出其適用版本為 JavaFX 11，可參考下表得知，其合適的開發工具版本為 JavaFX 11  + JDK 11，兩者皆屬 LTS 長期支援版本，較容易找到安裝檔。

Year EE Standard JPA Java DB JavaFX JDK
1999J2EE 1.2
2000
J2SE 1.3
2001J2EE 1.3
2002
J2SE 1.4
2003J2EE 1.4
2004

J2SE 5 (1.5)
2005Java DB 10.1
2006Java EE 5JPA 1.0Java DB 10.2J2SE 6 (1.6)
2007
2008Java DB 10.3, 10.4JavaFX 1.0.2
2009Java EE 6JPA 2.0Java DB 10.5JavaFX 1.1, 1.2
2010Java DB 10.6JavaFX 1.3
2011
JavaFX 2.0J2SE 7 (1.7)
2012JavaFX 2.2
2013Java EE 7JPA 2.1Java DB 10.10
2014Java DB 10.11JavaFX 8J2SE 8 (1.8), LTS
2015Java DB 10.12
2016Java DB 10.13
2017Java EE 8JPA 2.2
J2SE 9 (1.9)
2018Java DB 10.14JavaFX 11 (LTS)J2SE 10 (1.10), J2SE 11 (LTS)
2019
Java DB 10.15JavaFX 12, 13J2SE 12, 13
2020Jakarta EE 9

JavaFX 14, 15J2SE 14, 15
2021Jakarta EE 9.1JavaFX 16, 17 (LTS)J2SE 16, J2SE 17 (LTS)
2022Jakarta EE 10JPA 3.1Java DB 10.16JavaFX 18, 19J2SE 18, 19
2023Java DB 10.17JavaFX 20, 21 (LTS)J2SE 20, J2SE 21 (LTS)
2024Jakarta EE 11JavaFX 23J2SE 22, 23
2025JavaFX 24, 25J2SE 24, J2SE 25 (LTS)

以下表格摘要，由 NetBeans 測試，可和各版本 JavaFX (LTS) 相容的長期支援 JDK (LTS) 版本，供安裝參考。

Year JavaFX (LTS) Compatible JDK (LTS) Note
2018JavaFX 11 (LTS)J2SE 11, 17, 21JDK 8 不支援 JavaFX 11 模組功能
2021JavaFX 17 (LTS)J2SE 11, 17, 21
2023JavaFX 21 (LTS)J2SE 17, 21JDK 11 不支援 JavaFX 21 模組版本

註1: 網路參考來源: 以 Wikipedia 維基百科網站為主

  1. Jakarta EE
  2. JPA
  3. Apache Derby (Java DB)
  4. JavaFX
  5. Java版本歷史
於 沒有留言:
Labels: , , ,

how to set up the NetBeans environment for running Java EE 7 compilant JavaServer Faces with @ManagedBean annotation

若拿到使用 JavaServer Faces (JSF) 開發的套件，內含 @ManagedBean 註記，可依據附註的部落格，查出其合適的開發工具版本為 JSF 2.0 + GlassFish 3.x + JDK 6 + NetBeans 6.x 或 JSF 2.2 + GlassFish 4.x + JDK 7 + NetBeans 7.x。

若找不到JDK 6、JDK 7，支援 LTS (長期服務) 版本的 JDK 8 較好找，應該也可以。至於 NetBeans 版本似乎較不嚴苛，使用較新的 NetBeans 22 也是可以的，只是伺服器要安裝支援 Java EE 6 或 7 的 GlassFish 及 JDK 版本。其安裝步驟如下

1. 假設 NetBeans 要安裝 GlassFish 4.1.2 (內含符合Java EE 7 Web標準的JSF2.2) + JDK 8
      所須 JDK 8 如下:
        OpenJDK Zulu 8.0.442+6
        zulu8.84.0.15-ca-jdk8.0.442-win_x64.zip
        C:\Users\xx\Documents\NetBeansJDKs\zulu8.84.0.15-ca-jdk8.0.442-win_x64\

2. 開舊專案後，改伺服器選用 Java EE 7 Web 相容的 GlassFish 4.1.12
      Resolve Missing Server Problem
        Available Java EE 7 Web compatible servers:
          GlassFish Server 4
     【OK】

3. 啟動 GlassFish Server 4
      Window/Services/Servers: GlassFish Server 4
        GlassFish server couldn ot be started with JDK XX (Default).
        Please select another Java SE Platform.
        Java Platform: Zulu 8.0.442+6
     【OK】

     Windoww安全性警訊
       Windows Defender 允許 OpenJDK xxx 在這些網路上通訊:
       V 網域網路，例如工作場所網路
    【允許存取】

4. 安裝 GlassFish 4.1.2 步驟
    Tools/Servers:
       Add Server...
         Choose Server
           Server: GlassFish Server
           Name: GlassFish Server 4
       Next>
         Server Location
           Installation Location: C:\Users\xx\GlassFish_server4
           X Local Domain
           Choose server to download:
             GlassFish Server 4.1.2
             V I have read and accept the licence agreement...(click)
             Download Now... (104.2m)
       Next>
         Domain Location
           Domain: domain1
           Host: localhost, Vloopback
           DAS Port: 4848, HTTP Port: 8080, VDefault
           Target:
           User Name:
           Password:
      【Finish】
    

        Server Name: GlassFish Server 4
        Server Type: GlassFish Server 4.1.2
        Common:
          Installation Location: C:\Users\xx\GlassFish_server4\glassfish
          Domains Folder: C:\Users\xx\GlassFish_server4\glassfish\domains
          Host: localhost
          DAS Port: 484, HTTP Port:8080
          Domain: domain1
            Enable HTTP Monitor (維持不打勾)
          V Enable JDBC Driver Deployment
          V Preserve Sessions Across Redeployment
          V Start Registered Derby Server
      【Close】

5. 安裝  JDK 8 方法
    Tools/Java Platforms
      Add Platform...
        Select platform type
          Download OpenJDK (via Foojay.io Disco API)
        Connect to OpenJDK Discovery Service
          Quick:
            Version: 23,21,17,11,8
            Distribution: Microsoft or Zulu

附註: 有關於 Java 平台企業版各種開發工具的歷史相容關係，可參考如下說明:
    Blog: Version history of Java EE,  JSF, GlassFish, JDK, and NetBeans
於 沒有留言:
Labels: , , , , ,

Version history of Java EE, JSF, GlassFish, JDK, and NetBeans

下表為 Java 平台企業版 (EE, Enterprise Edition) 各種開發工具的版本歷史。資料來自網路，可看出從昇陽公司的 J2EE、甲骨文公司的 Java EE，到 Eclipse基金會的 Jakarta EE，EE 標準的主導權不斷異動。 如果有機會拿到依據各代 Java 平台 EE 標準開發的舊程式碼，建議查找下表找出最合適的相關開發工具，以免無法進行測試。

例如，若拿到使用 JavaServer Faces (JSF) 開發的套件，內含 @ManagedBean 註記，可先查出其適用版本為 Java EE 6 或 Java EE 7。接著，參考下表得知，其合適的開發工具版本為 JSF 2.0 + GlassFish 3.x + JDK 6 + NetBeans 6.x 或 JSF 2.2 + GlassFish 4.x + JDK 7 + NetBeans 7.x。

其中，Java 開發套件 (Java Development Kit)，簡稱 JDK，也歷經多代更迭。若找不到 JDK 6、JDK 7，支援 LTS (長期服務) 版本的 JDK 8 較好找，應該也可以。至於 NetBeans 版本的要求較不嚴苛，使用較新的 NetBeans 22 也是可以的，只是伺服器要安裝支援 Java EE 6 或 7 的 GlassFish 及 JDK 版本。

Year EE Standard JSF/Jakarta GlassFish JDK NetBeans
1999J2EE 1.2
2000J2SE 1.3
2001J2EE 1.3
2002J2SE 1.4
2003J2EE 1.4
2004JSF 1.0,1.1J2SE 5 (1.5)NetBeans 4.0
2005
2006Java EE 5JSF 1.2J2SE 6 (1.6)NetBeans 5.0
2007NetBeans 6.0
2008
2009Java EE 6JSF 2.0GlassFish 3.0
2010
2011J2SE 7 (1.7)NetBeans 7.0
2012
2013Java EE 7JSF 2.2GlassFish 4.0
2014J2SE 8 (1.8), LTSNetBeans 8.0
2015
2016
2017Java EE 8JSF 2.3J2SE 9 (1.9)
2018J2SE 10 (1.10), J2SE 11 (LTS)NetBeans 9.0, 10.0
2019Jakarta 2.3GlassFish 5.0J2SE 12, 13NetBeans 11.0
2020Jakarta EE 9Jakarta 3.0GlassFish 6.0J2SE 14, 15NetBeans 12.0
2021Jakarta EE 9.1J2SE 16, J2SE 17 (LTS)
2022Jakarta EE 10Jakarta 4.0GlassFish 7.0J2SE 18, 19NetBeans 13, 14, 15, 16
2023J2SE 20, J2SE 21 (LTS)NetBeans 17, 18, 19, 20
2024Jakarta EE 11J2SE 22, 23NetBeans 21, 22, 23, 24
2025J2SE 24, J2SE 25 (LTS)NetBeans 25, 26, 27, 28

以下表格摘要，由 NetBeans 測試，列出可和各版本 GlassFish 相容的長期支援 JDK (LTS) 版本，供安裝參考。

Year EE Standard JSF/Jakarta GlassFish Compatible JDK (LTS) Note
2009Java EE 6JSF 2.0GlassFish 3.0JDK 8
2013Java EE 7JSF 2.2GlassFish 4.0JDK 8支援 @ManagedBean 標註的最高版本組合
2019Java EE 8Jakarta 2.3GlassFish 5.0JDK 8@ManagedBean 廢止，改用環境及相依注入(CDI) 的 @Named 標註
2020Jakarta EE 9Jakarta 3.0GlassFish 6.0JDK 11, 17
2022Jakarta EE 10Jakarta 4.0GlassFish 7.0JDK 11, 17, 21

註1: Java EE 6,7 支援的 @ManagedBean 寫法，可參考如下要點，改成 Jakarta EE 支援的 @Named 註記。 


  // 原來 Java EE 6,7 寫法
  import javax.faces.bean.ManagedBean;

  @ManagedBean(name="webBean")
  public class MyWebBean
  
  // 改成 Jakarta EE 寫法

  import jakarta.inject.Named;
  import jakarta.enterprise.context.SessionScoped;
  import java.io.Serializable;

  @Named("webBean")
  @SessionScoped
  public class MyWebBean implements Serializable

註2: 網路參考來源: 以 Wikipedia 維基百科網站為主

  1. Jakarta EE
  2. JavaServer Faces
  3. GlassFish
  4. Java版本歷史
  5. NetBeans
  6. NetBeans Release Schedule
於 沒有留言:
Labels: , , , , ,

Diagnosing the Error: Module javafx.fxml not found 

在 NetBeans 使用 JavaFX 時，常遇到如下錯誤

  Error occurred during initialization of boot layer
  java.lang.module.FindException: Module javafx.fxml not found 

表示啟動層初始化時 Java 執行環境無法找到 javafx.fxml 模組。
這可能是由於 NetBeans 模組路徑的設定錯誤 或 根本未安裝模組所致。
以下為診斷和解決這個問題的步驟。

1.檢查 JavaFX SDK 安裝 及 NetBeans 設定正確否
   依據如下提示逐項檢查:
     how to set up NetBeans environment for JavaFX applications

2.打開 NetBeans 列印 Ant 腳本功能
   依據如下設定選項 
     Tools/Options/Java/Ant 或者 NetBeans/Settings...
        Ant Home: ...
        [v] Always Show Output

     Verbosity Level: Quiet/Normal/[Verbose]/Debug

    即可在執行 Run File 時，於 Output 視窗
    觀看Ant Target (build.xml) Output

3.檢查 NetBeans 執行 Ant run 腳本的參數填對否
   核對如下重要 java 執行參數
   run:
    Executing '/path/to/bin/java' with arguments:
    '-Dfile.encoding=UTF-8'
    
    '--add-modules'
    'javafx.controls,javafx.fxml,javafx.media'
    
    '-classpath'
    '/path/to/javafx-sdk-xx/lib/javafx-swt.jar:
     /path/to/javafx-sdk-xx/lib/javafx.base.jar:
     /path/to/javafx-sdk-xx/lib/javafx.controls.jar:
     /path/to/javafx-sdk-xx/lib/javafx.fxml.jar:
     /path/to/javafx-sdk-xx/lib/javafx.graphics.jar:
     /path/to/javafx-sdk-xx/lib/javafx.media.jar:
     /path/to/javafx-sdk-xx/lib/javafx.swing.jar:
     /path/to/javafx-sdk-xx/lib/javafx.web.jar:
     /path/to/MyProject/build/classes'
     
    '--module-path'
    '/path/to/MyProject/build/classes:
     /path/to/javafx-sdk-xx/lib/javafx-swt.jar:
     /path/to/javafx-sdk-xx/lib/javafx.base.jar:
     /path/to/javafx-sdk-xx/lib/javafx.controls.jar:
     /path/to/javafx-sdk-xx/lib/javafx.fxml.jar:
     /path/to/javafx-sdk-xx/lib/javafx.graphics.jar:
     /path/to/javafx-sdk-xx/lib/javafx.media.jar:
     /path/to/javafx-sdk-xx/lib/javafx.swing.jar:
     /path/to/javafx-sdk-xx/lib/javafx.web.jar'
     
    'MyJavaFXApp'

4.任何一處 Ant run 腳本的參數有缺，可對應到如下 NetBeans 設定有誤:
     Project Properties
       Libraries/
           Java Platform: JDK xx (Default)
           Compile/Compile-time Libraries:
               Classpath: JavaFX yy
           Run/Run-time Libraries:
               Modulepath: JavaFX yy

       Run/
           Configuration: <default config>
           VM Options:
               --add-modules javafx.controls,javafx.fxml,javafx.media
               
註1: 其實 Ant build 及 run 腳本的工作原理就是由 NetBeans 設定抽取相關參數，
    組合成如下命令列編譯及執行指令。故執行有問題可找回相關設定哪裏出問題。

    命令列編譯指令
    > javac -classpath "...\javafx-sdk-xx\lib\javafx.fxml.jar;...;." \
      MyJavaFXApp.java

    命令列執行指令
    > java --add-modules javafx.controls,javafx.fxml,javafx.media \
      -classpath . \
      --module-path "...\javafx-sdk-xx\lib\javafx.fxml.jar;..." \
      MyJavaFXApp

註2: NetBeans 執行 Ant run 腳本時，依序參考如下檔案
       MyProject/
         build.xml
         nbproject/
           build-impl.xml
           project.properties
     其中，project.properties有專案屬性如下，存放設定執行參數，亦可對照檢視設定錯誤原因。
       run.classpath=\
         ${javac.classpath}:\
         ${build.classes.dir}
       run.jvmargs=--add-modules javafx.controls,javafx.fxml,javafx.media
       run.modulepath=\
         ${javac.modulepath}:\
         ${libs.JavaFX_xx.classpath}
於 沒有留言:
Labels: , , , ,

Two ways to draw shapes in JavaFX 

 JavaFX 有 2 種畫形狀的寫法如下:

A. Pane容器放 Shape 形狀

import javafx.scene.layout.Pane;
import javafx.scene.paint.Color;
import javafx.scene.shape.Circle;
import javafx.scene.shape.Rectangle;

....

        Pane pane = new Pane();

        Circle circle = new Circle(50, 50, 30);
        circle.setFill(Color.BLUE);

        Rectangle rectangle = new Rectangle(100, 100, 80, 40);
        rectangle.setFill(Color.RED);

        pane.getChildren().addAll(circle, rectangle);

註1: Pane小孩清單會記住所有加入形狀元件，Pane大小調整後也會重新顯示所有形狀
註2: javafx.scene.shape支援形狀有
         Circle, Rectangle, Ellipse, Line, Polygon, Polyline, 
         Arc, CubicCurve, QuadCurve, Path 等

B. Canvas元件上畫出形狀

import javafx.scene.canvas.Canvas;
import javafx.scene.canvas.GraphicsContext;
import javafx.scene.paint.Color;

.....

        Canvas canvas = new Canvas(300, 200);
        GraphicsContext gc = canvas.getGraphicsContext2D();

        gc.setFill(Color.BLUE);
        gc.fillOval(50, 50, 60, 60); // Draw a circle

        gc.setFill(Color.RED);
        gc.fillRect(150, 100, 80, 40); // Draw a rectangle

        
註1: javafx.scene.canvas.GraphicsContext會暫時記住所有畫圖區內容，直到大小異動才清空
註2: javafx.scene.canvas.GraphicsContext支援形狀有

// 矩形
 fillRect(double x, double y, double w, double h) // 前景色填滿
 strokeRect(double x, double y, double w, double h) // 前景色畫框
 clearRect(double x, double y, double w, double h)  // 背景色填滿

// 圓形
 fillOval(double x, double y, double w, double h)
 strokeOval(double x, double y, double w, double h)

// 弧形
 fillArc(double x, double y, double w, double h, 
         double startAngle, double arcExtent, ArcType closure)
 strokeArc(double x, double y, double w, double h, 
           double startAngle, double arcExtent, ArcType closure)

// 多邊形,多邊線
 fillPolygon(double[] xPoints, double[] yPoints, int nPoints)
 strokePolygon(double[] xPoints, double[] yPoints, int nPoints)
 fillPolyline(double[] xPoints, double[] yPoints, int nPoints)
 strokePolyline(double[] xPoints, double[] yPoints, int nPoints)
 strokeLine(double x1, double y1, double x2, double y2)

// 路徑模式, 一次只能維護一條路徑
 beginPath()
 moveTo(double x, double y)
 lineTo(double x, double y)
 closePath()
 stroke()  // 畫路徑框
 fill() // 畫路徑內部
於 沒有留言:
Labels: , , ,
訂閱： 文章 (Atom)

how to install and use Jeddict AI Assistant on NetBeans IDE 23+

Jeddict AI Assistant  為適用於  NetBeans IDE 23 以上版本的插件，能夠連接大語言模型，協助編寫程式碼，大幅提升開發體驗，讓程式撰寫更輕鬆、更智慧。以下簡介其安裝方法及功能。 A.安裝與解除安裝 安裝步驟： ...

總網頁瀏覽量