{"id":50422476,"url":"https://github.com/upowerman/small-rpc","last_synced_at":"2026-05-31T09:02:05.939Z","repository":{"id":36694742,"uuid":"216314705","full_name":"upowerman/small-rpc","owner":"upowerman","description":"🔥基于netty和hessian的一个轻量级RPC调用框架","archived":false,"fork":false,"pushed_at":"2026-05-31T08:16:05.000Z","size":432,"stargazers_count":25,"open_issues_count":1,"forks_count":0,"subscribers_count":0,"default_branch":"master","last_synced_at":"2026-05-31T08:18:59.416Z","etag":null,"topics":["hessian","netty","rpc","spring-boot","springframework"],"latest_commit_sha":null,"homepage":"https://github.com/upowerman/small-rpc","language":"Java","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/upowerman.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2019-10-20T05:56:00.000Z","updated_at":"2026-05-31T08:16:09.000Z","dependencies_parsed_at":"2025-03-14T04:22:58.678Z","dependency_job_id":"539b4e7d-e015-4ff2-b67b-ff8b82d7342e","html_url":"https://github.com/upowerman/small-rpc","commit_stats":null,"previous_names":[],"tags_count":4,"template":false,"template_full_name":null,"purl":"pkg:github/upowerman/small-rpc","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/upowerman%2Fsmall-rpc","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/upowerman%2Fsmall-rpc/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/upowerman%2Fsmall-rpc/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/upowerman%2Fsmall-rpc/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/upowerman","download_url":"https://codeload.github.com/upowerman/small-rpc/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/upowerman%2Fsmall-rpc/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":33725060,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-05-31T02:00:06.040Z","response_time":95,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["hessian","netty","rpc","spring-boot","springframework"],"created_at":"2026-05-31T09:02:03.450Z","updated_at":"2026-05-31T09:02:05.928Z","avatar_url":"https://github.com/upowerman.png","language":"Java","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Small-RPC\n\n[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)\n[![Java](https://img.shields.io/badge/java-8+-green.svg)](https://www.oracle.com/java/)\n[![Netty](https://img.shields.io/badge/netty-4.1.108-orange.svg)](https://netty.io/)\n[![Spring](https://img.shields.io/badge/spring-5.3.39-brightgreen.svg)](https://spring.io/)\n\n## 描述\n\nSmall-RPC 是一款基于 Netty + Hessian 的精简版 RPC 框架，支持 Local / Redis / Zookeeper 注册中心，专为学习和理解 RPC 原理而设计。\n\n⚠️ **注意**: 该框架仅适合学习使用，未经生产环境验证。\n\n## 特性\n\n- 🚀 **高性能**: 基于 Netty NIO 框架\n- 🔄 **序列化**: 支持 Hessian 高效序列化\n- 🔧 **Spring 集成**: 完美集成 Spring 生态\n- 💡 **简单易用**: 注解驱动的开发方式\n- 🛡️ **资源管理**: 优化的线程池和连接管理\n- 📊 **监控友好**: 可观测的线程命名和错误处理\n\n## 最新优化 (v1.2.0)\n\n### 🔧 依赖更新\n- **Netty**: 4.1.39 → 4.1.108 (最新稳定版)\n- **Spring**: 4.3.24 → 5.3.39 (安全更新)\n- **Spring Boot**: 1.5.22 → 2.7.18 (LTS 版本)\n- **Maven 插件**: 更新至最新版本\n- **注册中心扩展**: 支持 Local / Redis / Zookeeper，并通过配置项统一切换\n\n### ⚡ 性能优化\n- **线程池增强**: 更好的命名和监控能力\n- **资源管理**: 优雅关闭和超时控制\n- **连接优化**: 更好的连接池管理和错误处理\n- **Netty 配置**: 优化的 socket 选项设置\n\n### 🛡️ 可靠性提升\n- **错误处理**: 全面的异常处理和恢复机制\n- **资源清理**: 自动资源清理和内存泄漏防护\n- **参数验证**: 严格的输入参数验证\n- **日志改进**: 更详细的调试信息\n\n## 架构简图\n\n```mermaid\nflowchart LR\n    subgraph Consumer[\"服务消费端（Consumer）\"]\n        C1[\"业务层\u003cbr/\u003eController / Service\"]\n        C2[\"@RpcReference 注入代理\u003cbr/\u003eRpcSpringInvokerFactory\"]\n        C3[\"调用代理\u003cbr/\u003eRpcReferenceInvocationHandler\"]\n        C4[\"服务发现与路由\u003cbr/\u003eBaseServiceRegistry + LoadBalance\"]\n        C5[\"网络客户端\u003cbr/\u003eNettyClient / NettyConnectClient\"]\n        C6[\"响应绑定\u003cbr/\u003eRpcFutureResponse + RpcInvokerFactory\"]\n        C1 --\u003e C2 --\u003e C3 --\u003e C4 --\u003e C5\n        C5 --\u003e C6\n    end\n\n    subgraph Registry[\"注册中心层（可插拔）\"]\n        R1[\"LocalServiceRegistry\"]\n        R2[\"RedisServiceRegistry\"]\n        R3[\"ZookeeperServiceRegistry\"]\n    end\n\n    subgraph Provider[\"服务提供端（Provider）\"]\n        P1[\"网络服务端\u003cbr/\u003eNettyServer / NettyServerHandler\"]\n        P2[\"服务调用核心\u003cbr/\u003eRpcProviderFactory#invokeService\"]\n        P3[\"@RpcService 服务实现 Bean\"]\n        P1 --\u003e P2 --\u003e P3\n    end\n\n    C4 -. discovery .-\u003e R1\n    C4 -. discovery .-\u003e R2\n    C4 -. discovery .-\u003e R3\n    P2 -. registry/remove .-\u003e R1\n    P2 -. registry/remove .-\u003e R2\n    P2 -. registry/remove .-\u003e R3\n\n    C5 -- \"RpcRequest（Netty + Hessian）\" --\u003e P1\n    P1 -- \"RpcResponse（按 requestId 回填）\" --\u003e C6\n```\n\n\u003e 说明：主调用链固定为 **Consumer 代理调用 → 注册中心发现地址 → Netty 发送请求 → Provider 反射执行 → 响应回填 future**，`local/redis/zookeeper` 仅影响“地址发现与注册”环节。\n\n## 工程结构\n\n```\nsmall-rpc\n├── small-rpc-core                           -- 核心模块\n├── small-rpc-simple                         -- Spring Boot 示例\n│   ├── small-rpc-sample-springboot-api      -- 接口 API JAR\n│   ├── small-rpc-sample-springboot-client   -- 调用方示例\n│   └── small-rpc-sample-springboot-server   -- 服务提供方示例\n```\n\n## 快速开始\n\n### 1. 构建项目\n\n```bash\nmvn clean package\n```\n\n### 2. 引入依赖\n\n```xml\n\u003cdependency\u003e\n    \u003cgroupId\u003eio.github.upowerman\u003c/groupId\u003e\n    \u003cartifactId\u003esmall-rpc-core\u003c/artifactId\u003e\n    \u003cversion\u003e1.0.0\u003c/version\u003e\n\u003c/dependency\u003e\n```\n\n### 3. 服务提供方配置\n\n示例工程 `small-rpc-sample-springboot-server` 已内置统一配置类 `RpcProviderConfig`，通过配置项自动选择注册中心：\n\n```properties\nsmall-rpc.registry.type=local      # local | redis | zookeeper\nsmall-rpc.provider.port=7080\n```\n\n### 4. 服务消费方配置\n\n示例工程 `small-rpc-sample-springboot-client` 已内置统一配置类 `RpcInvokerConfig`，同样通过配置项自动选择注册中心：\n\n```properties\nsmall-rpc.registry.type=local      # local | redis | zookeeper\nsmall-rpc.registry.address=localhost:7080   # 仅 local 模式需要\n```\n\n### 5. 服务实现\n\n服务类需要使用 `@RpcService` 注解（服务必须在 IoC 容器中）：\n\n```java\n@Service\n@RpcService\npublic class HelloServiceImpl implements HelloService {\n    @Override\n    public HelloDTO hello(String name) {\n        return new HelloDTO(\"Hello \" + name);\n    }\n}\n```\n\n### 6. 服务调用\n\n消费方使用 `@RpcReference` 注解进行服务引用：\n\n```java\n@RestController\n@RequestMapping(\"/\")\npublic class HelloController {\n\n    @RpcReference\n    private HelloService helloService;\n\n    @GetMapping(\"/hello\")\n    public HelloDTO hello(String name) {\n        return helloService.hello(name);\n    }\n}\n```\n\n## RPC 全流程详解（入门必读）\n\n这一节按“**服务启动** → **发起调用** → **服务执行** → **结果返回**”完整讲一次，建议结合 `small-rpc-core` 源码一起看。\n\n### 1. 启动阶段：Provider 和 Consumer 各做了什么\n\n#### 1.1 Provider 启动（服务端）\n\n1. Spring 启动时加载 `RpcProviderConfig`，创建 `RpcSpringProviderFactory`。  \n2. `RpcProviderConfig` 根据 `small-rpc.registry.type` 选择注册中心实现：  \n   - `LocalServiceRegistry`\n   - `RedisServiceRegistry`\n   - `ZookeeperServiceRegistry`\n3. `RpcSpringProviderFactory#setApplicationContext(...)` 扫描所有 `@RpcService` Bean。  \n4. 每个 `@RpcService` 对应服务会调用 `RpcProviderFactory#addService(iface, version, bean)`，形成 `serviceKey -\u003e serviceBean` 映射。  \n   - `serviceKey` 由 `RpcProviderFactory.makeServiceKey(iface, version)` 生成（格式：`接口全名#版本`）。  \n5. `RpcSpringProviderFactory#afterPropertiesSet()` 调用 `RpcProviderFactory#start()`：  \n   - 初始化 `NettyServer`  \n   - 设置 `onStart` 回调：服务端口绑定成功后，把已暴露服务注册到注册中心  \n   - 设置 `onStop` 回调：停止时从注册中心移除节点并关闭注册中心\n\n#### 1.2 Consumer 启动（调用端）\n\n1. Spring 启动时加载 `RpcInvokerConfig`，创建 `RpcSpringInvokerFactory`。  \n2. `RpcInvokerConfig` 同样根据 `small-rpc.registry.type` 选择注册中心实现并传参。  \n3. `RpcSpringInvokerFactory#afterPropertiesSet()` 内部创建 `RpcInvokerFactory` 并启动注册中心客户端。  \n4. `RpcSpringInvokerFactory#postProcessAfterInstantiation(...)` 扫描每个 Bean 的字段：  \n   - 找到 `@RpcReference` 字段后，构建 `RpcReferenceBean`  \n   - 调用 `RpcReferenceBean#getObject()` 生成 JDK 动态代理  \n   - 把代理对象注入原字段（业务代码拿到的是代理，不是真实实现类）\n\n---\n\n### 2. 一次 RPC 调用从请求到返回的完整链路\n\n假设业务代码执行：\n\n```java\nhelloService.hello(\"World\")\n```\n\n#### 2.1 Consumer 侧：组装请求 + 发包\n\n1. 进入 `RpcReferenceInvocationHandler#invoke(...)`。  \n2. 从 `RpcReferenceBean` 读取配置：`version`、`timeout`、`loadBalance`、`address`、`client`、`invokerFactory`。  \n3. 若注解未写死 `address`，则走注册中心发现：  \n   - 调用 `RpcProviderFactory.makeServiceKey(className, version)` 生成服务键  \n   - 调用 `BaseServiceRegistry#discovery(serviceKey)` 获取地址集合  \n   - 多地址时按 `LoadBalance`（ROUND/RANDOM）选择一个地址  \n4. 创建 `RpcRequest`：  \n   - `requestId`（UUID）  \n   - `createMillisTime`  \n   - `className / methodName / parameterTypes / parameters`  \n   - `version`\n5. 创建 `RpcFutureResponse` 并放入 `RpcInvokerFactory.futureResponsePool`（key=`requestId`）。  \n6. 调用 `NettyClient#asyncSend(address, request)`。  \n7. 底层 `ConnectClient.asyncSend(...)` 获取/创建 `NettyConnectClient` 连接并 `writeAndFlush` 发出请求。  \n8. 当前线程在 `RpcFutureResponse#get(timeout)` 阻塞等待响应。\n\n#### 2.2 Provider 侧：解码 + 执行 + 回包\n\n1. `NettyServer` pipeline 通过 `NettyDecoder` 把字节流反序列化为 `RpcRequest`。  \n2. `NettyServerHandler#channelRead0(...)` 收到请求后，丢到业务线程池执行。  \n3. 在线程池中调用 `RpcProviderFactory#invokeService(request)`：  \n   - 用 `className + version` 计算 `serviceKey`  \n   - 从 `serviceData` 找到目标服务 Bean  \n   - 通过反射 `method.invoke(serviceBean, parameters)` 执行真实业务方法  \n   - 把结果写入 `RpcResponse.result`，异常写入 `RpcResponse.errorMsg`\n4. `NettyServerHandler` 将 `RpcResponse` 回写到 Channel。\n\n#### 2.3 Consumer 侧：收包 + 唤醒等待线程\n\n1. `NettyClientHandler#channelRead0(...)` 收到 `RpcResponse`。  \n2. 调用 `RpcInvokerFactory#notifyInvokerFuture(requestId, response)`。  \n3. 找到对应 `RpcFutureResponse`，设置响应并 `notifyAll()`。  \n4. 业务线程从 `future.get(timeout)` 返回：  \n   - 若 `errorMsg != null`，抛 `RpcException`  \n   - 否则返回 `result` 给业务代码\n\n---\n\n### 3. 关键类职责对照表（先记这些就够用）\n\n| 类/组件 | 角色 | 关键职责 |\n|---|---|---|\n| `RpcProviderConfig` | Provider 配置入口 | 读取配置并装配 `RpcSpringProviderFactory`、注册中心类型和参数 |\n| `RpcInvokerConfig` | Consumer 配置入口 | 读取配置并装配 `RpcSpringInvokerFactory`、注册中心类型和参数 |\n| `RpcSpringProviderFactory` | Provider-Spring 桥接 | 扫描 `@RpcService`，收集服务并启动 `RpcProviderFactory` |\n| `RpcSpringInvokerFactory` | Consumer-Spring 桥接 | 扫描 `@RpcReference`，创建并注入动态代理 |\n| `RpcProviderFactory` | 服务端核心工厂 | 管理服务映射、注册/下线、反射调用 |\n| `RpcInvokerFactory` | 调用端核心工厂 | 管理注册中心客户端、维护 requestId→future 映射 |\n| `RpcReferenceInvocationHandler` | 动态代理调用入口 | 组装请求、服务发现、负载均衡、同步等待响应 |\n| `RpcFutureResponse` | 同步等待容器 | 把异步网络响应转换成同步 `get(timeout)` 语义 |\n| `NettyServer`/`NettyServerHandler` | 服务端网络层 | 接收请求、线程池执行、回写响应 |\n| `NettyClient`/`NettyConnectClient`/`NettyClientHandler` | 调用端网络层 | 建连复用、发送请求、接收响应并回填 future |\n| `BaseServiceRegistry` 及实现类 | 注册中心抽象层 | 提供 `registry/remove/discovery` 统一接口 |\n\n---\n\n### 4. 组件关系图（类协作）\n\n```mermaid\nclassDiagram\ndirection LR\n\nclass RpcProviderConfig\nclass RpcInvokerConfig\nclass RpcSpringProviderFactory\nclass RpcProviderFactory\nclass RpcSpringInvokerFactory\nclass RpcInvokerFactory\nclass RpcReferenceInvocationHandler\nclass RpcFutureResponse\nclass NettyServer\nclass NettyServerHandler\nclass NettyClient\nclass NettyConnectClient\nclass NettyClientHandler\nclass BaseServiceRegistry\nclass LocalServiceRegistry\nclass RedisServiceRegistry\nclass ZookeeperServiceRegistry\n\nRpcProviderConfig --\u003e RpcSpringProviderFactory\nRpcInvokerConfig --\u003e RpcSpringInvokerFactory\nRpcSpringProviderFactory --|\u003e RpcProviderFactory\nRpcSpringInvokerFactory --\u003e RpcInvokerFactory\nRpcReferenceInvocationHandler --\u003e RpcInvokerFactory\nRpcReferenceInvocationHandler --\u003e NettyClient\nRpcReferenceInvocationHandler --\u003e RpcFutureResponse\nNettyClient --\u003e NettyConnectClient\nNettyConnectClient --\u003e NettyClientHandler\nNettyServer --\u003e NettyServerHandler\nNettyServerHandler --\u003e RpcProviderFactory\nRpcProviderFactory --\u003e BaseServiceRegistry\nRpcInvokerFactory --\u003e BaseServiceRegistry\nBaseServiceRegistry \u003c|-- LocalServiceRegistry\nBaseServiceRegistry \u003c|-- RedisServiceRegistry\nBaseServiceRegistry \u003c|-- ZookeeperServiceRegistry\n```\n\n### 5. 请求时序图（调用链）\n\n```mermaid\nsequenceDiagram\nautonumber\nparticipant B as 业务代码(Controller/Service)\nparticipant P as JDK代理(RpcReferenceInvocationHandler)\nparticipant R as 注册中心(BaseServiceRegistry)\nparticipant C as NettyClient/ConnectClient\nparticipant S as NettyServerHandler\nparticipant F as RpcProviderFactory\nparticipant H as NettyClientHandler\nparticipant Future as RpcFutureResponse\n\nB-\u003e\u003eP: helloService.hello(\"World\")\nP-\u003e\u003eR: discovery(serviceKey)\nR--\u003e\u003eP: addressSet\nP-\u003e\u003eFuture: new RpcFutureResponse(requestId)\nP-\u003e\u003eC: asyncSend(address, RpcRequest)\nC-\u003e\u003eS: 发送 RpcRequest\nS-\u003e\u003eF: invokeService(request)\nF--\u003e\u003eS: RpcResponse(result/error)\nS--\u003e\u003eH: 回写 RpcResponse\nH-\u003e\u003eFuture: setResponse + notifyAll\nFuture--\u003e\u003eP: get(timeout) 返回\nP--\u003e\u003eB: 返回 result / 抛出 RpcException\n```\n\n### 6. 三种注册中心在链路中的差异\n\n三种模式的**调用主链路完全一致**，只在“服务地址来源”不同：\n\n- `local`：`LocalServiceRegistry` 直接返回配置里的 `small-rpc.registry.address`。  \n- `redis`：`RedisServiceRegistry` 从 Redis 集合读取健康实例并返回。  \n- `zookeeper`：`ZookeeperServiceRegistry` 从 ZK 节点读取实例地址并返回。  \n\n所以你可以把注册中心理解为“**地址簿插件**”，而不是调用流程本身。\n\n## 配置说明\n\n### 线程池配置\n\n```properties\n# 核心线程数\nsmall-rpc.provider.core-pool-size=10\n# 最大线程数  \nsmall-rpc.provider.max-pool-size=20\n# 服务端口\nsmall-rpc.provider.port=8080\n```\n\n### 注册中心配置\n\n```properties\n# 注册中心类型: local | redis | zookeeper\nsmall-rpc.registry.type=local\n# local 模式下直连地址(consumer)\nsmall-rpc.registry.address=localhost:8080\n```\n\n```properties\n# redis 模式\nsmall-rpc.registry.type=redis\nsmall-rpc.redis.host=localhost\nsmall-rpc.redis.port=6379\nsmall-rpc.redis.password=\nsmall-rpc.redis.database=0\nsmall-rpc.redis.timeout=2000\n```\n\n```properties\n# zookeeper 模式\nsmall-rpc.registry.type=zookeeper\nsmall-rpc.zookeeper.connect-string=localhost:2181\nsmall-rpc.zookeeper.namespace=small-rpc\nsmall-rpc.zookeeper.base-path=/services\nsmall-rpc.zookeeper.session-timeout=60000\nsmall-rpc.zookeeper.connection-timeout=15000\n```\n\n### Redis 模式运行\n\n1. 启动 Redis：\n```bash\ndocker run -d --name redis -p 6379:6379 redis:latest\n```\n\n2. 启动 provider：\n```bash\ncd small-rpc-simple/small-rpc-sample-springboot-server\nmvn spring-boot:run -Dspring-boot.run.arguments=\"--small-rpc.registry.type=redis\"\n```\n\n3. 启动 consumer：\n```bash\ncd small-rpc-simple/small-rpc-sample-springboot-client\nmvn spring-boot:run -Dspring-boot.run.arguments=\"--small-rpc.registry.type=redis\"\n```\n\n### Zookeeper 模式运行\n\n1. 启动 Zookeeper：\n```bash\ndocker run -d --name zookeeper -p 2181:2181 zookeeper:3.9\n```\n\n2. 启动 provider：\n```bash\ncd small-rpc-simple/small-rpc-sample-springboot-server\nmvn spring-boot:run -Dspring-boot.run.arguments=\"--small-rpc.registry.type=zookeeper\"\n```\n\n3. 启动 consumer：\n```bash\ncd small-rpc-simple/small-rpc-sample-springboot-client\nmvn spring-boot:run -Dspring-boot.run.arguments=\"--small-rpc.registry.type=zookeeper\"\n```\n\n## 运行示例\n\n1. 启动服务提供方：\n```bash\ncd small-rpc-simple/small-rpc-sample-springboot-server\nmvn spring-boot:run\n```\n\n2. 启动服务消费方：\n```bash\ncd small-rpc-simple/small-rpc-sample-springboot-client  \nmvn spring-boot:run\n```\n\n使用 Redis 或 Zookeeper 时，在配置文件中把 `small-rpc.registry.type` 改成 `redis` 或 `zookeeper`，或通过启动参数覆盖。\n\n3. 访问测试接口：\n```bash\ncurl http://localhost:8081/hello?name=World\n```\n\n## 版本历史\n\n### v1.2.0 (最新版本)\n- ✅ 新增 Zookeeper 注册中心实现\n- ✅ 注册中心统一改为配置驱动选择：`local | redis | zookeeper`\n- ✅ 示例工程配置简化为单入口（provider/client 统一配置方式）\n- ✅ 文档更新，补充多注册中心使用方式\n\n### v1.1.0\n- 🔧 依赖版本更新至稳定版本（Netty / Spring / Spring Boot）\n- ⚡ 线程池、连接管理、资源清理等性能优化\n- 🛡️ 参数校验与异常处理增强\n- 📊 日志与可观测性改进\n\n### v1.0.0\n- 基础 RPC 功能实现\n- Netty + Hessian 技术栈\n- Spring 集成支持\n\n## 参考资料\n\n1. [Netty 官方文档](https://netty.io/wiki/)\n2. [Spring Framework](https://spring.io/projects/spring-framework)\n3. [Hessian 序列化](http://hessian.caucho.com/)\n4. [参考项目 - Mango](https://github.com/TFdream/mango)\n5. [参考项目 - Dubbo](https://github.com/apache/dubbo)\n\n## 许可证\n\n本项目基于 [Apache License 2.0](LICENSE) 开源协议。\n\n## 贡献指南\n\n欢迎提交 Issue 和 Pull Request 来改进项目！\n\n1. Fork 项目\n2. 创建特性分支\n3. 提交变更\n4. 推送到分支\n5. 创建 Pull Request","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fupowerman%2Fsmall-rpc","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fupowerman%2Fsmall-rpc","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fupowerman%2Fsmall-rpc/lists"}