Glossary

Spring-specific and Spring-leaning terminology you will encounter while reading the codebase.

Core IoC concepts

• Bean — Any object managed by the Spring container. The container instantiates, configures, and assembles beans on your behalf.
• BeanDefinition — Metadata describing how to create a bean: class, scope, constructor args, properties, init/destroy callbacks. See BeanDefinition in spring-beans/src/main/java/org/springframework/beans/factory/config/BeanDefinition.java.
• BeanFactory — The low-level container interface (org.springframework.beans.factory.BeanFactory). Provides lookup, no lifecycle management.
• ApplicationContext — A BeanFactory plus message resolution, event publication, resource loading, and lifecycle. The user-facing container interface; defined in spring-context/src/main/java/org/springframework/context/ApplicationContext.java.
• IoC (Inversion of Control) — The pattern where the container constructs and wires objects rather than the objects looking up their dependencies. Spring's IoC is realized by the bean factory.
• DI (Dependency Injection) — A specific form of IoC where dependencies are passed in (constructor, setter, field). @Autowired, @Inject, @Resource.
• Configuration class — A class annotated @Configuration whose @Bean methods declare beans. Processed by ConfigurationClassPostProcessor.
• Component scanning — Discovery of beans by scanning the classpath for @Component, @Service, @Repository, @Controller. Driven by @ComponentScan.
• Stereotype — A specialized @Component (@Service, @Repository, @Controller) that signals role.
• Scope — singleton (default), prototype, request, session, application, websocket. Pluggable via Scope SPI.

Lifecycle and post-processing

• BeanPostProcessor — Callback that wraps or modifies beans during initialization. Used by AOP to install proxies and by @Autowired to inject dependencies.
• BeanFactoryPostProcessor — Modifies BeanDefinitions before any bean is instantiated. Used to expand placeholders and process configuration classes.
• InitializingBean / DisposableBean — Spring-specific lifecycle interfaces; @PostConstruct/@PreDestroy are the JSR-250 equivalents.
• Lifecycle / SmartLifecycle — Beans that need to start/stop on container events.

AOP

• Pointcut — Predicate matching join points (method executions).
• Advice — Code to run at matched join points: @Before, @AfterReturning, @AfterThrowing, @After, @Around.
• Advisor — A pointcut + advice pair.
• Proxy — A wrapper object that intercepts calls to a bean and applies advice. JDK dynamic proxies for interfaces, CGLIB subclassing for classes.
• AspectJ — A separate AOP language. spring-aspects provides compile-time/load-time woven aspects for @Transactional, @Async, @Cacheable.

SpEL

• SpEL (Spring Expression Language) — A unified expression language used in @Value, security expressions, web flow conditions. Lives in spring-expression.

Web

• Handler — A controller method or function that processes a request.
• DispatcherServlet — The front controller for Spring MVC (spring-webmvc).
• DispatcherHandler — The reactive analogue (spring-webflux).
• HandlerMapping — Maps requests to handlers (e.g., @RequestMapping).
• HandlerAdapter — Invokes handlers, regardless of their signature shape.
• HandlerInterceptor / WebFilter — Pre/post processing hooks (MVC vs WebFlux).
• HttpMessageConverter — Reads/writes request/response bodies (JSON, XML, form data).
• WebMvcConfigurer / WebFluxConfigurer — User-supplied callbacks to customize the stack.
• Functional endpoints — Lambda-based routing API: RouterFunction, HandlerFunction. Both stacks support it.
• MockMvc — Servlet-stack test framework that bypasses the network. In spring-test.
• WebTestClient — Reactive-stack test client with both bound (no network) and connected modes.

Data access

• JdbcTemplate — A boilerplate-eliminating JDBC template (spring-jdbc).
• DataSource — JDBC connection factory; Spring provides DriverManagerDataSource, transaction-aware wrappers, etc.
• PlatformTransactionManager — Imperative transaction abstraction.
• ReactiveTransactionManager — Reactive transaction abstraction (used by spring-r2dbc).
• @Transactional — Declarative transaction boundary. Implemented as AOP advice.
• EntityManager / LocalContainerEntityManagerFactoryBean — JPA integration in spring-orm.

Reactive

• Mono / Flux — Reactor's 0..1 and 0..N publishers; the dominant types in spring-webflux and spring-r2dbc.
• Reactive Streams — The four-interface SPI (Publisher, Subscriber, Subscription, Processor) Reactor implements.
• Backpressure — Demand signaling: subscribers tell publishers how many items they can accept.

Test framework

• TestContext framework — Spring's caching and lifecycle for test ApplicationContexts. Lives in spring-test.
• @SpringJUnitConfig / SpringExtension — JUnit 5 wiring for the TestContext framework.
• @MockBean (Spring Boot, not framework) vs @MockitoBean — Bean replacement helpers.

Build and AOT

• Native image / GraalVM — Ahead-of-time compiled Java binaries. Spring contributes RuntimeHints so reflection, resources, and proxies survive AOT.
• Hints — Reflection / resource / proxy / serialization hints registered via RuntimeHintsRegistrar (in spring-core/src/main/java/org/springframework/aot/hint/).
• MultiReleaseJar — A JAR with META-INF/versions/<n>/... overrides per JDK release. spring-core ships an MRJAR.
• BOM (Bill of Materials) — A POM that aggregates compatible versions; published as framework-bom.
• Platform — A Gradle-style enforced platform; framework-platform constrains transitive dependency versions.

Common acronyms

• AOP — Aspect-Oriented Programming
• AOT — Ahead-Of-Time (native compilation)
• DI — Dependency Injection
• IoC — Inversion of Control
• JSR — Java Specification Request
• MRJAR — Multi-Release JAR
• MVC — Model-View-Controller
• R2DBC — Reactive Relational Database Connectivity
• SpEL — Spring Expression Language
• STOMP — Simple/Streaming Text Oriented Messaging Protocol
• TCF — TestContext Framework