Apakah proses permulaan SpringBoot?

Pengenalan kepada proses permulaan SpringBoot

Proses permulaan aplikasi SpringBoot boleh dibahagikan kepada langkah berikut:

• Memuatkan konteks aplikasi

• Imbas semua komponen dalam aplikasi

• Konfigurasikan persekitaran aplikasi secara automatik

• Mulakan pelayan web terbenam

Muat konteks aplikasi

Bekas yang mengandungi semua komponen aplikasi SpringBoot ialah konteksnya. Semasa proses permulaan, SpringBoot akan memuatkan dan memulakan bekas ini.

Kod sumber langkah ini berada dalam kelas SpringApplication. Khususnya, kaedah SpringApplication kelas run ialah titik masuk untuk proses ini. Dalam kaedah ini, Spring Boot akan mencipta konteks aplikasi dengan memanggil kaedah createApplicationContext.

Berikut ialah kod sumber kaedah createApplicationContext:

protected ConfigurableApplicationContext createApplicationContext() {
    Class<?> contextClass = this.applicationContextClass;
    if (contextClass == null) {
        try {
            switch (this.webApplicationType) {
                case SERVLET:
                    contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);
                    break;
                case REACTIVE:
                    contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
                    break;
                default:
                    contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
            }
        }
        catch (ClassNotFoundException ex) {
            throw new IllegalStateException(
                    "Unable to create a default ApplicationContext, " +
                    "please specify an ApplicationContextClass", ex);
        }
    }
    return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
}

Dalam kaedah ini, SpringBoot akan memilih kelas konteks yang sesuai berdasarkan jenis aplikasi (Servlet atau Reaktif). Seterusnya, gunakan mekanisme pantulan Java untuk membuat instantiate kelas dan mengembalikan objek konteks aplikasi boleh dikonfigurasikan.

Imbas semua komponen dalam aplikasi

Dalam langkah sebelumnya, SpringBoot mencipta konteks aplikasi. Pada peringkat ini, SpringBoot mengimbas semua komponen dalam aplikasi dan mendaftarkannya dengan konteks aplikasi.

Kod sumber langkah ini adalah dalam kaedah SpringApplication dalam kelas scan. Khususnya, dalam kaedah ini, SpringBoot mencipta objek SpringBootBeanDefinitionScanner dan menggunakannya untuk mengimbas semua komponen dalam aplikasi.

Berikut ialah kod sumber kaedah scan:

private void scan(String... basePackages) {
    if (ObjectUtils.isEmpty(basePackages)) {
        return;
    }
    ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(
            this.includeFilters, this.excludeFilters, this.resourceLoader);
    scanner.setResourceLoader(this.resourceLoader);
    scanner.setEnvironment(this.environment);
    scanner.setIncludeAnnotationConfig(this.useAnnotatedConfig);
    scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
        @Override
        protected boolean matchClassName(String className) {
            return getExcludeClassNames().contains(className);
        }
    });
    for (String basePackage : basePackages) {
        scanner.findCandidateComponents(basePackage).forEach(this.componentDefinitions::add);
    }
}

Dalam kaedah ini, SpringBoot akan mencipta objek ClassPathScanningCandidateComponentProvider dan menggunakannya untuk mengimbas semua komponen dalam aplikasi. Objek ini mengimbas semua kelas di bawah laluan pakej yang ditentukan dan menukarnya kepada definisi kacang Spring. Takrifan kacang ini akan didaftarkan dengan konteks aplikasi.

Konfigurasikan persekitaran aplikasi secara automatik

SpringBoot mendaftarkan semua komponen dalam aplikasi ke dalam konteks aplikasi dalam langkah sebelumnya. SpringBoot mengkonfigurasi persekitaran aplikasi secara automatik, termasuk sumber data, pengurus transaksi dan konfigurasi JPA.

Kod sumber langkah ini adalah dalam kaedah SpringApplication dalam kelas configureEnvironment. Dalam kaedah ini, Spring Boot mencipta objek SpringApplicationRunListeners dan menggunakannya untuk mengkonfigurasi persekitaran aplikasi.

Berikut ialah kod sumber kaedah configureEnvironment:

private void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
    if (this.addCommandLineProperties) {
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        environment.getPropertySources().addLast(new CommandLinePropertySource(applicationArguments));
    }
    this.listeners.environmentPrepared(environment);
    if (this.logStartupInfo) {
        this.logStartupInfo(environment);
    }
    ConfigurationPropertySources.attach(environment);
    Binder.get(environment).bind(ConfigurationPropertyName.EMPTY, Bindable.ofInstance(this.sources));
    if (!this.isCustomEnvironment) {
        EnvironmentConverter.configureEnvironment(environment, this.deduceEnvironmentClass());
    }
    this.listeners.environmentPrepared(environment);
}

Dalam kaedah ini, SpringBoot akan mencipta objek ApplicationArguments dan menukarnya menjadi sumber sifat baris arahan. Ia kemudian memanggil kaedah listeners dalam environmentPrepared untuk memberitahu aplikasi bahawa persekitaran sudah sedia. Selepas itu, SpringBoot akan mengikat sumber harta kepada persekitaran aplikasi dan memanggil kaedah listeners dalam environmentPrepared untuk memberitahu persekitaran aplikasi bahawa ia sudah sedia.

Mulakan pelayan web terbenam

Dalam langkah sebelumnya, SpringBoot telah melengkapkan konfigurasi persekitaran aplikasi secara automatik. Dalam langkah ini, SpringBoot akan memulakan pelayan web terbenam supaya aplikasi boleh menyediakan perkhidmatan web.

Kod sumber langkah ini adalah dalam kaedah SpringApplication dalam kelas run. Khususnya, dalam kaedah ini, SpringBoot memilih pelayan web terbenam yang sesuai berdasarkan jenis aplikasi (Servlet atau Reaktif) dan menggunakannya untuk memulakan aplikasi.

Berikut ialah kod sumber kaedah run:

public ConfigurableApplicationContext run(String... args) {
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    ConfigurableApplicationContext context = null;
    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
    configureHeadlessProperty();
    SpringApplicationRunListeners listeners = getRunListeners(args);
    listeners.starting();
    try {
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
        configureIgnoreBeanInfo(environment);
        Banner printedBanner = printBanner(environment);
        context = createApplicationContext();
        exceptionReporters = getSpringFactoriesInstances(
                SpringBootExceptionReporter.class,
                new Class[] { ConfigurableApplicationContext.class }, context);
        prepareContext(context, environment, listeners, applicationArguments, printedBanner);
        refreshContext(context);
        afterRefresh(context, applicationArguments);
        stopWatch.stop();
        if (this.logStartupInfo) {
            new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
        }
        listeners.started(context);
        callRunners(context, applicationArguments);
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, exceptionReporters, listeners);
        throw new IllegalStateException(ex);
    }
    try {
        listeners.running(context);
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, exceptionReporters, null);
        throw new IllegalStateException(ex);
    }
    return context;
}

Dalam kaedah ini, SpringBoot akan menggunakan objek StopWatch untuk mengira masa permulaan aplikasi. Ia kemudian memanggil kaedah listeners dalam starting untuk memberitahu aplikasi bahawa ia akan dimulakan. Seterusnya, SpringBoot menyediakan persekitaran aplikasi dan menggunakannya untuk mencipta konteks aplikasi. Selepas itu, SpringBoot akan memanggil kaedah listeners dalam started untuk memberitahu aplikasi bahawa ia telah dimulakan. Akhir sekali, SpringBoot akan memanggil kaedah callRunners untuk menjalankan semua komponen CommandLineRunner dan ApplicationRunner.

Atas ialah kandungan terperinci Apakah proses permulaan SpringBoot?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!