springboot 的starter原理及自定義starter

1. starter原理

1.1 @Enable*注解

Spring-boot 中提供了大量的@Enable* 的注解，用來開啟某些功能，其底層是依賴@Import來實作的
Spring-boot 啟動時會描述@ComponentScan下的包，只要不在其下的類都不能創建bean，擴寫@ComponentScan代碼不美觀
也可以用@Import用解決第二點中提到的問題，但@Import(“類名”)需要記住要引入的類名
當我們作為組件的提供者時，可以用@Enable* 對@Import進行封裝，用戶只要記住一個注解就能開啟相應的功能

1.1.1 示例

定義一個project:lab-starter，分別有兩個子模塊user-starter，user-comsumer

JYZs0f7g-1639993665177)(/Users/yangge/Library/Application Support/typora-user-images/image-20211214225335596.png)]

user-starter中定義UserConfig，用于向ioc容器注入User

package com.userLab.config;

import com.userLab.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

/**
 * 用戶配置類
 *
 * @author 楊秋頤 wyuyangqy@163.com
 * @since 2021-12-14 22:38
 */
@Component
public class UserConfig {

    @Bean
    public User user(){
        return new User();
    }
}

user-starter中定義@EnableUser注解，用@Import(UserConfig.class)使用戶啟動配置生效

package com.userLab.anno;

import com.userLab.config.UserConfig;
import org.springframework.context.annotation.Import;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 啟動用戶注解
 *
 * @author 楊秋頤 wyuyangqy@163.com
 * @since 2021-12-14 22:40
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(UserConfig.class)//使UserConfig配置生效
public @interface EnableUser {

}

在user-comsumer模塊中引入user-starter

<dependency>
    <groupId>com.lab</groupId>
    <artifactId>user-starter</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

在user-comsumer模塊中撰寫springboot啟動類

package com.lab;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

/**
 * springboot啟動類
 *
 * @author 楊秋頤 wyuyangqy@163.com
 * @since 2021-12-14 22:35
 */
@SpringBootApplication
//@EnableUser
public class UserComsumerApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(UserComsumerApplication.class, args);
        Object user = context.getBean("user");
        System.out.println("user = " + user);
    }
}

運行，沒有用@EnableUser注解，報錯，在ioc容器沒有user類，使用@EnableUser，則在ioc容器找到user，因為啟動類在com.lab包下，面UserConfig類在com.userLab下，spring默認掃描啟動類所在包及其子包

1.2 @Import注解

查看@Import的原始碼

/*
 * Copyright 2002-2016 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.context.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Indicates one or more {@link Configuration @Configuration} classes to import.
 *
 * <p>Provides functionality equivalent to the {@code <import/>} element in Spring XML.
 * Allows for importing {@code @Configuration} classes, {@link ImportSelector} and
 * {@link ImportBeanDefinitionRegistrar} implementations, as well as regular component
 * classes (as of 4.2; analogous to {@link AnnotationConfigApplicationContext#register}).
 *
 * <p>{@code @Bean} definitions declared in imported {@code @Configuration} classes should be
 * accessed by using {@link org.springframework.beans.factory.annotation.Autowired @Autowired}
 * injection. Either the bean itself can be autowired, or the configuration class instance
 * declaring the bean can be autowired. The latter approach allows for explicit, IDE-friendly
 * navigation between {@code @Configuration} class methods.
 *
 * <p>May be declared at the class level or as a meta-annotation.
 *
 * <p>If XML or other non-{@code @Configuration} bean definition resources need to be
 * imported, use the {@link ImportResource @ImportResource} annotation instead.
 *
 * @author Chris Beams
 * @author Juergen Hoeller
 * @since 3.0
 * @see Configuration
 * @see ImportSelector
 * @see ImportResource
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Import {

   /**
    * {@link Configuration}, {@link ImportSelector}, {@link ImportBeanDefinitionRegistrar}
    * or regular component classes to import.
    */
   Class<?>[] value();

}

可知@Import()里可以使用bean,Configuration,ImportSelector,ImportBeanDefinitionRegistra，這就是@Import的四種用法

1.2.2 @Import四種用法

匯入bean，使用剛才的啟動類，修改一下獲取bean的方法

package com.lab;

import com.userLab.pojo.User;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Import;

/**
 * springboot啟動類
 *
 * @author 楊秋頤 wyuyangqy@163.com
 * @since 2021-12-14 22:35
 */
@SpringBootApplication
//@EnableUser
@Import(User.class)
public class UserComsumerApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(UserComsumerApplication.class, args);
        //使用型別獲取用戶
        User user = context.getBean(User.class);
        System.out.println("user = " + user);
    }
}

啟動，能正常在ioc容器中獲取到user

匯入配置類，同樣使用剛才的啟動類

package com.lab;

import com.userLab.config.UserConfig;
import com.userLab.pojo.User;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Import;

/**
 * springboot啟動類
 *
 * @author 楊秋頤 wyuyangqy@163.com
 * @since 2021-12-14 22:35
 */
@SpringBootApplication
//@EnableUser
@Import(UserConfig.class)
public class UserComsumerApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(UserComsumerApplication.class, args);
        //使用型別獲取用戶
        User user = context.getBean(User.class);
        System.out.println("user = " + user);
    }
}

啟動，能正常在ioc容器中獲取到user

匯入，ImportSelector子類，與匯入bean不同的是：ImportSelector子類是批量，查看ImportSelector介面

/*
 * Copyright 2002-2013 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.context.annotation;

import org.springframework.core.type.AnnotationMetadata;

/**
 * Interface to be implemented by types that determine which @{@link Configuration}
 * class(es) should be imported based on a given selection criteria, usually one or
 * more annotation attributes.
 *
 * <p>An {@link ImportSelector} may implement any of the following
 * {@link org.springframework.beans.factory.Aware Aware} interfaces,
 * and their respective methods will be called prior to {@link #selectImports}:
 * <ul>
 * <li>{@link org.springframework.context.EnvironmentAware EnvironmentAware}</li>
 * <li>{@link org.springframework.beans.factory.BeanFactoryAware BeanFactoryAware}</li>
 * <li>{@link org.springframework.beans.factory.BeanClassLoaderAware BeanClassLoaderAware}</li>
 * <li>{@link org.springframework.context.ResourceLoaderAware ResourceLoaderAware}</li>
 * </ul>
 *
 * <p>{@code ImportSelector} implementations are usually processed in the same way
 * as regular {@code @Import} annotations, however, it is also possible to defer
 * selection of imports until all {@code @Configuration} classes have been processed
 * (see {@link DeferredImportSelector} for details).
 *
 * @author Chris Beams
 * @since 3.1
 * @see DeferredImportSelector
 * @see Import
 * @see ImportBeanDefinitionRegistrar
 * @see Configuration
 */
public interface ImportSelector {

   /**
    * Select and return the names of which class(es) should be imported based on
    * the {@link AnnotationMetadata} of the importing @{@link Configuration} class.
    * 入參：注解元物件
    * 回傳的是一系列類名，都會被實體化到ioc容器
    */
   String[] selectImports(AnnotationMetadata importingClassMetadata);

}

示例：

撰寫一個類實作ImportSelector

package com.userLab.config;

import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;

/**
 * 實體化配置類
 *
 * @author 楊秋頤 wyuyangqy@163.com
 * @since 2021-12-15 11:03
 */
public class BeanImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        // 實體化用戶、角色類
        return new String[]{"com.userLab.pojo.User","com.userLab.pojo.Role"};
    }
}

使用剛才的啟動類測驗

package com.lab;

import com.userLab.config.BeanImportSelector;
import com.userLab.config.UserConfig;
import com.userLab.pojo.Role;
import com.userLab.pojo.User;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Import;

/**
 * springboot啟動類
 *
 * @author 楊秋頤 wyuyangqy@163.com
 * @since 2021-12-14 22:35
 */
@SpringBootApplication
//@EnableUser
@Import(BeanImportSelector.class)
public class UserComsumerApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(UserComsumerApplication.class, args);
        //使用型別獲取用戶
        User user = context.getBean(User.class);
        System.out.println("user = " + user);
        //使用型別獲取角色
        Role role = context.getBean(Role.class);
        System.out.println("role = " + role);
    }
}

啟動，正常獲取到ioc中的用戶類及角色類

匯入ImportBeanDefinitionRegistrar 子類，通過注冊器把bean放入到容器中

撰寫一個ImportBeanDefinitionRegistrar的實作類

package com.userLab.config;

import com.userLab.pojo.Role;
import com.userLab.pojo.User;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;

/**
 * 物件實體化注冊器
 *
 * @author 楊秋頤 wyuyangqy@163.com
 * @since 2021-12-15 11:17
 */
public class BeanImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        // 能過BeanDefinitionBuilder 獲取 beanDefinition
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(User.class).getBeanDefinition();
        // 把user 注冊到ioc容器中
        registry.registerBeanDefinition("user",beanDefinition);

        beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(Role.class).getBeanDefinition();
        // 把role 注冊到ioc容器中
        registry.registerBeanDefinition("role",beanDefinition);
    }
}

使用啟動類測驗

package com.lab;

import com.userLab.config.BeanImportBeanDefinitionRegistrar;
import com.userLab.config.BeanImportSelector;
import com.userLab.config.UserConfig;
import com.userLab.pojo.Role;
import com.userLab.pojo.User;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Import;

/**
 * springboot啟動類
 *
 * @author 楊秋頤 wyuyangqy@163.com
 * @since 2021-12-14 22:35
 */
@SpringBootApplication
//@EnableUser
@Import(BeanImportBeanDefinitionRegistrar.class)
public class UserComsumerApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(UserComsumerApplication.class, args);
        //使用型別獲取用戶
        User user = context.getBean(User.class);
        System.out.println("user = " + user);
        //使用型別獲取角色
        Role role = context.getBean(Role.class);
        System.out.println("role = " + role);
    }
}

啟動，正常獲取到ioc中的用戶類及角色類

1.3 @EnableAutoConfigure注解

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.springframework.boot.autoconfigure;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.context.annotation.Import;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    Class<?>[] exclude() default {};

    String[] excludeName() default {};
}

可見用@@Import({AutoConfigurationImportSelector.class})，點擊進入AutoConfigurationImportSelector.class

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.springframework.boot.autoconfigure;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.Aware;
import org.springframework.beans.factory.BeanClassLoaderAware;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.boot.context.properties.bind.Binder;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.ResourceLoaderAware;
import org.springframework.context.annotation.DeferredImportSelector;
import org.springframework.context.annotation.DeferredImportSelector.Group;
import org.springframework.context.annotation.DeferredImportSelector.Group.Entry;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.AnnotationAttributes;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.Environment;
import org.springframework.core.io.ResourceLoader;
import org.springframework.core.io.support.SpringFactoriesLoader;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import org.springframework.util.StringUtils;

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
    private static final AutoConfigurationImportSelector.AutoConfigurationEntry EMPTY_ENTRY = new AutoConfigurationImportSelector.AutoConfigurationEntry();
    private static final String[] NO_IMPORTS = new String[0];
    private static final Log logger = LogFactory.getLog(AutoConfigurationImportSelector.class);
    private static final String PROPERTY_NAME_AUTOCONFIGURE_EXCLUDE = "spring.autoconfigure.exclude";
    private ConfigurableListableBeanFactory beanFactory;
    private Environment environment;
    private ClassLoader beanClassLoader;
    private ResourceLoader resourceLoader;

    public AutoConfigurationImportSelector() {
    }

    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        } else {
          
            AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
          // 重點看下面這個方法
            AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);
            return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
        }
    }
}

往后的方法跟進不在貼原始碼 getAutoConfigurationEntry -> getCandidateConfigurations -> loadFactoryNames -> getCandidateConfigurations -> loadSpringFactories -> classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :

而public static final String FACTORIES_RESOURCE_LOCATION = “META-INF/spring.factories”;

也就是說我們可以在META-INF/spring.factories組態檔中定義大量的自動配置類

我們可以在spring-boot-autoconfigure包中的 META-INF/spring.factories 看到spring已經整合了大量的自動配置
這些配置里又結合了Condition（可見《springboot Condition 詳解》），用于決策是否加載對應的物體配置

1.4 spring.factories配置

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\

能過以上key去定義相應的自動配置，多個時，以逗號隔開

2. 自定義starter

還是用剛才的例子，區別：我們這次不用在啟動類上加任何@Enable注解，在我們引入自定義starter包時自動，創建用戶類放入到容器中

2.1 代碼實作

在user-starter的resources下添加META-INF檔案夾

在META-INF下添加spring.factories檔案

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.userLab.config.UserConfig

在user-comsumer工程中，去掉啟動類中之前添加的引入UserConfig的注解

package com.lab;

import com.userLab.pojo.Role;
import com.userLab.pojo.User;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

/**
 * springboot啟動類
 *
 * @author 楊秋頤 wyuyangqy@163.com
 * @since 2021-12-14 22:35
 */
@SpringBootApplication
public class UserComsumerApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(UserComsumerApplication.class, args);
        //使用型別獲取用戶
        User user = context.getBean(User.class);
        System.out.println("user = " + user);
        //使用型別獲取角色
        Role role = context.getBean(Role.class);
        System.out.println("role = " + role);
    }
}

啟動，可見user自動注入到了ioc中，而role（沒配置）沒有

正常starter各級定義

定義一個starter包，用于引入其它包，什么都不做（類似parent，用來做starter包里引入的包的版本管理，確保引入的包版本為最佳兼容），其中引入了我們另外定義 XXX-autoconfig
XXX-autoconfig包內定義了spring.factories及自動配置類

轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/388427.html

標籤：其他

上一篇：Spring Data 家族之Redis

下一篇：jdk1.8 base64注意事項