Which BeanPostProcessors handle @Autowired, @Resource, and @Inject, and how do their qualifier/name semantics interact when multiple candidates exist?

### The processors Spring turns injection annotations into actual wiring using **BeanPostProcessors** registered during context bootstrap (by `AnnotationConfigApplicationContext`, Spring Boot auto-config, or `<context:annotation-config/>`): - **`AutowiredAnnotationBeanPostProcessor`** — handles `@Autowired`, `@Value`, and **`@Inject`** (`jakarta.inject.Inject`) when that API is on the classpath. All are **by-type** resolvers. - **`CommonAnnotationBeanPostProcessor`** — handles JSR-250 common annotations including **`@Resource`** (by-name-first), plus lifecycle annotations `@PostConstruct`/`@PreDestroy`. `@Resource` resolution: explicit `name`, else derived injection-point name, else **type fallback**. Qualifier interpretation is delegated to a `AutowireCandidateResolver` — specifically `QualifierAnnotationAutowireCandidateResolver`, which understands Spring's `@Qualifier` **and** JSR-330 `@Named` (because @Named is meta-annotated with the JSR-330 `@Qualifier`), matching candidates by qualifier value / bean name. ### Resolution precedence for by-type injection (@Autowired / @Inject) Given multiple candidates of the required type, Spring narrows in this order: 1. **Qualifier match** — a `@Qualifier("x")` / `@Named("x")` on the injection point restricts to the bean(s) whose qualifier/name is `x`. 2. **@Primary** — among remaining candidates, a bean marked `@Primary` wins. (A qualifier match narrows the set *before* @Primary is consulted, so an explicit qualifier effectively beats @Primary.) 3. **`@Priority`** (jakarta.annotation.Priority) — if still multiple, the lowest priority value wins. 4. **Fallback to injection-point name** — the field/parameter name is used as a default qualifier matching a bean id. 5. If none of these yields exactly one → `NoUniqueBeanDefinitionException`; if zero → `NoSuchBeanDefinitionException` (unless `required=false`/Optional/ObjectProvider). ### Resolution for @Resource (by-name) 1. Bean whose **name** equals the explicit `name` attribute, or the derived field/property name. 2. If no name match → **by-type** fallback (then subject to the same ambiguity rules as above — but note @Primary applies in this type-fallback stage, not in the name stage). Because @Resource matches an exact name, it **ignores @Primary** whenever the name resolves — the name is authoritative. ### Interaction subtleties - **@Primary vs @Qualifier:** @Qualifier/@Named is a *filter*; @Primary is a *tiebreaker*. An explicit qualifier that selects a non-primary bean wins over @Primary because the primary is filtered out of the candidate set. - **@Primary vs @Resource name:** an exact @Resource name wins; @Primary only matters if @Resource falls back to type. - **@Inject + @Named vs @Autowired + @Qualifier:** functionally equivalent; both route through the same candidate resolver. - **Ordering of processors:** they operate on different annotations, so on a given element only one applies; there's no conflict unless you redundantly annotate (e.g., both @Autowired and @Resource on one field — avoid; behavior is confusing and order-dependent). - **Classpath dependency:** @Inject/@Named/@Resource all need the relevant Jakarta APIs (`jakarta.inject-api`, `jakarta.annotation-api`) present, or the annotations are ignored. ### Why this matters at a design level Understanding which processor owns which annotation explains **why** @Resource can disambiguate without @Qualifier, **why** @Primary sometimes seems ignored (a qualifier or @Resource name overrode it), and **why** mixing annotation families in one codebase invites confusion. A principal engineer standardizes on one style (typically constructor `@Autowired` + `@Qualifier`/`@Primary`) and reserves @Resource/JSR-330 for deliberate portability or by-name needs. ### Gotchas - Redundant `<context:annotation-config/>` plus component scanning can register processors twice; Spring guards against double-registration, but hand-declaring these processors as beans can cause surprises. - `@Priority` uses `jakarta.annotation.Priority` and only breaks ties among by-type candidates, not by-name. - On collections/arrays (`List<Foo>`), @Autowired injects **all** matching beans (ordered by @Order/@Priority), which changes the 'ambiguity' story entirely.