As Spring Boot continues to be the backbone of modern Java-based microservices and enterprise applications in 2025, recruiters need to identify developers who can efficiently build, deploy, and manage scalable and high-performance applications. With its simplified configuration, built-in support for microservices, and seamless integration with cloud platforms, Spring Boot remains a top choice for backend development.
This resource, "100+ Spring Boot Interview Questions and Answers," is designed to help recruiters evaluate candidates effectively. It covers topics from fundamentals to advanced concepts, including Spring Boot starters, dependency injection, security, microservices architecture, and cloud deployment.
Whether hiring junior Java developers or experienced backend engineers, this guide enables you to assess a candidate’s:
For a streamlined assessment process, consider platforms like WeCP, which allow you to:
✅ Create tailored Spring Boot assessments with hands-on coding challenges.
✅ Include real-world scenarios to test API development, security, and database integration.
✅ Conduct remote proctored exams to ensure test integrity.
✅ Leverage AI-powered analysis for faster, data-driven hiring decisions.
Save time, improve hiring efficiency, and confidently recruit Spring Boot developers who can build robust, scalable applications from day one.
Spring Boot is a framework that simplifies the process of building production-ready Spring applications. It provides pre-configured settings, which eliminate much of the boilerplate code required by the traditional Spring framework. It also helps developers focus on writing business logic rather than worrying about configuration.
Main Features:
Spring Boot simplifies Java application development by providing:
The @SpringBootApplication annotation is a combination of three key annotations:
By using @SpringBootApplication, developers can replace multiple annotations with one, making the code cleaner and easier to manage.
You can create a Spring Boot project using Spring Initializr through the following steps:
Spring Boot starters are pre-configured sets of dependencies that provide all the necessary libraries to start building specific types of applications. For example:
These starters simplify dependency management and save developers from manually defining multiple dependencies.
The application. properties or application. yml file is used to define configuration settings for a Spring Boot application. It contains key-value pairs for properties like server ports, database configurations, logging levels, and more.
Example of application. properties:
server.port=8081
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=rootExample of application.yml:
server:
port: 8081
spring:
datasource:
url: jdbc:mysql://localhost:3306/mydb
username: root
password: rootBy default, Spring Boot applications run on port 8080. This can be changed by setting the server.port property in the application.properties or application.yml file.
Example:
server.port=9090To create a simple RESTful API in Spring Boot:
Example:
@RestController
public class HelloController {
@GetMapping("/hello")
public String sayHello() {
return "Hello, World!";
}
}The @RestController annotation is used to define a RESTful web service controller. It combines the functionality of @Controller and @ResponseBody, meaning that methods in a class marked with @RestController will return data directly in the HTTP response body, typically as JSON or XML.
Exceptions can be handled globally in Spring Boot using:
Example using @ControllerAdvice:
@ControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(value = Exception.class)
public ResponseEntity<Object> handleException(Exception e) {
return new ResponseEntity<>("An error occurred: " + e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
}
}
Dependency Injection is a design pattern in which a class receives its dependencies from an external source rather than creating them internally. Spring Boot supports three types of dependency injection:
Example:
@Service
public class MyService {
private final MyRepository repository;
@Autowired
public MyService(MyRepository repository) {
this.repository = repository;
}
}The @Autowired annotation is used to inject dependencies automatically into a class by Spring’s Dependency Injection framework. It can be applied to constructors, setter methods, or fields. When used, Spring Boot will resolve and inject the required bean from the application context.
The @Value annotation is used to inject values from properties files into Spring beans. It helps in binding the value of configuration parameters to a field in a class.
Example:
@Component
public class MyComponent {
@Value("${app.name}")
private String appName;
public String getAppName() {
return appName;
}
}A Spring Boot application can be run from the command line using the following methods:
The @RequestMapping annotation is used to map HTTP requests to specific handler methods in a controller. It can be used at the class level to define a common base URL and at the method level to specify specific HTTP operations like GET, POST, PUT, DELETE, etc.
A bean can be defined in Spring Boot using the @Bean annotation within a @Configuration class or using stereotype annotations like @Component, @Service, or @Repository.
Spring Boot DevTools is a module that enhances the development experience by enabling automatic restarts, live reloading, and quick changes during development. It helps developers to see the effects of code changes without having to restart the application manually.
You can include external libraries in a Spring Boot project by adding the library's dependency in the pom.xml (for Maven) or build.gradle (for Gradle).
Example in pom.xml:
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.12.0</version>
</dependency>Spring Boot uses Logback as the default logging framework. It auto-configures a console appender with different log levels (INFO, DEBUG, WARN, etc.). You can customize logging by changing properties in application.properties or application.yml.
Spring Boot can be configured to use an embedded database like H2, HSQLDB, or Derby. These databases are typically used during development and testing.
To enable an embedded database, follow these steps:
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
</dependency>You can also define database properties in application.properties:
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.h2.console.enabled=trueThe @Entity annotation is used in JPA (Java Persistence API) to mark a class as a persistent entity, which means it will be mapped to a table in the database. Each instance of this class corresponds to a row in the table.
Example:
@Entity
public class User {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
private String name;
private String email;
// getters and setters
}To configure a basic web application in Spring Boot:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>@RestController
public class HelloController {
@GetMapping("/hello")
public String hello() {
return "Hello, Spring Boot!";
}
}24. Explain the concept of profiles in Spring Boot.
Profiles in Spring Boot allow different configurations to be used for different environments (development, testing, production, etc.). You can define environment-specific configurations in separate properties files like application-dev.properties and application-prod.properties.
To activate a profile, use the spring.profiles.active property in application.properties or pass it as a JVM argument:
spring.profiles.active=devWhen active, Spring Boot will load configuration from application-dev.properties along with application.properties.
You can access request parameters in Spring Boot using the @RequestParam annotation in controller methods.
Example:
@RestController
public class GreetingController {
@GetMapping("/greet")
public String greet(@RequestParam String name) {
return "Hello, " + name;
}
}URL: http://localhost:8080/greet?name=Sanjeet
Output: Hello, Sanjeet
The @ResponseBody annotation is used to indicate that the return value of a method should be written directly to the HTTP response body (rather than rendering a view). In Spring Boot, it is commonly used in RESTful services to return JSON or XML data.
Example:
@GetMapping("/user")
@ResponseBody
public User getUser() {
return new User("Sanjeet", "sanjeet@example.com");
}The method returns a JSON representation of the User object.
You can handle form data in Spring Boot using the @RequestParam or @ModelAttribute annotations.
Example using @RequestParam:
@PostMapping("/submit")
public String submitForm(@RequestParam String name, @RequestParam String email) {
return "Form submitted by " + name + " with email " + email;
}Example using @ModelAttribute:
@PostMapping("/submit")
public String submitForm(@ModelAttribute User user) {
return "Form submitted by " + user.getName() + " with email " + user.getEmail();
}The @ComponentScan annotation is used to specify the packages to scan for Spring components like @Component, @Service, @Repository, and @Controller. By default, Spring Boot scans the package where the @SpringBootApplication annotated class resides, but @ComponentScan can be used to specify additional packages to scan.
To customize the default error response in Spring Boot, you can:
Example:
@Controller
public class CustomErrorController implements ErrorController {
@RequestMapping("/error")
public String handleError() {
return "An error occurred!";
}
}Alternatively, you can create a custom JSON response by handling exceptions globally using @ControllerAdvice and @ExceptionHandler.
The @SpringBootTest annotation is used to create an application context for integration testing in Spring Boot. It loads the entire application context, enabling tests to run with full application behavior, including dependency injection, autowiring, and property configurations.
Example:
@SpringBootTest
public class MyApplicationTests {
@Test
void contextLoads() {
// Test context loading
}
}To create a simple HTML page in a Spring Boot application:
Example HTML (src/main/resources/templates/hello.html):
<html>
<body>
<h1>Hello, Thymeleaf!</h1>
</body>
</html>In the controller, use @GetMapping to return the view:
@Controller
public class HelloController {
@GetMapping("/hello")
public String hello() {
return "hello";
}
}Spring Boot provides dependency management through:
Spring Boot allows you to create environment-specific configuration files like application-dev.properties or application-prod.properties. You can specify which file to use by setting the spring.profiles.active property.
Example:
spring.profiles.active=devThe @PathVariable annotation is used to extract values from the URI path. It is often used in RESTful services to capture dynamic parts of the URL.
Example:
@GetMapping("/user/{id}")
public String getUser(@PathVariable("id") Long id) {
return "User ID: " + id;
}To return a JSON response from a Spring Boot controller, ensure that the controller method is annotated with @ResponseBody or use @RestController for the entire class. Spring Boot automatically converts the returned object to JSON using Jackson.
Example:
@RestController
public class UserController {
@GetMapping("/user")
public User getUser() {
return new User("Sanjeet", "sanjeet@example.com");
}
}Logging levels in Spring Boot can be configured in the application.properties or application.yml file.
Example:
logging.level.org.springframework=INFO
logging.level.com.example=DEBUGSpring Boot Actuator provides production-ready features like monitoring, metrics, health checks, and environment information via HTTP endpoints. Actuator endpoints include /health, /metrics, /info, and more.
To enable Actuator, add the following dependency:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>You can disable a specific Spring Boot auto-configuration by using the exclude attribute in the @SpringBootApplication annotation:
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
public class MyApplication {
}The @EnableAutoConfiguration annotation in Spring Boot enables the framework to configure Spring Beans automatically based on the dependencies and classpath settings. It is typically used as part of the @SpringBootApplication annotation.
To configure a custom banner, create a banner.txt file in the src/main/resources directory and put your custom ASCII art or text inside it. Spring Boot will display the contents of this file in the console when the application starts.
Spring Boot Actuator provides production-ready features to help monitor and manage Spring Boot applications. Key features include:
You can access these endpoints like /actuator/health, /actuator/metrics, and more.
You can customize Actuator endpoints in Spring Boot using application.properties:
Change Base Path:
management.endpoints.web.base-path=/manageEnable or Disable Specific Endpoints:
management.endpoint.health.enabled=true
management.endpoint.shutdown.enabled=trueAdditionally, custom endpoints can be created using the @Endpoint or @RestController annotations.
3. What are the main differences between @RestController and @Controller in Spring Boot?
4. How does Spring Boot support externalized configuration?
Spring Boot allows you to externalize configuration via properties files (application.properties or application.yml), environment variables, and command-line arguments. This helps in separating application code from configuration, enabling easy changes across different environments (dev, prod).
You can access configuration values in Spring Boot using:
@Value("${property.name}")
private String propertyName;The @ConfigurationProperties annotation is used to map properties from the application.properties or application.yml files to POJO classes, allowing type-safe access to configuration values.
Example:
@ConfigurationProperties(prefix = "app")
public class AppConfig {
private String name;
private int version;
// getters and setters
}Then, add @EnableConfigurationProperties(AppConfig.class) in the main application class.
Spring Boot can be secured using Spring Security. To enable it:
Example:
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http.authorizeRequests()
.antMatchers("/admin/**").hasRole("ADMIN")
.antMatchers("/user/**").hasAnyRole("USER", "ADMIN")
.and().formLogin();
}
}Spring Data JPA is a module of Spring that provides a data access layer based on JPA (Java Persistence API). It simplifies database access by providing repository interfaces with built-in CRUD operations.
To integrate it into Spring Boot:
Example:
public interface UserRepository extends JpaRepository<User, Long> {}Spring Boot can automatically initialize the database and generate the schema by leveraging JPA and Hibernate. You can configure this behavior in the application.properties file:
spring.jpa.hibernate.ddl-auto=create-dropOther options include none, validate, update, and create.
For running SQL scripts, you can place schema.sql or data.sql files in src/main/resources, and Spring Boot will automatically execute them on application startup.
Spring Boot’s auto-configuration feature automatically configures beans and settings based on the dependencies and the environment. It tries to guess the best configuration by inspecting the classpath and properties.
Auto-configuration can be disabled globally or selectively:
Globally using:
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})10. What are some strategies for managing transactions in Spring Boot?
Spring Boot manages transactions using Spring’s @Transactional annotation. Some strategies include:
11. How does Spring Boot handle dependency injection?
Spring Boot handles dependency injection using the core principles of Inversion of Control (IoC) in Spring. It automatically injects beans into your components using @Autowired (field, constructor, or setter injection).
Example:
@Service
public class UserService {
private final UserRepository userRepository;
@Autowired
public UserService(UserRepository userRepository) {
this.userRepository = userRepository;
}
}Spring Boot starters are pre-configured sets of dependencies that help developers quickly include the needed libraries for a specific task without manually managing individual dependencies.
Common examples include:
The @SpringBootApplication annotation is a convenience annotation that combines three annotations:
Spring Boot supports asynchronous processing using the @Async annotation. By marking a method with @Async, it is executed in a separate thread asynchronously.
Example:
@Service
public class AsyncService {
@Async
public void asyncMethod() {
// some asynchronous logic
}
}To enable asynchronous processing, you need to annotate your configuration class with @EnableAsync.
Profiles in Spring Boot allow the application to load different configurations based on the active environment. For example, you can have separate properties files for development and production environments (application-dev.properties, application-prod.properties).
To activate a profile, use the spring.profiles.active property:
spring.profiles.active=devYou can handle exceptions globally using the @ControllerAdvice and @ExceptionHandler annotations.
Example:
@ControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(Exception.class)
public ResponseEntity<String> handleException(Exception e) {
return new ResponseEntity<>("An error occurred: " + e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
}
}The default embedded server used in Spring Boot is Tomcat. You can change it by excluding the Tomcat dependency and including a different server like Jetty or Undertow in your pom.xml.
Example (for Jetty):
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jetty</artifactId>
</dependency>Actuator provides the /actuator/metrics endpoint that exposes a variety of application metrics like memory usage, request counts, and more. You can enable it in application.properties:
management.endpoint.metrics.enabled=trueYou can also monitor specific metrics like JVM memory using:
GET /actuator/metrics/jvm.memory.usedSpring Boot starters are a set of pre-defined dependency packages that simplify adding necessary libraries for specific functionalities. They encapsulate dependencies and ensure compatibility, saving developers from manually including and managing multiple dependencies.
Common examples:
The @ConditionalOnMissingBean annotation is used to conditionally load a bean only if the specified bean is not already present in the Spring context. This is often used in auto-configuration classes to provide default beans that can be overridden.
Example:
@Bean
@ConditionalOnMissingBean
public DataSource dataSource() {
return new HikariDataSource();
}Spring Boot DevTools offers a set of tools that improve developer productivity. Key features include:
To use devtools, add the following dependency:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional>
</dependency>Spring Boot provides built-in support for testing through:
Example of unit testing with MockMVC for testing controllers:
@RunWith(SpringRunner.class)
@WebMvcTest(UserController.class)
public class UserControllerTest {
@Autowired
private MockMvc mockMvc;
@Test
public void shouldReturnUser() throws Exception {
mockMvc.perform(get("/user"))
.andExpect(status().isOk())
.andExpect(content().json("{name: 'Sanjeet'}"));
}
}@DataJpaTest is used for testing JPA repositories. It provides configuration that is limited to testing JPA components without the need to load the full application context.
Example:
@DataJpaTest
public class UserRepositoryTest {
@Autowired
private UserRepository userRepository;
@Test
public void testFindByName() {
User user = userRepository.findByName("Sanjeet");
assertNotNull(user);
}
}Configuring multiple data sources in Spring Boot involves:
Example configuration:
@Primary
@Bean(name = "primaryDataSource")
@ConfigurationProperties(prefix = "spring.datasource.primary")
public DataSource primaryDataSource() {
return DataSourceBuilder.create().build();
}
@Bean(name = "secondaryDataSource")
@ConfigurationThe @EnableScheduling annotation is used in Spring Boot to enable support for scheduled tasks. It allows methods to be executed at fixed intervals or with custom schedules by using the @Scheduled annotation on methods.
Example:
@EnableScheduling
@SpringBootApplication
public class MyApplication {}
@Component
public class ScheduledTask {
@Scheduled(fixedRate = 5000)
public void run() {
System.out.println("Task is running every 5 seconds");
}
}Pagination and sorting in Spring Data JPA are achieved using the Pageable and Sort interfaces. The repository method should accept a Pageable parameter for pagination and a Sort parameter for sorting.
Example:
public interface UserRepository extends JpaRepository<User, Long> {
Page<User> findByLastName(String lastName, Pageable pageable);
}
Pageable pageable = PageRequest.of(0, 10, Sort.by("firstName"));
Page<User> users = userRepository.findByLastName("Doe", pageable);The @EnableAutoConfiguration annotation in Spring Boot enables automatic configuration based on the classpath settings and environment. It allows Spring Boot to automatically configure beans and settings needed for the application.
To exclude specific auto-configurations, use the exclude attribute:
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class MyApplication {}Spring Boot can auto-configure H2 as an in-memory database if the H2 dependency is on the classpath. You can configure it in application.properties:
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.h2.console.enabled=trueThis configuration starts an H2 in-memory database and enables the H2 console at /h2-console.
The @Profile annotation in Spring Boot is used to specify beans that should be created only when a specific profile is active. It helps in defining different beans for different environments (e.g., dev, prod).
Example:
@Bean
@Profile("dev")
public DataSource devDataSource() {
return new HikariDataSource();
}
@Bean
@Profile("prod")
public DataSource prodDataSource() {
return new HikariDataSource();
}There are several ways to run a Spring Boot application:
Using java -jar: You can package the application as a JAR file and run it using the java -jar command.
java -jar myapp.jarUsing Maven/Gradle: Run the application with Maven or Gradle:
mvn spring-boot:run31. How can you access a property value defined in application.properties in your Java code?
You can access property values defined in application.properties using the @Value annotation or by using @ConfigurationProperties.
Example using @Value:
@Value("${app.name}")
private String appName;Example using @ConfigurationProperties:
@ConfigurationProperties(prefix = "app")
public class AppConfig {
private String name;
// getters and setters
}The spring-boot-starter-test dependency provides essential libraries and tools for testing Spring Boot applications. It includes:
Spring Boot allows file uploads using MultipartFile. To enable file uploads, ensure that the multipart feature is enabled in application.properties:
spring.servlet.multipart.enabled=trueExample of file upload controller:
@PostMapping("/upload")
public String handleFileUpload(@RequestParam("file") MultipartFile file) {
// process file
return "File uploaded successfully!";
}Spring Boot uses Logback as the default logging framework. The logging level can be configured in application.properties:
logging.level.org.springframework=INFO
logging.level.com.example=DEBUGYou can change the default logging framework by excluding Logback and including dependencies for Log4j or another logging framework.
The @Conditional annotation is used to define beans or configurations conditionally, based on certain conditions. Spring provides several conditional annotations, like @ConditionalOnProperty, @ConditionalOnMissingBean, etc.
Example:
@Bean
@ConditionalOnProperty(name = "feature.enabled", havingValue = "true")
public FeatureService featureService() {
return new FeatureService();
}Cross-Origin Resource Sharing (CORS) can be enabled in Spring Boot by using the @CrossOrigin annotation or by configuring it globally through a WebMvcConfigurer.
Example with @CrossOrigin:
@CrossOrigin(origins = "http://example.com")
@GetMapping("/resource")
public ResponseEntity<String> getResource() {
return ResponseEntity.ok("Resource data");
}Global configuration using WebMvcConfigurer:
@Configuration
public class WebConfig implements WebMvcConfigurer {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**").allowedOrigins("http://example.com");
}
}@RestControllerAdvice is used to handle exceptions globally in Spring Boot applications for REST controllers. It combines @ControllerAdvice and @ResponseBody.
Example:
@RestControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(Exception.class)
public ResponseEntity<String> handleException(Exception e) {
return new ResponseEntity<>("Error: " + e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
}
}The @Entity annotation is used in Spring Boot to mark a class as a JPA entity. The entity is mapped to a database table, and its fields are mapped to columns in that table.
Example:
@Entity
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
}Caching in Spring Boot can be implemented using Spring’s caching abstraction. First, enable caching by adding @EnableCaching in your configuration class. Then, use @Cacheable, @CachePut, and @CacheEvict annotations on methods to cache their results.
Example:
@Service
public class UserService {
@Cacheable("users")
public User findUserById(Long id) {
return userRepository.findById(id).orElse(null);
}
}Spring Boot provides default error handling through /error endpoint. To customize error handling, you can:
Spring Boot integrates with Spring Security to handle authentication and authorization. You can secure your application using spring-boot-starter-security, which provides built-in security mechanisms such as HTTP Basic, form-based login, and CSRF protection.
For custom security configurations, you create a class that extends WebSecurityConfigurerAdapter and override methods to configure HTTP security.
Example:
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.csrf().disable()
.authorizeRequests()
.antMatchers("/public/**").permitAll()
.anyRequest().authenticated()
.and()
.formLogin().loginPage("/login").permitAll()
.and()
.logout().permitAll();
}
}2. How can you implement distributed tracing in Spring Boot microservices?
Distributed tracing helps track requests that span multiple microservices. You can implement distributed tracing in Spring Boot applications using Spring Cloud Sleuth along with Zipkin or Jaeger as the tracing systems.Steps to set up:
Example in application.properties:
spring.zipkin.base-url=http://localhost:9411
spring.sleuth.sampler.probability=1.0This configuration sends traces to Zipkin, allowing you to visualize how requests move through the system.
High availability and fault tolerance in Spring Boot applications can be achieved using various approaches:
Example of circuit breaker using Resilience4j:
@RestController
public class MyController {
@GetMapping("/data")
@CircuitBreaker(name = "backendA", fallbackMethod = "fallback")
public String getData() {
// call to external service
}
public String fallback(Throwable t) {
return "Fallback response";
}
}4. What is the role of Spring Boot Admin, and how do you set it up?
Spring Boot Admin is used to monitor and manage Spring Boot applications in real-time. It provides a dashboard where you can view the status of different services, monitor metrics, view logs, and more.
To set up Spring Boot Admin:
Add the following dependency to your admin server:
<dependency>
<groupId>de.codecentric</groupId>
<artifactId>spring-boot-admin-starter-server</artifactId>
</dependency>1.Add the admin client dependency to the application you want to monitor:
<dependency>
<groupId>de.codecentric</groupId>
<artifactId>spring-boot-admin-starter-client</artifactId>
</dependency>2.Configure application.properties:
spring.boot.admin.client.url=http://localhost:80803.The admin server aggregates and displays the data of the registered applications.
5. Explain how Spring Boot handles reactive programming with WebFlux.
Spring Boot supports reactive programming using Spring WebFlux. Reactive programming is an asynchronous, non-blocking programming model that handles high-concurrency environments efficiently. WebFlux is based on the Reactor framework and supports reactive types like Mono and Flux.
Example of a reactive controller using Mono and Flux:
@RestController
public class ReactiveController {
@GetMapping("/mono")
public Mono<String> getMono() {
return Mono.just("Hello Mono");
}
@GetMapping("/flux")
public Flux<String> getFlux() {
return Flux.just("Hello", "Flux");
}
}WebFlux works well with backpressure mechanisms to handle data streams efficiently, making it suitable for high-load applications such as chat apps or real-time systems.
Performance optimization in Spring Boot involves several strategies:
Connection Pooling: Configure a connection pool (e.g., HikariCP) for efficient database access. Example:
spring.datasource.hikari.maximum-pool-size=10Lazy Initialization: Enable lazy initialization to load beans only when they are needed.
spring.main.lazy-initialization=true7. What are the challenges of deploying Spring Boot applications in a containerized environment (e.g., Docker)?
Common challenges when deploying Spring Boot applications in Docker include:
Example Dockerfile for a Spring Boot application:
FROM openjdk:11-jre
COPY target/app.jar /app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]Ensuring reliability and availability in Spring Boot microservices involves:
Spring Boot supports database migrations using tools like Flyway and Liquibase.
V1__initial_schema.sql
V2__add_new_column.sqlTo enable Flyway, add the dependency:
<dependency>
<groupId>org.flywaydb</groupId>
<artifactId>flyway-core</artifactId>
</dependency>10. What are some best practices for error handling in Spring Boot applications?
Best practices for error handling in Spring Boot applications include:
Example of a global exception handler:
@RestControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(ResourceNotFoundException.class)
public ResponseEntity<ErrorResponse> handleNotFound(ResourceNotFoundException ex) {
ErrorResponse errorResponse = new ErrorResponse("RESOURCE_NOT_FOUND", ex.getMessage());
return new ResponseEntity<>(errorResponse, HttpStatus.NOT_FOUND);
}
}Spring Boot uses SLF4J with Logback as the default logging framework. You can configure logging properties in the application.properties or application.yml file.
Example of logging configuration:
logging.level.root=INFO
logging.level.com.example=DEBUG
logging.file.name=app.logTo use logging in your application, you inject a logger instance into your class:
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class MyService {
private static final Logger logger = LoggerFactory.getLogger(MyService.class);
public void doSomething() {
logger.info("Doing something");
}
}For structured logging, consider using Logstash or ELK Stack for centralized logging and monitoring.
Spring Boot DevTools is a set of tools that enhance the development experience by providing features like automatic restarts, live reload, and enhanced logging. It helps developers see changes in their code without needing to restart the application manually.
To enable DevTools, add the following dependency in your pom.xml:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
</dependency>Key features:
Note: DevTools should not be included in the production environment.
You can configure custom error pages in Spring Boot by creating HTML or JSP files in the src/main/resources/templates directory. By default, Spring Boot will map error codes to specific error pages.
For example, create an error.html for generic errors and 404.html for 404 errors:
<!-- src/main/resources/templates/error.html -->
<html>
<body>
<h1>Error</h1>
<p>Something went wrong.</p>
</body>
</html>To create specific error pages, you can use the following naming conventions:
You can also customize error handling by implementing ErrorController:
@Controller
public class CustomErrorController implements ErrorController {
@RequestMapping("/error")
public String handleError() {
return "error"; // return the name of the error page
}
}
To handle file uploads in Spring Boot, you can use @RequestParam to receive multipart files. Ensure you have the spring-boot-starter-web dependency in your project.
Example of a file upload controller:
@RestController
public class FileUploadController {
@PostMapping("/upload")
public ResponseEntity<String> uploadFile(@RequestParam("file") MultipartFile file) {
try {
// Save the file to the server
Path path = Paths.get("uploads/" + file.getOriginalFilename());
Files.copy(file.getInputStream(), path, StandardCopyOption.REPLACE_EXISTING);
return ResponseEntity.ok("File uploaded successfully: " + file.getOriginalFilename());
} catch (IOException e) {
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("File upload failed");
}
}
}In your HTML form, ensure you use enctype="multipart/form-data":
<form method="post" action="/upload" enctype="multipart/form-data">
<input type="file" name="file" />
<button type="submit">Upload</button>
</form>CORS (Cross-Origin Resource Sharing) can be enabled in Spring Boot by configuring a CorsConfigurationSource bean or using the @CrossOrigin annotation at the controller or method level.
Example of global CORS configuration:
@Configuration
public class WebConfig implements WebMvcConfigurer {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**")
.allowedOrigins("http://example.com")
.allowedMethods("GET", "POST", "PUT", "DELETE")
.allowedHeaders("*");
}
}Example of using @CrossOrigin:
@RestController
@CrossOrigin(origins = "http://example.com")
public class MyController {
@GetMapping("/data")
public ResponseEntity<String> getData() {
return ResponseEntity.ok("Data");
}
}The @SpringBootApplication annotation is a convenience annotation that combines several other annotations:
It serves as the main entry point for Spring Boot applications and is typically used on the main application class.
Example:
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}To integrate Spring Boot with MongoDB, you need the spring-boot-starter-data-mongodb dependency. This provides support for MongoDB repository and template.
Example of integration:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>spring.data.mongodb.uri=mongodb://localhost:27017/mydatabase@Document(collection = "users")
public class User {
@Id
private String id;
private String name;
// Getters and setters
}public interface UserRepository extends MongoRepository<User, String> {
List<User> findByName(String name);
}Spring Boot starters are a set of convenient dependency descriptors that aggregate common libraries and dependencies for specific functionalities. They simplify dependency management by allowing developers to include a single starter dependency instead of managing multiple individual dependencies.
For example:
Example of using a starter:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>By using starters, you can quickly set up a Spring Boot application with all the necessary dependencies for specific features.
Swagger is used for API documentation and can be easily integrated into Spring Boot applications using springdoc-openapi or springfox-swagger2.
Example using springdoc-openapi:
<dependency>
<groupId>org.springdoc</groupId>
<artifactId>springdoc-openapi-ui</artifactId>
<version>1.5.10</version>
</dependency>Example of annotating a controller:
@RestController
@RequestMapping("/api/users")
public class UserController {
@GetMapping
@Operation(summary = "Get all users")
public List<User> getAllUsers() {
return userService.findAll();
}
}You can also customize API information using the @OpenAPIDefinition annotation.
Advantages of using Spring Boot include:
Exception handling in REST APIs can be achieved using @ControllerAdvice and @ExceptionHandler to manage exceptions globally.
Example of a global exception handler:
@ControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(ResourceNotFoundException.class)
public ResponseEntity<ErrorResponse> handleNotFound(ResourceNotFoundException ex) {
ErrorResponse errorResponse = new ErrorResponse("NOT_FOUND", ex.getMessage());
return new ResponseEntity<>(errorResponse, HttpStatus.NOT_FOUND);
}
@ExceptionHandler(Exception.class)
public ResponseEntity<ErrorResponse> handleGlobalException(Exception ex) {
ErrorResponse errorResponse = new ErrorResponse("INTERNAL_SERVER_ERROR", "An error occurred");
return new ResponseEntity<>(errorResponse, HttpStatus.INTERNAL_SERVER_ERROR);
}
}This approach allows you to return structured error responses for different exception types.
The @Async annotation in Spring Boot is used to run methods asynchronously in a separate thread, allowing the main thread to continue without waiting for the asynchronous task to complete. This is useful for long-running operations.
To enable asynchronous processing, add @EnableAsync to your configuration class:
@Configuration
@EnableAsync
public class AsyncConfig {
}Example of using @Async:
@Service
public class MyService {
@Async
public void performAsyncTask() {
// Long-running task
}
}You can also specify a Future return type if you need to handle the result of the asynchronous method.
Spring Data JPA provides built-in support for pagination and sorting through Pageable and Sort interfaces.
Example of using pagination and sorting:
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
Page<User> findByName(String name, Pageable pageable);
}In your service or controller, you can create PageRequest objects to define pagination and sorting:
@GetMapping("/users")
public Page<User> getUsers(@RequestParam int page, @RequestParam int size, @RequestParam String sort) {
Pageable pageable = PageRequest.of(page, size, Sort.by(sort));
return userRepository.findByName("John", pageable);
}This allows you to retrieve a subset of results with sorting capabilities.
Spring Cloud is a set of tools and frameworks designed to help developers build distributed systems and microservices architectures. It provides features like configuration management, service discovery, circuit breakers, and more.
Spring Boot serves as the foundation for Spring Cloud applications, providing the necessary tools to build stand-alone, production-ready Spring applications. By combining Spring Boot with Spring Cloud, developers can leverage auto-configuration and starter dependencies to simplify the setup and configuration of cloud-native applications.
Examples of Spring Cloud components:
Configuring a datasource in Spring Boot is done through properties in application.properties or application.yml.
Example of configuring a MySQL datasource:
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=password
spring.datasource.driver-class-name=com.mysql.cj.jdbc.DriverIf you are using JPA, you can also include:
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=trueWith these configurations, Spring Boot will automatically create a DataSource bean, and you can use repositories or EntityManager to interact with the database.
CommandLineRunner and ApplicationRunner are two interfaces provided by Spring Boot that can be implemented to execute code after the application context has been loaded.
Example using CommandLineRunner:
@Component
public class StartupRunner implements CommandLineRunner {
@Override
public void run(String... args) throws Exception {
System.out.println("Application started with command-line arguments: " + Arrays.toString(args));
}
}Example using ApplicationRunner:
@Component
public class StartupRunner implements ApplicationRunner {
@Override
public void run(ApplicationArguments args) throws Exception {
System.out.println("Application started with option names: " + args.getOptionNames());
}
}To create a REST API with Spring Boot using JPA, follow these steps:
Example of a REST API:
@Entity
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
// Getters and Setters
}
public interface UserRepository extends JpaRepository<User, Long> {}
@Service
public class UserService {
@Autowired
private UserRepository userRepository;
public List<User> getAllUsers() {
return userRepository.findAll();
}
public User createUser(User user) {
return userRepository.save(user);
}
}
@RestController
@RequestMapping("/api/users")
public class UserController {
@Autowired
private UserService userService;
@GetMapping
public List<User> getAllUsers() {
return userService.getAllUsers();
}
@PostMapping
public User createUser(@RequestBody User user) {
return userService.createUser(user);
}
}To use Spring Boot with external REST APIs, you can leverage RestTemplate or the WebClient class (for reactive programming).
Example using RestTemplate:
@Bean
public RestTemplate restTemplate() {
return new RestTemplate();
}@Service
public class ApiService {
@Autowired
private RestTemplate restTemplate;
public String getDataFromExternalApi() {
ResponseEntity<String> response = restTemplate.getForEntity("https://api.example.com/data", String.class);
return response.getBody();
}
}Example using WebClient (for reactive programming):
@Bean
public WebClient.Builder webClientBuilder() {
return WebClient.builder();
}
@Service
public class ApiService {
@Autowired
private WebClient.Builder webClientBuilder;
public Mono<String> getDataFromExternalApi() {
return webClientBuilder.build()
.get()
.uri("https://api.example.com/data")
.retrieve()
.bodyToMono(String.class);
}
}Spring Boot integrates with Spring Security to provide authentication and authorization capabilities.
Basic steps to implement security:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.authorizeRequests()
.antMatchers("/api/public/**").permitAll()
.anyRequest().authenticated()
.and()
.httpBasic();
}
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.inMemoryAuthentication()
.withUser("user").password(passwordEncoder().encode("password")).roles("USER")
.and()
.withUser("admin").password(passwordEncoder().encode("admin")).roles("ADMIN");
}
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
}This configuration secures all endpoints except those under /api/public/** and uses in-memory authentication for demonstration purposes. For production applications, consider using database-backed authentication or OAuth2.
