介绍

LiteFlow支持了用Java本身作为脚本语言的特性。

也就是说，在写组件脚本时，你可以完全用Java自身的语法来写脚本。同样这部分的脚本，也是可以进行热刷新的。

依赖

LiteFlow提供了两种不同的Java脚本引擎，分别是：

liteflow-script-java：以Janino为底层来实现。版本支持：v2.11.0+

你需要额外依赖LiteFlow提供的脚本插件：

<dependency>
    <groupId>com.yomahub</groupId>
    <artifactId>liteflow-script-java</artifactId>
    <version>2.12.4.1</version>
</dependency>

liteflow-script-javax：以Liquor为底层来实现。版本支持：v2.12.4+

你需要额外依赖LiteFlow提供的脚本插件：

<dependency>
    <groupId>com.yomahub</groupId>
    <artifactId>liteflow-script-javax</artifactId>
    <version>2.12.4.1</version>
</dependency>

提示

使用以Liquor为核心的javax插件，部署运行的时候必须为JDK，而不能是JRE，这点要注意下。

为什么提供两个实现引擎

liteflow-script-java是以前就提供的。而liteflow-script-javax是后来提供的。他们两个引擎在底层选型上面不同。运行机制不同。使用起来的实现接口也略微有些区别。为了向前兼容。选择另外提供一个脚本引擎。而没有覆盖原有的引擎。

要注意的是，这2个插件只能二选一，不能并存同时依赖。

两个引擎的优劣势

两个引擎的对比，也就是底层所用引擎Janino和Liquor的对比。

Janino的优点是编译和运行速度都非常快，缺点是只支持Jdk 6的语法，不支持lambda和泛型。

Liquor的优点是运行速度非常快，支持jdk的所有语法，缺点是编译速度比较慢。

这里推荐一般使用者使用Liquor为底层的liteflow-script-javax插件。

如果你的逻辑是每次通过动态构建脚本节点去运行（可以参考用代码动态构造规则-构造Node），那么推荐还是用Janino为底层的liteflow-script-java插件。

使用(liteflow-script-java)

使用liteflow-script-java插件，需要像如下去定义，以下是个例子：

<node id="s1" name="普通脚本1" type="script" language="java">
    <![CDATA[
    import com.yomahub.liteflow.slot.DefaultContext;
    import com.yomahub.liteflow.spi.holder.ContextAwareHolder;
    import com.yomahub.liteflow.test.script.java.common.cmp.TestDomain;
    import com.yomahub.liteflow.script.body.JaninoCommonScriptBody;
    import com.yomahub.liteflow.script.ScriptExecuteWrap;

    public class Demo implements JaninoCommonScriptBody{
        public Void body(ScriptExecuteWrap wrap){
            int v1 = 2;
            int v2 = 3;
            DefaultContext ctx = (DefaultContext)wrap.cmp.getFirstContextBean();
            ctx.setData("s1", v1 * v2);

            TestDomain domain = (TestDomain)ContextAwareHolder.loadContextAware().getBean(TestDomain.class);

            String str = domain.sayHello("jack");
            ctx.setData("hi", str);

            return null;
        }
    }
    ]]>
</node>

script：普通脚本节点，需要实现JaninoCommonScriptBody接口，脚本里返回null即可。

switch_script：选择脚本节点，需要实现JaninoSwitchScriptBody接口，脚本里需要返回选择的节点Id。

boolean_script：布尔脚本节点，需要实现JaninoBooleanScriptBody接口，脚本里需要返回true/false。

for_script：数量循环节点，需要实现JaninoForScriptBody接口，脚本里需要返回数值类型，表示循环次数。

正如上面所说到那样，使用liteflow-script-java是没有lambda语法的，并且不支持泛型。 所以以上很多地方要进行强转，例如：

<node id="s1" name="普通脚本1" type="script" language="java">
    <![CDATA[
    ...

    public class Demo implements JaninoCommonScriptBody{
        public Void body(ScriptExecuteWrap wrap){
            ...
            DefaultContext ctx = (DefaultContext)wrap.cmp.getFirstContextBean();
            ...
            TestDomain domain = (TestDomain)ContextAwareHolder.loadContextAware().getBean(TestDomain.class);
            ...
            return null;
        }
    }
    ]]>
</node>

使用(liteflow-script-javax)

使用liteflow-script-java插件，需要像如下去定义，以下是个例子：

<node id="s1" name="普通脚本1" type="script" language="java">
    <![CDATA[
    import cn.hutool.core.collection.ListUtil;
    import com.alibaba.fastjson2.JSON;
    import com.yomahub.liteflow.script.body.CommonScriptBody;
    import com.yomahub.liteflow.slot.DefaultContext;
    import com.yomahub.liteflow.spi.holder.ContextAwareHolder;
    import com.yomahub.liteflow.test.script.javax.common.cmp.Person;
    import com.yomahub.liteflow.test.script.javax.common.cmp.TestDomain;
    import com.yomahub.liteflow.script.ScriptExecuteWrap;
    import java.util.List;
    import java.util.function.ToIntFunction;

    public class Demo implements CommonScriptBody {
        public Void body(ScriptExecuteWrap wrap) {
            int v1 = 2;
            int v2 = 3;
            DefaultContext ctx = wrap.getCmp().getFirstContextBean();
            ctx.setData("s1", v1 * v2);

            TestDomain domain = ContextAwareHolder.loadContextAware().getBean(TestDomain.class);
            System.out.println(domain);
            String str = domain.sayHello("jack");
            ctx.setData("hi", str);

            List<Person> personList = ListUtil.toList(
                    new Person("jack", 15000),
                    new Person("tom", 13500),
                    new Person("peter", 18600)
            );

            int totalSalary = personList.stream().mapToInt(Person::getSalary).sum();

            System.out.println(totalSalary);
            ctx.setData("salary", 47100);

            return null;
        }
    }
    ]]>
</node>

script：普通脚本节点，需要实现CommonScriptBody接口，脚本里返回null即可。

switch_script：选择脚本节点，需要实现SwitchScriptBody接口，脚本里需要返回选择的节点Id。

boolean_script：布尔脚本节点，需要实现BooleanScriptBody接口，脚本里需要返回true/false。

for_script：数量循环节点，需要实现ForScriptBody接口，脚本里需要返回数值类型，表示循环次数。

和Java类进行交互

由于Java作为脚本，是需要定义一个类的。并且实现其接口所定义的方法。

方法里有ScriptExecuteWrap这个参数。而warp.cmp就是当前的NodeComponent，等同于this，所以你可以用warp.cmp来调取上下文，或者是元数据。使用方式和Java类组件是一致的。

如何取Spring上下文中的数据

值得注意的是，虽然脚本组件完全是Java的语法，但是你无法用@Resource或者@Autowired来进行注入spring的bean。

LiteFlow提供一个方法，用来获取Spring中的bean数据，如下示例（如果是liteflow-script-java要进行强转类型）

UserDomain domain = ContextAwareHolder.loadContextAware().getBean(UserDomain.class);

这样就可以获得在spring上下文中注入的UserDomain对象了。