Spring Framework

Spring is a Java framework for building enterprise applications with dependency injection, modular architecture, and infrastructure support.

It reduces boilerplate, improves testability, and provides consistent solutions for common backend concerns.

A design principle where object creation and wiring are handled by a container instead of application code.

A technique where dependencies are provided to a class from outside rather than created internally.

An object managed by the Spring IoC container.

The central Spring container interface for bean lifecycle, configuration, and dependency resolution.

BeanFactory is basic IoC; ApplicationContext adds enterprise features (events, i18n, AOP integration, etc.).

A Spring-based project that simplifies setup with auto-configuration and starter dependencies.

No: Spring Boot builds on top of Spring Framework for faster development and deployment.

Spring Boot feature that configures beans automatically based on classpath and properties.

Curated dependency bundles like spring-boot-starter-web.

Using sensible defaults so less manual configuration is needed.

Combination of @Configuration, @EnableAutoConfiguration, and @ComponentScan.

Generic stereotype for Spring-managed component classes.

Specialized stereotype indicating service/business-layer component.

Stereotype for persistence components, with exception translation support.

Stereotype for MVC web controller returning views or model/view responses.

Combination of @Controller and @ResponseBody for REST endpoints.

Class-level annotation indicating bean definitions via @Bean methods.

Method-level annotation registering returned object as a Spring bean.

Automatic detection and registration of annotated classes as beans.

It injects dependencies by type (with additional resolution rules if needed).

Constructor injection is preferred for immutability and easier testing.

Makes required dependencies explicit and supports final fields.

Used to choose a specific bean when multiple candidates of same type exist.

Marks a bean as default candidate for autowiring when ambiguity exists.

Defines bean lifecycle/visibility (singleton, prototype, request, session, etc.).

Singleton.

A new bean instance is created each time requested.

One bean instance per HTTP request (web context).

One bean instance per HTTP session.

Creation, dependency injection, initialization, usage, and destruction.

Use @PostConstruct or init-method configuration.

Use @PreDestroy or destroy-method configuration.

A way to activate environment-specific bean/config sets.

Via property/env var/command-line (e.g., spring.profiles.active=dev).

Keeping config outside code (properties, YAML, env vars, secrets systems).

application.properties and application.yml.

Injecting configuration values into fields/constructors/method params.

Type-safe binding of grouped configuration properties into POJOs.

Better structure, validation, and maintainability.

Front controller in Spring MVC routing requests to handlers.

Maps HTTP requests to controller methods.

@GetMapping is specialized shortcut for HTTP GET mapping.

Binds URI path segment to method parameter.

Binds query/form parameter to method parameter.

Binds HTTP request body to Java object.

Writes method return value directly to HTTP response body.

Typically Jackson via HTTP message converters.

Type giving full control over HTTP status, headers, and body.

Using @ExceptionHandler and global @ControllerAdvice.

Global component for exception handling and cross-controller concerns.

Abstraction simplifying JPA repository/data-access patterns.

Spring Data interface providing CRUD, paging, sorting, and query methods.

Declarative/programmatic control of database transaction boundaries.

Declares transactional behavior for class or method.

Not with proxy-based default AOP; typically public methods are proxied.

Spring Boot module exposing production endpoints (health, metrics, info, etc.).

Tool for generating Spring Boot project templates quickly.

Start simple: constructor injection, clear layers, external config, and test early.

Aspect-Oriented Programming support for cross-cutting concerns like logging, security, transactions.

A module containing advice and pointcuts.

A point during execution (commonly method execution) where advice can apply.

Expression selecting join points where advice runs.

Action taken by an aspect (before/after/around/throwing).

• @Before
• @After
• @AfterReturning
• @AfterThrowing
• @Around

Spring wraps beans in proxies that intercept method calls.

JDK proxies interfaces; CGLIB proxies concrete classes via subclassing.

Internal method calls bypass proxy, so advice may not execute.

Refactor to separate bean or use proxy exposure patterns carefully.

Rules for how nested method calls join/create transactions.

REQUIRED, REQUIRES_NEW, SUPPORTS, MANDATORY, NEVER, NOT_SUPPORTED, NESTED.

Join existing transaction or create new one if none exists.

Always start a new transaction, suspending existing one.

Underlying DB isolation setting controlling read/write visibility anomalies.

READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE (DB dependent).

Runtime (unchecked) exceptions by default.

Use rollbackFor in @Transactional.

Hint for optimization for read operations (behavior DB/provider dependent).

Core Spring strategy interface managing transactions.

Bean created on first use instead of startup.

Faster startup but potential first-request latency and delayed failures.

Bean A depends on B and B depends on A, causing resolution complexity/failure.

Refactor design, use interfaces/events, avoid field injection loops.

Defers bean initialization or injects lazy proxy.

Access to properties and active profiles from Spring context.

Declares additional property file sources.

Expression language for dynamic values and wiring logic.

Type conversion system used in binding configuration and request params.

Using Bean Validation annotations with @Valid / @Validated.

@Validated supports groups and method-level validation in Spring contexts.

Applying validation constraints to method parameters/return values.

Holds validation/binding errors in MVC request handling.

MVC interceptor before/after controller execution.

Filter is servlet-level; interceptor is Spring MVC handler-level.

Customize MVC config (formatters, CORS, interceptors, message converters).

Global or per-controller mapping via CORS configuration.

Selecting response representation (JSON/XML/etc.) based on request preferences.

Converts HTTP body to/from Java objects.

Synchronous HTTP client (still used, but newer apps often prefer WebClient).

Reactive/non-blocking HTTP client from Spring WebFlux.

MVC is servlet/blocking; WebFlux supports reactive/non-blocking model.

Avoid when possible; blocking can negate reactive scalability benefits.

Framework for authentication, authorization, and security protections.

Configures HTTP security behavior in modern Spring Security.

Defense against cross-site request forgery on state-changing requests.

CORS controls cross-origin browser access; CSRF protects authenticated state-changing requests.

Component hashing passwords (e.g., BCryptPasswordEncoder).

Adaptive hashing designed for password storage security.

Authorization checks at method level (e.g., @PreAuthorize).

Unified annotations/API for caching regardless of cache provider.

@Cacheable, @CachePut, @CacheEvict.

Caches method result based on key unless already cached.

Removes cache entries, often after data updates.

Running tasks periodically using @Scheduled.

Running methods asynchronously using @Async and executors.

Enables async processing infrastructure.

Enables scheduled task processing.

Control thread pool size, queueing, naming, and rejection policy.

Diagnostic info showing applied/ignored auto-configurations and reasons.

Registering beans only when conditions match (class, property, missing bean, etc.).

@ConditionalOnClass, @ConditionalOnMissingBean, @ConditionalOnProperty.

Includes additional configuration classes/selectors into context.

Registers configuration properties classes for binding.

Component contributing subsystem health status.

Expose different health details for liveness/readiness/security needs.

Liveness: app alive; readiness: app ready to serve traffic.

Load partial context for focused tests (@WebMvcTest, @DataJpaTest, etc.).

Faster, more focused tests with fewer dependencies.

Understand proxies/transactions deeply and keep configuration explicit but minimal.

Extension point to modify beans before/after initialization.

Allows modifying bean definitions before beans are instantiated.

Multiple hooks/advisors can execute in order-sensitive ways; define order explicitly.

Controls precedence among ordered components (interceptors, aspects, etc.).

Reusable dependency + auto-configuration package for organization-wide conventions.

Based on metadata/import selectors reading configuration registrations.

Prevents accidental hard dependency coupling and improves modular reuse.

Validate required properties/credentials at startup and stop early on errors.

Environment configs diverge unexpectedly across deployments.

Central config management, validation, immutable deployments, config review.

Repeated same request yields same final effect/result semantics.

Idempotency keys, unique constraints, conditional writes, safe retries.

Persist event record with domain transaction, publish asynchronously for consistency.

Lower operational complexity and better microservice resilience.

Event listener tied to transaction phase (before/after commit, etc.).

Data converges across services asynchronously, not instantly.

Coordinates multi-step distributed workflows with compensating actions.

Producers emitting faster than consumers can process, requiring flow control.

Via Reactive Streams semantics (Publisher/Subscriber demand signals).

Identifying accidental blocking operations that hurt reactive throughput.

Optimize write consistency and read scalability independently (CQRS style).

Application-level event representing meaningful business occurrence.

In-process is local and simple; external messaging supports inter-service communication.

Retries, circuit breakers, bulkheads, timeouts via libraries and config.

Can amplify outages and duplicate side effects.

Increasing delay + randomization to reduce retry storms.

Stops calls to failing dependency temporarily to protect system.

Isolates resource pools so one failure domain doesn’t exhaust all resources.

Provide partial functionality/fallback when dependencies fail.

Logs, metrics, traces correlated for production diagnosis.

Use request/trace IDs propagated via filters/interceptors and MDC.

Metrics facade used by Spring Boot for monitoring integrations.

Averages hide tail latency; percentiles show real user experience.

Emit machine-parseable key-value/JSON logs with stable fields.

Move more analysis/generation to build time for startup/performance benefits.

Dynamic reflection needs explicit configuration/hints.

Clear bounded contexts, explicit interfaces, minimal shared mutable state.

Split by business capability and keep service responsibilities focused.

Translation boundary protecting domain model from external model leakage.

Prevent package/layer violations and preserve design over time.

Backward-compatible API/schema changes and safe rollout strategies.

Blue/green switches environments; rolling updates instances gradually.

Deploy schema changes in backward-compatible phases before code relying on new constraints.

Increases lock duration/contention and harms scalability.

Rising latency/timeouts, queued tasks, rejected executions.

Measure workload, set bounded queues, monitor rejection/queue time/active threads.

Static caches, unbounded collections, thread-local misuse, classloader leaks.

Layered tests: unit, slice, integration, contract, and selective end-to-end.

Overusing magic auto-configuration without understanding runtime behavior.

Keep framework usage explicit, observable, and aligned with domain-driven design.