feat(generic): add generic call sample for both Dubbo and Triple protocols

This PR refactors and enhances the generic call sample to demonstrate
both Dubbo protocol and Triple protocol generic calls between Go and Java.

## Changes Overview

### 1. Dual Protocol Support
| Protocol | Port  | Group    | Description                      |
|----------|-------|----------|----------------------------------|
| Dubbo    | 20000 | `dubbo`  | Traditional Dubbo binary protocol|
| Triple   | 50052 | `triple` | HTTP/2 based Triple protocol     |

### 2. Direct Connection Mode
- Removed ZooKeeper dependency in favor of direct URL connection
- Simplifies local testing and CI/CD pipelines
- No external dependencies required to run the sample

### 3. Project Structure Simplification
- Removed redundant nested directories (java-server/java-server → java-server)
- Added run.sh scripts for easy execution

### 4. Comprehensive Test Suite
Added client_test.go with test cases covering:
- Dubbo Protocol Tests (6 cases)
- Triple Protocol Tests (13 cases)
- Benchmarks for both protocols

### 5. Code Improvements
- Go server uses direct connection mode (no registry)
- user_provider.go Invoke method returns proper error for unknown methods
- Fixed QueryUsers parameter type to match Java array signature

## Dependencies
This PR depends on apache/dubbo-go#3154 which adds `NewGenericService` API.
CI will pass after that PR is merged to main branch.

Signed-off-by: TsukiKage <chongyanx@163.com>

Author: Tsukikage7

generic/README.md

@@ -1,88 +1,97 @@
-# Generic Call
+# Generic Sample (Triple Generic Call)
 
-Generic call is a mechanism that ensures information is correctly transmitted when the client does not have interface information. It generalizes POJOs into generic formats (such as dictionaries, strings), and is generally used in scenarios like integration testing and gateways.
+[English](README.md) | [中文](README_zh.md)
 
-This example demonstrates generic calls between Dubbo-Go and Dubbo Java services, showing how services can interoperate regardless of the language they're implemented in.
+This sample demonstrates how to use generic invocation with the Triple protocol for Go-Java interoperability. Generic invocation allows calling remote services without generating stubs or having the service interface locally.
 
-## Directory Structure
+## Layout
 
-- go-server: Dubbo-Go server example
-- go-client: Dubbo-Go client example with generic calls
-- java-client: Dubbo Java client example
-- java-server: Dubbo Java server example
-- build: For integration test
-
-Dubbo Java examples can be used to test interoperability with Dubbo-Go. You can start java server with go client, or go server with java client for testing.
+```
+generic/
+├── go-server/      # Go provider listening on :50052
+├── go-client/      # Go consumer with generic invocation
+├── java-server/    # Java provider listening on :50052
+└── java-client/    # Java consumer with generic invocation
+```
 
 ## Prerequisites
 
-- Docker and Docker Compose for running ZooKeeper registry
-- Go 1.23+ for Dubbo-Go examples
-- Java 8+ and Maven for Dubbo Java examples
+Start ZooKeeper:
 
-## Registry
+```bash
+docker run -d --name zookeeper -p 2181:2181 zookeeper:3.8
+```
 
-This example uses ZooKeeper as the registry. The following command starts ZooKeeper from docker, so you need to ensure that docker and docker-compose are installed first.
+## Run the Go Server
 
-```shell
-# Start ZooKeeper registry
-docker run -d --name zookeeper -p 2181:2181 zookeeper:3.4.14
+```bash
+cd generic/go-server/cmd
+go run .
 ```
 
-## Running the Examples
+The server listens on port `50052` and registers to ZooKeeper.
 
-### Dubbo-Go Server
+## Run the Go Client
 
-Using Dubbo-Go as provider, you can start it from command line tool:
-
-```shell
-cd go-server/cmd && go run server.go
+```bash
+cd generic/go-client/cmd
+go run .
 ```
 
-### Dubbo-Go Client (Generic Call)
+The client discovers the service via ZooKeeper and uses `client.WithGenericType("true")` to perform generic calls.
 
-Using Dubbo-Go as consumer with generic calls:
+## Run the Java Server
 
-```shell
-cd go-client/cmd && go run client.go
-```
+Build and run from the java-server directory:
 
-### Dubbo Java Server
+```bash
+cd generic/java-server
+mvn clean compile exec:java -Dexec.mainClass="org.apache.dubbo.samples.ApiProvider"
+```
 
-Using Dubbo Java as provider:
+## Run the Java Client
 
-```shell
-cd java-server/java-server
-mvn clean package
-sh run.sh
+```bash
+cd generic/java-client
+mvn clean compile exec:java -Dexec.mainClass="org.apache.dubbo.samples.ApiTripleConsumer"
 ```
 
-### Dubbo Java Client
+The client uses `reference.setGeneric("true")` to perform generic calls.
+
+## Tested Methods
 
-Using Dubbo Java as consumer:
+| Method | Parameters | Return |
+|--------|------------|--------|
+| GetUser1 | String | User |
+| GetUser2 | String, String | User |
+| GetUser3 | int | User |
+| GetUser4 | int, String | User |
+| GetOneUser | - | User |
+| GetUsers | String[] | User[] |
+| GetUsersMap | String[] | Map<String, User> |
+| QueryUser | User | User |
+| QueryUsers | User[] | User[] |
+| QueryAll | - | Map<String, User> |
+
+## Expected Output
+
+Server log:
+
+```
+Generic Go/Java server started on port 50052
+Registry: zookeeper://127.0.0.1:2181
+```
+
+Client log:
 
-```shell
-cd java-client/java-client
-mvn clean package
-sh run.sh
 ```
+[PASS] GetUser1(String): {id=A003, name=Joe, age=48, ...}
+[PASS] GetUser2(String, String): {id=A003, name=lily, age=48, ...}
+...
+[OK] All tests passed!
+```
+
+## Notes
 
-## Testing Interoperability
-
-This example is designed to test interoperability between Dubbo-Go and Dubbo Java:
-
-1. Start the ZooKeeper registry
-2. Start either go-server or java-server
-3. Run either go-client or java-client to test the generic calls
-
-The client will make various generic calls to the server, including:
-- GetUser1(String userId)
-- GetUser2(String userId, String name)
-- GetUser3(int userCode)
-- GetUser4(int userCode, String name)
-- GetOneUser()
-- GetUsers(String[] userIdList)
-- GetUsersMap(String[] userIdList)
-- QueryUser(User user)
-- QueryUsers(List<User> userObjectList)
-- QueryAll()
+- Do NOT start Go Server and Java Server at the same time. Both listen on port 50052.
+- Make sure ZooKeeper is running before starting the server or client.

generic/README_zh.md

@@ -1,88 +1,97 @@
-# 泛化调用
+# 泛化调用示例 (Triple 协议)
 
-泛化调用是在客户端没有接口信息时保证信息被正确传递的手段，即把 POJO 泛化为通用格式（如字典、字符串），一般被用于集成测试、网关等场景。
+[English](README.md) | [中文](README_zh.md)
 
-本示例演示了 Dubbo-Go 和 Dubbo Java 服务之间的泛化调用，展示了不同语言实现的服务如何互操作。
+本示例演示了如何使用 Triple 协议进行泛化调用，实现 Go 和 Java 服务之间的互操作。泛化调用允许在没有服务接口定义的情况下调用远程服务。
 
 ## 目录结构
 
-- go-server: Dubbo-Go 服务端示例
-- go-client: Dubbo-Go 客户端示例（泛化调用）
-- java-client: Dubbo Java 客户端示例
-- java-server: Dubbo Java 服务端示例
-- build: 集成测试需要的脚本
+```
+generic/
+├── go-server/      # Go 服务端，监听 :50052
+├── go-client/      # Go 客户端，泛化调用
+├── java-server/    # Java 服务端，监听 :50052
+└── java-client/    # Java 客户端，泛化调用
+```
 
-Dubbo Java 示例可以用来测试与 Dubbo-Go 的互操作性。您可以启动 java 服务端配合 go 客户端，或者启动 go 服务端配合 java 客户端进行测试。
+## 前置条件
 
-## 环境准备
+启动 ZooKeeper：
 
-- Docker 和 Docker Compose 用于运行 ZooKeeper 注册中心
-- Go 1.23+ 用于 Dubbo-Go 示例
-- Java 8+ 和 Maven 用于 Dubbo Java 示例
+```bash
+docker run -d --name zookeeper -p 2181:2181 zookeeper:3.8
+```
 
-## 注册中心
+## 启动 Go 服务端
 
-本示例使用 ZooKeeper 作为注册中心。以下命令通过 docker 启动 ZooKeeper，因此需要确保已安装 docker 和 docker-compose。
+```bash
+cd generic/go-server/cmd
+go run .
+```
 
-```shell
-# 启动 ZooKeeper 注册中心
-docker run -d --name zookeeper -p 2181:2181 zookeeper:3.4.14
+服务端监听 `50052` 端口，并注册到 ZooKeeper。
+
+## 启动 Go 客户端
+
+```bash
+cd generic/go-client/cmd
+go run .
 ```
 
-## 运行示例
+客户端通过 ZooKeeper 发现服务，使用 `client.WithGenericType("true")` 进行泛化调用。
 
-### Dubbo-Go 服务端
+## 启动 Java 服务端
 
-使用 Dubbo-Go 作为服务提供者，可以通过命令行工具启动：
+在 java-server 目录下构建并运行：
 
-```shell
-cd go-server/cmd && go run server.go
+```bash
+cd generic/java-server
+mvn clean compile exec:java -Dexec.mainClass="org.apache.dubbo.samples.ApiProvider"
 ```
 
-### Dubbo-Go 客户端（泛化调用）
-
-使用 Dubbo-Go 作为服务消费者进行泛化调用：
+## 启动 Java 客户端
 
-```shell
-cd go-client/cmd && go run client.go
+```bash
+cd generic/java-client
+mvn clean compile exec:java -Dexec.mainClass="org.apache.dubbo.samples.ApiTripleConsumer"
 ```
 
-### Dubbo Java 服务端
+客户端使用 `reference.setGeneric("true")` 进行泛化调用。
 
-使用 Dubbo Java 作为服务提供者：
+## 测试方法
 
-```shell
-cd java-server/java-server
-mvn clean package
-sh run.sh
-```
+| 方法 | 参数 | 返回值 |
+|------|------|--------|
+| GetUser1 | String | User |
+| GetUser2 | String, String | User |
+| GetUser3 | int | User |
+| GetUser4 | int, String | User |
+| GetOneUser | - | User |
+| GetUsers | String[] | User[] |
+| GetUsersMap | String[] | Map<String, User> |
+| QueryUser | User | User |
+| QueryUsers | User[] | User[] |
+| QueryAll | - | Map<String, User> |
 
-### Dubbo Java 客户端
+## 预期输出
 
-使用 Dubbo Java 作为服务消费者：
+服务端日志：
 
-```shell
-cd java-client/java-client
-mvn clean package
-sh run.sh
 ```
+Generic Go/Java server started on port 50052
+Registry: zookeeper://127.0.0.1:2181
+```
+
+客户端日志：
+
+```
+[PASS] GetUser1(String): {id=A003, name=Joe, age=48, ...}
+[PASS] GetUser2(String, String): {id=A003, name=lily, age=48, ...}
+...
+[OK] All tests passed!
+```
+
+## 注意事项
 
-## 测试互操作性
-
-本示例旨在测试 Dubbo-Go 和 Dubbo Java 之间的互操作性：
-
-1. 启动 ZooKeeper 注册中心
-2. 启动 go-server 或 java-server 之一
-3. 运行 go-client 或 java-client 之一来测试泛化调用
-
-客户端将向服务端发起多种泛化调用，包括：
-- GetUser1(String userId)
-- GetUser2(String userId, String name)
-- GetUser3(int userCode)
-- GetUser4(int userCode, String name)
-- GetOneUser()
-- GetUsers(String[] userIdList)
-- GetUsersMap(String[] userIdList)
-- QueryUser(User user)
-- QueryUsers(List<User> userObjectList)
-- QueryAll()
+- 不要同时启动 Go 服务端和 Java 服务端，它们都监听 50052 端口。
+- 启动服务端或客户端之前，请确保 ZooKeeper 正在运行。