Spring Boot Vocabulary: 30 Terms for Java Backend Developers
Spring Boot auto-configuration, beans, dependency injection, Spring Data, Spring Security, and enterprise Java vocabulary.
Spring Boot is the dominant framework for building Java backend applications, and it comes with a rich vocabulary that shapes how developers communicate every day. Whether you are joining a new team, reading code review comments, or preparing for a technical interview, knowing these terms will help you follow conversations, ask the right questions, and sound like a confident backend engineer. This guide covers the essential Spring Boot vocabulary with plain-English definitions and real examples of how developers use these terms at work.
Core Spring Boot Concepts
Bean
A bean is any object that is managed by the Spring container — that is, Spring creates it, configures it, and handles its lifecycle. You do not use new to create a bean yourself; Spring does that for you based on your configuration.
“That service class is a singleton bean — there is only one instance across the whole application.”
“I forgot to annotate the class, so it was not registered as a bean and the injection failed.”
Application Context
The application context is the central container in a Spring application. It holds all the beans, manages their dependencies, and provides services like event publishing and internationalisation support. Think of it as the “brain” of your Spring application.
“When the application context starts up, it wires all the beans together.”
“We are loading a test application context that only includes the database layer — no web layer.”
Auto-configuration
Auto-configuration is one of Spring Boot’s most powerful features. When you add a dependency to your project, Spring Boot automatically configures the related beans and settings without requiring manual XML or Java configuration. It inspects what is on the classpath and applies sensible defaults.
“Auto-configuration detected the H2 driver on the classpath and set up an in-memory database for us.”
“I had to exclude the DataSourceAutoConfiguration class because we handle the data source manually.”
Starter Dependency
A starter dependency is a curated group of libraries bundled together for a specific purpose. Instead of adding ten separate libraries and managing their versions, you add one starter and Spring Boot handles the rest. Common examples include spring-boot-starter-web, spring-boot-starter-data-jpa, and spring-boot-starter-security.
“Just add the web starter to your
pom.xmland you get Tomcat, Jackson, and Spring MVC out of the box.”
“We switched from the web starter to the WebFlux starter to use the reactive stack.”
Embedded Server
An embedded server is a web server (typically Tomcat or Netty) that is packaged inside your application JAR rather than deployed separately. Spring Boot includes an embedded server by default, so you can run your application with a single java -jar command.
“We ship a fat JAR with an embedded Tomcat — no need to install or configure a separate server.”
“We are using the reactive stack, so the embedded server is Netty, not Tomcat.”
Annotations and Dependency Injection
@Component, @Service, @Repository, @Controller
These four annotations all tell Spring to manage a class as a bean, but they carry different semantic meaning:
- @Component — a generic Spring-managed component.
- @Service — marks a class as containing business logic.
- @Repository — marks a class that accesses the database; also enables Spring’s exception translation.
- @Controller (or @RestController) — marks a class that handles HTTP requests.
“Put the business logic in a
@Serviceclass, not in the controller — keep the layers clean.”
“The
@Repositoryannotation is important because Spring will wrap any database exceptions in its own exception hierarchy.”
@Autowired
@Autowired is the annotation that tells Spring to inject a dependency automatically. You place it on a constructor, method, or field, and Spring finds the matching bean and provides it. Constructor injection is generally preferred because it makes dependencies explicit and easier to test.
“I prefer constructor injection over
@Autowiredon fields — it is cleaner and works better in unit tests.”
“Spring could not autowire the dependency because it found two beans of the same type — you need
@Qualifierto tell it which one to use.”
@SpringBootApplication
@SpringBootApplication is a convenience annotation placed on the main class of a Spring Boot application. It is a combination of three annotations: @Configuration, @EnableAutoConfiguration, and @ComponentScan. It tells Spring Boot to scan for components, enable auto-configuration, and treat the class as a configuration source.
“The main class with
@SpringBootApplicationis the entry point — that is where the application context starts.”
“We placed the main class in the root package so
@ComponentScanpicks up all the sub-packages automatically.”
Data, Security, and Configuration
Spring Data JPA
Spring Data JPA is a layer on top of JPA (Java Persistence API) that dramatically reduces the boilerplate required to interact with a relational database. You define a repository interface, declare method names following a convention (e.g. findByEmailAndStatus), and Spring Data generates the implementation at runtime.
“With Spring Data JPA you rarely write SQL by hand — the method name convention handles most queries.”
“We had a complex query that method names could not express, so we used
@Querywith JPQL instead.”
JPQL
JPQL (Java Persistence Query Language) is a query language that looks similar to SQL but operates on Java entity objects rather than database tables. You write queries against your domain model, and the JPA provider translates them to the appropriate SQL dialect.
“In JPQL you write
SELECT u FROM User u WHERE u.email = :email— you are querying the entity, not the table.”
“Watch out: JPQL is case-sensitive for entity names but not for keywords.”
Spring Security — Filter Chain
The filter chain in Spring Security is a sequence of filters that every incoming HTTP request passes through. Each filter handles a specific concern — parsing the JWT token, checking CSRF protection, enforcing HTTPS — before the request reaches your controller. You can customise the chain by adding, removing, or reordering filters.
“The filter chain is where authentication happens before the request ever reaches the controller.”
“I added a custom filter to the chain to log all incoming requests with their correlation IDs.”
Spring Security — Authentication Manager
The authentication manager is the central component that Spring Security calls to verify a user’s credentials. It delegates to one or more AuthenticationProvider implementations, which check the credentials against a database, an LDAP server, or any other source.
“The authentication manager checks the username and password and returns a populated
Authenticationobject if they are valid.”
“We have two authentication providers — one for regular users and one for API keys — and the authentication manager tries them in order.”
Actuator
Spring Boot Actuator adds production-ready endpoints to your application that expose health information, metrics, environment details, and more. Common endpoints include /actuator/health, /actuator/metrics, and /actuator/info. These are invaluable for monitoring and observability in production.
“The load balancer calls
/actuator/healthevery 30 seconds to check if the instance is alive.”
“We exposed the metrics endpoint and scraped it with Prometheus to build our Grafana dashboards.”
Profile
A profile in Spring Boot is a way to define sets of configuration that apply in specific environments. You can have a dev profile with an in-memory database and a prod profile pointing to the real PostgreSQL cluster. You activate profiles via environment variables or command-line arguments.
“The datasource bean is only created when the
prodprofile is active — locally we use the H2 in-memory database.”
“Run the application with
--spring.profiles.active=stagingto use the staging configuration.”
@ConfigurationProperties
@ConfigurationProperties is an annotation that binds a group of related configuration values from application.properties or application.yml to a typed Java class. It is cleaner and safer than injecting individual values with @Value, especially when you have many related settings.
“We wrapped all the payment gateway settings in a
@ConfigurationPropertiesclass — it makes the configuration much easier to manage and document.”
“If you use
@ConfigurationProperties, Spring validates the fields on startup, so a missing required property fails fast.”
Spring Boot DevTools
Spring Boot DevTools is a developer-convenience module that speeds up the development loop. It watches for changes to your classpath, automatically restarts the application when you recompile, and supports LiveReload so the browser refreshes when static resources change.
“With DevTools enabled, the application restarts in under two seconds when I save a file — much faster than a full cold start.”
“Make sure DevTools is not included in your production build — it is a development-only dependency.”
How to Use These Terms in Conversation
Knowing the vocabulary is one thing; using it naturally is another. Here are patterns you will hear in real team discussions:
In code reviews:
“This class has too many responsibilities — split it into a
@Servicefor the business logic and a separate@Repositoryfor the data access.”
In architecture discussions:
“We are using the filter chain to handle JWT validation centrally, so individual controllers do not need to think about authentication at all.”
In debugging sessions:
“The application context failed to start because two beans of the same type were eligible for autowiring. Add
@Primaryto the one that should take precedence, or use@Qualifierat the injection point.”
In onboarding conversations:
“The auto-configuration is doing a lot of work behind the scenes. If something behaves unexpectedly, run with
--debugto see the auto-configuration report — it shows exactly which conditions passed and which were skipped.”
In DevOps conversations:
“The health endpoint from Actuator is already set up — you just need to configure the load balancer to poll
/actuator/healthand check for"status": "UP".”
Understanding these patterns will help you contribute to discussions, write clearer commit messages, and give more precise explanations when something goes wrong.
Quick Reference
| Term | One-line definition |
|---|---|
| Bean | An object managed by the Spring container |
| Application context | The central container that holds and wires all beans |
| Auto-configuration | Spring Boot automatically configures beans based on the classpath |
| Starter dependency | A bundled group of libraries for a specific purpose |
| @Autowired | Tells Spring to inject a dependency automatically |
| Spring Data JPA | Generates repository implementations from interface method names |
| JPQL | SQL-like query language that operates on Java entity objects |
| Filter chain | Ordered sequence of security filters each request passes through |
| Actuator | Production-ready endpoints for health checks and metrics |
| Profile | Named set of configuration values for a specific environment |