blocks|key|1589983|text|Spring+AutoConfiguration用于提供基本配置，如果某些类是否在类路径中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1589984|如果要配置按spring实例化bean的顺序，则可以使用|1589985|@DependsOn("A")+
+public+class+B+{
+...++++
}|code-block|syntax|javascript|1589986|这将创建bean+"A"，然后创建"B“。因此，您可以根据首先需要执行的bean对配置进行排序。无论如何，Spring通过分析bean类自动检测依赖项。要获得更多帮助，请查看此问题弹簧启动AutoConfiguration命令|offset|length|1589987|替代方案:还有"@AutoConfigureOrder“注释(您可以在其中对配置进行优先级排序)，您可以查看代码以获得更深入的理解。|1589988|AutoConfiguration的文档是这里|1589989|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/27667516/spring-boot-autoconfiguration-order|1|https://github.com/spring-projects/spring-boot/blob/master/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/AutoConfigurationSorter.java|2|https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-developing-auto-configuration.html^0|0|0|0|2I|N|0|0|1I|2|1|0|L|2|2|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|15|8|@]|9|@$K|16|L|17|1|18]]|A|$]]|$1|M|3|N|5|6|7|19|8|@]|9|@$K|1A|L|1B|1|1C]]|A|$]]|$1|O|3|P|5|6|7|1D|8|@]|9|@$K|1E|L|1F|1|1G]]|A|$]]|$1|Q|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]|Y|$5|T|U|V|A|$W|Z]]|10|$5|T|U|V|A|$W|11]]]]

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

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

<pre><code>@DependsOn("A") 
 public class B {
 ... 
}
</code></pre>

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 
<a href="https://stackoverflow.com/questions/27667516/spring-boot-autoconfiguration-order">Spring Boot AutoConfiguration Order</a>

Alternative : 
There is also "@AutoConfigureOrder" annotation(where you can prioritise the configuration), you can have a look in the <a href="https://github.com/spring-projects/spring-boot/blob/master/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/AutoConfigurationSorter.java" rel="noreferrer">code</a> for deeper understanding.

Documentation of AutoConfiguration is <a href="https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-developing-auto-configuration.html" rel="noreferrer">here</a>

blocks|key|1590035|text|首先，类加载和bean创建是两件不同的事情。我们不需要创建bean来加载类，但是必须加载类才能创建bean。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1590036|现在，回到Spring的示例，Spring查看由@componentScan配置的所有包，并创建带有@Bean、@Configuration和/或@Component注释的所有类的bean。Spring的容器跟踪创建的所有bean，因此，当它遇到与默认bean相同的名称和类类型的用户定义bean时，它会用用户定义的bean替换原始定义(例如，我们可以创建自定义@ObjectMapper来覆盖Spring自己的实例)。如果存在具有相同类的另一个定义(Documents这里)，您也可以使用@Primary注释来使bean优先。|offset|length|style|CODE|1590037|以下是你的问题的答案：|1590038|Spring使用反射加载类并创建实例。尽管您可以使用自定义类加载器加载类(更多关于这里)，但是对于@Configuration，您不需要担心它。|ordered-list-item|1590039|是的，您可以使用@Primary注释给bean一个优先级。您还可以使用@Order(这里)来定义bean的创建顺序。|1590040|使用@Primary、@Order和@Qualifier+注解，您可以为创建bean定义自己的层次结构。|1590041|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.spring.io/spring-boot/docs/current/reference/html/howto-data-access.html|1|https://stackoverflow.com/questions/5660115/loading-spring-context-with-specific-classloader|2|http://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/core/annotation/Order.html|3|https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/beans/factory/annotation/Qualifier.html^0|0|O|E|1E|5|1K|E|21|A|51|D|6T|8|6J|2|0|0|0|1D|E|15|2|1|0|8|8|Z|6|16|2|2|0|2|8|B|6|I|A|T|2|3|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@$D|16|E|17|F|G]|$D|18|E|19|F|G]|$D|1A|E|1B|F|G]|$D|1C|E|1D|F|G]|$D|1E|E|1F|F|G]|$D|1G|E|1H|F|G]]|9|@$D|1I|E|1J|1|1K]]|A|$]]|$1|H|3|I|5|6|7|1L|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1M|8|@$D|1N|E|1O|F|G]]|9|@$D|1P|E|1Q|1|1R]]|A|$]]|$1|M|3|N|5|L|7|1S|8|@$D|1T|E|1U|F|G]|$D|1V|E|1W|F|G]]|9|@$D|1X|E|1Y|1|1Z]]|A|$]]|$1|O|3|P|5|L|7|20|8|@$D|21|E|22|F|G]|$D|23|E|24|F|G]|$D|25|E|26|F|G]]|9|@$D|27|E|28|1|29]]|A|$]]|$1|Q|3|-4|5|6|7|2A|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]|Y|$5|T|U|V|A|$W|Z]]|10|$5|T|U|V|A|$W|11]]|12|$5|T|U|V|A|$W|13]]]]

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.

Now, coming back to Spring's example, Spring looks into all the packages configured by <code>@componentScan</code> and creates beans of all the classes annotated with <code>@Bean</code>, <code>@Configuration</code> and/or <code>@Component</code>. 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 <code>@ObjectMapper</code> to override Spring boot's own instance). You can also use <code>@Primary</code> annotation to make you bean take precedence if another definition with same class exists (documentation <a href="https://docs.spring.io/spring-boot/docs/current/reference/html/howto-data-access.html" rel="noreferrer">here</a>). 

Below are the answers for your questions:

<ol>
<li>Spring uses reflection to load the classes and create instances. Although you can load the classes with your custom class loader (more on that <a href="https://stackoverflow.com/questions/5660115/loading-spring-context-with-specific-classloader">here</a>), you don't need to worry about it for <code>@Configuration</code>.</li>
<li>Yes, you can use <code>@Primary</code> annotation to give your bean a precedence. You can also use <code>@Order</code>(<a href="http://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/core/annotation/Order.html" rel="noreferrer">here</a>) to define the creation order for your beans.</li>
<li>With <code>@Primary</code>, <code>@Order</code> and <code>@Qualifier</code> <a href="https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/beans/factory/annotation/Qualifier.html" rel="noreferrer">annotation</a> you can define your own hierarchy for bean creation.</li>
</ol>

blocks|key|1590053|text|只需知道:+Spring+(特别是)自动配置类总是最后配置的。在创建了所有用户been之后。Spring自动配置类几乎总是使用@ConditionalXXXX注释，以确保应用程序中配置的任何类型/名称相同的bean和其他条件都优先于Spring自动配置的bean。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1590054|entityMap^0|1R|G|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Just know this: Spring Boot (specifically) auto configuration classes are always configured last. After all user beans have been created. Spring Boot auto configuration classes almost always use the <code>@ConditionalXXXX</code> annotations 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-configured beans.

blocks|key|1590185|text|如果您希望您的@组件在春季扫描所有组件时优先于其他@组件，请使用@Order(Ordered.LOWEST_PRECEDENCE)即最大值来加载组件。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1590186|@+using用于给bean一个默认的首选项，我们可以使用@限定符覆盖默认的首选项|1590187|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

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.

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

blocks|key|296067|text|我能以类似的方式优先考虑我的bean吗？|type|blockquote|depth|inlineStyleRanges|entityRanges|data|296068|是。|unstyled|296069|(+A)要定义一个特定的顺序，您的配置类将被处理(顺便说一句，配置类不需要使用@Configuration+(所谓的完整定义)注释，但是只要用@Component、@ComponentScan、@Import、@ImportResource注释，或者仅仅有一个用@Bean+--所谓的lite定义注释的方法就足够了，您应该|offset|length|style|CODE|296070|1)将您的配置选择添加到您的SpringApplication的primarySource中，例如，在这样的主要方法中。|296071|SpringApplication.run(
+++new+Class[]{YourSpringBootApplication.class,+Config1.class,+Config2.class,+...},
+++args);|code-block|syntax|javascript|296072|2)用@Order注释对每个配置候选进行注释，Ordered接口、@DependsOn等任何其他排序方法都将被ConfigurationClassPostProcessor忽略，primarySource数组中的顺序也将被忽略。|296073|然后，ConfigurationClassPostProcessor将对您的配置候选进行排序，并根据您指定的@Order注释值处理它们。|296074|(+B)还可以通过定义自己的AutoConfiguration类来实现优先级。虽然配置和AutoConfiguration都由同一个ConfigurationClassPostProcessor处理，但本质上是与众不同的机器。这样做|BOLD|296075|1)在类路径/META-INF/spring.factories文件中定义，并将类似的AutoConfiguration类放入其中的EnableAutoConfiguration部分|296076|+++org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
+++your.package.AutoConfig1,your.package.AutoConfig2|296077|2)并用AutoConfiguration、@AutoConfigureAfter或@AutoConfigureAfter注释对您的类进行注释，任何其他排序方法都将再次被忽略。|296078|正如@Strelok所指出的，配置候选列表的末尾将添加AutoConfiguration类，您自己的类和spring-boot-autoconfigure库提供的类都是这样。|296079|但是，请记住，命令--配置候选项将由ConfigurationClassPostProcessor+处理--并不一定与将创建配置类定义的bean的顺序一致。例如，您可以定义覆盖TomcatServletWebServerFactory的配置类，以便对Tomcat服务器进行如下所示的自定义|296080|@Configuration
public+class+EmbeddedTomcatConfig+{

@Bean
public+TomcatServletWebServerFactory+containerFactory()+{
++++...
++++return+customizedTomcatWebServerFactory;
}|296081|但是，当Spring应用程序决定创建一个Web服务器时，无论您如何定义EmbeddedTomcatConfig配置类的优先级，这个方法都将被调用。|296082|Spring是否通过一些自定义的类加载器来实现这一目标？|296083|没有必要这样做。尽管您可以(与Spring一样)为ClassLoader定义自己的BeanFactory，但是如果应用程序中配置所需的所有东西都可以在类路径中使用，那么标准ClassLoader就足够了。请注意，在第一阶段，ConfigurationClassPostProcessor不加载(即不解析)配置候选类(否则，spring-boot-autoconfigure库中的大多数类将无法加载)。相反，它使用字节码分析器(默认情况下为ASM+)分析它们的注释。为此，只需获得类的二进制形式，字节数组，就可以将其提供给字节码分析器。|296084|entityMap^0|0|0|13|E|1Z|A|2A|E|2P|7|2X|F|3N|5|0|E|H|W|D|0|0|3|6|N|7|X|A|1J|V|2H|D|0|3|V|1I|6|0|15|K|2T|B|1U|V|0|6|Q|0|0|M|J|16|J|0|1G|P|0|7|9|1E|M|I|V|2G|T|0|0|Z|K|0|0|P|B|15|B|2E|B|34|V|4H|P|63|3|0^^$0|@$1|2|3|4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1J|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|1K|8|@$G|1L|H|1M|I|J]|$G|1N|H|1O|I|J]|$G|1P|H|1Q|I|J]|$G|1R|H|1S|I|J]|$G|1T|H|1U|I|J]|$G|1V|H|1W|I|J]]|9|@]|A|$]]|$1|K|3|L|5|D|7|1X|8|@$G|1Y|H|1Z|I|J]|$G|20|H|21|I|J]]|9|@]|A|$]]|$1|M|3|N|5|O|7|22|8|@]|9|@]|A|$P|Q]]|$1|R|3|S|5|D|7|23|8|@$G|24|H|25|I|J]|$G|26|H|27|I|J]|$G|28|H|29|I|J]|$G|2A|H|2B|I|J]|$G|2C|H|2D|I|J]]|9|@]|A|$]]|$1|T|3|U|5|D|7|2E|8|@$G|2F|H|2G|I|J]|$G|2H|H|2I|I|J]]|9|@]|A|$]]|$1|V|3|W|5|D|7|2J|8|@$G|2K|H|2L|I|X]|$G|2M|H|2N|I|X]|$G|2O|H|2P|I|J]]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|2Q|8|@$G|2R|H|2S|I|J]]|9|@]|A|$]]|$1|10|3|11|5|O|7|2T|8|@]|9|@]|A|$P|Q]]|$1|12|3|13|5|D|7|2U|8|@$G|2V|H|2W|I|J]|$G|2X|H|2Y|I|J]]|9|@]|A|$]]|$1|14|3|15|5|D|7|2Z|8|@$G|30|H|31|I|J]]|9|@]|A|$]]|$1|16|3|17|5|D|7|32|8|@$G|33|H|34|I|X]|$G|35|H|36|I|X]|$G|37|H|38|I|J]|$G|39|H|3A|I|J]]|9|@]|A|$]]|$1|18|3|19|5|O|7|3B|8|@]|9|@]|A|$P|Q]]|$1|1A|3|1B|5|D|7|3C|8|@$G|3D|H|3E|I|J]]|9|@]|A|$]]|$1|1C|3|1D|5|6|7|3F|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|D|7|3G|8|@$G|3H|H|3I|I|J]|$G|3J|H|3K|I|J]|$G|3L|H|3M|I|J]|$G|3N|H|3O|I|J]|$G|3P|H|3Q|I|J]|$G|3R|H|3S|I|J]]|9|@]|A|$]]|$1|1G|3|-4|5|D|7|3T|8|@]|9|@]|A|$]]]|1H|$]]

<blockquote>
 Can I give some precedence in similar manner to my beans
</blockquote>

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 <code>@Configuration</code> (so-called full definition), but it's enough to be annotated with <code>@Component</code>, <code>@ComponentScan</code>, <code>@Import</code>, <code>@ImportResource</code> or just have a method annotated with <code>@Bean</code> - so-called lite definition), you should 

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

<pre><code>SpringApplication.run(
 new Class[]{YourSpringBootApplication.class, Config1.class, Config2.class, ...},
 args);
</code></pre>

2) and annotate each of your Configuration Candidates with <code>@Order</code> annotation, any other ordering means like <code>Ordered</code> interface, <code>@DependsOn</code> etc will be ignored by <code>ConfigurationClassPostProcessor</code>, the order in the <code>primarySource</code> array will also be ignored.

Then <code>ConfigurationClassPostProcessor</code> will sort your Configuration Candidates and handle them according the <code>@Order</code> annotation value you specified.

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

1) define in your classpath <code>/META-INF/spring.factories</code> file and put in the EnableAutoConfiguration section of it your AutoConfiguration classes like that

<pre><code> org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
 your.package.AutoConfig1,your.package.AutoConfig2
</code></pre>

2) and annotate your AutoConfiguration classes with <code>@AutoConfigureOrder</code>, <code>@AutoConfigureAfter</code>, or <code>@AutoConfigureAfter</code> annotations, any other ordering means again will be ignored.

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

Remember, however, that the order the Configuration Candidates will be handled by <code>ConfigurationClassPostProcessor</code> does not necessarily coincide with the order the beans defined by the Configuration classes will be created. For example, you might define your Configuration class that overrides <code>TomcatServletWebServerFactory</code> to make your own customization of Tomcat web server like 

<pre><code>@Configuration
public class EmbeddedTomcatConfig {

@Bean
public TomcatServletWebServerFactory containerFactory() {
 ...
 return customizedTomcatWebServerFactory;
}
</code></pre>

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 <code>EmbeddedTomcatConfig</code> Configuration class.

<blockquote>
 Is Spring achieving this via some custom class loader
</blockquote>

There is no need to. Although you could, as always with Spring, define your own <code>ClassLoader</code> for <code>BeanFactory</code>, standard <code>ClassLoader</code> is good enough if everything you need for Configuration in your application is available in the classpath. Please notice, that at first phase <code>ConfigurationClassPostProcessor</code> does not load (i.e. does not resolve) the Configuration candidates classes (otherwise, most of the classes in <code>spring-boot-autoconfigure</code> library will fail to load). Instead it analyzes their annotations with bytecode analyzer, <code>ASM</code> by 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.

I am trying to understand how beans that we make using <code>@Configuration</code> tends 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,

<ol>
<li>Is Spring achieving this via some custom class loader</li>
<li>If not how is this precedence working. Can I give some precedence in similar manner to my beans</li>
<li>Can I generate similar hierarchy in my project,if so how</li>
</ol>

The help is highly appreciated

Order of Configuration in SpringBoot

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我试图了解我们使用@Configuration制作的bean是如何在默认情况下覆盖由SpringBoot生成的bean。我一直在做一个项目，在许多情况下，我们为像ZuulConfigs这样的东西创建bean，假设是，我们所做的任何事情都将优先于默认生成的bean。我一直在努力想办法，但做不到。基本上，Spring是否通...

问SpringBoot中的配置顺序
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问SpringBoot中的配置顺序EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问SpringBoot中的配置顺序
EN