加入收藏 | 设为首页 |

心有不甘-面试必问 —— Spring Boot 是怎么完成主动装备的?

海外新闻 时间: 浏览:317 次

Spring Boot是Spring旗下许多的子项目之一,其理念是约好优于装备,它经过完结了主动装备(大多数用户平常习气设置的装备作为默许装备)的功用来为用户快速构建出标准化的运用。Spring Boot的特色能够概述为如下几点:

  • 内置了嵌入式的Tomcat、Jetty等Servlet容器,运用能够不必打包成War格局,而是能够直接以Jar格局运转。
  • 供给了多个可挑选的”starter”以简化Maven的依靠办理(也支撑Gradle),让您能够按需加载需求的功用模块。
  • 尽可能地进行主动装备,减少了用户需求动手写的各种冗余装备项,Spring Boot发起无XML装备文件的理念,运用Spring Boot生成的运用彻底不会生成任何装备代码与XML装备文件。
  • 供给了一整套的对运用状况的监控与办理的功用模块(经过引进spring-boot-starter-actuator),包括运用的线程信息、内存信息、运用是否处于健康状况等,为了满意更多的资源监控需求,Spring Cloud中的许多模块还对其进行了扩展。

有关Spring Boot的运用办法就不做多介绍了,如有爱好请自行阅览官方文档Spring Boot或其他文章。

现在微服务的概念愈来愈热,转型或测验微服务的团队也在如日渐增,而关于技能选型,Spring Cloud是一个比较好的挑选,它供给了一站式的分布式体系解决方案,包括了许多构建分布式体系与微服务需求用到的组件,例如服务办理、API网关、装备中心、音讯总线以及容错办理等模块。能够说,Spring Cloud”全家桶”极端合适刚刚触摸微服务的团队。好像有点跑题了,不过说了这么多,我想要着重的是,Spring Cloud中的每个组件都是依据Spring Boot构建的,而理解了Spring Boot的主动装备的原理,明显也是有优点的。

Spring Boot的主动装备看起来奇特,其实原理十分简略,背面全依靠于@Condition心有不甘-面试必问 —— Spring Boot 是怎么完成主动装备的?al注解来完结的。

什么是@Conditional?

@Conditional是由Spring 4供给的一个新特性,用于依据特定条件来操控Bean的创立行为。而在咱们开发依据Spring的运用的时分,难免会需求依据条件来注册Bean。

例如,你想要依据不同的运转环境,来让Spring注册对应环境的数据源Bean,关于这种简略的状况,彻底能够运用@Profile注解完结,就像下面代码所示:

@Configuration
public class AppConfig {
@Bean
@Profile("DEV")
public DataSource devDataSource() {
...
}
@Bean
@Profile("PROD")
public DataSource prodDataSource() {
...
}
}

剩余只需求设置对应的Profile特点即可,设置办法有如下三种:

  • 经过context.getEnvironment().setActiveProfiles("PROD")来设置Profile特点。
  • 经过设定jvm的spring.profiles.active参数来设置环境(Spring Boot中能够直接在application.properties装备文件中设置该特点)。
  • 经过在DispatcherServlet的初始参数中设置。

dispatcher
org.springframework.web.servlet.DispatcherServlet

spring.profiles.active
PROD


但这种办法只局限于简略的状况,并且经过源码咱们能够发现@Profile本身也运用了@Conditional注解。

package org.springframework.context.annotation;
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional({ProfileCondition.class}) // 组合了Conditional注解
public @interface Profile {
String[] value();
}
package org.springframework.context.annotation;
class ProfileCondition implements Condition {
ProfileCondition() {
}
// 经过提取出@Profile注解中的value值来与profiles装备信息进行匹配
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
if(context.getEnvironment() != null) {
MultiValueMap attrs = metadata.getAllAnnotationAttributes(Profile.class.getName());
if(attrs != null) {
Iterator var4 = ((List)attrs.get("value")).iterator();
Object value;
do {
if(!var4.hasNext()) {
return false;
}
value = var4.next();
} while(!context.getEnvironment().acceptsProfiles((String[])((String[])value)));
return true;
}
}
return true;
}
}

在事务杂乱的状况下,明显需求运用到@Conditional注解来供给愈加灵敏的条件判别,例如以下几个判别条件:

  • 在类途径中是否存在这样的一个类。
  • 在Spring容器中是否现已注册了某种类型的Bean(如未注册,咱们能够让其主动注册到容器中,上一条同理)。
  • 一个文件是否在特定的方位上。
  • 一个特定的体系特点是否存在。
  • 在Spring的装备文件中是否设置了某个特定的值。

举个栗子,假定咱们有两个依据不同数据库完结的DAO,它们全都完结了UserDao,其间JdbcUserDAO与MySql进行衔接,MongoUserDAO与MongoDB进行衔接。现在,咱们有了一个需求,需求依据命令行传入的体系参数来注册对应的UserDao,就像java -jar app.jar -DdbType=MySQL会注册JdbcUserDao,而java -jar app.jar -DdbType=MongoDB则会注册MongoUserDao。运用@Conditional能够很轻松地完结这个功用,只是需求在你自界说的条件类中去完结Condition接口,让咱们来看下面的代码。(以下事例来自:https://dzone.com/articles/how-springboot-autoconfiguration-magic-works)

public interface UserDAO {
....
}
public class JdbcUserDAO implements UserDAO {
....
}
public class MongoUserDAO implements UserDAO {
....
}
public class MySQLDatabaseTypeCondition implements Condition {
@Override
public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata metadata) {
String enabledDBType = System.getProperty("dbType"); // 取得体系参数 dbType
// 假设该值等于MySql,则条件建立
return (enabledDBType != null && enabledDBType.equalsIgnoreCase("MySql"));
}
}
// 与上述逻辑共同
public class MongoDBDatabaseTypeCondition implements Condition {
@Override
public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata metadata) {
String enabledDBType = System.getProperty("dbType");
return (enabledDBType != null && enabledDBType.equalsIgnoreCase("MongoDB"));
}
}
// 依据条件来注册不同的Bean
@Configuration
public class AppConfig {
@Bean
@Conditional(MySQLDatabaseTypeCondition.class)
public UserDAO jdbcUserDAO() {
return new JdbcUserDAO();
}
@Bean
@Conditional(MongoDBDatabaseTypeCondition.class)
public UserDAO mongoUserDAO() {
return new MongoUserDAO();
}
}

现在,咱们又有了一个新需求,咱们想要依据当时工程的类途径中是否存在MongoDB的驱动类来承认是否注册MongoUserDAO。为了完结这个需求,能够创立检查MongoDB驱动是否存在的两个条件类。

public class MongoDriverPresentsCondition implements Condition {
@Override
public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata metadata) {
try {
Class.forName("com.mongodb.Server");
return true;
} catch (ClassNotFoundException e) {
return false;
}
}
}
public class MongoDriverNotPresentsCondition implements Condition {
@Override
public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata metadata) {
try {
Class.forName("com.mongodb.Server");
return false;
} catch (ClassNotFoundException e) {
return true;
}
}
}

假设,你想要在UserDAO没有被注册的状况下去注册一个UserDAOBean,那么咱们能够界说一个条件类来检查某个类是否在容器中已被注册。

public class UserDAOBeanNotPresentsCondition implements Condition {
@Override
public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata metadata) {
UserDAO userDAO = conditionContext.getBeanFactory().getBean(UserDAO.class);
return (userDAO == null);
}
}

假设你想依据装备文件中的某项特点来决议是否注册MongoDAO,例如app.dbType是否等于MongoDB,咱们能够完结以下的条件类。

public class MongoDbTypePropertyCondition implements Condition {
@Override
public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata metadata) {
String dbType = conditionContext.getEnvironment().getProperty("app.dbType");
return "MONGO".equalsIgnoreCase(dbType);
}
}

咱们现已测验并完结了各种类型的条件判别,接下来,咱们能够挑选一种更为高雅的办法,就像@Profile相同,以注解的办法来完结条件判别。首要,咱们需求界说一个注解类。

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(DatabaseTypeCondition.class)
public @interface DatabaseType {
String value();
}

详细的条件判别逻辑在DatabaseTypeCondition类中,它会依据体系参数dbType来判别注册哪一个Bean。

public class DatabaseTypeCondition implements Condition {
@Override
public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata metadata) {
Map attributes = metadata
.getAnnotationAttributes(DatabaseType.class.getName());
String type = (String) attributes.get("value");
// 默许值为MySql
String enabledDBType = System.getProperty("dbType", "MySql");
return (enabledDBType != null && type != null && enabledDBType.equalsIgnoreCase(type));
}
}

最终,在装备类运用该注解即可。

@Configuration
@ComponentScan
public class AppConfig {
@Bean
@DatabaseType("MySql")
public UserDAO jdbcUserDAO() {
return new JdbcUserDAO();
}
@Bean
@DatabaseType("mongoDB")
public UserDAO mongoUserDAO() {
return new MongoUserDAO();
}
}

AutoConfigure源码剖析

经过了解@Co心有不甘-面试必问 —— Spring Boot 是怎么完成主动装备的?nditional注解的机制其完结已能够猜到主动装备是怎样完结的了,接下来咱们经过源码来看看它是怎样做的。本文中解说的源码依据Spring Boot 1.5.9版别(最新的正式版别)。

运用过Spring Boot的童鞋应该都很清楚,它会替咱们生成一个进口类,其命名标准为ArtifactNameApplication,经过这个进口类,咱们能够发现一些信息。

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

首要该类被@SpringBootApplication注解润饰,咱们能够先从它开端剖析,检查源码后能够发现它是一个包括许多注解的组合注解。

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
excludeFilters = {@Filter(
type = FilterType.CUSTOM,
classes = {TypeExcludeFilter.class}
), @Filter(
type = FilterType.CUSTOM,
classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
@AliasFor(
annotation = EnableAutoConfiguration.class,
attribute = "exclude"
)
Class
@AliasFor(
annotation = EnableAutoConfiguration.class,
attribute = "excludeName"
)
String[] excludeName() default {};
@AliasFor(
annotation = ComponentScan.class,
attribute = "basePackages"
)
String[] scanBasePackages() default {};
@AliasFor(
annotation = ComponentScan.class,
attribute = "basePackageClasses"
)
Class
}

该注解相当于一起声明晰@Configuration、@EnableAutoConfiguration与@ComponentScan三个注解(假设咱们想定制自界说的主动装备完结,声明这三个注解就足够了),而@EnableAutoConfiguration是咱们的关注点,从它的姓名能够看出来,它是用来敞开主动装备的,源码如下:

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

咱们发现@Import(Spring 供给的一个注解,能够导入装备类或许Bean到当时类中)导入了EnableAutoConfigurationImportSelector类,依据姓名来看,它应该便是咱们要找到的方针了。不过检查它的源码发现它现已被Deprecated了,而官方API中奉告咱们去检查它的父类AutoConfigurationImportSelector。

/** @deprecated */
@Deprecated
public class EnableAutoConfigurationImportSelector extends AutoConfigurationImportSelector {
public EnableAutoConfigurationImportSelector() {
}
protected boolean isEnabled(AnnotationMetadata metadata) {
return this.getClass().equals(EnableAutoConfigurationImportSelector.class)?((Boolean)this.getEnvironment().getProperty("spring.boot.enableautoconfiguration", Boolean.class, Boolean.valueOf(true))).booleanValue():true;
}
}

因为AutoConfigurationImportSelector的源码太长了,这儿我只截出要害的当地,明显办法selectImports是挑选主动装备的主进口,它调用了其他的几个办法来加载元数据等信息,最终回来一个包括许多主动装备类信息的字符串数组。

public String[] selectImports(AnnotationMetadata annotationMetadata) {
if(!this.isEnabled(annotationMetadata)) {
return NO_IMPORTS;
} else {
try {
AutoConfigurationMetadata ex = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
List configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
configurations = this.removeDuplicates(configurations);
configurations = this.sort(configurations, ex);
Set exclusions = this.getExclusions(annotationMetadata, attributes);
this.checkExcludedClasses(configurations, exclusions);
configurations.removeAll(exclusions);
configurations = this.filter(configurations, ex);
this.fireAutoConfigurationImportEvents(configurations, exclusions);
return (String[])configurations.toArray(new String[configurations.size()]);
} catch (IOException var6) {
throw new IllegalStateException(var6);
}
}
}

要点在于办法getCandidateConfigurations()回来了主动装备类的信息列表,而它经过调用SpringFactoriesLoader.loadFactoryNames()来扫描加载含有META-INF/spring.factories文件的jar包,该文件记录了具有哪些主动装备类。

protected List getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
List configurations = SpringFactoriesLoader
.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
Assert.notEmpty(configurations, "No auto configuration classes
found in META-INF spring.factories.
If you are using a custom packaging, make sure that file is correct.");
return configurations;
}
public static List loadFactoryNames(Class
String factoryClassName = factoryClass.getName();
try {
Enumeration ex = classLoader != null?classLoader.getResources("META-INF/spring.factories"):ClassLoader.getSystemResources("META-INF/spring.factories");
ArrayList result = new ArrayList();
while(ex.hasMoreElements()) {
URL url = (URL)ex.nextElement();
Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
String factoryClassNames = properties.getProperty(factoryClassName);
result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));
}
return result;
} catch (IOException var8) {
throw new IllegalArgumentException("Unable to load [" + factoryClass.getName() + "] factories from location [" + "META-INF/spring.factories" + "]", var8);
}
}

spring.factories

全套java材料,电子书、视频、源码各种宝贵学习材料,需求的小伙伴私信小编(学习)限时免费收取!

主动装备类中的条件注解

接下来,咱们在spring.factories文件中随意找一个主动装备类,来看看是怎样完结的。我检查了MongoDataAutoConfiguration的源码,发现它声明晰@ConditionalOnClass注解,经过看该注解的源码后能够发现,这是一个组合了@Conditional的组合注解,它的条件类是OnClassCondition。

@Configuration
@ConditionalOnClass({Mongo.class, MongoTemplate.class})
@EnableConfigurationProperties({MongoProperties.class})
@AutoConfigureAfter({MongoAutoConfiguration.class})
public class MongoDataAutoConfiguration {
....
}
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional({OnClassCondition.class})
public @interface ConditionalOnClass {
Class
String[] name() default {};
}

然后,咱们开端看OnClassCondition的源码,发现它并没有直接完结Condition接口,只好往上找,发现它的父类SpringBootCondition完结了Condition接口。

class OnClassCondition extends SpringBootCondition implements AutoConfigurationImportFilter, BeanFactoryAware, BeanClassLoaderAware {
.....
}
public abstract class SpringBootCondition implements Condition {
private final Log logger = LogFactory.getLog(this.getClass());
public SpringBootCondition() {
}
public final boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
String classOrMethodName = getClassOrMethodName(metadata);
try {
ConditionOutcome ex = this.getMatchOutcome(context, metadata);
this.logOutcome(classOrMethodName, ex);
this.recordEvaluation(context, classOrMethodName, ex);
retur性和爱n ex.isMatch();
} catch (NoClassDefFoundError var5) {
throw new IllegalStateException("Could not evaluate condition on " + classOrMethodName + " due to " + var5.getMessage() + " not found. Make sure your own configuration does not rely on that class. This can also happen if you are @ComponentScanning a springframework package (e.g. if you put a @ComponentScan in the default package by mistake)", var5);
} catch (RuntimeException var6) {
throw new IllegalStateException("Error processing condition on " + this.getName(metadata), var6);
}
}
public abstract ConditionOutcome getMatchOutcome(ConditionContext var1, AnnotatedTypeMetadata var2);
}

SpringBootCondition完结的matches办法依靠于一个笼统办法this.getMatchOutcome(context, metadata),咱们在它的子类OnClassCondition中能够找到这个办法的详细完结。

public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
ClassLoader classLoader = context.getClassLoader();
ConditionMessage matchMessage = ConditionMessage.empty();
// 找出一切ConditionalOnClass注解的特点
List onClasses = this.getCandidates(metadata, ConditionalOnClass.class);
List onMissingClasses;
if(onClasses != null) {
// 找出不在类途径中的类
onMissingClasses = this.getMatches(onClasses, OnClassCondition.MatchType.MISSING, classLoader);
// 假设存在不在类途径中的类,匹配失利
if(!onMissingClasses.isEmpty()) {
return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnClass.class, new Object[0]).didNotFind("required class", "required classes").items(Style.QUOTE, onMissingClasses));
}
matchMessage = matchMessage.andCondition(ConditionalOnClass.class, new Object[0]).found("required class", "required classes").items(Style.QUOTE, this.getMatches(onClasses, OnClassCondition.MatchType.PRESENT, classLoader));
}
// 接着找出一切ConditionalOnMissingClass注解的特点
// 它与ConditionalOnClass注解的意义正好相反,所以以下逻辑也与上面相反
onMissingClasses = this.getCandidates(metadata, ConditionalOnMissingClass.class);
if(onMissingClasses != null) {
List present = this.getMatches(onMissingClasses, OnClassCondition.MatchType.PRESENT, classLoader);
if(!present.isEmpty()) {
return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnMissingClass.class, new Object[0]).found("unwanted class", "unwanted classes").items(Style.QUOTE, present));
}
matchMessage = matchMessage.andCondition(ConditionalOnMissingClass.class, new Object[0]).didNotFind("unwanted class", "unwanted classes").items(Style.QUOTE, this.getMatches(onMissingClasses, OnClassCondition.MatchType.MISSING, classLoader));
}
return ConditionOutcome.match(matchMessage);
}
// 取得一切annotationType注解的特点
private List getCandidates(AnnotatedTypeMetadata metadata, Class
MultiValueMap attributes心有不甘-面试必问 —— Spring Boot 是怎么完成主动装备的? = metadata.getAllAnnotationAttributes(annotationType.getName(), true);
ArrayList candidates = new ArrayList();
if(attributes == null) {
return Collections.emptyList();
} else {
this.addAll(candidates, (List)attributes.get("value"));
this.addAll(candidates, (List)attributes.get("name"));
return candidates;
}
}
private void addAll(List list, List itemsToAdd) {
if(itemsToAdd != null) {
Iterator var3 = itemsToAdd.iterator();
while(var3.hasNext()) {
Object item = var3.next();
Collections.addAll(list, (String[])((String[])item));
}
}
}
// 依据matchType.matches办法来进行匹配
private List getMatches(Collection candidates, OnClassCondition.MatchType matchType, ClassLoader classLoader) {
ArrayList matches = new ArrayList(candidates.size());
Iterator var5 = candidates.iterator();
while(var5.hasNext()) {
String candidate = (String)var5.next();
if(matchType.matches(candidate, classLoader)) {
matches.add(candidate);
}
}
return matches;
}

关于match的详细完结在MatchType中,它是一个枚举类,供给了PRESENT和MISSING两种完结,前者回来类途径中是否存在该类,后者相反。

private static enum MatchType {
PRESENT {
public boolean matches(String className, ClassLoader classLoader) {
return OnClassCondition.MatchType.isPresent(className, classLoader);
}
},
MISSING {
public boolean matches(String className, ClassLoader classLoader) {
return !OnClassCondition.MatchType.isPresent(className, classLoader);
}
};
private MatchType() {
}
// 跟咱们之前看过的事例相同,都利用了类加载功用来进行判别
private static boolean isPresent(String className, ClassLoader classLoader) {
if(classLoader == null) {
classLoader = ClassUtils.getDefaultClassLoader();
}
try {
forName(className, classLoader);
return true;
} catch (Throwable var3) {
return false;
}
}
private static Class
return classLoader != null?classLoader.loadClass(className):Class.forName(className);
}
public abstract boolean matches(String var1, ClassLoader var2);
}

现在总算水落石出,@ConditionalOnClass的意义是指定的类有必要存在于类途径下,MongoDataAutoConfiguration类中声明晰类途径下有必要含有Mongo.class, MongoTemplate.class这两个类,不然该主动装备类不会被加载。

在Spring Boot中处处都有相似的注解,像@ConditionalOnBean(容器中是否有指定的Bean),@ConditionalOnWebApplication(当时工程是否为一个Web工程)等等,它们都只是@Conditional注解的扩展。当你揭开奥秘的面纱,去探究实质时,发现其实Spring Boot主动装备的原理便是如此简略,在了解这些常识后,你彻底能够自己去完结自界说的主动装备类,然后编写出自界说的starter。

java零根底进阶,教程、源码、实战项目,你还怕学不会吗?赶忙私信小编(学习)收取吧!