Configuration & Component Model

@Conditional is an annotation you put on a @Bean or @Configuration. It points to a class implementing the Condition interface, whose matches() method returns true/false. Spring registers the bean only when matches() returns true.

@Configuration marks a class as a source of bean definitions. Inside it, a method annotated with @Bean returns an object that Spring registers as a bean in the application context, managing its lifecycle.

It registers beans by calling code — e.g. context.registerBean(MyService.class, MyService::new) — instead of using @Component scanning or @Bean methods. You give Spring a name, a type, and a lambda that creates the instance.

@Import lets one Java @Configuration class pull in beans defined in another. You can import other @Configuration classes, ImportSelector or ImportBeanDefinitionRegistrar implementations, and (since Spring 4.2) plain component classes.

Stereotype annotations mark a class as a Spring-managed bean so component scanning picks it up. @Component is the base; @Service, @Repository, and @Controller are specializations of @Component for the service, persistence, and web layers.

@ComponentScan can narrow what it registers using includeFilters (register extra matching classes) and excludeFilters (skip matching classes). Each filter has a FilterType: ANNOTATION, ASSIGNABLE_TYPE, ASPECTJ, REGEX, or CUSTOM.

In a @Configuration class (full mode), Spring CGLIB-subclasses it so calling one @Bean method from another returns the cached singleton, not a new object. @Bean methods in a plain class (lite mode) aren't intercepted, so each direct call runs the method again.

registerBean(Class, Supplier, BeanDefinitionCustomizer...): the Class is the bean type, the Supplier is a lambda that creates the instance, and each BeanDefinitionCustomizer is a lambda that tweaks the BeanDefinition — e.g. set scope, primary, or lazy.

ImportSelector is a Spring interface with one method, selectImports(AnnotationMetadata), that returns an array of fully-qualified class names. Spring imports each returned class as if you had listed it in @Import, letting you choose configs dynamically.

@Repository marks persistence classes and enables automatic translation of native, technology-specific exceptions (like JDBC SQLException or JPA PersistenceException) into Spring's consistent DataAccessException hierarchy, so callers don't depend on the underlying data-access API.

ConfigurationCondition extends Condition and adds getConfigurationPhase(), returning PARSE_CONFIGURATION or REGISTER_BEAN. It tells Spring when to evaluate the condition. 'Missing bean' checks use REGISTER_BEAN so they run after all bean definitions are known.

@Indexed marks a class or stereotype so a build-time tool records it in a file, META-INF/spring.components. At startup Spring reads that file instead of scanning the whole classpath, which makes startup faster.

Add the spring-context-indexer as an annotation processor (Maven optional dependency or Gradle annotationProcessor). It runs at compile time and writes META-INF/spring.components, where each line maps a class name to the comma-separated stereotype annotations it has.

Use component scanning (@Component/@ComponentScan) for your own annotated classes — it's concise and auto-wires by constructor. Use explicit @Bean methods for third-party classes you can't annotate or when you need custom construction/conditional logic.

ConditionContext is the first argument to matches(). It exposes the BeanDefinitionRegistry, the (possibly null) ConfigurableListableBeanFactory, the Environment, the ResourceLoader, and the ClassLoader — enough to check properties, classpath, and already-registered bean definitions.

@Bean(initMethod="...") names a method Spring calls after the bean is created and dependencies are set; @Bean(destroyMethod="...") names one called on shutdown. They let you run setup/cleanup on third-party classes without annotations.

BeanDefinitionBuilder is a fluent helper to build a BeanDefinition. You call BeanDefinitionBuilder.genericBeanDefinition(MyBean.class), chain addPropertyValue/addConstructorArgValue/setScope, call getBeanDefinition(), then register it via registry.registerBeanDefinition(name, definition).

@ImportResource loads bean definitions from external resource files — typically XML — into a Java @Configuration class. You point it at locations like "classpath:legacy-beans.xml", and those beans join the same context.

@Controller is a @Component specialization Spring MVC detects to route web requests to handler methods. @RestController is a composed annotation = @Controller + @ResponseBody, so every handler's return value is serialized directly to the response body (typically JSON) instead of resolving a view.

Spring uses the index only if a spring.components file exists AND every include filter is one the index can answer — annotation filters on @Indexed-marked annotations, or assignable-type filters. If any filter isn't index-supported (e.g. a regex or custom filter), it silently falls back to normal scanning.

By default a scanned bean's name is the class's simple name with a lowercased first letter (OrderService → orderService), or the value you pass to the stereotype (@Service("x")). You override the strategy with a BeanNameGenerator via @ComponentScan(nameGenerator = ...).

It's the low-level engine behind @ComponentScan: given base packages and filters, it scans the classpath and returns candidate BeanDefinitions. You use it directly to find annotated/typed classes yourself — outside the normal bean registration flow.

It keeps @Configuration semantics but skips CGLIB enhancement, so the class isn't proxied. @Bean methods then behave like lite mode: direct inter-bean calls create new objects. Use it when methods don't call each other, to speed startup and help native images.

The beans { } DSL builds bean definitions in Kotlin without annotations. Inside it you write bean<Foo>() to register a type, or bean { Bar(ref()) } to construct one and pull dependencies with ref(). It returns a BeanDefinitionDsl you initialize against a GenericApplicationContext.

A plain ImportSelector runs inline while its config class is parsed. A DeferredImportSelector runs after all @Configuration classes have been processed. That late timing lets Spring Boot auto-configuration apply last, so user-defined beans and @Conditional checks take precedence.

ImportBeanDefinitionRegistrar is a Spring hook referenced from @Import. Its registerBeanDefinitions method gives you the BeanDefinitionRegistry so you can build and register BeanDefinitions programmatically — ideal when the number or shape of beans is dynamic, like scanning for interfaces.

Define your own annotation and meta-annotate it with @Component (and any others you want to bundle, like @Scope or @Transactional). Component scanning treats classes with your annotation as beans because @Component is present transitively.

Boot's conditions are meta-annotations: each is annotated with @Conditional pointing to a Spring Condition implementation (e.g. OnClassCondition, OnBeanCondition). They read attributes via AnnotatedTypeMetadata. OnBeanCondition runs in the REGISTER_BEAN phase, and Boot parses user config before auto-config so user beans win.

Choose functional registration for library code that shouldn't force scanning, dynamic sets of beans (one per config entry), and reflection-free startup for GraalVM native / Spring AOT. Trade-off: you lose annotation discoverability and must wire dependencies explicitly.