What core principle lets the Spring container create and wire your objects instead of you calling new yourself?

Inversion of Control, where the container owns object creation and wiring.

Reflection, because Spring reads annotations at runtime.

Aspect-oriented programming, because it intercepts method calls.

Lazy initialization, because beans are created on demand.

Which injection style does the Spring team recommend for required dependencies?

Constructor injection, which makes dependencies explicit and final.

Field injection with @Autowired on the private field.

Setter injection so dependencies can change at runtime.

Static injection through a shared singleton holder.

What is the default scope of a Spring bean?

Singleton, one shared instance per application context.

Prototype, so a new instance is created on every injection.

Request, one instance per HTTP request.

Thread, one instance per thread.

When two beans of the same type exist, how do you tell Spring which one to inject?

Mark one with @Qualifier (or @Primary) to disambiguate.

Rename the injection field to match one bean name automatically.

Delete one of the beans so only one candidate remains.

Spring picks one at random and logs a warning.

What three annotations does @SpringBootApplication combine?

@Configuration, @EnableAutoConfiguration, and @ComponentScan.

@Controller, @Service, and @Repository.

@RestController, @RequestMapping, and @Bean.

@EnableWebMvc, @EnableJpaRepositories, and @Import.

How does Spring Boot auto-configuration decide whether to configure a feature?

It uses conditional annotations like @ConditionalOnClass and @ConditionalOnMissingBean.

It runs everything and disables what fails at startup.

It reads a mandatory autoconfig.xml file you must provide.

It asks the developer interactively on first run.

What is the main purpose of a Spring Boot "starter" dependency?

It is a curated set of dependencies for a capability, versioned together.

It generates boilerplate controller code for you.

It replaces the need for a build tool like Maven or Gradle.

It is a runtime agent that profiles your application.

How does @RestController differ from @Controller?

It adds @ResponseBody semantics so return values are serialized to the response body.

It only works with WebFlux, not Spring MVC.

It automatically secures every endpoint it declares.

It disables JSON serialization in favor of plain text.

Which annotation binds a JSON request body to a method parameter?

@RequestBody, which deserializes the body into the parameter type.

@PathVariable, because it maps URI segments.

@RequestParam, because it reads query parameters.

@ModelAttribute, because it always builds the object from the body.

Which annotation is the shortcut for handling HTTP GET requests on a path?

@GetMapping, a specialization of @RequestMapping for GET.

@RequestMapping(method = POST) with a GET flag.

@HttpGet, the standard Servlet annotation.

@Query, which maps read-only endpoints.

What does ResponseEntity let a controller method control that a plain return type cannot?

The HTTP status code, headers, and body together.

The database transaction boundary for the request.

The bean scope of the controller.

The order in which filters run.

What do you get by extending JpaRepository ?

A generated proxy providing CRUD and pagination methods without an implementation.

An abstract class you must subclass and implement manually.

A raw JDBC connection you manage yourself.

A REST endpoint automatically for every entity.

How does Spring Data derive a query from a method named findByEmailAndActiveTrue?

It parses the method name into a query at startup using property and keyword conventions.

It requires a matching stored procedure in the database.

It executes the method name as literal SQL text.

It always needs an explicit @Query annotation to work.

What problem does the N+1 select issue describe in JPA?

One query for the parents plus one additional query per parent to load a relation.

A query returns one extra row beyond what was requested.

A deadlock between N transactions competing for one row.

A cache miss that forces N retries of the same query.

Where should @Transactional typically be applied in a layered Spring Boot app?

On the service-layer method that groups the related repository calls.

On every repository method individually.

On the controller method handling the request.

What does a Spring profile let you do?

Activate different beans and property values per environment.

Profile CPU usage of your beans at runtime.

Encrypt the application properties file.

Restrict which users can call an endpoint.

Which annotation injects a single property value into a field?

@Value("${app.timeout}") on the field or constructor parameter.

@ConfigurationProperties on the field.

@Autowired with the property name.

@Bean on a getter returning the value.

What advantage does @ConfigurationProperties offer over scattered @Value fields?

Type-safe binding of a whole group of related properties into one object.

It disables externalized configuration entirely.

It forces all properties to be constants at compile time.

It removes the need for any properties file.

What triggers bean validation on an incoming request body in a controller?

Adding @Valid (or @Validated) before the @RequestBody parameter.

Annotating the controller class with @Validated only.

Nothing; Spring validates every request body automatically.

Declaring the DTO fields as final.

What is the role of @ControllerAdvice (or @RestControllerAdvice)?

To centralize exception handling and response shaping across many controllers.

To advise the container on bean creation order.

To cache controller responses automatically.

To generate OpenAPI documentation for controllers.

In Spring Security, what is the difference between authentication and authorization?

Authentication verifies identity; authorization decides what that identity may access.

Authentication checks permissions; authorization logs the user in.

They are two names for the same login step.

Authentication encrypts traffic; authorization compresses it.

How is HTTP security most commonly configured in modern Spring Boot?

By declaring a SecurityFilterChain bean that customizes the HttpSecurity.

By editing an XML security-config.xml file.

By annotating the main class with @Secure.

By setting a single property security.enabled=true.

What does Spring Boot Actuator provide?

Production-ready endpoints for health, metrics, and application info.

A code generator that scaffolds controllers.

A replacement for your logging framework.

An embedded database for testing.

Which Actuator endpoint is typically wired to a load balancer or orchestrator readiness probe?

/actuator/health, which reports application and dependency status.

/actuator/beans, which lists every bean.

/actuator/env, which dumps configuration properties.

/actuator/mappings, which lists request mappings.

What does @SpringBootTest do that a plain unit test does not?

It loads a full application context so beans are wired as in production.

It mocks every bean automatically so nothing real runs.

It disables the database for all tests.

It only compiles the test without executing it.

When would you use a slice test like @WebMvcTest instead of @SpringBootTest?

To load only the web layer for a controller, keeping the test fast and focused.

To run the test against the real production database.

To disable dependency injection completely.

To test only static utility methods.

What does @MockBean do inside a Spring Boot test?

It replaces a bean in the context with a Mockito mock.

It permanently deletes the bean from the application.

It generates a new real implementation of the bean.

It marks the bean as lazy in production.

Quizzes

Spring Boot Java Backend Development

Spring Boot: Java Application Framework Essentials

Mohammad Abu Mattar20 QuestionsIntermediatePublished: 11 Aug, 2026Updated: 11 Aug, 2026

Markdown for AI

Spring Boot: Java Application Framework Essentials

Test your knowledge up to 20 randomized questions

Quiz Configuration

Enterto start

Spring Boot removed most of the ceremony from Java backend development, but the framework still does a lot of work you cannot see. This quiz walks through dependency injection, auto-configuration, REST controllers, Spring Data JPA, configuration and profiles, security basics, Actuator, and testing. Answer each question and read the explanations to sharpen your mental model of what Spring is really doing under the hood.

Answer key and explanations27 questions

The quiz above draws 20 questions at random from these 27, so a second attempt will not be the same run. Everything in the pool is listed here.

What core principle lets the Spring container create and wire your objects instead of you calling `new` yourself?
AnswerInversion of Control, where the container owns object creation and wiring.
Inversion of Control means the framework, not your code, decides when and how collaborators are created and injected.
Which injection style does the Spring team recommend for required dependencies?
AnswerConstructor injection, which makes dependencies explicit and final.
Constructor injection produces fully initialized, immutable beans and is trivial to instantiate in unit tests.
What is the default scope of a Spring bean?
AnswerSingleton, one shared instance per application context.
Singleton scope is the default; the same bean instance is shared across the whole context.
When two beans of the same type exist, how do you tell Spring which one to inject?
AnswerMark one with `@Qualifier` (or `@Primary`) to disambiguate.
Use `@Qualifier` to select a specific bean by name, or `@Primary` to declare the default candidate.
What three annotations does `@SpringBootApplication` combine?
Answer`@Configuration`, `@EnableAutoConfiguration`, and `@ComponentScan`.
`@SpringBootApplication` merges `@Configuration`, `@EnableAutoConfiguration`, and `@ComponentScan` into one annotation.
How does Spring Boot auto-configuration decide whether to configure a feature?
AnswerIt uses conditional annotations like `@ConditionalOnClass` and `@ConditionalOnMissingBean`.
Auto-configuration classes are gated by `@Conditional` checks on classpath contents, properties, and existing beans.
What is the main purpose of a Spring Boot "starter" dependency?
AnswerIt is a curated set of dependencies for a capability, versioned together.
Starters group the libraries needed for a feature into a single, version-aligned dependency.
How does `@RestController` differ from `@Controller`?
AnswerIt adds `@ResponseBody` semantics so return values are serialized to the response body.
`@RestController` combines `@Controller` and `@ResponseBody`, writing return values straight to the HTTP body.
Which annotation binds a JSON request body to a method parameter?
Answer`@RequestBody`, which deserializes the body into the parameter type.
`@RequestBody` triggers HTTP message conversion, turning the request payload into a Java object.
Which annotation is the shortcut for handling HTTP GET requests on a path?
Answer`@GetMapping`, a specialization of `@RequestMapping` for GET.
`@GetMapping`, along with `@PostMapping`, `@PutMapping`, and `@DeleteMapping`, are HTTP-method shortcuts for `@RequestMapping`.
What does `ResponseEntity` let a controller method control that a plain return type cannot?
AnswerThe HTTP status code, headers, and body together.
`ResponseEntity<T>` gives explicit control of status code, headers, and body in one return value.
What do you get by extending `JpaRepository<User, Long>`?
AnswerA generated proxy providing CRUD and pagination methods without an implementation.
Extending a Spring Data repository interface yields a generated proxy with CRUD, sorting, and paging support.
How does Spring Data derive a query from a method named `findByEmailAndActiveTrue`?
AnswerIt parses the method name into a query at startup using property and keyword conventions.
Query derivation parses the method name against entity properties and keywords to generate the query.
What problem does the N+1 select issue describe in JPA?
AnswerOne query for the parents plus one additional query per parent to load a relation.
N+1 happens when loading a collection lazily issues one query per parent; a fetch join or entity graph fixes it.
Where should `@Transactional` typically be applied in a layered Spring Boot app?
AnswerOn the service-layer method that groups the related repository calls.
Place `@Transactional` on service methods so a whole business operation commits or rolls back together.
What does a Spring profile let you do?
AnswerActivate different beans and property values per environment.
Profiles group beans and property files so a single build behaves differently per environment.
Which annotation injects a single property value into a field?
Answer`@Value("${app.timeout}")` on the field or constructor parameter.
`@Value` with a `${...}` placeholder injects one resolved property; use `@ConfigurationProperties` for grouped, type-safe binding.
What advantage does `@ConfigurationProperties` offer over scattered `@Value` fields?
AnswerType-safe binding of a whole group of related properties into one object.
`@ConfigurationProperties` binds a prefixed group of settings into a strongly typed, validatable object.
What triggers bean validation on an incoming request body in a controller?
AnswerAdding `@Valid` (or `@Validated`) before the `@RequestBody` parameter.
Mark the `@RequestBody` parameter with `@Valid` so its Jakarta Validation constraints are checked before the handler executes.
What is the role of `@ControllerAdvice` (or `@RestControllerAdvice`)?
AnswerTo centralize exception handling and response shaping across many controllers.
`@ControllerAdvice` groups cross-cutting handler logic, most commonly global `@ExceptionHandler` methods, in one place.
In Spring Security, what is the difference between authentication and authorization?
AnswerAuthentication verifies identity; authorization decides what that identity may access.
Authentication answers "who are you?" and authorization answers "what are you allowed to do?".
How is HTTP security most commonly configured in modern Spring Boot?
AnswerBy declaring a `SecurityFilterChain` bean that customizes the `HttpSecurity`.
Modern Spring Security is configured with a `SecurityFilterChain` bean using the lambda `HttpSecurity` DSL.
What does Spring Boot Actuator provide?
AnswerProduction-ready endpoints for health, metrics, and application info.
Actuator adds ready-made monitoring and management endpoints for running applications.
Which Actuator endpoint is typically wired to a load balancer or orchestrator readiness probe?
Answer`/actuator/health`, which reports application and dependency status.
The health endpoint, with its liveness and readiness groups, is the standard target for orchestration probes.
What does `@SpringBootTest` do that a plain unit test does not?
AnswerIt loads a full application context so beans are wired as in production.
`@SpringBootTest` starts the Spring context so components collaborate as they would at runtime.
When would you use a slice test like `@WebMvcTest` instead of `@SpringBootTest`?
AnswerTo load only the web layer for a controller, keeping the test fast and focused.
`@WebMvcTest` boots just the web slice with `MockMvc`, so controller tests stay fast and isolated from lower layers.
What does `@MockBean` do inside a Spring Boot test?
AnswerIt replaces a bean in the context with a Mockito mock.
`@MockBean` adds or replaces a bean in the test context with a Mockito mock you can program and verify.