# enQuick

**Repository Path**: BeanInJ/enQuick

## Basic Information

- **Project Name**: enQuick
- **Description**: 转换器框架
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2021-12-14
- **Last Updated**: 2022-01-15

## Categories & Tags

**Categories**: Uncategorized

**Tags**: Java

## README

# 项目简介

转换器框架

# 如何使用

## 快速创建

### 构建主体

![](READMEIMG/1.png)

如上图，IcoEnter对象是本项目的入口，你可以自由的在上面插入三种 “设备” ：输入设备、转换器、输出设备。本项目内置了部分 “设备” 的实现，如下图。

![](READMEIMG/2.png)

当然你也可以插入 `new Func(){// DIY}` 去自己实现一个“设备”，如下图。

![](READMEIMG/3.png)


### “借参输入”

如上图中 “.saveParam(User.class);” 是本框架中 “借参输入” 的一个 “还参” 方法。

在Ico类中提供了一个队列 `private Queue<Object> bank = new LinkedList<Object>();` ，供 Input、Convert、Output三个设备按顺序消费，谁需要就往里面取。

为什么叫“借”呢，因为当我们去创建某个设备的时候，发现需要往设备里面传入一些参数，那么这些参数从哪儿来呢，Ico在完成组装以前里面的“bank”也是空的，所以这时候就需要“借”。如下代码是设备“Convert”的借参过程。

```java
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;

import com.vita.common.PojoUtils;
import com.vita.core.function.Func2;

public class PojoConvert implements Func2 {
    private Class<?> clazz;
    @Override
    public Object apply(Object t) {
        List<String> list = (List<String>) t;
        List<Object> listClass = new ArrayList<>();
        for(String s:list){
            String[] str = s.split(",");
            try {
                Object pojo = PojoUtils.getObjectList(clazz, str);
                listClass.add(pojo);
            } catch (Exception e) {
                e.printStackTrace();
            }
            
        }
        return listClass;
    }

    @Override
    public void borrow(Queue<Object> bank) {
        if(this.clazz == null){
            this.clazz = (Class)bank.poll();
        }
    }
    
}
```

# 项目设计历程

## 1、第一版

使用示例

```java
public class Test {
    public static void main(String[] args) {
        TextForm.init()
                .end();
    }
}
```

```java
public class Test {
    public static void main(String[] args) {
        TextForm.init()
                .input(InputEnum.TXTFILE, InputFormat.LIST,"1.txt")
                .end();
    }
}
```

核心结构
```java
public interface converter {
    V run(T t,V v);
}
```
## 2、第二版

从第二版开始构建基于事务流的链式结构

使用示例
```java
public class Test {
    public static void main(String[] args) {
        TaskManager.addTask(task -> {

            task.input("这是第一句话");
            task.input("这是第二句话");
            task.input("这是第三句话");
            task.output();

        }).plan(new Actuator() {

            private StringBuffer inputContext = new StringBuffer();

            @Override
            public void input(String... s) {
                for(String input :s){
                    inputContext.append(input).append("\n");
                }
            }

            @Override
            public void output(String... s) {
                System.out.println(inputContext);
            }

        });
    }
}
```

核心结构：被观察者-> 订阅者 -> 观察者

## 3、第三版

使用示例
```java
public class Test {
    public static void main(String[] args) {

        TaskManager.addTask(new Task() {

            @Override
            public void plan(TaskExecute execute) {
                execute.run("1.txt", "2.txt");
            }
            
        }).plan(new TaskExecute() {

            @Override
            public <I, O> void run(I inputs, O outputs) {
                // TODO Auto-generated method stub
            }
            
        });


        TaskManager
            .input("1.txt")
            .output("2.txt")
            .plan(new TaskExecute() {

                @Override
                public <I, O> void run(I inputs, O outputs) {
                    // TODO Auto-generated method stub
                    
                }
                
            });

        TaskManager
            .input("1.txt")
            .input("2.txt")
            .output("3.txt")
            .plan(new PutsExecute() {

                @Override
                public <I, O> void run(List<I> inputs, List<O> outputs) {
                    // TODO Auto-generated method stub
                    
                }
                
            });
    }
}
```
核心结构：

1、任务管理器 -> 添加任务 -> 处理任务

2、任务管理器 -> 操作符任务 -> 处理任务

## 4、当前版本
使用示例
```java
package com.vita;

import com.vita.core.Func;
import com.vita.core.Ico;
import com.vita.core.IcoEnter;

public class Test {
    public static void main(String[] args) {    
        Object object = IcoEnter.input()
                .convert((o)->{
                    return o;
                }).output((o)->{
                    return o;
                }).run();

        System.out.println(object);

        Ico ico = IcoEnter
                .input(new Func() {

                    @Override
                    public Object apply(Object t) {
                        return (int)t+1;
                    }
                    
                })
                .convert(new Func() {

                    @Override
                    public Object apply(Object t) {
                        return (int)t*10;
                    }
                    
                }).output(new Func() {

                    @Override
                    public Object apply(Object t) {
                        return (int)t-1;
                    }
                    
                });

        int i = 1;
        System.out.println(ico.run(3,i));
    }
}

```

核心结构：
```java
package com.vita.core;

import java.util.Objects;

/**
 * 每个Ico里面都有一个value，用来储存Ico执行前的入参
 */
public class Ico extends ValueStore<Object> {
    private Func inputAct = (o)->o;
    private Func convertAct;
    private Func outputAct = (o)->o;
    

    /**
     * 输入执行器:将需要转换的内容构建为java对象
     */
    public Ico input(Func input){
        this.inputAct = input;
        return this;
    }

     /**
      * 直接输入java对象，不需要输入执行器时调用
      * @return 返回参数为Ico对象（转换器、输出执行器缺省）
      */
    public Ico input(){
        return this;
    }

     /**
      * 获取转换器
      * @param convert 转换器（将一个java对象转换为另一个java对象）
      * @return 返回参数为Ico对象（输出执行器缺省）
      */
    public Ico convert(Func convert){
        this.convertAct = convert;
        return this;
    }

     /**
      * 获取输出执行器
      * @param output 输出执行器
      * @return 返回参数为完整的Ico对象
      */
    public Ico output(Func output){
        this.outputAct = output;
        return this;
    }

    /**
     * 直接输出java对象，不需要输出执行器时调用
     */
    public Ico output(){
        return this;
    }


    /**
     * 获取Input输入对象
     */
    public Func getInputAct(){
        return this.inputAct;
    }

    /**
     * 获取Output输出对象
     */
    public Func getOutputAct(){
        return this.outputAct;
    }

    /**
     * 获取Convert转换对象
     */
    public Func getConvertAct(){
        return this.convertAct;
    }

    /**
     * 获取runInput后的值
     */
    public Object getInputValue() {
        return this.inputAct.apply(getValue());
    }

    /**
     * 获取runConvert后的值
     */
    public Object getConvertValue() {
        Objects.requireNonNull(this.convertAct,"转换器缺省");
        return this.convertAct.apply(getInputValue());
    }

    /**
     * 获取runOutput后的值
     * 转换完成必须清空value
     */
    private Object getOutputValue() {
        Object object = this.outputAct.apply(getConvertValue());
        clear();
        return object;
    }

    /**
     * 清空入值，以便再次使用
     */
    private void clear() {
        this.setValue(null);
    }

    /**
     * 执行run(),直接得到转换对象
     */
    public Object run() {
        return getOutputValue();
    }

    public <I> Object run(I i) {
        this.setValue(i);
        return run();
    }

    public <I,O> O run(I i,O o) {
        return (O)run(i);
    }
}

```

函数式接口参考：https://blog.csdn.net/xcy1193068639/article/details/8060161