Java SpringBoot中的配置顺序

Order of Configuration in SpringBoot

提问by chinmay

I am trying to understand how beans that we make using @Configurationtends to override the beans that are generated by SpringBoot by default. I have been working on a project where in many cases we create beans for things like ZuulConfigs and the assumption is, whatever we are making shall take precedence over the default generated bean. I have been trying to figure this out but can't. Basically,

我试图了解我们使用@Configuration的 bean如何覆盖默认情况下由 SpringBoot 生成的 bean。我一直在从事一个项目，在许多情况下，我们为 ZuulConfigs 之类的东西创建 bean，并且假设我们所做的一切都应优先于默认生成的 bean。我一直试图弄清楚这一点，但不能。基本上，

1. Is Spring achieving this via some custom class loader
2. If not how is this precedence working. Can I give some precedence in similar manner to my beans
3. Can I generate similar hierarchy in my project,if so how

1. Spring 是通过一些自定义类加载器实现的吗
2. 如果不是，这个优先级是如何工作的。我可以以类似的方式给我的豆子一些优先权吗
3. 我可以在我的项目中生成类似的层次结构吗，如果可以，如何

The help is highly appreciated

非常感谢您的帮助

回答by virsha

Spring AutoConfiguration is used to provide a basic configuration if certain classes are in the classpath or not.

如果某些类是否在类路径中，Spring AutoConfiguration 用于提供基本配置。

If you want to configure the order in which beans are instantiated by spring you can use

如果要配置 spring 实例化 bean 的顺序，可以使用

@DependsOn("A") 
 public class B {
 ...    
}

This would create bean "A", then "B". Hence you can order the configuration depending upon the beans need first to be done. Anyways Spring automatically detects the dependencies by analyzing the bean classes. for more help check this question Spring Boot AutoConfiguration Order

这将创建bean“A”，然后是“B”。因此，您可以根据首先需要完成的 bean 来订购配置。无论如何，Spring 通过分析 bean 类自动检测依赖项。如需更多帮助，请查看此问题 Spring Boot AutoConfiguration Order

Alternative : There is also "@AutoConfigureOrder" annotation(where you can prioritise the configuration), you can have a look in the codefor deeper understanding.

另一种选择：还有“@AutoConfigureOrder”注解（可以优先配置），可以查看代码更深入的理解。

Documentation of AutoConfiguration is here

AutoConfiguration 的文档在这里

回答by Darshan Mehta

First of all, class loading and bean creation are two different things. We don't need to create a bean to load a class, however, a class has to be loaded in order to create a bean.

首先，类加载和bean创建是两件不同的事情。我们不需要创建一个 bean 来加载一个类，但是，为了创建一个 bean，必须加载一个类。

Now, coming back to Spring's example, Spring looks into all the packages configured by @componentScanand creates beans of all the classes annotated with @Bean, @Configurationand/or @Component. Spring's container keeps track of all the beans created and hence, when it encounters user defined bean with same name and class type as default bean, it replaces the original definition with user defined one (e.g. we can create our custom @ObjectMapperto override Spring boot's own instance). You can also use @Primaryannotation to make you bean take precedence if another definition with same class exists (documentation here).

现在，回到 Spring 的示例，Spring 查看由,和/或@componentScan注释的所有类配置的所有包并创建 bean 。Spring 的容器会跟踪所有创建的 bean，因此，当它遇到与默认 bean 具有相同名称和类类型的用户定义 bean 时，它用用户定义的替换原始定义（例如，我们可以创建我们的自定义来覆盖 Spring boot 自己的实例）。如果存在具有相同类的另一个定义（此处的文档），您还可以使用注释使 bean 优先。@Bean@Configuration@Component@ObjectMapper@Primary

Below are the answers for your questions:

以下是您的问题的答案：

1. Spring uses reflection to load the classes and create instances. Although you can load the classes with your custom class loader (more on that here), you don't need to worry about it for @Configuration.
2. Yes, you can use @Primaryannotation to give your bean a precedence. You can also use @Order(here) to define the creation order for your beans.
3. With @Primary, @Orderand @Qualifierannotationyou can define your own hierarchy for bean creation.

1. Spring 使用反射来加载类并创建实例。虽然您可以使用您的自定义类加载器加载类（更多关于这里的内容），但您无需为@Configuration.
2. 是的，您可以使用@Primary注释为您的 bean 提供优先级。您还可以使用@Order（此处）来定义 bean 的创建顺序。
3. 使用@Primary,@Order和@Qualifier注释，您可以为 bean 创建定义自己的层次结构。

回答by Strelok

Just know this: Spring Boot (specifically) auto configuration classes are always configuredlast. After all user beans have been created. Spring Boot auto configuration classes almost always use the @ConditionalXXXXannotations to make sure that any beans of the same type/name and other conditions that are configured in your application will take precedence over the Spring Boot auto-configuredbeans.

只要知道这一点：Spring Boot（特别是）自动配置类总是最后配置。在创建了所有用户 bean 之后。Spring Boot 自动配置类几乎总是使用@ConditionalXXXX注释来确保应用程序中配置的任何具有相同类型/名称和其他条件的 bean 将优先于 Spring Boot自动配置的bean。

回答by Shruti Gupta

If you want your @Component to take precedence over other @Component while scanning all the components by spring, use @Order(Ordered.LOWEST_PRECEDENCE) i.e. the max value to load your component over other.

如果您希望 @Component 在通过 spring 扫描所有组件时优先于其他 @Component，请使用 @Order(Ordered.LOWEST_PRECEDENCE) 即加载您的组件而不是其他组件的最大值。

@Primary is used to give your bean a default preference, we can override the default preference using @Qualifier

@Primary 用于为您的 bean 提供默认首选项，我们可以使用 @Qualifier 覆盖默认首选项

回答by igor.zh

Can I give some precedence in similar manner to my beans

我可以以类似的方式给我的豆子一些优先权吗

Yes.

是的。

A) To define a specific order your Configuration classes will be handled (by the way, a Configuration class does not have to be annotated with @Configuration(so-called full definition), but it's enough to be annotated with @Component, @ComponentScan, @Import, @ImportResourceor just have a method annotated with @Bean- so-called lite definition), you should

A) 要定义您的 Configuration 类将被处理的特定顺序（顺便说一句，Configuration 类不必用@Configuration（所谓的完整定义）注释，但用@Component, @ComponentScan,注释就足够了@Import，@ImportResource或者只需要一个用@Bean- 所谓的 lite 定义注释的方法），你应该

1) add your Configuration Candidates to your SpringApplication's primarySource, for example, in your main method like that

1）将您的配置候选添加到您的SpringApplication's primarySource，例如，在您的主要方法中

SpringApplication.run(
   new Class[]{YourSpringBootApplication.class, Config1.class, Config2.class, ...},
   args);

2) and annotate each of your Configuration Candidates with @Orderannotation, any other ordering means like Orderedinterface, @DependsOnetc will be ignored by ConfigurationClassPostProcessor, the order in the primarySourcearray will also be ignored.

2) 并用注释对每个候选配置进行@Order注释，任何其他排序方式（如Ordered接口@DependsOn等）都将被忽略ConfigurationClassPostProcessor，primarySource数组中的顺序也将被忽略。

Then ConfigurationClassPostProcessorwill sort your Configuration Candidates and handle them according the @Orderannotation value you specified.

然后ConfigurationClassPostProcessor将对您的配置候选进行排序并根据@Order您指定的注释值处理它们。

B) The precedence can also be achieved by defining your own AutoConfiguration classes. Although both Configuration and AutoConfigurationare handled by the same ConfigurationClassPostProcessor, they are essentially distinctive machineries. To do so

B) 优先级也可以通过定义您自己的 AutoConfiguration 类来实现。尽管Configuration 和 AutoConfiguration由相同的处理方式处理ConfigurationClassPostProcessor，但它们本质上是不同的机器。这样做

1) define in your classpath /META-INF/spring.factoriesfile and put in the EnableAutoConfiguration section of it your AutoConfiguration classes like that

1）在你的类路径/META-INF/spring.factories文件中定义并在它的 EnableAutoConfiguration 部分中放入你的 AutoConfiguration 类

   org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
   your.package.AutoConfig1,your.package.AutoConfig2

2) and annotate your AutoConfiguration classes with @AutoConfigureOrder, @AutoConfigureAfter, or @AutoConfigureAfterannotations, any other ordering means again will be ignored.

2），并与注解你自动配置类@AutoConfigureOrder，@AutoConfigureAfter或@AutoConfigureAfter注解，任何其他排序手段再次将被忽略。

Like @Strelok pointed out, AutoConfiguration classes, your own and provided e.g. by spring-boot-autoconfigurelibrary alike, will be added to the end of the list of Configuration Candidates.

就像@Strelok 指出的那样，您自己的和由spring-boot-autoconfigure库等提供的 AutoConfiguration 类将被添加到候选配置列表的末尾。

Remember, however, that the order the Configuration Candidateswill be handled by ConfigurationClassPostProcessordoes not necessarily coincide with the order the beansdefined by the Configuration classes will be created. For example, you might define your Configuration class that overrides TomcatServletWebServerFactoryto make your own customization of Tomcat web server like

但是请记住，候选配置的处理ConfigurationClassPostProcessor顺序不一定与配置类定义的 bean 的创建顺序一致。例如，您可以定义您的 Configuration 类，该类覆盖TomcatServletWebServerFactory以进行您自己的 Tomcat Web 服务器自定义，例如

@Configuration
public class EmbeddedTomcatConfig {

@Bean
public TomcatServletWebServerFactory containerFactory() {
    ...
    return customizedTomcatWebServerFactory;
}

but this method will be called right at the moment when your Spring Boot application decides to create a Web server, regardless of how you defined the precedence for your EmbeddedTomcatConfigConfiguration class.

但是这个方法会在你的 Spring Boot 应用程序决定创建一个 Web 服务器的那一刻被调用，不管你如何定义你的EmbeddedTomcatConfigConfiguration 类的优先级。

Is Spring achieving this via some custom class loader

Spring 是通过一些自定义类加载器实现的吗

There is no need to. Although you could, as always with Spring, define your own ClassLoaderfor BeanFactory, standard ClassLoaderis good enough if everything you need for Configuration in your application is available in the classpath. Please notice, that at first phase ConfigurationClassPostProcessordoes not load(i.e. does not resolve) the Configuration candidates classes (otherwise, most of the classes in spring-boot-autoconfigurelibrary will fail to load). Instead it analyzes their annotations with bytecode analyzer, ASMby default. For that purpose, it is just enough to get a binary form, a byte array, of a class to feed it to bytecode analyzer.

没有必要。尽管您可以像往常一样使用 Spring 定义自己的ClassLoaderfor BeanFactory，但ClassLoader如果您的应用程序中的 Configuration 所需的一切都在类路径中可用，那么标准就足够了。请注意，第一阶段ConfigurationClassPostProcessor不加载（即不解析）配置候选类（否则，spring-boot-autoconfigure库中的大多数类将无法加载）。相反，它ASM默认使用字节码分析器分析它们的注释。为此，获取一个类的二进制形式，一个字节数组，将其提供给字节码分析器就足够了。