Spring terms

Brief definitions for concepts used on the Spring Boot & Spring Framework page. Terms are listed in alphabetical order.

@Configuration

Marks a Java class that defines beans with @Bean methods or imports other config. Replaces much of the old XML configuration in modern Spring apps.

@SpringBootApplication

Single annotation on your main class. Combines @Configuration, @EnableAutoConfiguration, and component scan — entry point for a Boot app.

AOP (Aspect-Oriented Programming)

A technique that lets you separate "cross-cutting concerns"—tasks that apply to multiple parts of your app (like logging, security, or transaction management)—so you don't have to rewrite the same code everywhere.

application.properties / application.yml

External config files for datasource URLs, server port, logging, and feature flags. Boot reads them at startup; no recompile to change settings.

ApplicationContext

The main Spring IoC container implementation. It loads configuration, creates beans, injects dependencies, and publishes lifecycle events. AnnotationConfigApplicationContext and AnnotationConfigWebApplicationContext are common variants.

Auto-configuration

Spring Boot feature: if certain libraries are on the classpath (e.g. JPA, embedded Tomcat), Boot creates sensible default beans without you writing config. Override with your own beans or properties when needed.

Bean

Bean is just a standard Java object that is managed by the Spring container (IoC container).
Created once (or per scope), wired with dependencies, and destroyed when the context shuts down. Classes become beans via @Component, @Service, @Repository, or @Configuration.

BOM (Bill of Materials)

A version list Spring Boot publishes so all starter dependencies use compatible versions of Spring, Hibernate, Jackson, etc. Avoids dependency conflicts.

Component scan

Tells Spring which packages to search for @Component, controllers, and services. Spring Boot enables scan from the package of @SpringBootApplication. @ComponentScan(basePackages = "com.example") sets the root package explicitly.

Convention over configuration

Design idea behind Boot: assume sensible defaults (embedded server on port 8080, JSON via Jackson) so you only configure exceptions, not every detail.

DataSource and EntityManagerFactory

Beans plain Spring must define manually: DataSource is the JDBC connection pool; EntityManagerFactory is Hibernate/JPA’s engine for mapping entities to the database. Boot creates both when JPA is on the classpath.

Dependency Injection (DI)

The actual mechanism used to achieve IoC. Instead of an object creating the other objects it relies on (its "dependencies") using the new keyword, Spring injects (passes) them into the object automatically.
If OrderService needs OrderRepository, Spring injects the repository into the service (usually via constructor). This makes code easier to test and change.

DispatcherServlet

Servlet that receives all incoming HTTP traffic, finds the matching controller method, runs it, and returns the response. Spring Boot registers it automatically; plain Spring requires manual setup in WebApplicationInitializer.

Embedded server vs WAR

Spring Boot embeds Tomcat/Jetty inside your JAR — run with java -jar. Plain Spring often packages a WAR (Web Application Archive) and deploys it to an external servlet container.

Hibernate

Object-Relational Mapping (ORM) framework for Java for storing/updating data into Database
Without Hibernate, you have to write long, tedious, and error-prone SQL queries manually inside your Java code using standard JDBC.

import javax.persistence.*;

@Entity                     // Tells Hibernate this class maps to a DB table
@Table(name = "users")      // Name of the DB table
public class User {

    @Id                     // Primary key
    @GeneratedValue        // Auto-increment the ID
    private Long id;

    private String name;
    private String email;

    // Constructors, Getters, and Setters...
    public User(String name, String email) {
        this.name = name;
        this.email = email;
    }
}
            

String sql = "INSERT INTO users (name, email) VALUES (?, ?)";   //manually construct SQL strings
PreparedStatement stmt = connection.prepareStatement(sql);
stmt.setString(1, "Alice");
stmt.setString(2, "alice@example.com");
stmt.executeUpdate(); // Lots of boilerplate code!
            

ORMs in Other Languages

IoC (Inversion of Control)

A design principle where you give up control of creating and managing your objects, handing that responsibility over to a framework (like Spring).
The Spring runtime creates and manages objects for you instead of your code calling new everywhere. You describe components; the container builds the object graph at startup.

Profiles (dev, test, prod)

Named config sets activated with spring.profiles.active. Lets one codebase use H2 in dev and PostgreSQL in production.

Servlet container

A web server that runs Java servlets — e.g. Apache Tomcat, Jetty, or WildFly. Plain Spring apps deploy a WAR here; Spring Boot bundles an embedded container inside the JAR.

Spring Boot Actuator

Production endpoints such as /actuator/health and metrics for monitoring, Kubernetes probes, and ops dashboards — included via spring-boot-starter-actuator.

Spring Data / JPA

Modules for database access. JPA maps Java classes to tables; Spring Data adds repository interfaces so you get CRUD methods without writing SQL for simple cases.

Spring MVC (Model-View-Controller)

A design pattern (and Spring module) used to build web applications by splitting your code into three distinct roles:
1. Model (DB): The data and business logic (e.g., your database user profile).
2. View (UI): What the user actually sees (e.g., an HTML page, JSON response, or React frontend).
3. Controller: Application server between model and view.
The web module that maps HTTP requests to Java methods. @Controller / @RestController handle URLs; responses can be HTML views or JSON. Works with the DispatcherServlet as the front controller.

Spring Security

Authentication (who you are) and authorization (what you may do). Filters run before controllers; integrates with login forms, JWT, OAuth2, and method-level rules.

Starters

Maven/Gradle dependencies that bundle related libraries (e.g. spring-boot-starter-web = Spring MVC + Jackson + embedded Tomcat). One dependency instead of listing many JARs.

WebApplicationInitializer

Interface used in plain Spring (no Boot) to bootstrap a web app when deployed as a WAR. You create the ApplicationContext, register the DispatcherServlet, and map it to URL paths — work Boot does automatically.