[JAVA] J'ai essayé l'initialisation paresseuse avec Spring Boot 2.2.0

Spring Boot v2.2.0

Spring Boot v2.2.0 a été publié et est maintenant GA.

Examinons donc l'une de ses fonctions, l'initialisation paresseuse.

Spring Boot 2.2.0 Release v2.2.0.RELEASE · spring-projects/spring-boot · GitHub Spring Boot 2.2 Release Notes · spring-projects/spring-boot Wiki · GitHub Spring Boot Reference Documentation

environnement

Windows10
OracleJDK 13(build 13)
Spring Boot 2.2.0 RELEAS

Créer un projet

Le projet Hinagata est créé à partir de Spring Initializr.

Gradle Nous avons confirmé que Gradle 5.6.2 s'applique aux projets Gradle créés avec Spring Initializr.

> gradlew -version

------------------------------------------------------------
Gradle 5.6.2
------------------------------------------------------------

Build time:   2019-09-05 16:13:54 UTC
Revision:     55a5e53d855db8fc7b0e494412fc624051a8e781

Kotlin:       1.3.41
Groovy:       2.5.4
Ant:          Apache Ant(TM) version 1.9.14 compiled on March 12 2019
JVM:          13-ea (Oracle Corporation 13-ea+33)
OS:           Windows 10 10.0 amd64

Lazy Initialization

L'initialisation différée est utilisée pour générer des beans gérés par ApplicationContext lorsque le bean cible est appelé, et non au démarrage de l'application (≒ ApplicationContext est initialisé).

Ce mécanisme était disponible depuis les versions précédentes, mais à partir de la v2.2.0, l'initialisation différée sera appliquée uniformément en appliquant true à la propriétéspring.main.lazy-initialization.

application.yml

spring:
  main:
    lazy-initialization: true

Bean class

package jp.co.musako.domain.model;

public class LazyInitializationDemoBean {

    private String message;

    public LazyInitializationDemoBean(String message) {
        this.message = message;
        System.out.println("call constructor " + this.message);
    }

    public void writer(String message){
        System.out.println(this.message + " is " + message);
    }
}

config class

package jp.co.musako.config;

import jp.co.musako.domain.model.LazyInitializationDemoBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class Config {

    @Bean("lazyInitializationDemoBean1")
    public LazyInitializationDemoBean lazyInitializationDemoBean1(){
        return new LazyInitializationDemoBean("create lazyInitializationDemoBean1");
    }

    @Bean("lazyInitializationDemoBean2")
    public LazyInitializationDemoBean lazyInitializationDemoBean2(){
        return new LazyInitializationDemoBean("create lazyInitializationDemoBean2");
    }
}

main class

package jp.co.musako;

import jp.co.musako.domain.model.LazyInitializationDemoBean;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        ApplicationContext ctx = SpringApplication.run(Application.class, args);
        System.out.println("Initialize Application Context");

        LazyInitializationDemoBean bean1 = ctx.getBean("lazyInitializationDemoBean1", LazyInitializationDemoBean.class);
        bean1.writer("first bean");

        LazyInitializationDemoBean bean2 = ctx.getBean("lazyInitializationDemoBean2", LazyInitializationDemoBean.class);
        bean2.writer("second bean");
    }
}

Résultat d'exécution

>gradlew bootRun

> Task :bootRun

2019-10-23 18:16:37.620  INFO 12708 --- [           main] jp.co.musako.Application                 : Started Application in 4.295 seconds (JVM running for 4.933)
Initialize Application Context
call constructor lazyInitializationDemoBean1
lazyInitializationDemoBean1 is first bean
call constructor lazyInitializationDemoBean2
lazyInitializationDemoBean2 is second bean

Ici, vous pouvez voir que le traitement est effectué dans l'ordre suivant.

Démarrez l'application

Sortie "Initialiser le contexte d'application" après le démarrage

Génération de haricots --Output "appeler le constructeur lazyInitializationDemoBean1" dans le constructeur du bean
La méthode d'écriture du bean généré est appelée

Sortie "lazyInitializationDemoBean1 est le premier bean" avec la méthode d'écriture

Exemption de l'initialisation paresseuse

Pour appliquer LazyInitialization à votre projet en définissant spring.main.lazy-initialization = true, vous pouvez exclure des beans spécifiques de LazyInitialization en:

Définissez @ org.springframework.context.annotation.Lazy (false) sur Bean
- Lazy (Spring Framework 5.2.0.RELEASE API)
Enregistrez le bean cible dans ʻorg.springframework.boot.LazyInitializationExcludeFilter`

LazyInitializationExcludeFilter (Spring Boot Docs 2.2.0.BUILD-SNAPSHOT API)
config class

package jp.co.musako.config;

import jp.co.musako.domain.model.ExcludeLazyInitializationDemoBean;
import jp.co.musako.domain.model.LazyInitializationDemoBean;
import org.springframework.boot.LazyInitializationExcludeFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;

@Configuration
public class Config {
    
    @Bean
    static LazyInitializationExcludeFilter integrationLazyInitExcludeFilter() {
        return LazyInitializationExcludeFilter.forBeanTypes(ExcludeLazyInitializationDemoBean.class);
    }

    //Initialisation paresseuse applicable
    @Bean("lazyInitializationDemoBean1")
    public LazyInitializationDemoBean lazyInitializationDemoBean1(){
        return new LazyInitializationDemoBean("lazyInitializationDemoBean1");
    }

    //Non applicable à l'initialisation paresseuse
    @Bean("lazyInitializationDemoBean2")
    @Lazy(false)
    public LazyInitializationDemoBean lazyInitializationDemoBean2(){
        return new LazyInitializationDemoBean("lazyInitializationDemoBean2");
    }

    //Non applicable à l'initialisation paresseuse
    @Bean
    public ExcludeLazyInitializationDemoBean ExcludeLazyInitializationDemoBean(){
        return new ExcludeLazyInitializationDemoBean("excludeLazyInitializationDemoBean");
    }
}

main class

package jp.co.musako;

import jp.co.musako.domain.model.ExcludeLazyInitializationDemoBean;
import jp.co.musako.domain.model.LazyInitializationDemoBean;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        ApplicationContext ctx = SpringApplication.run(Application.class, args);
        System.out.println("Initialize Application Context");

        LazyInitializationDemoBean bean1 = ctx.getBean("lazyInitializationDemoBean1", LazyInitializationDemoBean.class);
        bean1.writer("first bean");

        LazyInitializationDemoBean bean2 = ctx.getBean("lazyInitializationDemoBean2", LazyInitializationDemoBean.class);
        bean2.writer("second bean");

        ExcludeLazyInitializationDemoBean ExcludeLazyInitializationBean = ctx.getBean("ExcludeLazyInitializationDemoBean", ExcludeLazyInitializationDemoBean.class);
        ExcludeLazyInitializationBean.writer("third bean");
    }

}

Résultat d'exécution

>gradlew bootRun

> Task :bootRun

call constructor lazyInitializationDemoBean2
call constructor excludeLazyInitializationDemoBean
2019-10-23 18:52:52.464  INFO 6004 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2019-10-23 18:52:52.468  INFO 6004 --- [           main] jp.co.musako.Application                 : Started Application in 2.978 seconds (JVM running for 3.454)
Initialize Application Context
call constructor lazyInitializationDemoBean1
lazyInitializationDemoBean1 is first bean
lazyInitializationDemoBean2 is second bean
excludeLazyInitializationDemoBean is third bean

Comme mentionné ci-dessus, sur les trois beans définis dans Config.java, seul lazyInitializationDemoBean1 est la cible de LazyInitialization.

Cliquez ici pour le code source: GitHub --forests-k / spring-boot-lazy-initialization : Spring Boot v2.2.0 lazy-initialization sample

Éléments à prendre en compte lors de l'application de l'initialisation paresseuse

Les avantages de l'introduction de Lazy Intialization sont qu'elle accélère le démarrage de l'application et qu'elle ne gaspille pas de mémoire car elle s'initialise en cas de besoin.

Cependant, l'initialisation du haricot et le maintien du haricot dans le conteneur si nécessaire modifie le cycle de vie du haricot jusqu'à présent, et le nombre maximum de haricots contenus dans le conteneur (= occupation de la mémoire) Il peut ne pas être visible, donc cela peut avoir un impact sur la charge du processeur et la charge moyenne, c'est-à-dire que vous ne devez pas trop vous fier à l'initialisation différée.

Par conséquent, il est nécessaire d'envisager d'effectuer des tests tels que la désactivation temporaire de l'initialisation différée dans un environnement de test ou un environnement équivalent à la production.

ref