easy-work

KO | EN

gitlite — search

#javascript #python #react #typescript #go #rust #deep-learning #windows #kubernetes #awesome-list #vue #security #ios #openai

(★ 12)

The simple, easy-used, stupid workflow engine for Java

easy-work 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

***

<div align="center">
    <b><em>Easy Work</em></b><br>
    The simple, easy-used, stupid workflow engine for Java™
</div>

</div>

***

📖 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:
<p align="center">
    <img src="./img/example.png" width="70%">
</p>

* `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:
<p align="center">
    <img src="./img/point.png" width="70%">
</p>

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.

## Build workflow from JSON
Now (from version V1.0.8) EasyWork support JSON-based construction, allowing you to build workflows of arbitrary complexity using JSON.

Based on the example shown in the diagram above, the fragment for constructing a workflow using JSON is (example. json):
```json
{
  "type": "sequential",
  "works": [{
    "type": "repeat",
    "times": 3,
    "work": {
      "type": "work.PrintMessageWork",
      "message": "a"
    }
  },{
    "type": "sequential",
    "works": [{
      "type": "work.PrintMessageWork",
      "message": "b"
    },{
      "type": "work.PrintMessageWork",
      "message": "c"
    },{
      "type": "work.PrintMessageWork",
      "message": "d"
    }]
  },{
      "type": "conditional",
      "decide": {
        "type": "parallel",
        "autoShutdown": true,
        "works": [{
          "type": "work.PrintMessageWork",
          "message": "e"
        },{
          "type": "work.PrintMessageWork",
          "message": "f"
        }]
      },
      "predicate": {
        "left" : "$status",
        "operator": "eq",
        "right": "COMPLETED"
      },
      "trueWork": {
        "type": "work.PrintMessageWork",
        "message": "g"
      },
      "falseWork": {
        "type": "work.PrintMessageWork",
        "message": "h"
      }
  }],
  "then": {
    "type": "work.PrintMessageWork",
    "message": "z"
  }
}
```
You can deserialize the workflow using the following code and execute it (for more examples, please refer to test/Java/ReservializeTest)
```java
String json = ResourceReader.readJSON("json/example.json");
SequentialFlow sequentialFlow = (SequentialFlow) deserialize(json);
sequentialFlow.execute(new WorkContext());
```
## Serialize workflow to JSON
Now (from version V1.0.9) EasyWork support serialize to `JSON`, After building the workflow, you can serialize it to `JSON` using the `serialize()` method.

Based on the example shown in the diagram above, you can use the following code to serialize to JSON (for more example, please refer to test/java/serializeTest):
```java
String json = ResourceReader.readJSON("json/example.json");
SequentialFlow sequentialFlow = (SequentialFlow) deserialize(json);
System.out.println(sequentialFlow.serialize());
```
## Rich conditional assertions
EasyWork comes with a rich set of Predicate assertions, helping you build `conditional` workflows more quickly and easily. Even complex nested conditional workflows become simple. 
The following code is an example of building a `conditional` workflow:
```java
PrintMessageWork ageEqualTen = new PrintMessageWork("age equal than 10");
PrintMessageWork ageLessThanTen = new PrintMessageWork("age less than 10");
UserPrintWork userWork = new UserPrintWork(new User().setAge(15).setName("john"));
aNewConditionalFlow(userWork)
  .when(
     andPredicate( 
     //Assertions can be directly constructed through method references
     aNewEqPredicate(WorkReport::getStatus, "COMPLETED"),
     //The result attributes can be cascaded directly through expressions: workReport->result->age
     aNewGreaterEqualPredicate("$result.$age",10),
     //It can also be constructed through expressions and method references, express: workReport->result
     aNewEqPredicate("$result",User::getName, "john")
   ),    
   ageEqualTen,
   ageLessThanTen
 ).execute(new WorkContext());

```
## Pause and redo
From version V1.1.0, `EasyWork` provides `pause` and `redo` support. You can pause the workflow in the `execute` method of a Work as needed, and `EasyWork` will re-execute the `execute` method of that Work when resuming.
This method is primarily used to meet the requirements in the `AI` mode, where the Work is waited for and re-executed until specific conditions are met.

You can call the `doPause` method at `any` position of the execute method in `any` Work to achieve this requirement.
The following code is an example of pausing and redoing:
```java
@Setter
public class RedoWork implements Work {
 private String name;
 private Integer age;
 private String sex;
 @Override
 public Object execute(WorkContext context) {
  boolean nameEmpty = Checker.BeEmpty(name), ageEmpty = Checker.BeNull(age),sexEmpty = Checker.BeEmpty(sex);
  if (nameEmpty) {
   System.out.println("name is empty, please input it !");
   doPause(context);
   return aNewWorkReport;
  } else if (ageEmpty) {
   System.out.println("age is empty, please input it !");
   doPause(context);
   return aNewWorkReport();
  } else if (sexEmpty) {
   System.out.println("sex is empty, please input it !");
   doPause(context);
   return aNewWorkReport();
  } else {
   System.out.println("all info are not empty, do it!");
   return aNewWorkReport();
  }
 }
}
RedoWork redoWork = new RedoWork();
PrintMessageWork a = new PrintMessageWork("a");
PrintMessageWork b = new PrintMessageWork("b");
SequentialFlow flow = aNewSequentialFlow(a,redoWork,b);
//flow will be paused when invoke the `doPause` method and redo it when invoke the `execute` method
flow.execute();
redoWork.setName("Jerry");
flow.execute();
redoWork.setAge(18);
flow.execute();
redoWork.setSex("male");
//flow will continue the work when all infos are not empty
flow.execute();
```
You can view more test cases in `test/java`.

You can find more details about all of this in the [WIKI](docs/WIKI.md)

## License

Easy Work is released under the Apache License Version 2.0

easy-work

easy-work 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

easy-work

easy-work 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README