ROSIX Java Porting

ROSIX (Resource Operating System Interface) 的 Java 移植实现，将 C 接口翻译为符合 Java 习惯的现代化接口，为 UOS 人机物一体化操作系统提供 Java 编程体验

2025/8/11

ROSIX (Resource Operating System Interface) 的 Java 移植实现，将 C 接口翻译为符合 Java 习惯的现代化接口，为 UOS 人机物一体化操作系统提供 Java 编程体验。

🚀 项目概述

本项目将 ROSIX (Resource Operating System Interface) 从 C 语言移植到 Java，为 UOS 人机物一体化操作系统提供：

🔄 接口移植：将 C 接口翻译为符合 Java 习惯的现代化接口
🌐 统一资源抽象：为物理资源提供信息空间中的统一抽象
🔄 多范式编程：支持命令式、流式、规则式、编排式与 AI 驱动编程
⚡ Java 实现：完全用 Java 实现
🤖 AI 原生支持：内置智能体接口与意图驱动编程模型
🔧 异步操作：完整的异步编程支持
🛡️ 类型安全：强类型接口设计，避免运行时错误

🚀 快速开始

环境要求

Java: 17 或更高版本
Maven: 3.6 或更高版本
操作系统: Windows, macOS, Linux

安装依赖

<dependency>
    <groupId>com.uros</groupId>
    <artifactId>rosix-java-binding</artifactId>
    <version>1.0.0</version>
</dependency>

基本使用

import com.uros.rosix.ROSIXFactory;
import com.uros.rosix.core.ROSIX;
import com.uros.rosix.core.OpenMode;
import com.uros.rosix.core.ResourceHandle;

public class QuickStart {
    public static void main(String[] args) {
        // 创建 ROSIX 实例
        ROSIXFactory factory = ROSIXFactory.getDefault();
        ROSIX rosix = factory.createROSIX();
        
        try {
            // 打开传感器资源
            ResourceHandle sensor = rosix.open("sensor://temperature/room1", OpenMode.READ_ONLY);
            
            // 读取温度数据
            byte[] buffer = new byte[1024];
            int bytesRead = rosix.read(sensor, buffer);
            
            // 获取温度值
            String temperature = rosix.getAttribute(sensor, "temperature");
            System.out.println("当前温度: " + temperature + "°C");
            
            // 关闭资源
            rosix.close(sensor);
            
        } catch (Exception e) {
            System.err.println("操作失败: " + e.getMessage());
        }
    }
}

🏗️ 架构设计

设计原则

🔄 接口移植：将 C 接口翻译为符合 Java 习惯的接口
🎯 接口优先：先定义 Java 接口，再实现具体功能
🔒 类型安全：使用强类型接口，避免直接映射 C 结构体
⚡ 异步支持：提供完整的异步操作接口
🛡️ 异常处理：统一的异常处理机制
☕ Java 实现：完全用 Java 实现
🏭 工厂模式：使用工厂模式创建组件实例

架构图

┌─────────────────────────────────────────────────────────────┐
│                    ROSIX Java Porting                       │
├─────────────────────────────────────────────────────────────┤
│  Rule Engine     │  Workflow        │  AI Agent           │
│  ┌─────────────┐ │  ┌─────────────┐ │  ┌─────────────┐    │
│  │ RuleEngine  │ │  │WorkflowEng  │ │  │   AIAgent   │    │
│  │    Rule     │ │  │    Task     │ │  │ AgentConfig │    │
│  │ RuleContext │ │  │WorkflowCtx  │ │  │ AgentResult │    │
│  └─────────────┘ │  └─────────────┘ │  └─────────────┘    │
├─────────────────────────────────────────────────────────────┤
│  Core Interfaces  │  Resource Space  │  Stream Processing  │
│  ┌─────────────┐  │  ┌─────────────┐ │  ┌─────────────┐    │
│  │   ROSIX     │  │  │ResourceSpace│ │  │ ROSIXStream │    │
│  │ResourceHandle│  │  │SpatialCtx  │ │  │StreamProc   │    │
│  │  OpenMode   │  │  │TemporalCtx │ │  │StreamStats  │    │
│  └─────────────┘  │  │SemanticProf│ │  └─────────────┘    │
│                   │  └─────────────┘ │                     │
├─────────────────────────────────────────────────────────────┤
│                    Java Implementation                   │
│  ┌─────────────────────────────────────────────────────┐   │
│  │            Java Implementation Layer               │   │
│  │         (Java Native Implementation)              │   │
│  └─────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘

🧩 核心组件

1. ROSIX.Core - 资源访问与控制

提供类似 POSIX 的资源管理接口：

public interface ROSIX {
    // 资源操作
    ResourceHandle open(String uri, OpenMode mode) throws ROSIXException;
    void close(ResourceHandle handle) throws ROSIXException;
    int read(ResourceHandle handle, byte[] buffer) throws ROSIXException;
    int write(ResourceHandle handle, byte[] data) throws ROSIXException;
    
    // 属性管理
    String getAttribute(ResourceHandle handle, String key) throws ROSIXException;
    void setAttribute(ResourceHandle handle, String key, String value) throws ROSIXException;
    
    // 动作调用
    String invoke(ResourceHandle handle, String action, Map<String, Object> args) throws ROSIXException;
    
    // 事件订阅
    String subscribe(ResourceHandle handle, String event, EventCallback callback) throws ROSIXException;
    void unsubscribe(ResourceHandle handle, String subscriptionId) throws ROSIXException;
    
    // 异步操作
    CompletableFuture<ResourceHandle> openAsync(String uri, OpenMode mode);
    CompletableFuture<Integer> readAsync(ResourceHandle handle, byte[] buffer);
}

2. ResourceSpace - 资源语义管理

提供资源的时空语义和拓扑管理：

public interface ResourceSpace {
    // 资源解析
    ResourceRef resolve(String uri) throws ROSIXException;
    
    // 上下文更新
    void updateSpatialContext(ResourceHandle handle, SpatialContext ctx) throws ROSIXException;
    void updateTemporalContext(ResourceHandle handle, TemporalContext ctx) throws ROSIXException;
    void updateSemanticProfile(ResourceHandle handle, SemanticProfile profile) throws ROSIXException;
    
    // 空间查询
    List<ResourceRef> querySpatialRange(double x, double y, double z, double radius, int maxResults) throws ROSIXException;
    List<ResourceRef> queryByType(String type, int maxResults) throws ROSIXException;
    List<ResourceRef> queryByCapability(String capability, int maxResults) throws ROSIXException;
    
    // 拓扑查询
    List<ResourceRef> queryTopology(ResourceHandle handle, int maxNeighbors) throws ROSIXException;
    double calculateDistance(ResourceHandle handle1, ResourceHandle handle2) throws ROSIXException;
    boolean isAdjacent(ResourceHandle handle1, ResourceHandle handle2, double threshold) throws ROSIXException;
}

3. Stream - 流式处理

提供实时数据流处理能力：

public interface ROSIXStream {
    // 流控制
    void open(ResourceHandle source, StreamProcessor processor, Object context, int bufferSize, int maxRetries, int timeoutMs) throws ROSIXException;
    void start() throws ROSIXException;
    void stop() throws ROSIXException;
    void pause() throws ROSIXException;
    void resume() throws ROSIXException;
    
    // 流处理
    void addFilter(StreamProcessor filterFunction, Object filterContext) throws ROSIXException;
    void addTransform(StreamProcessor transformFunction, Object transformContext) throws ROSIXException;
    void setRateLimit(int maxRate) throws ROSIXException;
    
    // 统计信息
    StreamStats getStats() throws ROSIXException;
    boolean isActive() throws ROSIXException;
    int getBufferUsage() throws ROSIXException;
}

4. Rule - 规则引擎

提供基于规则的编程能力：

public interface RuleEngine {
    // 规则管理
    void defineRuleSet(String name, List<Rule> rules) throws ROSIXException;
    void enableRuleSet(String name) throws ROSIXException;
    void disableRuleSet(String name) throws ROSIXException;
    void deleteRuleSet(String name) throws ROSIXException;
    
    // 规则执行
    RuleResult executeRules(RuleContext context) throws ROSIXException;
    RuleResult executeSpecificRule(String ruleSetName, int ruleIndex, RuleContext context) throws ROSIXException;
    
    // 规则验证
    void validateCondition(String condition) throws ROSIXException;
    void validateAction(String action) throws ROSIXException;
    RuleResult testRule(Rule rule, String testData) throws ROSIXException;
}

5. Workflow - 工作流编排

提供复杂多资源协同能力：

public interface WorkflowEngine {
    // 工作流管理
    void createWorkflow(String name) throws ROSIXException;
    void addTask(String workflowName, Task task) throws ROSIXException;
    void removeTask(String workflowName, String taskName) throws ROSIXException;
    
    // 工作流执行
    void startWorkflow(String workflowName, WorkflowContext context) throws ROSIXException;
    void stopWorkflow(String executionId) throws ROSIXException;
    void pauseWorkflow(String executionId) throws ROSIXException;
    void resumeWorkflow(String executionId) throws ROSIXException;
    
    // 状态查询
    WorkflowContext getWorkflowStatus(String executionId) throws ROSIXException;
    WorkflowResult getWorkflowResult(String executionId) throws ROSIXException;
    List<String> listRunningWorkflows(int maxExecutions) throws ROSIXException;
}

6. AI - 智能体接口

提供意图驱动和语义理解能力：

public interface AIAgent {
    // 智能体管理
    void createAgent(AgentConfig config) throws ROSIXException;
    void deleteAgent(String agentId) throws ROSIXException;
    void updateAgent(String agentId, AgentConfig config) throws ROSIXException;
    
    // 智能体执行
    AgentResult invokeAgent(String agentId, AgentContext context) throws ROSIXException;
    AgentPlan createPlan(String agentId, String intent) throws ROSIXException;
    AgentResult executePlan(String planId) throws ROSIXException;
    
    // 资源绑定
    void bindAgentToResource(String agentId, ResourceHandle resourceHandle) throws ROSIXException;
    void unbindAgentFromResource(String agentId, ResourceHandle resourceHandle) throws ROSIXException;
    List<ResourceHandle> getBoundResources(String agentId, int maxResources) throws ROSIXException;
    
    // 通信和日志
    void sendMessage(String fromAgentId, String toAgentId, String message) throws ROSIXException;
    List<String> getMessages(String agentId, int maxMessages) throws ROSIXException;
    List<String> getLogs(String agentId, Instant startTime, Instant endTime, int maxLogs) throws ROSIXException;
}

💡 使用示例

传感器数据采集

public class SensorDataCollector {
    private final ROSIX rosix;
    private final ResourceSpace resourceSpace;
    
    public SensorDataCollector() {
        ROSIXFactory factory = ROSIXFactory.getDefault();
        this.rosix = factory.createROSIX();
        this.resourceSpace = factory.createResourceSpace();
    }
    
    public void collectTemperatureData() throws ROSIXException {
        // 打开温度传感器
        ResourceHandle sensor = rosix.open("sensor://temperature/room1", OpenMode.READ_ONLY);
        
        // 订阅温度更新事件
        String subscriptionId = rosix.subscribe(sensor, "update", (handle, eventType, eventData) -> {
            try {
                // 读取温度数据
                byte[] buffer = new byte[1024];
                int bytesRead = rosix.read(handle, buffer);
                
                // 解析温度值
                String temperature = rosix.getAttribute(handle, "temperature");
                System.out.println("温度更新: " + temperature + "°C");
                
                // 更新空间上下文
                SpatialContext spatialCtx = SpatialContext.builder()
                    .x(10.5).y(20.3).z(1.8)
                    .accuracy(0.1)
                    .coordinateSystem("WGS84")
                    .build();
                resourceSpace.updateSpatialContext(handle, spatialCtx);
                
            } catch (ROSIXException e) {
                System.err.println("处理温度数据失败: " + e.getMessage());
            }
        });
        
        // 保持运行
        try {
            Thread.sleep(60000); // 运行1分钟
        } finally {
            rosix.unsubscribe(sensor, subscriptionId);
            rosix.close(sensor);
        }
    }
}

智能家居控制

public class SmartHomeController {
    private final ROSIX rosix;
    private final RuleEngine ruleEngine;
    private final AIAgent aiAgent;
    
    public SmartHomeController() {
        ROSIXFactory factory = ROSIXFactory.getDefault();
        this.rosix = factory.createROSIX();
        this.ruleEngine = factory.createRuleEngine();
        this.aiAgent = factory.createAIAgent();
    }
    
    public void setupSmartHome() throws ROSIXException {
        // 创建智能体
        AgentConfig agentConfig = AgentConfig.builder()
            .modelUri("gpt-4")
            .capabilities("[\"light_control\", \"temperature_control\", \"security_monitoring\"]")
            .maxTokens(1000)
            .temperature(0.7)
            .build();
        aiAgent.createAgent(agentConfig);
        
        // 定义智能家居规则
        List<Rule> rules = Arrays.asList(
            Rule.builder()
                .condition("temperature > 25")
                .action("turn_on_air_conditioner")
                .priority(1)
                .description("温度过高时开启空调")
                .enabled(true)
                .build(),
            Rule.builder()
                .condition("motion_detected && time > '22:00'")
                .action("turn_on_security_light")
                .priority(2)
                .description("夜间检测到运动时开启安全灯")
                .enabled(true)
                .build()
        );
        
        ruleEngine.defineRuleSet("smart_home_rules", rules);
        ruleEngine.enableRuleSet("smart_home_rules");
        
        // 绑定智能体到资源
        ResourceHandle light = rosix.open("actuator://light/living_room", OpenMode.WRITE_ONLY);
        ResourceHandle ac = rosix.open("actuator://air_conditioner/living_room", OpenMode.WRITE_ONLY);
        
        aiAgent.bindAgentToResource("smart_home_agent", light);
        aiAgent.bindAgentToResource("smart_home_agent", ac);
    }
    
    public void processVoiceCommand(String command) throws ROSIXException {
        AgentContext context = AgentContext.builder()
            .sessionId("session_001")
            .userId("user_001")
            .intent(command)
            .context("smart_home_control")
            .timestamp(Instant.now())
            .build();
        
        AgentResult result = aiAgent.invokeAgent("smart_home_agent", context);
        System.out.println("智能体响应: " + result.getResponse());
        System.out.println("执行动作: " + result.getActionTaken());
    }
}

流式数据处理

public class DataStreamProcessor {
    private final ROSIXStream stream;
    
    public DataStreamProcessor() {
        ROSIXFactory factory = ROSIXFactory.getDefault();
        this.stream = factory.createStream();
    }
    
    public void processSensorData() throws ROSIXException {
        ResourceHandle sensor = rosix.open("sensor://multi_sensor/room1", OpenMode.READ_ONLY);
        
        // 配置流处理器
        stream.open(sensor, this::processData, null, 4096, 3, 5000);
        
        // 添加数据过滤器
        stream.addFilter(this::filterValidData, null);
        
        // 添加数据转换器
        stream.addTransform(this::transformData, null);
        
        // 设置速率限制
        stream.setRateLimit(100); // 每秒最多处理100条数据
        
        // 启动流处理
        stream.start();
        
        // 监控处理状态
        while (stream.isActive()) {
            StreamStats stats = stream.getStats();
            System.out.printf("已处理: %d 条消息, 错误: %d 次, 吞吐量: %.2f msg/s%n",
                stats.getMessagesProcessed(), stats.getErrors(), stats.getThroughput());
            
            Thread.sleep(1000);
        }
    }
    
    private void processData(byte[] data, Object context) {
        // 处理传感器数据
        System.out.println("处理数据: " + new String(data));
    }
    
    private void filterValidData(byte[] data, Object context) {
        // 过滤有效数据
        if (data.length > 0 && data[0] != 0) {
            // 数据有效，继续处理
        }
    }
    
    private void transformData(byte[] data, Object context) {
        // 转换数据格式
        // 例如：JSON 格式转换、数据标准化等
    }
}

📚 API 文档

核心接口

接口	描述	主要方法
`ROSIX`	核心资源管理接口	`open()`, `close()`, `read()`, `write()`, `invoke()`
`ResourceSpace`	资源空间管理接口	`resolve()`, `querySpatialRange()`, `queryByType()`
`ROSIXStream`	流式处理接口	`open()`, `start()`, `stop()`, `addFilter()`
`RuleEngine`	规则引擎接口	`defineRuleSet()`, `executeRules()`, `validateCondition()`
`WorkflowEngine`	工作流编排接口	`createWorkflow()`, `startWorkflow()`, `getStatus()`
`AIAgent`	AI 智能体接口	`createAgent()`, `invokeAgent()`, `createPlan()`

数据类

类	描述	主要属性
`ResourceHandle`	资源句柄	`uri`, `type`, `name`, `metadata`
`SpatialContext`	空间上下文	`x`, `y`, `z`, `orientation`, `accuracy`
`TemporalContext`	时间上下文	`timestamp`, `state`, `trend`, `confidence`
`SemanticProfile`	语义配置	`type`, `capabilities`, `ontologyUri`, `version`
`AgentConfig`	智能体配置	`modelUri`, `capabilities`, `maxTokens`, `temperature`
`Rule`	规则定义	`condition`, `action`, `priority`, `enabled`

异常处理

public class ROSIXException extends Exception {
    private final ROSIXErrorCode errorCode;
    
    public enum ROSIXErrorCode {
        SUCCESS(0, "操作成功"),
        ERROR(-1, "一般错误"),
        INVALID_HANDLE(-2, "无效句柄"),
        PERMISSION_DENIED(-3, "权限拒绝"),
        NOT_FOUND(-4, "资源未找到"),
        ALREADY_EXISTS(-5, "资源已存在"),
        TIMEOUT(-6, "操作超时"),
        INVALID_PARAM(-7, "无效参数"),
        OUT_OF_MEMORY(-8, "内存不足"),
        NOT_SUPPORTED(-9, "不支持的操作");
    }
}

🔧 构建和部署

Maven 构建

# 编译项目
mvn clean compile

# 运行测试
mvn test

# 打包
mvn clean package

# 安装到本地仓库
mvn clean install

# 运行示例
mvn exec:java -Dexec.mainClass="com.uros.rosix.example.ROSIXExample"

Gradle 构建

plugins {
    id 'java'
    id 'application'
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'com.uros:rosix-java-binding:1.0.0'
    implementation 'net.java.dev.jna:jna:5.13.0'
    implementation 'com.fasterxml.jackson.core:jackson-databind:2.15.3'
}

java {
    sourceCompatibility = JavaVersion.VERSION_17
    targetCompatibility = JavaVersion.VERSION_17
}

Docker 部署

FROM openjdk:17-jdk-slim

WORKDIR /app

# 复制 JAR 文件
COPY target/rosix-java-binding-1.0.0.jar app.jar

# 复制本地库文件
COPY libs/ /usr/local/lib/

# 设置环境变量
ENV LD_LIBRARY_PATH=/usr/local/lib

# 运行应用
CMD ["java", "-jar", "app.jar"]

🛠️ 开发指南

项目结构

rosix-java-binding/
├── src/main/java/com/uros/rosix/
│   ├── core/                    # 核心接口
│   │   ├── ROSIX.java          # 主要 ROSIX 接口
│   │   ├── ResourceHandle.java # 资源句柄
│   │   ├── OpenMode.java       # 访问模式枚举
│   │   ├── EventCallback.java  # 事件回调接口
│   │   └── ROSIXException.java # 异常类
│   ├── resource/               # 资源空间接口
│   │   ├── ResourceSpace.java  # 资源空间接口
│   │   ├── SpatialContext.java # 空间上下文
│   │   ├── TemporalContext.java# 时间上下文
│   │   ├── SemanticProfile.java# 语义配置
│   │   └── ResourceRef.java    # 资源引用
│   ├── stream/                 # 流式处理接口
│   │   ├── ROSIXStream.java    # 流处理器接口
│   │   ├── StreamProcessor.java# 流处理器
│   │   └── StreamStats.java    # 流统计信息
│   ├── rule/                   # 规则引擎接口
│   │   ├── RuleEngine.java     # 规则引擎接口
│   │   ├── Rule.java           # 规则定义
│   │   ├── RuleContext.java    # 规则上下文
│   │   ├── RuleResult.java     # 规则结果
│   │   └── RuleStats.java      # 规则统计
│   ├── workflow/               # 工作流接口
│   │   ├── WorkflowEngine.java # 工作流引擎接口
│   │   ├── Task.java           # 任务定义
│   │   ├── WorkflowContext.java# 工作流上下文
│   │   ├── TaskResult.java     # 任务结果
│   │   └── WorkflowResult.java # 工作流结果
│   ├── ai/                     # AI 智能体接口
│   │   ├── AIAgent.java        # AI 智能体接口
│   │   ├── AgentConfig.java    # 智能体配置
│   │   ├── AgentContext.java   # 智能体上下文
│   │   ├── AgentResult.java    # 智能体结果
│   │   ├── AgentPlan.java      # 智能体计划
│   │   ├── PlanStep.java       # 计划步骤
│   │   └── AgentMetrics.java   # 智能体指标
│   ├── impl/                   # 实现类
│   │   ├── DefaultROSIXImpl.java   # 默认核心实现
│   │   ├── DefaultResourceHandle.java# 默认资源句柄实现
│   │   ├── DefaultResourceSpaceImpl.java# 默认资源空间实现
│   │   ├── DefaultStreamImpl.java  # 默认流处理实现
│   │   ├── DefaultRuleEngineImpl.java# 默认规则引擎实现
│   │   ├── DefaultWorkflowEngineImpl.java# 默认工作流实现
│   │   └── DefaultAIAgentImpl.java # 默认 AI 智能体实现
│   ├── example/                # 示例代码
│   │   └── ROSIXExample.java   # 使用示例
│   ├── ROSIXFactory.java       # 工厂接口
│   └── DefaultROSIXFactory.java# 默认工厂实现
├── src/test/java/              # 测试代码
├── src/main/resources/         # 资源文件
├── target/                     # 构建输出目录
├── pom.xml                     # Maven 配置
├── README.md                   # 项目文档
└── .gitignore                  # Git 忽略文件

开发环境设置

克隆项目

git clone https://github.com/uos-projects/rosix-java-binding.git
cd rosix-java-binding

初始化子模块
```
git submodule update --init --recursive
```
安装依赖
```
mvn clean install
```
运行测试
```
mvn test
```

代码规范

命名规范：遵循 Java 标准命名规范
注释规范：使用 JavaDoc 格式
异常处理：统一使用 ROSIXException
日志记录：使用 SLF4J 进行日志记录
单元测试：每个公共方法都要有对应的单元测试

性能优化

性能优化：优化 Java 代码性能，减少对象创建
内存管理：及时释放资源，避免内存泄漏
异步处理：使用异步接口提高并发性能
缓存机制：对频繁访问的数据进行缓存

📊 开发状态

✅ 已完成功能

⏳ 待实现功能

🚧 已知问题

实现完整性：大部分功能目前抛出 NOT_SUPPORTED 异常
异常处理：需要更详细的错误信息和异常处理
性能考虑：需要优化代码性能
线程安全：当前实现不是线程安全的
内存管理：需要手动管理资源生命周期

🤝 贡献指南

我们欢迎所有形式的贡献！请遵循以下步骤：

贡献流程

Fork 项目

# 在 GitHub 上 Fork 项目
# 然后克隆你的 Fork
git clone https://github.com/your-username/rosix-java-binding.git
cd rosix-java-binding

创建功能分支

git checkout -b feature/your-feature-name

提交更改

git add .
git commit -m "Add your feature description"

推送分支

git push origin feature/your-feature-name

创建 Pull Request
- 在 GitHub 上创建 Pull Request
- 详细描述你的更改
- 确保所有测试通过

贡献类型

🐛 Bug 修复：修复现有功能的问题
✨ 新功能：添加新的功能或接口
📚 文档：改进文档和示例
🧪 测试：添加或改进测试
⚡ 性能：性能优化和改进
🔧 工具：开发工具和脚本

代码审查

所有提交都需要经过代码审查：

代码质量：遵循项目代码规范
测试覆盖：确保新代码有对应的测试
文档更新：更新相关文档
向后兼容：确保不破坏现有 API

📄 许可证

本项目采用 MIT 许可证。详见 LICENSE 文件。

MIT License

Copyright (c) 2024 UOS Projects

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

🔗 相关链接

🏠 项目主页：https://github.com/uos-projects/rosix-java
📖 ROSIX 白皮书：https://github.com/uos-projects/uos-rosix
🌐 UOS 项目：https://github.com/uos-projects
☕ Java 文档：https://docs.oracle.com/en/java/
📚 Java 文档：https://docs.oracle.com/en/java/
🏗️ Maven 文档：https://maven.apache.org/

📞 联系我们

📧 邮箱：contact@uos-projects.org
💬 讨论：GitHub Discussions
🐛 问题报告：GitHub Issues
💡 功能请求：GitHub Issues

🌟 如果这个项目对您有帮助，请给我们一个 Star！

Made with ❤️ by UOS Projects