Comment intégrer Springboot avec le script groovy

L'introduction de fonctionnalités de script dans nos applications peut améliorer considérablement la flexibilité. Notre travail de développement de base peut se concentrer sur le développement des fonctionnalités de base de la plate-forme. Les fonctions dans des scénarios spécifiques peuvent être implémentées via des scripts. Par exemple, Jenkins peut utiliser des scripts groovy pour écrire un pipeline. vous pouvez personnaliser le processus de construction de manière très flexible. Spring lui-même fournit un mécanisme d'intégration groovy, qui est divisé en deux manières. La première consiste à utiliser groovy pour développer des programmes, ce qui est similaire au développement avec Java et doit être compilé. La première consiste à exécuter groovy sous forme de script sans compilation. Ce que nous introduisons ici est la deuxième méthode, en utilisant groovy comme script.

1. Présentation

Il existe deux idées principales pour intégrer des scripts groovy au printemps. La première consiste à définir des beans dans des scripts groovy, afin que les scripts groovy soient intégrés dans l'ensemble du système Spring et ne soient pas différents de l'utilisation de beans ordinaires. La première consiste à appeler le script groovy dans le programme et à faire du script groovy un composant exécutable. Ci-dessous, nous présentons respectivement ces deux méthodes. Il existe deux façons de déclarer les beans définis dans les scripts groovy au printemps, l'une est le XML traditionnel et l'autre est la méthode de déclaration groovy introduite dans spring-framework-4.

2. Définir les beans dans groovy

Nous définissons d'abord une interface :

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

Voici une idée. Nous pouvons utiliser du code Java pour écrire l'implémentation par défaut de l'interface. Si l'implémentation par défaut ne répond pas aux exigences d'un scénario spécifique, coopérer avec le mode Stratégie utilise des scripts groovy pour implémenter des scénarios spécifiques. Grâce au mécanisme de chargement à chaud du script, lorsque la logique de traitement doit changer, nous pouvons ajuster le contenu du script à tout moment pendant l'exécution du programme. et cela prendra effet en temps opportun.

Implémentez cette interface dans le script groovy 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

Ce qui suit décrit comment déclarer des beans via les deux méthodes de configuration xml et groovy.

2.1. Déclarer les beans implémentés dans groovy via la configuration XML

La déclaration des beans via la configuration XML est une méthode Spring traditionnelle. Cette méthode a récemment été remplacée par la déclaration via le code Java, mais pour la déclaration, c'est toujours la plus simple. méthode pour les beans définis dans les scripts groovy.

@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);
    }
}

Le code XML ci-dessus déclare le bean myServiceXml, et script-source spécifie que la source de ce bean est le fichier de script classpath:MyServiceImpl.groovy. Remplacez classpath par file pour spécifier un fichier de script à n’importe quel emplacement.
refresh-check-delay définit l'intervalle d'actualisation du script Lorsque le contenu du script change, le contenu du script peut être automatiquement actualisé.
lang:propertyCette balise peut initialiser les propriétés du bean.

Nous utilisons XML et groovy pour déclarer les beans de deux manières afin d'attribuer différentes valeurs initiales à l'attribut myProp, ce qui peut être vu dans le code de démonstration suivant.

2.2. Déclarer les beans implémentés dans groovy via la configuration groovy

spring-framework-4 a introduit la méthode groovy de déclaration des beans. Nous utilisons groovy pour déclarer le bean myServiceGroovy. Par rapport à la méthode xml, la méthode de déclaration de groovy est. plus lisible.

Pour une introduction détaillée, consultez le billet de blog officiel de Spring : Configuration Groovy Bean dans Spring Framework 4🎜

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

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

🎜Vous pouvez spécifier l'emplacement du script groovy qui définit le bean via GroovyScriptFactory. Grâce à l'expression lambda du bean, les propriétés du bean peuvent être attribuées. En plus de la propriété myProp que nous avons définie, la portée et l'heure d'actualisation du script peuvent également être définies. 🎜

2.3. Appel des beans implémentés dans groovy

🎜 Plus tôt, nous avons déclaré 2 beans via xml et groovy : myServiceXml et myServiceGroovy , ci-dessous nous appelons ces deux beans dans le programme. 🎜

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

🎜Nous introduisons d'abord le fichier de déclaration du bean via @ImportResource, puis l'injection de dépendances et l'invocation de méthodes des beans ordinaires. Vous pouvez le voir dans l'utilisation des beans, des beans définis par script et des applications. il n'y a aucune différence dans les haricots écrits. Dans la méthode run, nous avons appelé respectivement les méthodes amusantes des deux beans myServiceXml et myServiceGroovy. Exécutez la méthode run pour voir le résultat : 🎜rrreee🎜 3. Exécutez le script groovy 🎜🎜En plus d'implémenter des beans dans groovy comme mentionné précédemment, nous pouvons également exécuter des scripts groovy via le GroovyScriptEngine fourni par groovy. Il peut également être utilisé dans le framework Spring et les programmes Java ordinaires. 🎜rrreee🎜Nous initialisons d'abord GroovyScriptEngine et transmettons le chemin d'accès au fichier de script dans la méthode de construction. 🎜🎜Il existe deux façons d'exécuter un script. La première consiste à obtenir le GroovyObject et à exécuter une méthode dans le script via InvokeMethod. Les paramètres de la méthode sont transmis via le tableau Object. 🎜rrreee🎜La seconde consiste à exécuter le script groovy directement, et vous pouvez transmettre des variables dans le script groovy via Binding. 🎜rrreee

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!