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
- 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及自动配置类
版权声明:本文为weixin_37560207原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。