https://github.com/hzn6426/easy-work
The simple, easy-used, stupid workflow engine for Java
https://github.com/hzn6426/easy-work
java parallel-processing process workflow workflow-engine
Last synced: about 2 months ago
JSON representation
The simple, easy-used, stupid workflow engine for Java
- Host: GitHub
- URL: https://github.com/hzn6426/easy-work
- Owner: hzn6426
- License: apache-2.0
- Created: 2025-11-30T03:03:47.000Z (3 months ago)
- Default Branch: master
- Last Pushed: 2025-12-17T09:10:01.000Z (3 months ago)
- Last Synced: 2025-12-20T20:49:57.484Z (3 months ago)
- Topics: java, parallel-processing, process, workflow, workflow-engine
- Language: Java
- Homepage: https://github.com/hzn6426/easy-work/blob/master/docs/WIKI.md
- Size: 587 KB
- Stars: 6
- Watchers: 0
- Forks: 1
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
***
Easy Work
The simple, easy-used, stupid workflow engine for Java™
***
📖 English | 📖 [中文](docs/README_CN.md)
## What is Easy Work?
Easy Work is a workflow engine for Java. It provides concise APIs and building blocks for creating and running composable workflows.
In Easy Work, work units are represented by the `Work` interface, while workflows are represented by the `WorkFlow` interface.
Easy Work provides six implementation methods for the WorkFlow interface:
Those are the only basic flows you need to know to start creating workflows with Easy Work.
You don't need to learn a complex notation or concepts, just a few natural APIs that are easy to think about.
## How does it work ?
First let's write some work:
```java
public class PrintMessageWork implements Work {
private final String message;
public PrintMessageWork(String message) {
this.message = message;
}
@Override
public String execute(WorkContext workContext) {
System.out.println(message);
return message;
}
}
```
This unit of work prints a given message to the standard output. Now let's suppose we want to create the following workflow:
1. print `a` three times
2. then print `b` `c` `d` in sequence
3. then print `e` `f` in parallel
4. then if both `e` and `f` have been successfully printed to the console, print `g`, otherwise print `h`
5. finally print `z`
This workflow can be illustrated as follows:
* `flow1` is a `RepeatFlow` of work which print `a` three times
* `flow2` is a `SequentialFlow` of work which print `b` `c` `d` in sequence order
* `flow3` is a `ParallelFlow` of work which respectively print `e` and `f` in parallel
* `flow4` is a `ConditionalFlow` based on conditional judgment. It first executes `flow3` then if the result is successful (in the state of 'Complete') execute `g`, otherwise, execute `h`
* `flow5` is a `SequentialFlow`, which ensures the sequential execution of `Flow1`, `Flow2`, `Flow4`, and finally executes `z`
With Easy Work，this workflow can be implemented with the following snippet:
```java
PrintMessageWork a = new PrintMessageWork("a");
PrintMessageWork b = new PrintMessageWork("b");
PrintMessageWork c = new PrintMessageWork("c");
PrintMessageWork d = new PrintMessageWork("d");
PrintMessageWork e = new PrintMessageWork("e");
PrintMessageWork f = new PrintMessageWork("f");
PrintMessageWork g = new PrintMessageWork("g");
PrintMessageWork h = new PrintMessageWork("h");
PrintMessageWork z = new PrintMessageWork("z");
WorkFlow flow = aNewSequentialFlow(
aNewRepeatFlow(a).times(3),
aNewSequentialFlow(b,c,d),
aNewConditionalFlow(
aNewParallelFlow(e,f).withAutoShutDown(true)
).when(
WorkReportPredicate.COMPLETED,
g,
h
),
z
);
aNewWorkFlowEngine().run(flow, new WorkContext());
```
## Pause Workflow
Now(from v1.0.5) the workflow support the `break point`, which can pause the workflow, do something
then recovery the workflow. You can use it in `Any` position of the workflow.
For example, you can break the point at `c` work, and then recovery to execute.
This workflow can be illustrated as follows:
This workflow can be implemented with the following snippet:
```java
SequentialFlow flow = aNewSequentialFlow(
aNewRepeatFlow(a).times(3),
aNewSequentialFlow(b,aNamePointWork(c).point("C_BREAK_POINT"),d),
aNewConditionalFlow(
aNewParallelFlow(e,f).withAutoShutDown(true)
).when(
WorkReportPredicate.COMPLETED,
g,
h
),
z
);
//execute to the break point
flow.execute("C_BREAK_POINT");
System.out.println("execute to the break point `C_BREAK_POINT`");
//recovery execute from the `C_BREAK_POINT` to the end.
flow.execute();
```
This is not a very useful workflow, but just to give you an idea about how to write workflows with Easy Work.
You can view more test cases in `test/java`.
You can find more details about all of this in the [wiki](docs/WIKI.md)
Note: Some of the naming conventions for the APIs in this project refer to Easy flow, a very simple and easy-to-use process engine.
## License
Easy Work is released under the Apache License Version 2.0