springboot使用起來確實很方便，做到開箱即用，減少了許多繁瑣的配置。不過在使用過程中時常會想，為啥會這樣方便，springboot為我們做哪些工作。或者是我們在使用的過程中，會遇到springboot不滿足的情況，我們要去了解內部實現機制，然后才能改進。

過去我們對這種方式確很少去了解，或者是了解了一些但是沒有徹底搞清楚。今天我們就學習一下springboot相關的幾個問題，希望能夠揭開一些疑問。相信對這些看似比較基礎的知識地理解，會給我們設計程序帶來好的思路。

注解

spring最開始大量使用xml進行配置，當然也支持注解進行配置，springboot做了很多自動化的工作，進行默認配置，在此過程中將注解發揮到極致。所以在此之前先回顧一下注解的基本知識。

注解為代碼添加信息提供了一種形式化的方法，使得我們可以在后面某個時刻非常方便地使用這些數據。java5引入注解的，有需要多好處，完整地描述程序需要的信息，相比于增加其他非java語言的文件對程序描述，這樣使得代碼可讀性變差，并且不容易檢查。可以生成新的描述符文件設置是新的類定義，可以減少許多重復的模板代碼。

注解定義和常見的注解

java中內置了幾個常見的注解，這也是我們經常在代碼中見到的。

@Override 用來表示覆蓋父類中的方法，如果方法簽名寫錯，編譯器將會報錯，該注解是可選的。

@Deprecated 表示廢棄的方法或者字段，如果程序中使用了會報出警告。

@SuppressWarnings 關閉不當的編譯器警告信息

注解的定義需要使用到元注解，顧名思義，元注解就是用來定義注解的注解,例如：

@Target(ElementType.METHOD)

@Retention(RetentionPolicy.RUNTIME)

public @interface Test{}

這樣就定義了一個注解，注解的定義和接口定義非常類似，編譯后也會生成一個class文件。如果像上面的注解一樣，不包含任何元素，叫做標記注解。可以包含元素，就類似于接口的方法定義。但是和方法定義又有一些區別，訪問權修飾符為默認或者public，類型為八種基本類型和String,Enum,Class,annotations類型，以及它們的數組。

值得說明的是如果為annotation類型，說明這個注解是嵌套注解。成員名字自定義，另外有一點不同的是，相比接口方法的定義，這里可以設置默認值：

@Target(ElementType.METHOD)

@Retention(RetentionPolicy.RUNTIME)

public @interface Test{

public String value() default "some value";

public int test();//沒有默認值

}

如果成員里面有一個名字是value，并且是唯一一個被賦值的成員，那么不需要寫出成員名字直接賦值，例如:

@Test("a")

public void hello(){

…

}

四種元注解：

@Target 表示注解作用的對象，ElementType參數包括：

CONSTRUCTOR,構造器聲明

FIELD，域聲明

LOCAL_VARIABLE,局部變量聲明

METHOD，方法聲明

PACKAGE，包聲明

PARAMETER，參數聲明

TYPE，類，接口包括注解類型或enum聲明,對于注解類型特別要提到的是，這樣可以自定義注解的注解。

@Retention Retention是保留的意思，這個注解說的是被注解的注解被保留的級別，RetentionPolicy可選有：

SOURCE，保留在源碼中，也就是說編譯成class文件不會有該注解，被編譯器丟棄了

CLASS，保留在class文件中，但是在虛擬機運行的時候會丟棄該注解

RUNTIME，保留在運行期，一般都是通過反射機制讀取注解的信息

@Documented 表示注解包含在javadoc中

@Inherited 表示子類可以繼承父類的注解

上面說到RUNTIME的注解，類都實現了AnnotatedElement接口，具有getAnnotation()的實現方法，可以獲取到某個類型的注解：

Test test = method.getAnnocation(Test.class);

@Enable*注解

既然我們搞清楚了注解的基本使用方法，那么讓我們還看一看springboot是怎樣使用注解的。對于很多功能的啟用的開關是加上了@Enable*的注解，例如開啟eureka：

@EnableDiscoveryClient

以此為例，搞清楚這類注解的使用原理，首先看這個注解的定義：

@Target(ElementType.TYPE) //作用在類上面

@Retention(RetentionPolicy.RUNTIME) //jvm使用該注解

@Documented //javadoc包含該注解

@Inherited //子類可以繼承該注解

@Import(EnableDiscoveryClientImportSelector.class) //自定義元注解

public @interface EnableDiscoveryClient {

/**

* If true, the ServiceRegistry will automatically register the local server.

*/

boolean autoRegister() default true; //將該應用注冊到eureka server

}

元素就一個boolean類型的，直接說明的是這里使用了一個自定義的元注解，也就是該注解的@Target是ElementType.TYPE,其中的TYPE指的是一個注解定義的類：

@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注解非常重要，可以看到有一個唯一的默認的元素，這個元素名字叫value，后面為元素賦值的時候，可以不寫value，類型是一個class數組。我們知道這個@Import注解是為了引入一個類，下面來看一下注解處理器做了什么操作：

package org.springframework.context.annotation;

/**

* Recursively collect all declared {@code @Import} values. Unlike most

* meta-annotations it is valid to have several {@code @Import}s declared with

* different values; the usual process of returning values from the first

* meta-annotation on a class is not sufficient.

*

For example, it is common for a {@code @Configuration} class to declare direct

* {@code @Import}s in addition to meta-imports originating from an {@code @Enable}

* annotation.

* @param sourceClass the class to search

* @param imports the imports collected so far

* @param visited used to track visited classes to prevent infinite recursion

* @throws IOException if there is any problem reading metadata from the named class

*/

private void collectImports(SourceClass sourceClass, Set imports, Set visited)

throws IOException {

if (visited.add(sourceClass)) {

for (SourceClass annotation : sourceClass.getAnnotations()) {

String annName = annotation.getMetadata().getClassName();

if (!annName.startsWith("java") && !annName.equals(Import.class.getName())) {

collectImports(annotation, imports, visited);

}

}

imports.addAll(sourceClass.getAnnotationAttributes(Import.class.getName(), "value"));

}

}

上面的代碼片段是從spring中摘錄出來，將@Import注解中value的類加到集合中，后續生成bean進行加載。也就是說會把EnableDiscoveryClientImportSelector這個類生成bean加載到上下文中。

@Order(Ordered.LOWEST_PRECEDENCE - 100)

public class EnableDiscoveryClientImportSelector

extends SpringFactoryImportSelector {

@Override

public String[] selectImports(AnnotationMetadata metadata) {

String[] imports = super.selectImports(metadata);

AnnotationAttributes attributes = AnnotationAttributes.fromMap(

metadata.getAnnotationAttributes(getAnnotationClass().getName(), true));

boolean autoRegister = attributes.getBoolean("autoRegister");

if (autoRegister) {

List importsList = new ArrayList<>(Arrays.asList(imports));

importsList.add("org.springframework.cloud.client.serviceregistry.AutoServiceRegistrationConfiguration");

imports = importsList.toArray(new String[0]);

}

return imports;

}

@Override

protected boolean isEnabled() {

return new RelaxedPropertyResolver(getEnvironment()).getProperty(

"spring.cloud.discovery.enabled", Boolean.class, Boolean.TRUE);

}

@Override

protected boolean hasDefaultFactory() {

return true;

}

}

這個類由于繼承了SpringFactoryImportSelector，spring會進行import操作，在這個類里面，引入了org.springframework.cloud.client.serviceregistry.AutoServiceRegistrationConfiguration，這個類，所以使得該應用開啟了eureka客戶端的功能。

自動配置

通過源碼可以發現@SpringBootApplication注解定義中有，有元注解@EnableAutoConfiguration，讓我們看一下這個定義：

package org.springframework.boot.autoconfigure;

@SuppressWarnings("deprecation")

@Target(ElementType.TYPE)

@Retention(RetentionPolicy.RUNTIME)

@Documented

@Inherited

@AutoConfigurationPackage

@Import(EnableAutoConfigurationImportSelector.class)

public @interface EnableAutoConfiguration {

String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

/**

* Exclude specific auto-configuration classes such that they will never be applied.

* @return the classes to exclude

*/

Class>[] exclude() default {};

/**

* Exclude specific auto-configuration class names such that they will never be

* applied.

* @return the class names to exclude

* @since 1.3.0

*/

String[] excludeName() default {};

}

所有自動配置功能都由@AutoConfigurationPackage和@Import(EnableAutoConfigurationImportSelector.class)這兩個注解來決定。

@AutoConfigurationPackage

這個注解的源碼如下：

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;

/**

* Indicates that the package containing the annotated class should be registered with

* {@link AutoConfigurationPackages}.

*

* @author Phillip Webb

* @since 1.3.0

* @see AutoConfigurationPackages

*/

@Target(ElementType.TYPE)

@Retention(RetentionPolicy.RUNTIME)

@Documented

@Inherited

@Import(AutoConfigurationPackages.Registrar.class)

public @interface AutoConfigurationPackage {

}

通過注釋可以知道，這個注解的作用是將被該注解進行注解的類所在的包進行掃描。EnableAutoConfiguration被注解了，而該類在org.springframework.boot.autoconfigure包下面，所以會掃描該包下的類，聲明成bean的，將會生成bean。

/**

* {@link ImportBeanDefinitionRegistrar} to store the base package from the importing

* configuration.

*/

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {

@Override

public void registerBeanDefinitions(AnnotationMetadata metadata,

BeanDefinitionRegistry registry) {

register(registry, new PackageImport(metadata).getPackageName());

}

@Override

public Set determineImports(AnnotationMetadata metadata) {

return Collections.singleton(new PackageImport(metadata));

}

}

可以看到將BasePackages注冊在了注冊中心,BasePackages中含有包名：

public static void register(BeanDefinitionRegistry registry, String... packageNames) {

if (registry.containsBeanDefinition(BEAN)) {

BeanDefinition beanDefinition = registry.getBeanDefinition(BEAN);

ConstructorArgumentValues constructorArguments = beanDefinition

.getConstructorArgumentValues();

constructorArguments.addIndexedArgumentValue(0,

addBasePackages(constructorArguments, packageNames));

}

else {

GenericBeanDefinition beanDefinition = new GenericBeanDefinition();

beanDefinition.setBeanClass(BasePackages.class);

beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(0,

packageNames);

beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

registry.registerBeanDefinition(BEAN, beanDefinition);

}

}

這個bean的名字叫做AutoConfigurationPackages，需要說明的是，此時并沒有掃描包。

正如該類的注釋所說，是為了存儲需要自動配置的包，以便于后面的掃描器進行掃描。

* Class for storing auto-configuration packages for reference later (e.g. by JPA entity

* scanner).

也許此時會有個疑問，為啥不用@ComponentScan進行包掃描？

實際上，在org.springframework.boot.autoconfigure包下面，并不是所有的組件都需要包掃描，只有幾個組件的集成才需要，例如cassandra、jpa等，一般都是這樣的代碼：

@Bean

@ConditionalOnMissingBean

public CassandraMappingContext cassandraMapping(

CassandraCustomConversions conversions) throws ClassNotFoundException {

CassandraMappingContext context = new CassandraMappingContext();

List packages = EntityScanPackages.get(this.beanFactory)

.getPackageNames();

if (packages.isEmpty() && AutoConfigurationPackages.has(this.beanFactory)) {

packages = AutoConfigurationPackages.get(this.beanFactory);

}

if (!packages.isEmpty()) {

context.setInitialEntitySet(CassandraEntityClassScanner.scan(packages));

}

if (StringUtils.hasText(this.properties.getKeyspaceName())) {

context.setUserTypeResolver(new SimpleUserTypeResolver(this.cluster,

this.properties.getKeyspaceName()));

}

context.setCustomConversions(conversions);

return context;

}

上述代碼說明，如果存在@EntityScan注解的包，則只需要scan該包即可，如果不存在則將autoconfigure都scan了。

需要說明的是該注解，不是每個組件的自動配置都會用到，只有一部分用到，比較重要的是下面的自動配置功能。

EnableAutoConfigurationImportSelector的作用

下面是最關鍵的源碼：

@Override

public String[] selectImports(AnnotationMetadata annotationMetadata) {

if (!isEnabled(annotationMetadata)) {

return NO_IMPORTS;

}

try {

AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader

.loadMetadata(this.beanClassLoader);

AnnotationAttributes attributes = getAttributes(annotationMetadata);

List configurations = getCandidateConfigurations(annotationMetadata,

attributes);

configurations = removeDuplicates(configurations);

configurations = sort(configurations, autoConfigurationMetadata);

Set exclusions = getExclusions(annotationMetadata, attributes);

checkExcludedClasses(configurations, exclusions);

configurations.removeAll(exclusions);

configurations = filter(configurations, autoConfigurationMetadata);

fireAutoConfigurationImportEvents(configurations, exclusions);

return configurations.toArray(new String[configurations.size()]);

}

catch (IOException ex) {

throw new IllegalStateException(ex);

}

}

protected boolean isEnabled(AnnotationMetadata metadata) {

if (getClass().equals(AutoConfigurationImportSelector.class)) {

return getEnvironment().getProperty(

EnableAutoConfiguration.ENABLED_OVERRIDE_PROPERTY, Boolean.class,

true);

}

return true;

}

這個類會選擇哪些類會被引入并且生成一個Bean，如果屬性spring.boot.enableautoconfiguration為false，將會關閉自動配置。如果開啟的話，會將META-INFO目錄下的配置文件的配置讀進來，選擇需要引入的Bean。

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\

org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\

org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\

org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\

...

以RabbitMq進行舉例說明，需要引入RabbitAutoConfiguration這個Bean。

RabbitAutoConfiguration的作用

下面是該類的定義的一部分：

@Configuration

@ConditionalOnClass({ RabbitTemplate.class, Channel.class })

@EnableConfigurationProperties(RabbitProperties.class)

@Import(RabbitAnnotationDrivenConfiguration.class)

public class RabbitAutoConfiguration {

@Configuration

@ConditionalOnMissingBean(ConnectionFactory.class)

@Configuration注解說明是一個配置Bean。

@EnableConfigurationProperties(RabbitProperties.class),該注解的源碼如下：

@Target(ElementType.TYPE)

@Retention(RetentionPolicy.RUNTIME)

@Documented

@Import(EnableConfigurationPropertiesImportSelector.class)

public @interface EnableConfigurationProperties {

/**

* Convenient way to quickly register {@link ConfigurationProperties} annotated beans

* with Spring. Standard Spring Beans will also be scanned regardless of this value.

* @return {@link ConfigurationProperties} annotated beans to register

*/

Class>[] value() default {};

}

其中EnableConfigurationPropertiesImportSelector在生成Bean的時候，如果發現沒有RabbitProperties這個bean，會生成這個bean，然后我們又發現這個bean有@ConfigurationProperties，凡事有這個注解的Bean都會將配置文件的屬性映射到這個Bean的字段上。

@ConfigurationProperties(prefix = "spring.rabbitmq")

public class RabbitProperties {

所以此時會有RabbitProperties這個Bean存在。基于此會生成許多其他配置Bean，例如CachingConnectionFactory，這個Bean就含有文件的配置信息，供后面RabbitMq連接通信使用。這樣就完成了自動配置。

@Conditional條件注解

上面的注解中用到了條件注解，是值得關注的地方。上面通過自動配置，得到了RabbitMq的連接配置Bean也就是CachingConnectionFactory，這個類的定義是在org.springframework.amqp.rabbit.connection中，實際上使用rabbit的核心類可能是在另外一個jar包中，也就是說了配置類，但是沒有rabbitmq的操作類也沒有作用，怎樣確保有核心類，然后再進行加載配置Bean呢？還有一個問題需要思考，如果用戶自定義了一個連接配置Bean，而不是使用自動配置Bean？這些問題該怎么解決呢？

實際上springboot定義了非常靈活的條件注解：

@ConditionalOnMissingBean(ConnectionFactory.class)

再去看看這個注解的定義：

@Target({ ElementType.TYPE, ElementType.METHOD })

@Retention(RetentionPolicy.RUNTIME)

@Documented

@Conditional(OnBeanCondition.class)

public @interface ConditionalOnMissingBean {

/**

* The class type of bean that should be checked. The condition matches when each

* class specified is missing in the {@link ApplicationContext}.

* @return the class types of beans to check

*/

Class>[] value() default {};

/**

* The class type names of bean that should be checked. The condition matches when

* each class specified is missing in the {@link ApplicationContext}.

* @return the class type names of beans to check

*/

String[] type() default {};

/**

@Conditional這個注解是spring中定義的，它的成員是一些條件類，比如現在是OnBeanCondition.class。這里面核心的方法是判斷ConditionalOnMissingBean中的value這個Bean是否存在：

if (metadata.isAnnotated(ConditionalOnMissingBean.class.getName())) {

BeanSearchSpec spec = new BeanSearchSpec(context, metadata,

ConditionalOnMissingBean.class);

MatchResult matchResult = getMatchingBeans(context, spec);

if (matchResult.isAnyMatched()) {

String reason = createOnMissingBeanNoMatchReason(matchResult);

return ConditionOutcome.noMatch(ConditionMessage

.forCondition(ConditionalOnMissingBean.class, spec)

.because(reason));

}

matchMessage = matchMessage.andCondition(ConditionalOnMissingBean.class, spec)

.didNotFind("any beans").atAll();

}

除了這些條件以外，還有其他條件，列舉如下：

@ConditionalOnJava 系統的java版本是否符合要求

@ConditionalOnBean 容器中存在指定Bean；

@ConditionalOnMissingBean 容器中不存在指定Bean；

@ConditionalOnExpression 滿足SpEL表達式指定

@ConditionalOnClass 系統中有指定的類

@ConditionalOnMissingClass 系統中沒有指定的類

@ConditionalOnSingleCandidate 容器中只有一個指定的Bean，或者這個Bean是首選Bean

@ConditionalOnProperty 系統中指定的屬性是否有指定的值

@ConditionalOnResource 類路徑下是否存在指定資源文件

@ConditionalOnWebApplication 當前是web環境

@ConditionalOnNotWebApplication 當前不是web環境

@ConditionalOnJndi JNDI存在指定項

這樣我們就把整個自動配置大致流程搞清楚了。

4+

總結

以上是生活随笔為你收集整理的bootdefault和configuration_springboot常用注解、包引入和自动配置功能解读的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。