# ScienceSmartJava
**Repository Path**: GengPu/science-smart-java
## Basic Information
- **Project Name**: ScienceSmartJava
- **Description**: 基础仓库，用来添加一些常用的工具包（以其他 commons-lang guava hutool 没有的为主）
- **Primary Language**: Java
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No
## Statistics
- **Stars**: 0
- **Forks**: 0
- **Created**: 2026-03-22
- **Last Updated**: 2026-03-22
## Categories & Tags
**Categories**: Uncategorized
**Tags**: None
## README
# ScienceSmartJava Framework
A smart Java framework with compile-time code generation and runtime utilities, designed for JDK 17+.
---
## 目录 | Table of Contents
- [功能特性 | Features](#功能特性-features)
- [项目结构 | Project Structure](#项目结构-project-structure)
- [快速开始 | Quick Start](#快速开始-quick-start)
- [核心注解 | Core Annotations](#核心注解-core-annotations)
- [DAG 任务流 | DAG Task Flow](#dag-任务流-dag-task-flow)
- [工具类 | Utility Classes](#工具类-utility-classes)
- [构建项目 | Building](#构建项目-building)
- [许可证 | License](#许可证-license)
---
## 功能特性 | Features
- **编译期代码生成**: 使用 ByteBuddy 在编译期生成辅助类
- **运行时工具类**: 提供便捷的工具类用于常用操作
- **AspectJ 集成**: 支持方法级别的日志、异步执行和异常处理
- **DAG 任务流引擎**: 支持有向无环图（DAG）任务编排与执行
- **JDK 17+ 兼容**: 完全兼容 JDK 17 及更高版本
---
## 项目结构 | Project Structure
```
science-smart-java (Parent POM)
├── science-smart-java-annotations # 注解定义 | Annotation definitions
├── science-smart-java-annotations-processor # 注解处理器 | Annotation processor
├── science-smart-java-runtime # 运行时工具和切面 | Runtime utilities and aspects
├── science-smart-java-maven-plugin # Maven 编译时插件 | Maven compile-time plugin
├── science-smart-java-gradle-plugin # Gradle 插件 | Gradle plugin
├── science-smart-java-demo # 示例模块 | Demo module
└── pom.xml
```
---
## 快速开始 | Quick Start
### Maven 配置 | Maven Configuration
Add the following to your `pom.xml`:
```xml
top.softwarescience
science-smart-java-annotations
1.0.0
top.softwarescience
science-smart-java-runtime
1.0.0
top.softwarescience
science-smart-java-maven-plugin
1.0.0
process-classes
enhance
```
### Gradle 配置 | Gradle Configuration
Add the following to your `build.gradle`:
```groovy
plugins {
id 'top.softwarescience.science-smart-java' version '1.0.0'
}
dependencies {
implementation 'top.softwarescience:science-smart-java-annotations:1.0.0'
implementation 'top.softwarescience:science-smart-java-runtime:1.0.0'
}
scienceSmartJava {
enabled = true
verbose = true
}
```
---
## 核心注解 | Core Annotations
### 属性注解 | Property Annotations
#### @UniqueId
标记字段为对象的唯一标识符，用于对象比较和哈希计算。
Marks a field as the unique identifier for the object.
```java
public class User {
@UniqueId
private String id;
private String name;
}
```
#### @Dict
标记字段用于字典翻译，支持状态码到文本的转换。
Marks a field for dictionary translation.
```java
public class User {
@Dict(key = "USER_STATUS")
private Integer status; // 0: Offline, 1: Online
}
```
### 对象注解 | Object Annotations
#### @Version
启用版本控制与历史记录跟踪。编译期会生成 `{ClassName}History` (Record) 和 `{ClassName}VersionManager` 类。
Enables version control and history tracking.
```java
@Version(maxHistory = 10)
public class Document {
private String title;
private String content;
}
// 使用生成的管理类 | Using the generated manager class
DocumentVersionManager manager = new DocumentVersionManager(doc);
manager.update(d -> d.setContent("New Content"));
List histories = manager.getHistories();
```
#### @TaskExecutor
并发任务执行器注解。编译期生成 `{ClassName}Executor` 类，通过 `ExecutorUtils.startTasks` 方法调用。
Enables concurrent task execution.
```java
@TaskExecutor(parallelism = 8, waitForCompletion = true)
public class Order {
private String orderId;
private Double amount;
}
// 使用执行器 | Using the executor
List results = ExecutorUtils.startTasks(orders, Order.class, order -> {
return "Processed: " + order.getOrderId();
});
```
#### @TaskNode
DAG 任务节点注解，用于定义有向无环图中的节点。
DAG task node annotation for defining nodes in a directed acyclic graph.
```java
@TaskNode(graph = "orderFlow", name = "A", depends = {})
public class ModelA implements TaskNodeRunner {
@Override
public List run(TaskExecutionContext context) {
return List.of("Data-A1", "Data-A2");
}
}
```
### 方法注解 | Method Annotations
#### @Async
异步执行方法。
Executes the method asynchronously.
```java
@Async
public CompletableFuture asyncCalculation() {
return CompletableFuture.completedFuture("Done");
}
```
#### @Callback
方法回调注解，用于任务完成后的回调处理。
Method callback annotation for post-task completion handling.
```java
@Callback
public void onComplete(String result) {
// Callback logic
}
```
#### @TaskMethod
标记方法为任务方法。
Marks a method as a task method.
```java
@TaskMethod
public void processTask() {
// Task logic
}
```
---
## DAG 任务流 | DAG Task Flow
DAG 任务流引擎允许你定义有向无环图（Directed Acyclic Graph）任务，并按拓扑顺序执行。
The DAG Task Flow Engine allows you to define directed acyclic graph tasks and execute them in topological order.
### 定义任务节点 | Defining Task Nodes
```java
@TaskNode(graph = "orderFlow", name = "A", depends = {})
public class ModelA implements TaskNodeRunner {
@Override
public List run(TaskExecutionContext context) {
System.out.println("ModelA running...");
return List.of("Data-A1", "Data-A2");
}
}
@TaskNode(graph = "orderFlow", name = "B", depends = {"A"})
public class ModelB implements TaskNodeRunner {
@Override
public List run(TaskExecutionContext context) {
System.out.println("ModelB running...");
List aResults = context.getOutputs("A", String.class);
return List.of("Data-B: " + aResults);
}
}
@TaskNode(graph = "orderFlow", name = "C", depends = {"B"})
public class ModelC implements TaskNodeRunner {
@Override
public List run(TaskExecutionContext context) {
System.out.println("ModelC running...");
List bResults = context.getOutputs("B", String.class);
return List.of("Data-C: " + bResults);
}
}
```
### 执行任务流 | Executing Task Flow
```java
public class Main {
static {
new GraphorderFlowMetadata(); // 初始化图元数据 | Initialize graph metadata
}
public static void main(String[] args) {
List