@ConditionalOnMissingBean与@Primary对比：Spring注解选型疑问

Great question! This isn't just about cutting down on annotation clutter—@ConditionalOnMissingBean is a foundational piece of Spring Boot's auto-configuration philosophy, and it solves problems that @Primary simply can't address. Let's break down its key advantages:

1. Decouples Framework Auto-Configuration from Business Code #

@ConditionalOnMissingBean enables a clean separation between framework-provided defaults and your custom business logic. The idea is simple: the framework creates a default Bean only if you haven't defined your own implementation of that type.

Compare this to @Primary: if you relied on @Primary for defaults, you'd have to either mark the framework's default Bean as @Primary (coupling your business code to framework internals) or add @Primary to your custom Bean to override it. This mixes framework logic with your application code, which is messy and hard to maintain.

For example, Spring Boot's default JdbcTemplate auto-config uses @ConditionalOnMissingBean. All you need to do to replace it is define your own JdbcTemplate Bean—no extra annotations, no modifying framework code, just clean, isolated business logic.

2. Clear "Fallback" Semantics That Avoid Accidental Overrides #

The intent behind @ConditionalOnMissingBean is crystal clear: "Create this Bean only as a fallback when no other Bean of this type exists." It's a passive, defensive mechanism that prevents conflicts by design.

@Primary, on the other hand, is an active priority declaration. If you forget to mark your custom Bean as @Primary, or if multiple Beans are marked @Primary, you'll get unexpected behavior (like the default Bean being used when you meant to use your custom one). Debugging these priority conflicts can be a headache, especially in large applications.

With @ConditionalOnMissingBean, there's no ambiguity: if you define a custom Bean, the default one never gets created. No conflicts, no surprises.

3. Flexible Combination with Other Conditional Annotations #

@ConditionalOnMissingBean shines when combined with other Spring Boot conditional annotations (like @ConditionalOnClass, @ConditionalOnProperty, or @ConditionalOnBean). This lets you build sophisticated auto-config rules that adapt to your application's environment.

For example, Spring Boot's Redis auto-config uses:

@Bean
@ConditionalOnClass(RedisOperations.class)
@ConditionalOnMissingBean(RedisTemplate.class)
public RedisTemplate<?, ?> redisTemplate() {
    // default implementation
}

This ensures the default RedisTemplate is only created if:

• Redis classes are present on the classpath, and
• You haven't defined your own RedisTemplate Bean.

@Primary can't handle this kind of conditional logic—it's only about priority, not about whether a Bean should exist at all.

4. Aligns with "Convention Over Configuration" #

Spring Boot's core philosophy is "convention over configuration": provide sensible defaults so users don't have to configure everything, but let them override defaults easily when needed. @ConditionalOnMissingBean is the perfect tool for this.

It lets you focus on writing your custom business logic without worrying about disabling framework defaults. The framework automatically steps back when you provide your own implementation, which is exactly the kind of seamless experience Spring Boot is known for.

When to Use @Primary Instead? #

Don't get me wrong—@Primary has its place! Use it when you have multiple Beans of the same type within your own application and need to specify which one should be injected by default. It's for intra-application priority, not for overriding framework defaults.

内容的提问来源于stack exchange，提问作者pixel