spring-: why-spring-cannot-match-by-name-for-injection

Spring dependence injection: Why can't it match the name automatically?

Spring's dependency injection mechanism is mainly

based on type , not names. When encountering multiple types of the same type (such as TenantDataSource), it will not automatically return to match according to the parameter name. This is because Spring cannot always guarantee the parameter name in the method to match the Bean name.

Java By default,

will not retain the parameter name in the compiled bytecode. If there is no special configuration, the parameter names (for example, TenantadataSource and TenantbDataSource) will be cleared during the compilation and replaced them with universal names, such as ARG0 and ARG1. Therefore, Spring cannot know that TenanTadataSource refers to the bean called "Tenanta-Datasource".

Solve the parameter name retention problem

You can use the Compiler logo to retain the parameter name in the byte code:

-parameters

Even if this logo is used, Spring will still not match the parameter name unless the configuration is clear.

<code>javac -parameters MyClass.java</code>

Spring avoids assumptions to prevent accidents. For example, if the parameter name is accidentally exchanged or named, or the developers expect different mappings, what will happen? If there is no clear guidance (such as

), Spring cannot determine the intention of the developer, and choose to throw an error instead of injecting the wrong bean.

@Qualifier Spring follows the principle of "explicitly better than hidden". Dependent injection should be predictable, and does not depend on the assumptions of parameter names to the matching of Bean name matching. Spring is consistent in different environments and frameworks. Some languages ​​or frameworks (such as KOTLIN) retain the parameter name by default, while other languages ​​are not retained. Therefore, Spring avoids dependent parameter names to achieve key functions.

When can the name match can work automatically?

Although Spring does not match the parameter name by default, it can be matched according to the parameter name in some cases, but it depends on your settings:

Spring 4.3 Parameter name Discover

If the logo compile code, when there is ambiguity, Spring can infer the name of the Bean from the parameter name.

Example: -parameters

If the logo and parameter names (Tenantadatasource, TenantbDataSource) and the Bean name are matched, Spring can solve the ambiguity. However, this behavior is not always reliable or predictable in complex configuration, which is why the preferred display configuration (such as

).

<code>@Autowired
public TenantService(TenantDataSource tenantADataSource, TenantDataSource tenantBDataSource) {
    this.tenantADataSource = tenantADataSource;
    this.tenantBDataSource = tenantBDataSource;
}</code>

Why is Spring more inclined to use @qualifier?

-parameters Use to ensure definition and eliminate ambiguity, so that both developers and frameworks can clearly intention. @Qualifier

Example:

In this way, Spring can accurately know which bean to inject, regardless of parameter name or other factors.

Spring should be smarter?

Some people may think that a framework like Spring should be more intelligent, and the Bean name is automatically matched with the parameter name when there is ambiguity. But:

1. Back compatibility : Automatically changing this behavior may destroy the existing applications that do not match the Bean name and parameter name.
predictability
2. : explicitly solve the ambiguity (for example, through ) to ensure that developers always know which bean is being injected. Reacable assumptions may cause difficulty in debugging, especially in large complex applications. @Qualifier
The situation in the real scene

In most actual applications:

Developers use meaningful bean names and parameter names, but they also prefer to prefer

to ensure their clarity.
• @Qualifier For multi -example scenes,
dynamically configure
• or factory -based methods (eg ABSTRACTROUTINGATASORCE), instead of manually connecting each bean.
Key points

Spring first injects by type

: If there is only one type of Bean, Spring will inject it without any problems. If there are multiple beans of the same type, Spring requires additional prompts (such as
1. ) to solve ambiguity. The parameter name is not reliable. @Qualifier: By default, the parameter name will not be kept in the Java bytecode, so Spring cannot use them to match the parameter with the parameters. Even if the parameter name (
) is retained, Spring will avoid the well -known matching matching, unless the configuration is clear.
2. Explicit is better than hidden : Spring priority consideration can be predictable, and encourages developers to use explicit configuration (such as -parameters or
) instead of relying on hidden matching.

3. Spring's design concept

   : Misty errors can prevent accidents and ensure that developers fully control the dependence injection. @Qualifier @Primary

The above is the detailed content of spring-: why-spring-cannot-match-by-name-for-injection. For more information, please follow other related articles on the PHP Chinese website!