So integrieren Sie Springboot mit Groovy-Skript

Die Einführung von Skriptfunktionen in unsere Anwendungen kann die Flexibilität erheblich verbessern. Die Funktionen spezifischer Szenarien können durch Skripte implementiert werden, wie z. B. das Schreiben von Pipelines durch Groovy-Skripte Sie können den Build-Prozess flexibel anpassen. Spring selbst bietet einen Mechanismus für die Groovy-Integration, der in zwei Arten unterteilt ist: Die Verwendung von Groovy zum Entwickeln von Programmen ähnelt der Entwicklung mit Java und muss kompiliert werden. Eine besteht darin, groovy als Skript ohne Kompilierung auszuführen. Was wir hier vorstellen, ist die zweite Möglichkeit, Groovy als Skript zu verwenden.

1. Übersicht

Es gibt zwei Hauptideen für die Integration von Groovy-Skripten in Spring. Eine besteht darin, Beans in Groovy-Skripten zu definieren, sodass Groovy-Skripte in den gesamten Frühling integriert werden . Das System unterscheidet sich nicht von der Verwendung gewöhnlicher Bohnen. Eine besteht darin, das Groovy-Skript im Programm aufzurufen und das Groovy-Skript zu einer ausführbaren Komponente zu machen. Im Folgenden stellen wir diese beiden Methoden vor. Es gibt zwei Möglichkeiten, Beans zu deklarieren, die im Frühjahr in Groovy-Skripten definiert sind: Eine ist das traditionelle XML und die andere ist die in Spring-Framework-4 eingeführte Groovy-Deklarationsmethode.

2. Definieren Sie Beans in groovy

Zuerst definieren wir eine Schnittstelle:

public interface MyService {
    String fun(MyDomain myDomain);
}

Hier finden Sie eine Idee, wir können Java-Code verwenden. Schreiben Sie einen Standard Wenn die Standardimplementierung die Anforderungen eines bestimmten Szenarios nicht erfüllt, verwenden Sie Groovy-Skripte, um bestimmte Szenarien zu implementieren. Mit dem Hot-Loading-Mechanismus wird das Programm sehr flexibel Die Logik muss sich ändern. Während das Programm läuft, können wir den Skriptinhalt jederzeit anpassen und er wird zeitnah wirksam.

Implementieren Sie diese Schnittstelle im Groovy-Skript MyServiceImpl.groovy: MyServiceImpl.groovy中实现这个interface：

class MyServiceImpl implements MyService {
    @Autowired
    FunBean useBean;

    String myProp;

    String fun(MyDomain myDomain) {
        return myDomain.toString() + useBean.getFunName() + myProp;
    }
}

下面分别介绍通过xml和groovy两种配置方式来声明bean。

2.1、通过xml配置的方式声明groovy中实现的bean

通过xml配置声明bean是spring传统的方法，这种方法近来已经被通过java代码声明的方式取代，但是对于声明groovy脚本中定义的bean来说还是最简单的方法。

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:lang="http://www.springframework.org/schema/lang"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/lang https://www.springframework.org/schema/lang/spring-lang.xsd">
    <lang:groovy id="myServiceXml" script-source="classpath:MyServiceImpl.groovy" refresh-check-delay="10000" >
        <lang:property name="myProp" value=" this is xml init prop" />
    </lang:groovy>
</beans>

以上xml代码声明了myServiceXml这个bean，script-source指定了这个bean的来源是classpath:MyServiceImpl.groovy这个脚本文件。将classpath替换为file，可以指定任一位置的脚本文件。
refresh-check-delay定义了脚本的刷新间隔，当脚本内容发生变化后，可以自动刷新脚本的内容。
lang:property这个标签可以对bean的属性进行初始化赋值。

我们分别用xml和groovy两种声明bean的方式给myProp这个属性赋值不同的初始值，在后续的演示代码中可以看到。

2.2、通过groovy配置的方式声明groovy中实现的bean

spring-framework-4中引入了groovy声明bean的方式，我们用groovy来声明myServiceGroovy这个bean，相比于xml的方式，groovy的声明方式可读性更强一些。

详细介绍见spring的官方博文： Groovy Bean Configuration in Spring Framework 4

import org.springframework.scripting.groovy.GroovyScriptFactory
import org.springframework.scripting.support.ScriptFactoryPostProcessor

beans {
    scriptFactoryPostProcessor(ScriptFactoryPostProcessor) {
        defaultRefreshCheckDelay = 10000
    }
    myServiceGroovy(GroovyScriptFactory, 'classpath:MyServiceImpl.groovy') {
        bean ->
            bean.scope = "prototype"
            myProp = ' this is Bean Builder init prop'
            bean.beanDefinition.setAttribute(ScriptFactoryPostProcessor.REFRESH_CHECK_DELAY_ATTRIBUTE, 6000)
    }
}

通过GroovyScriptFactory可以指定定义bean的groovy脚本位置。 通过bean的lambda表达式，可以对bean的属性进行赋值，除了我们定义的myProp这个属性外，还可以定义scope和脚本刷新时间。

2.3、调用groovy中实现的bean

前面我们通过xml和groovy两种方式分别声明了2个bean: myServiceXml和myServiceGroovy，下面我们在程序中调用这2个bean。

@SpringBootApplication
@ImportResource({"classpath:xml-bean-config.xml", "classpath:BeanBuilder.groovy"})
public class Application implements CommandLineRunner {

    @Autowired
    private MyService myServiceXml;
    @Autowired
    private MyService myServiceGroovy;

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

    @Override
    public void run(String... args) throws ScriptException, ResourceException, IllegalAccessException, InstantiationException {
        MyDomain myDomain = new MyDomain();
        myDomain.setName("test");
        System.out.println(myServiceXml.fun(myDomain));
        myDomain.setName("test2");
        System.out.println(myServiceGroovy.fun(myDomain));
    }
}

首先我们通过@ImportResource

MyDomain(name=test)FunBean this is xml init prop
MyDomain(name=test2)FunBean this is Bean Builder init prop

Im Folgenden wird beschrieben, wie Beans über zwei Konfigurationsmethoden deklariert werden: XML und Groovy .

2.1. Deklarieren Sie Beans über die XML-Konfiguration. Diese Methode wurde kürzlich durch Java-Code deklariert ist immer noch die einfachste Methode zum Deklarieren von Beans, die in Groovy-Skripten definiert sind.

@Component
public class MyEngine {
    private final GroovyScriptEngine engine;

    @Autowired
    private FunBean funBean;

    public MyEngine() throws IOException {

        engine = new GroovyScriptEngine(ResourceUtils.getFile("classpath:scripts/").getAbsolutePath()
                , this.getClass().getClassLoader());
    }

    public void runScript(int x, int y) throws IllegalAccessException,
            InstantiationException, ResourceException, ScriptException {
        Class<GroovyObject> calcClass = engine.loadScriptByName("CalcScript.groovy");
        GroovyObject calc = calcClass.newInstance();

        Object result = calc.invokeMethod("calcSum", new Object[]{x, y});
        System.out.println("Result of CalcScript.calcSum() method is " + result);

        Binding binding = new Binding();
        binding.setVariable("arg", "test");
        binding.setVariable("funBean", funBean);
        Object result1 = engine.run("CalcScript.groovy", binding);
        System.out.println("Result of CalcScript.groovy is " + result1);
    }
}

Der obige XML-Code deklariert die Bean myServiceXml und script-source gibt an, dass die Quelle dieser Bean die Skriptdatei classpath:MyServiceImpl.groovy ist. Code> . Ersetzen Sie den Klassenpfad durch „Datei“, um eine Skriptdatei an einem beliebigen Speicherort anzugeben. <br><code>refresh-check-delay definiert das Aktualisierungsintervall des Skripts. Wenn sich der Inhalt des Skripts ändert, kann der Inhalt des Skripts automatisch aktualisiert werden.
lang:propertyDieses Tag kann die Eigenschaften der Bean initialisieren und ihnen Werte zuweisen.

Wir verwenden XML und Groovy, um Beans zu deklarieren und der Eigenschaft myProp unterschiedliche Anfangswerte zuzuweisen, was im folgenden Demonstrationscode zu sehen ist.

2.2. In Groovy implementierte Beans

Spring-Framework-4 hat die Groovy-Methode zum Deklarieren von Beans eingeführt xml ist die Deklarationsmethode von groovy besser lesbar.

Eine ausführliche Einführung finden Sie im offiziellen Blogbeitrag von Spring: Groovy Bean-Konfiguration in Spring Framework 4

Class<GroovyObject> calcClass = engine.loadScriptByName("CalcScript.groovy");
GroovyObject calc = calcClass.newInstance();

Object result = calc.invokeMethod("calcSum", new Object[]{x, y});

#🎜🎜#Sie können den Speicherort des Groovy-Skripts, das die Bean definiert, über GroovyScriptFactory. Über den Lambda-Ausdruck von bean können die Eigenschaften der Bean zugewiesen werden. Zusätzlich zu der von uns definierten myProp-Eigenschaft können auch der Umfang und die Aktualisierungszeit des Skripts definiert werden. #🎜🎜#

2.3. Aufruf von in groovy implementierten Beans

#🎜🎜# Zuvor haben wir 2 Beans über XML und groovy deklariert: myServiceXml und myServiceGroovy, Nachfolgend nennen wir diese beiden Beans im Programm. #🎜🎜#

Binding binding = new Binding();
binding.setVariable("arg", "test");
binding.setVariable("funBean", funBean);
Object result1 = engine.run("CalcScript.groovy", binding);

#🎜🎜#Zuerst führen wir die Bean-Deklarationsdatei über @ImportResource ein und dann die gewöhnliche Bean-Abhängigkeitsinjektion und den Methodenaufruf. Das können Sie an der Verwendung von Beans, dem Skript, erkennen Es gibt keinen Unterschied zwischen definierten Beans und programmgesteuert geschriebenen Beans. In der run-Methode haben wir die Fun-Methoden der beiden Beans myServiceXml bzw. myServiceGroovy aufgerufen. Durch Ausführen der run-Methode wird die Ausgabe des Ergebnisses angezeigt: #🎜🎜#rrreee#🎜🎜#3. Führen Sie das Groovy-Skript aus #🎜🎜##🎜🎜#Zusätzlich zur oben genannten Bean-Implementierung in Groovy können wir es auch bereitstellen über groovy GroovyScriptEngine zum Ausführen von groovigen Skripten. Diese Methode ist nicht vom Springframework abhängig und kann auch in normalen Java-Programmen verwendet werden. #🎜🎜#rrreee#🎜🎜#Zuerst initialisieren wir GroovyScriptEngine und übergeben in der Konstruktionsmethode den Pfad zur Skriptdatei. #🎜🎜##🎜🎜#Es gibt zwei Möglichkeiten, ein Skript auszuführen. Eine besteht darin, das GroovyObject abzurufen und eine Methode im Skript über invokeMethod auszuführen. Die Parameter der Methode werden über das Object-Array übergeben. #🎜🎜#rrreee#🎜🎜#Die zweite besteht darin, das Groovy-Skript direkt auszuführen, und Sie können Variablen über die Bindung an das Groovy-Skript übergeben. #🎜🎜#rrreee

Das obige ist der detaillierte Inhalt vonSo integrieren Sie Springboot mit Groovy-Skript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!