[JAVA] Ich habe Lazy Initialization mit Spring Boot 2.2.0 ausprobiert

Spring Boot v2.2.0

Spring Boot v2.2.0 wurde veröffentlicht und ist jetzt GA.

Untersuchen wir also eine seiner Funktionen, die Lazy Initialization.

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

Umgebung

Windows10
OracleJDK 13(build 13)
Spring Boot 2.2.0 RELEAS

Ein Projekt erstellen

Das Hinagata-Projekt wird aus Spring Initializr erstellt.

Gradle Wir haben bestätigt, dass Gradle 5.6.2 für Gradle-Projekte gilt, die mit Spring Initializr erstellt wurden.

> 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

Lazy Initialization erstellt eine Bean, die von ApplicationContext verwaltet wird, wenn die Ziel-Bean aufgerufen wird, nicht beim Starten der Anwendung (≒ ApplicationContext wird initialisiert).

Dieser Mechanismus war in früheren Versionen verfügbar, aber ab Version 2.2.0 wird die Lazy-Initialisierung einheitlich angewendet, indem true auf die Eigenschaftspring.main.lazy-initialization angewendet wird.

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

Ausführungsergebnis

>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

Hier sehen Sie, dass die Verarbeitung in der folgenden Reihenfolge erfolgt.

Starten Sie die Anwendung

Ausgabe "Anwendungskontext initialisieren" nach dem Start

Bohnenerzeugung

Ausgabe "Aufrufkonstruktor lazyInitializationDemoBean1" im Konstruktor der Bean

Die Writer-Methode der generierten Bean wird aufgerufen

Ausgabe "lazyInitializationDemoBean1 is first bean" mit der Writer-Methode

Befreiung von der Lazy Initialization

Sie können spring.main.lazy-initialization = true festlegen, um Lazy Initialization auf Ihr Projekt anzuwenden, aber bestimmte Beans von Lazy Initialization ausschließen, indem Sie:

Setzen Sie @ org.springframework.context.annotation.Lazy (false) auf Bean
- Lazy (Spring Framework 5.2.0.RELEASE API)
Registrieren Sie die ausgeschlossenen Beans in "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);
    }

    //Lazy Initialization anwendbar
    @Bean("lazyInitializationDemoBean1")
    public LazyInitializationDemoBean lazyInitializationDemoBean1(){
        return new LazyInitializationDemoBean("lazyInitializationDemoBean1");
    }

    //Gilt nicht für Lazy Initialization
    @Bean("lazyInitializationDemoBean2")
    @Lazy(false)
    public LazyInitializationDemoBean lazyInitializationDemoBean2(){
        return new LazyInitializationDemoBean("lazyInitializationDemoBean2");
    }

    //Gilt nicht für Lazy Initialization
    @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");
    }

}

Ausführungsergebnis

>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

Wie oben erwähnt, ist von den drei in Config.java definierten Beans nur lazyInitializationDemoBean1 das Ziel von LazyInitialization.

Klicken Sie hier für den Quellcode: GitHub --forests-k / spring-boot-lazy-initialization : Spring Boot v2.2.0 lazy-initialization sample

Dinge, die bei der Anwendung von Lazy Initialization zu beachten sind

Die Einführung von Lazy Intialization bietet den Vorteil, dass der Start der Anwendung beschleunigt wird und kein Speicher verschwendet wird, da er bei Bedarf initialisiert wird.

Durch Initialisieren der Bohne und Halten der Bohne im Container bei Bedarf ändert sich jedoch der bisherige Lebenszyklus der Bohne und die maximale Anzahl der Beans, die im Container gehalten werden können (= Speicherbelegung). Es ist möglicherweise nicht sichtbar, daher kann es sich auf die CPU-Auslastung und den Auslastungsdurchschnitt auswirken. Das heißt, Sie sollten sich nicht zu sehr auf die verzögerte Initialisierung verlassen.

Daher müssen Tests in Betracht gezogen werden, z. B. das vorübergehende Deaktivieren der Lazy Initialization in einer Testumgebung oder einer Umgebung, die der Produktion entspricht.

ref