Analisis contoh proses pelaksanaan SpringBoot

Setiap projek Spring Boot mempunyai kelas permulaan program utama Dalam kelas permulaan program utama, terdapat kaedah utama() untuk memulakan projek Dalam kaedah ini, keseluruhan program Spring Boot boleh dimulakan dengan melaksanakan SpringApplication.run () .

Soalan: Jadi bagaimanakah kaedah SpringApplication.run() memulakan projek Spring Boot?

Mari kita lihat kod sumber di dalam kaedah run() Kod teras adalah seperti berikut:

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

public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
    return run(new Class[]{primarySource}, args);
}
    public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
        return (new SpringApplication(primarySources)).run(args);
}

Seperti yang dapat dilihat daripada kod sumber di atas, kaedah SpringApplication.run() menjalankan dua operasi, masing-masing Ia adalah penciptaan awal instance SpringApplication dan memanggil run() untuk memulakan projek tersebut. Pelaksanaan kedua-dua peringkat ini diperincikan seperti berikut

1. Penciptaan awal instance SpringApplication

Lihat maklumat kod sumber bagi permulaan dan penciptaan objek instance SpringApplication Kod teras adalah seperti berikut

    public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
        this.sources = new LinkedHashSet();
        this.bannerMode = Mode.CONSOLE;
        this.logStartupInfo = true;
        this.addCommandLineProperties = true;
        this.addConversionService = true;
        this.headless = true;
        this.registerShutdownHook = true;
        this.additionalProfiles = new HashSet();
        this.isCustomEnvironment = false;
        this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");
    // 把项目启动类.class设置为属性存储起来
        this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
    // 判断当前webApplicationType应用的类型
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
    // 设置初始化器(Initializer),最后会调用这些初始化器
        this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
    // 设置监听器(Listener)
        this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
    // 用于推断并设置项目main()方法启动的主程序启动类
        this.mainApplicationClass = this.deduceMainApplicationClass();

Seperti yang dapat dilihat daripada kod sumber di atas, permulaan. proses SpringApplication terutamanya merangkumi 4 bahagian, penerangan terperinci seperti berikut.

(1) this.webApplicationType = WebApplicationType.deduceFromClasspath()

digunakan untuk menentukan jenis aplikasi webApplicationType semasa. Kaedah deduceFromClasspath() digunakan untuk menyemak sama ada kelas ciri tertentu wujud di bawah laluan kelas Classpath, untuk menentukan sama ada jenis webApplicationType semasa ialah aplikasi SERVLET (aplikasi MVC tradisional sebelum Spring 5) atau aplikasi REAKTIF (aplikasi interaktif WebFlux yang mula muncul pada Spring 5)

(2) this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class))

Untuk tetapan pemula aplikasi SpringApplication. Semasa proses tetapan pemula, pemuat kelas Spring SpringFactoriesLoader akan digunakan untuk mendapatkan semua kelas pemula aplikasi yang tersedia ApplicationContextInitializer daripada fail spring.factores di bawah META-INF di bawah laluan kelas META-INF/spring.factories.

(3) this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class))

Digunakan untuk tetapan pendengar aplikasi SpringApplication. Proses tetapan pendengar pada asasnya adalah sama seperti proses tetapan pemula dalam langkah sebelumnya SpringFactoriesLoader juga digunakan untuk mendapatkan semua kelas pendengar yang tersedia ApplicationListener daripada fail spring.factores di bawah META-INF di bawah laluan kelas META-INF/spring.factories. .

(4) this.mainApplicationClass = this.deduceMainApplicationClass()

Digunakan untuk membuat kesimpulan dan menetapkan kelas permulaan program utama yang dimulakan oleh kaedah main() projek

2. Permulaan permulaan projek

Selepas menganalisis pemulaan dan penciptaan objek contoh SpringApplication di bahagian sebelumnya kod sumber (SpringApplication(primarySources)).run(args) baharu, semak proses permulaan permulaan projek dan kod teras dilaksanakan dengan kaedah run(args) Butirannya adalah seperti berikut:

  public ConfigurableApplicationContext run(String... args) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        ConfigurableApplicationContext context = null;
        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
        this.configureHeadlessProperty();
    // 第一步：获取并启动监听器
        SpringApplicationRunListeners listeners = this.getRunListeners(args);
        listeners.starting();
        Collection exceptionReporters;
        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
    // 第二步：根据SpringApplicationRunListeners以及参数来准备环境
            ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
            this.configureIgnoreBeanInfo(environment);
    // 准备Banner打印器 - 就是启动Spring Boot的时候打印在console上的ASCII艺术字体
            Banner printedBanner = this.printBanner(environment);
    // 第三步：创建Spring容器
            context = this.createApplicationContext();
            exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, new Object[]{context});
    // 第四步：Spring容器前置处理
            this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
    // 第五步：刷新容器
            this.refreshContext(context);
    // 第六步：Spring容器后置处理
            this.afterRefresh(context, applicationArguments);
            stopWatch.stop();
            if (this.logStartupInfo) {
                (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
            }
    // 第七步：发出结束执行的事件
            listeners.started(context);
    // 返回容器
            this.callRunners(context, applicationArguments);
        } catch (Throwable var10) {
            this.handleRunFailure(context, var10, exceptionReporters, listeners);
            throw new IllegalStateException(var10);
        }
        try {
            listeners.running(context);
            return context;
        } catch (Throwable var9) {
            this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners) null);
            throw new IllegalStateException(var9);
        }
    }

Seperti yang dapat dilihat daripada kod sumber di atas, proses permulaan permulaan projek secara amnya merangkumi bahagian berikut:

Langkah 1: Dapatkan dan mulakan pendengar

kaedah this.getRunListeners (args) dan listeners.starting() digunakan terutamanya untuk mendapatkan dan menjalankan pendengar SpringApplicationRunListener yang dimulakan semasa proses permulaan contoh SpringApplication.

Langkah 2: Sediakan persekitaran mengikut SpringApplicationRunListeners dan parameter

Kaedah.prepareEnvironment(pendengar, applicationArguments) ini digunakan terutamanya untuk pratetap persekitaran berjalan projek, dan pada masa yang sama, melalui ini Kaedah .configureIgnoreBeanInfo(environment ) untuk mengecualikan beberapa persekitaran berjalan yang tidak perlu

Langkah 3: Buat bekas Spring

Hakim berdasarkan webApplicationType dan tentukan jenis bekas Jika jenisnya adalah jenis SERVLET, yang sepadan akan dimuatkan melalui refleksi Bytecode, iaitu, AnnotationConfigServletWebServerApplicationContext, dan kemudian menggunakan konteks yang dimulakan sebelumnya (persekitaran konteks aplikasi), persekitaran (persekitaran berjalan projek), pendengar (pendengar berjalan), applicationArguments (parameter projek) dan printedBanner (maklumat ikon projek) untuk mencipta konteks aplikasi Pasang konfigurasi dan muat semula konfigurasi

Langkah 4: Pra-pemprosesan bekas spring

Langkah ini terutamanya tindakan persediaan sebelum bekas dimuat semula. Sediakan persekitaran kontena, termasuk pelbagai pembolehubah, dsb., yang merangkumi operasi yang sangat kritikal: menyuntik kelas permulaan ke dalam bekas untuk meletakkan asas bagi konfigurasi automatik seterusnya

Langkah 5: Muat semula bekas

Mula menyegarkan bekas spring, mulakan keseluruhan bekas IOC melalui kaedah muat semula (termasuk penentududukan sumber kacang, penghuraian, pendaftaran, dll.), dan daftarkan cangkuk penutupan dengan masa jalan JVM Konteks ini akan ditutup apabila JVM ditutup, melainkan pada masa itu Ditutup

Langkah 6: Pemprosesan pasca bekas spring

Antara muka sambungan, kaedah templat dalam mod reka bentuk, pelaksanaan lalai kosong. Jika anda mempunyai keperluan tersuai, anda boleh mengatasi kaedah ini. Contohnya, mencetak beberapa log permulaan dan penyiapan, atau beberapa pemprosesan pasca lain.

Langkah 7: Keluarkan acara yang menamatkan pelaksanaan

Dapatkan pendengar EventPublishingRunListener dan laksanakan kaedah yang dimulakan, dan masukkan bekas Spring yang dicipta, buat acara ApplicationStartedEvent dan laksanakan ConfigurableApplicationContext

kaedah publishEvent, iaitu, acara diterbitkan dalam bekas Spring, bukan dalam SpringApplication Ini berbeza daripada permulaan sebelumnya, yang menerbitkan terus kepada pendengar dalam acara SpringApplication.

Langkah 8: Laksanakan Pelari

Digunakan untuk memanggil kelas XxxRunner pelaksana tersuai dalam projek untuk melaksanakan beberapa program tertentu serta-merta selepas projek dimulakan. Antaranya, antara muka pelaksana yang disediakan oleh Spring Boot termasuk ApplicationRunner dan CommandLineRunner Apabila menggunakannya, anda hanya perlu menyesuaikan kelas pelaksana untuk melaksanakan salah satu antara muka dan menulis semula antara muka kaedah run() yang sepadan dimulakan serta-merta. Jalankan program khusus ini

Di bawah, melalui carta aliran pelaksanaan Spring Boot, beritahu semua orang dengan lebih jelas proses pelaksanaan keseluruhan dan peringkat permulaan utama Spring Boot:

Atas ialah kandungan terperinci Analisis contoh proses pelaksanaan SpringBoot. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!