Spring Boot Interview Questions

Interview questions

Expand a question to read the answer. Tick when you’re prepared (progress saved on this device).

0%

Advantage of Spring Boot is, It provides various tools and annotations that simplifies application development.

Some of them are:

Spring Initializr: An online tool to quickly generate a Spring Boot project structure with your chosen dependencies. It sets up a basic project template, reducing initial setup time.
Annotations: Spring Boot heavily relies on annotations to reduce boilerplate code. Significant ones include: @SpringBootApplication: A combination of three annotations (@Configuration, @EnableAutoConfiguration, and @ComponentScan). It signals the main class that starts the Spring application. @RestController and @RequestMapping: For creating RESTful web services with ease. @Autowired: For dependency injection, allowing Spring to resolve and inject collaborating beans into your bean.
Auto-Configuration: Automatically configures your application based on the added dependencies, significantly reducing the need for manual configuration.
Embedded Servers: Comes with embedded server options like Tomcat, Jetty, or Undertow, eliminating the need for explicit server setup.

These features collectively contribute to a streamlined, efficient development process, making Spring Boot a preferred choice for rapid application development.

Some of the More Advantages of Spring Boot are

It offers numerous advantages that make it popular among developers, especially for enterprise-level applications. Key benefits include:

Ease of Development: With its convention-over-configuration approach, Spring Boot reduces the need for extensive XML configurations, making the development process simpler and faster.
Rapid Prototyping: Features like auto-configuration and embedded servers enable rapid prototyping and easy testing of applications.
Microservices Support: Its lightweight nature and built-in features like service discovery and configuration management make it ideal for microservices architecture.
Wide Range of Extensions: Spring Boot supports a variety of extensions and plugins, facilitating integration with other tools and technologies.
Comprehensive Ecosystem: Being part of the larger Spring ecosystem, it offers seamless integration with other Spring projects like Spring Security and Spring Data.
Strong Community and Support: A robust community and extensive documentation ensure continuous support and learning resources for developers.

These advantages make Spring Boot a versatile and efficient choice for modern Java application development.

In a Spring Boot application, the entry point is the main class, which is typically annotated with @SpringBootApplication. This annotation serves a crucial role, encapsulating three key annotations:

@Configuration: Tags the class as a source of bean definitions for the application context.
@EnableAutoConfiguration: Tells Spring Boot to start adding beans based on classpath settings, other beans, and various property settings.
@ComponentScan: Enables Spring to scan for other components, configurations, and services in the specified package, allowing it to find controllers, services, etc.

The main class also contains the main method, which is the standard entry point for a Java application. This method runs the Spring application by calling SpringApplication.run(), which sets up the Spring context and launches the application.

public static void main(String[] args) {
    SpringApplication.run(MyApplication.class, args);
}

This structure allows Spring Boot to simplify configuration and bootstrap processes, streamlining the application startup.

Interview questions

Expand a question to read the answer. Tick when you’re prepared (progress saved on this device).

0%

Spring Boot Starters are a set of convenient dependency descriptors that you can include in your application. Each starter is designed to provide a specific type of functionality, bundling the necessary dependencies together so that you don’t have to hunt them down individually.

Key Features of Spring Boot Starters:

Streamlined Dependency Management: Starters include a comprehensive list of dependencies needed for a specific feature or library, ensuring compatibility and reducing the risk of version conflicts.
Rapid Set-Up: By simply adding a starter to your project’s build file, you automatically import a set of dependencies related to a particular functionality. This significantly speeds up project setup.
Consistency: Using starters ensures consistency across projects, as they standardize the versioning and configuration of dependencies.
Wide Range of Options: There are starters for various needs – web applications, data access, messaging, security, and more. For example, spring-boot-starter-web is used for building web applications, including RESTful applications using Spring MVC.

Example of Adding a Starter :

In a Maven project, you add a starter to your pom.xml:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

Understanding spring-boot-starter-web in Spring Boot

The spring-boot-starter-web is one of the most widely used starters in Spring Boot, specifically tailored for web application development. It simplifies the setup process by bundling together essential dependencies needed to create web applications, including RESTful services.

Key Components of spring-boot-starter-web :

Spring MVC (Model-View-Controller): A framework for building web applications in Java, allowing the creation of dynamic web pages.
Embedded Tomcat Server: Provides an embedded Tomcat server, enabling easy deployment and testing of web applications without the need for external Tomcat installation.
Jackson: A popular JSON parser for Java, which is essential for RESTful web services to handle HTTP requests and responses in JSON format.
Validation: Supports validation mechanisms, which are crucial for ensuring the integrity of data in web forms and API requests.
Spring Boot Autoconfiguration: Automatically configures the necessary settings for a Spring MVC application, such as dispatcher servlets, resource handlers, and message converters.

In Spring Boot, the spring-boot-starter-parent POM plays a pivotal role in simplifying Maven configurations for your application. It serves as a parent POM (Project Object Model) for your projects and manage the following things for multiple child projects and modules like

Configuration: Java version and other properties. Dependency management: Version of dependencies. Default plugin configuration: This includes configurations such as build plugins.

It Provides following key functionalities:

Default Configuration: It comes with pre-defined configurations for Maven plugins and dependencies. This reduces the need to specify common build configurations in your project’s POM file.
Dependency Management: It manages versions for common dependencies, ensuring that your project uses compatible versions of Spring Boot libraries and other related dependencies. This feature is particularly beneficial as it minimizes issues related to version conflicts.
Plugin Configuration: It configures commonly used Maven plugins like maven-compiler-plugin (sets Java version) and maven-jar-plugin (for creating JAR files), ensuring that they are properly set up for a Spring Boot application.
Spring Boot Version Alignment: By inheriting from spring-boot-starter-parent, your project automatically aligns with the version of Spring Boot defined in the parent POM. This ensures consistency and compatibility in the Spring Boot ecosystem.

Usage Example: In your Maven pom.xml, you would specify the spring-boot-starter-parent as the parent:

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.x.x</version> <!-- specify the desired version -->
</parent>

By leveraging spring-boot-starter-parent, developers can focus more on their application’s unique aspects rather than on configuring build settings.

Interview questions

Expand a question to read the answer. Tick when you’re prepared (progress saved on this device).

0%

In Spring Boot, Dependency Injection is a technique where the framework supplies objects that another object depends on (aka dependencies).

We can also define it as, Dependency Injection (DI) is a core concept in Spring Boot, central to how it manages and configures application components. It’s a design pattern that Spring Boot uses to implement Inversion of Control (IoC), where objects don’t create their dependencies but are instead provided with them.

How It Works:

In Spring Boot, objects (commonly known as beans) are created and managed by the Spring Container. Dependency Injection allows these beans to receive their dependencies automatically from the container. This process simplifies code management, making it more modular, testable, and maintainable.

Types of Dependency Injection in Spring Boot:

1). Constructor Injection: Dependencies are provided through a class constructor.

@Component
public class MyClass {
    private final Dependency dependency;

    @Autowired
    public MyClass(Dependency dependency) {
        this.dependency = dependency;
    }
}

2). Setter Injection: Dependencies are provided through setter methods.

@Component
public class MyClass {
    private Dependency dependency;

    @Autowired
    public void setDependency(Dependency dependency) {
        this.dependency = dependency;
    }
}

3). Field Injection: Dependencies are injected directly into the fields.

@Component
public class MyClass {
    @Autowired
    private Dependency dependency;
}

Advantages of Dependency Injection:

Decoupling: DI reduces the coupling between classes, making the system more flexible and easier to maintain.
Ease of Testing: It simplifies unit testing as dependencies can be easily mocked or stubbed.
Simplified Configuration: With Spring Boot’s auto-configuration, dependencies are automatically resolved and injected, reducing the need for explicit configuration.

Example to understand Dependency Injection

Suppose you have a Car class that depends on an Engine class.

First, define the Engine class:

@Component
public class Engine {
    public String start() {
        return "Engine started";
    }
}

Here, @Component makes Engine a Spring-managed bean, meaning Spring will create and manage instances of Engine.

Next, create the Car class, which depends on Engine:

@Component
public class Car {
    private final Engine engine;

    @Autowired
    public Car(Engine engine) {
        this.engine = engine;
    }

    public String startCar() {
        return engine.start();
    }
}

In Car, the Engine is injected through the constructor, as indicated by the @Autowired annotation. This tells Spring to supply an instance of Engine when creating a Car.

Now, when you run a Spring Boot application, and a Car bean is created, Spring automatically injects an Engine instance into it, thanks to Dependency Injection. This injection decouples the creation of dependent objects, making the code more modular and testable.

@SpringBootApplication
public class MyApplication {

    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(MyApplication.class, args);
        Car car = context.getBean(Car.class);
        System.out.println(car.startCar()); // Outputs: Engine started
    }
}

In this setup, MyApplication runs the Spring Boot application, and you get the Car bean from the application context, demonstrating how Engine was automatically injected into Car.

In Spring Boot, both @Autowired and @Resource annotations are used for dependency injection, but they have some key differences in how they operate and inject dependencies:

Source of Annotation: @Autowired is a part of the Spring framework. @Resource is specified by the JSR-250 Java standard and not Spring-specific.
Injection Mechanism: @Autowired performs dependency injection by type. When more than one bean of the same type is present, it can be further qualified using @Qualifier. @Resource, by default, performs injection by name. It uses the name of the bean to be injected, which can be specified through its name attribute (@Resource(name="beanName")). If the name is not specified, it falls back to injection by type.
Fallback Behavior: With @Autowired, if a matching bean is not found, it results in an exception by default. However, you can set it to optional (@Autowired(required=false)). @Resource fails if a named bean is not found. It doesn’t have an explicit optional attribute like @Autowired.
Customization and Flexibility: @Autowired is more flexible with customizations, especially when used with @Qualifier to resolve specific beans. @Resource is simpler for straightforward cases where a bean is identified by its name.

Example Usage :

@Autowired without @Qualifier:

@Autowired
private MyService myService;

@Autowired with @Qualifier:

@Autowired
@Qualifier("specificService")
private MyService myService;

@Resource by name:

@Resource(name="myService")
private MyService myService;

In Spring Boot, a bean is an object that is instantiated, managed, and wired by the Spring IoC (Inversion of Control) container. Defining a bean can be done in several ways, making the application modular and easy to manage.

1. Using Annotations :

Component Scanning: The most common approach is to use annotations like @Component, @Service, @Repository, and @Controller. These annotations automatically register the class as a bean when component scanning is enabled.

@Service
public class MyService {
    // class details
}

Spring Boot automatically scans and registers beans defined with these annotations.

2. Explicit Bean Definition :

You can also define beans explicitly in a configuration class using the @Bean annotation. This is useful for third-party classes or more complex bean configurations.

@Configuration
public class MyConfiguration {
    @Bean
    public MyBean myBean() {
        return new MyBean();
    }
}

Here, MyBean is explicitly defined as a Spring bean in the configuration class MyConfiguration.

3. Using XML Configuration :

While less common in modern Spring Boot applications, beans can also be defined using XML configuration files. This approach involves specifying beans in an XML file, which is then loaded by the application context.

<bean id="myBean" class="com.example.MyBean" />

In Spring Boot, the default scope of a bean is “Singleton.” This means that only one instance of the bean is created and managed by the Spring Container throughout the entire lifecycle of the application context.

Key Characteristics of Singleton Scope :

Shared Instance: Any injection of this bean will refer to the same instance, ensuring consistency and saving resources.
Global State: As there’s only one instance, it maintains a global state within the application context.
Efficiency: This scope is efficient for beans that are stateless or where a shared instance is desirable.

For example, when you define a service class with the @Service annotation without specifying a scope, Spring Boot treats it as a singleton:

@Service
public class MyService {
    // Class details
}

In this scenario, MyService is a singleton bean, and the same instance will be used wherever it’s injected in the application.

Types of Bean Scopes in Spring Boot

Singleton: This is the default scope. Only one instance of the bean is created per Spring IoC container, and the same instance is returned every time the bean is requested.
Prototype: A new instance of the bean is created each time it is requested. This scope is useful when you need a unique state for each use of the bean.
Request: Each HTTP request will have its own instance of a bean. This scope is valid only in the context of a web-aware Spring ApplicationContext.
Session: A bean is scoped to an HTTP session. Each session will have its own instance of the bean. This is also specific to web applications.

Example :

To define a bean with a specific scope, you use the @Scope annotation:

@Service
@Scope("prototype")
public class MyPrototypeService {
    // Class details
}

Here, MyPrototypeService is defined with a prototype scope, creating a new instance every time it’s injected.

In Spring Boot, you have several options to control and interact with the lifecycle of a bean. The framework provides specific callback annotations and interfaces to manage the lifecycle events of a bean:

Using @PostConstruct and @PreDestroy Annotations :

@PostConstruct: This annotation marks a method to be called after a bean is created and property values are set. It’s used for initialization.
@PreDestroy: This annotation marks a method to be called just before a bean is removed from the container. It’s used for cleanup activities.

@Component
public class MyBean {
    @PostConstruct
    public void init() {
        // Initialization code
    }

    @PreDestroy
    public void destroy() {
        // Cleanup code
    }
}

Implementing InitializingBean and DisposableBean Interfaces :

InitializingBean: Implementing this interface allows the bean to perform initialization work after its properties have been set by overriding the afterPropertiesSet method.
DisposableBean: Implementing this interface allows the bean to perform cleanup work before it’s destroyed by overriding the destroy method.

@Component
public class MyBean implements InitializingBean, DisposableBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        // Initialization code
    }

    @Override
    public void destroy() throws Exception {
        // Cleanup code
    }
}

Custom Init and Destroy Methods :

You can also define custom init and destroy methods in your bean configuration using @Bean annotation in a configuration class.

@Configuration
public class AppConfig {
    @Bean(initMethod = "customInit", destroyMethod = "customDestroy")
    public MyBean myBean() {
        return new MyBean();
    }
}

In MyBean, you would then define customInit() and customDestroy() methods.

Interview questions

Expand a question to read the answer. Tick when you’re prepared (progress saved on this device).

0%

Externalizing configuration in a Spring Boot application allows you to separate configuration from code, making your application adaptable to different environments without requiring code changes.

Using Application Properties or YAML Files

Spring Boot looks for application.properties or application.yml (YAML) files in the following locations and orders them by precedence:

A /config subdirectory of the current directory.
The current directory.
A classpath /config package.
The classpath root.

You can specify configurations in these files, and Spring Boot will automatically load them. For example, to configure the server port:

# application.properties
server.port=8081

Or, in YAML format:

# application.yml
server:
  port: 8081

In Spring Boot, overriding properties is a common practice to adapt an application’s configuration to different environments (like development, testing, or production).

Here’s how you can do it:

1. Profiles-Specific Properties Files :

You can create profile-specific properties files like application-dev.properties or application-prod.properties. Activating a specific profile (using the spring.profiles.active property) will override the default properties.

2. Command-Line Arguments :

When running your application, you can pass properties as command-line arguments which will override those in application.properties.

For example:

java -jar myapp.jar --server.port=8081

3. Environment Variables :

Setting environment variables is another way to override properties. This is particularly useful in cloud deployments or containerized environments.

4. External Configuration Files :

Placing an application.properties file in a location outside your packaged application can override the properties packaged inside the application. Spring Boot will automatically detect and use them.

In Spring Boot, the @Value annotation is used for injecting property values into components. It’s a convenient way to externalize configuration and change it without altering the code.

Here’s how it works:

1. Injecting Literal Values :

You can directly inject constant or literal values:

@Value("Spring Framework")
private String name;

2. Injecting Property Values :

More commonly, @Value is used to inject properties from configuration files like application.properties:

@Value("${property.key}")
private String propertyValue;

Here, property.key is a placeholder for a property defined in application.properties or other property sources.

if property.key doesn’t exist in the properties file or is not assigned a value, Spring Boot will throw an exception (IllegalStateException or BeanCreationException) and fail to start the application.

To handle missing properties more gracefully, you can specify a default value directly in the @Value annotation:

@Value("${property.key:default_value}")
private String propertyValue;

Here, if property.key is not found, propertyValue will be set to "default_value".

3. Using with Expressions :

@Value can also be used with SpEL (Spring Expression Language) for more dynamic values:

@Value("#{systemProperties['user.timezone']}")
private String timezone;

This annotation simplifies the process of injecting values and promotes loose coupling and flexibility in your application. It’s especially useful for setting configuration parameters like database URLs, API keys, default values, etc., which may vary between environments.

Remember that @Value works only on beans managed by the Spring container. For it to work, the class should be a Spring component (e.g., annotated with @Component, @Service, @Controller, etc.).

Interview questions

Expand a question to read the answer. Tick when you’re prepared (progress saved on this device).

0%

The @SpringBootApplication annotation is a key feature in Spring Boot, significantly simplifying the initial setup and configuration of a Spring Boot application.

It’s a convenient composite annotation that encapsulates the following:

@Configuration: Indicates that the class has @Bean definitions, so the Spring container can process the class and generate Spring beans to be used in the application.
@EnableAutoConfiguration: Tells Spring Boot to automatically configure the application based on the dependencies present in the classpath. This auto-configuration attempts to guess and configure beans that you are likely to need.
@ComponentScan: Enables Spring to scan for other components, configurations, and services in the same package or sub-packages, automatically registering them as beans.

Typically, this annotation is placed on the main application class. Here’s an example:

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

With @SpringBootApplication, Spring Boot sets up a host of defaults (like embedding a server, setting up default database connections, etc.), making it much easier to develop stand-alone, production-grade Spring applications that you can “just run”.

The @RestController annotation in Spring Boot is used for building RESTful web services. It’s a specialized version of the @Controller annotation, and it simplifies the creation of RESTful web services by combining @Controller and @ResponseBody.

When to Use @RestController :

Building RESTful Web Services: Use it when you are developing web services that will respond with JSON or XML, and not views or HTML templates.
API Development: Ideal for developing APIs for front-end applications to consume.

How to Use @RestController :

1. Annotate the Controller Class: Apply @RestController at the class level to define a controller that handles HTTP requests.

@RestController
public class MyRestController {
    // Handler methods
}

2. Define Handler Methods:Within the controller, define methods to handle various HTTP requests (GET, POST, etc.). These methods should return data that will be written directly to the HTTP response body, thanks to @ResponseBody.

@GetMapping("/greeting")
public String greeting() {
    return "Hello, World";
}

3. Response Conversion:By default, Spring Boot uses Jackson (JSON) or JAXB (XML) to convert the response objects to JSON or XML format.

4. Combine with Other Annotations:Often used in combination with @RequestMapping or HTTP method-specific annotations like @GetMapping, @PostMapping, etc., to map web requests to handler methods.

@RestController is a basically used in modern Spring Boot applications for creating services that are consumed by various clients (web, mobile, etc.), leveraging the simplicity and power of RESTful principles.

In Spring Boot, @Service and @Repository are stereotypes annotations that indicate the role of a class in the application and how it should be treated by the framework.

@Service Annotation :

Purpose: @Service is used on classes that define business logic or business services.
Functionality: This annotation marks a class as a service provider, making it a candidate for auto-detection when using annotation-based configuration and classpath scanning.
Usage Context: Typically, classes annotated with @Service encapsulate business logic, calculations, or call functions from repository layers.

Example:

@Service
public class UserService {
    // Business logic and service methods
}

@Repository Annotation :

Purpose: @Repository is used on classes that interact with the data layer – accessing databases, performing CRUD operations.
Functionality: This annotation serves as a specialization of @Component, indicating that the class provides the mechanism for storage, retrieval, update, delete operations on objects.
Exception Translation: It also allows Spring to translate technology-specific exceptions (like JDBC exceptions) into consistent, unchecked exceptions.
Usage Context: Used mainly with Data Access Object (DAO) implementations.

Example:

@Repository
public class UserRepository {
    // Data access methods
}

The @RequestMapping annotation in Spring Boot is fundamental for handling HTTP requests. It’s used to map web requests to specific handler methods or classes in your controllers.

Key Aspects of @RequestMapping :

1. Mapping Requests: It can be applied at the class or method level to specify which URL paths should be mapped to which controller or method.

2. HTTP Methods:By default, @RequestMapping maps all HTTP operations (GET, POST, etc.). However, you can restrict this to specific methods using the method attribute.

@RequestMapping(value = "/greeting", method = RequestMethod.GET)
public String getGreeting() {
    // Handler code
}

3. Path Variables: You can extract parts of the URL to be used as parameters in the controller method using @PathVariable.

@RequestMapping(value = "/user/{id}")
public String getUserById(@PathVariable String id) {
    // Handler code
}

4. Combining Annotations:For convenience, Spring Boot provides specific variations like @GetMapping, @PostMapping, etc., which are specialized versions of @RequestMapping for specific HTTP methods.

@GetMapping("/greeting")
public String getGreeting() {
    // Handler code
}

5. Handling Multiple URLs: @RequestMapping can handle multiple URLs and can be configured to accept different header and content type requirements.

The @ComponentScan annotation in Spring Boot plays a crucial role in automatic detection and registration of beans. It’s used to specify the packages that the Spring framework should scan for components, services, repositories, controllers, and other Spring-managed components.

Key Functions of @ComponentScan :

1. Automated Bean Detection:It tells Spring where to look for annotated components. Spring then automatically registers these components as beans in the ApplicationContext.

2. Flexibility in Package Structure: Without @ComponentScan, Spring would only scan the default package. With this annotation, you can structure your packages more flexibly and tell Spring exactly which packages to consider for component scanning.

3. Customization:By default, @ComponentScan scans the package of the class it’s annotated on and all its sub-packages. However, you can customize this behavior by specifying particular packages:

@ComponentScan(basePackages = "com.example.myapp.services")

4. Use with @Configuration:Often used in conjunction with @Configuration to indicate that a class declares one or more @Bean methods and also triggers a component scan.

@ComponentScan is vital for Spring’s component-based development, as it automates the process of identifying and registering beans, reducing manual configuration and making the application more modular and easier to test.

Interview questions

Expand a question to read the answer. Tick when you’re prepared (progress saved on this device).

0%

Spring Data JPA (Java Persistence API) is a part of the larger Spring Data family, which makes it easier to implement JPA-based data access layers. It’s essentially a bridge between your domain model and the database.

Key Features of Spring Data JPA :

1. Repository Abstraction:One of the main features of Spring Data JPA is its repository support. By simply declaring an interface extending JpaRepository or CrudRepository, Spring Data JPA provides basic CRUD (Create, Read, Update, Delete) operations without the need for boilerplate code.

public interface UserRepository extends JpaRepository<User, Long> {

}

2. Query Methods: Spring Data JPA allows you to define query methods directly in the repository interface. The framework automatically generates the necessary query implementation from the method name.

List<User> findByLastName(String lastName);

3. Entity Management: It handles all the entity manager operations and translates exceptions into Spring’s DataAccessException, simplifying error handling.

4. Integration with JPA/Hibernate:While Spring Data JPA abstracts a lot of the complexities, it still provides the flexibility to use the full power of JPA and Hibernate when needed.

5. Custom Query Options:For complex queries, it supports the @Query annotation to write custom JPQL (Java Persistence Query Language) or SQL queries.

In Spring Data, the CrudRepository interface is a fundamental part of the Spring Data repository abstraction, playing a crucial role in simplifying data access and manipulation in database layers.

Key Features of CrudRepository :

1. Basic CRUD Operations:As the name suggests, CrudRepository provides methods for basic CRUD (Create, Read, Update, Delete) operations. This includes saving entities, finding entities by their id, updating entities, and deleting them.

2. Generic Interface:It’s a generic interface where you can specify the type of the entity and the type of its identifier (ID).

For example:

public interface UserRepository extends CrudRepository<User, Long> {
}

3. Simplification of Data Access Code: By extending CrudRepository, your repository interface automatically inherits several methods for handling entities, reducing the need to write boilerplate data access code.

Method Signatures: Some of the common methods include:

save(S entity): Save or update an entity.
findById(ID id): Retrieve an entity by its ID.
findAll(): Retrieve all entities.
delete(S entity): Delete an entity.

4. Custom Query Methods:Beyond these, you can also define custom query methods that Spring Data will automatically implement.

The CrudRepository interface is ideal for applications that require basic data access operations without the need for specific custom behavior.

Configuring a data source in Spring Boot is a straightforward process, thanks to its auto-configuration capabilities.

Here’s how to set it up:

1. Add Database Dependency :

First, include the database driver dependency in your build file (pom.xml for Maven or build.gradle for Gradle). For example, for a MySQL database:

Maven:

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

Gradle:

runtimeOnly 'mysql:mysql-connector-java'

2. Configure Properties :

In your application.properties or application.yml file, specify the database connection properties. For example, for a MySQL database:

application.properties:

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=myuser
spring.datasource.password=mypassword
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

application.yml:

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: myuser
    password: mypassword
    driver-class-name: com.mysql.cj.jdbc.Driver

3. Spring Boot Auto-Configuration :

Spring Boot will automatically configure the data source based on the properties and the database driver in the classpath.

4. Custom Configuration :

If you need more control, you can define a DataSource bean in your configuration class. However, for most cases, auto-configuration suffices.

5. JPA Configuration (Optional) :

If you’re using JPA, you might also specify JPA-specific properties, like the dialect.

6 . Profile-Specific Configuration :

For different environments (dev, test, prod), you can use profile-specific property files like application-dev.properties.

Interview questions

Expand a question to read the answer. Tick when you’re prepared (progress saved on this device).

0%

Spring Security is a powerful and highly customizable authentication and access-control framework. It’s the de-facto standard for securing Spring-based applications.

Here’s a basic guide on how to implement Spring Security:

1. Add Spring Security Dependency :

First, include Spring Security in your project. For Maven, add the following dependency to your pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

2. Basic Configuration :

Upon adding Spring Security, all endpoints are secured by default. Spring Boot auto-configures a default user and generates a password at startup, shown in the console.

3. Custom UserDetailsService :

Implement your own UserDetailsService to retrieve user information from a database or other source. This service loads user-specific data and roles.

@Service
public class CustomUserDetailsService implements UserDetailsService {
    // Load user by username logic
}

4. Configure HTTP Security :

Create a configuration class that extends WebSecurityConfigurerAdapter. Override the configure(HttpSecurity http) method to define which endpoints are secured and the level of access required.

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .antMatchers("/", "/home").permitAll()
            .anyRequest().authenticated()
            .and()
            .formLogin()
            .loginPage("/login")
            .permitAll()
            .and()
            .logout()
            .permitAll();
    }
}

5. Password Encoding :

Use a password encoder, like BCryptPasswordEncoder, to securely store passwords.

6. Role-Based Access Control :

Define roles and use them to restrict access to certain parts of the application.

.antMatchers("/admin/**").hasRole("ADMIN")

7. Protect Against Attacks :

Spring Security provides protection against common vulnerabilities like CSRF, session fixation, clickjacking, etc., by default.

Spring Security’s default behavior can be extensively customized to fit the security requirements of your application. Whether it’s form-based authentication, OAuth, method-level security, or JDBC authentication, Spring Security offers a wide range of features to secure your Spring Boot application.

In Spring Security, the @EnableWebSecurity annotation is used to enable Spring Security’s web security support and provide the Spring MVC integration. It’s typically used in conjunction with a configuration class that extends WebSecurityConfigurerAdapter.

Key Functions of @EnableWebSecurity :

Activates Spring Security: It signals to Spring Framework to start considering security measures for your application.
Custom Security Configuration: When placed on a class, it allows the customization of security settings through overriding methods from WebSecurityConfigurerAdapter. This is where you configure things like URL access rules, user authentication processes, and custom login forms.
Extends Default Web Security Configuration: By default, Spring Security provides basic web security configuration. Using @EnableWebSecurity, you can extend and customize this default behavior to suit your application’s needs.

Example of @EnableWebSecurity :

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    // Custom configuration
}

This annotation is essential for fine-tuning how security is handled in your Spring Boot application, making it a fundamental aspect of applying Spring Security effectively.

Role-based access control (RBAC) in Spring Security is a way to restrict access to certain parts of your application based on the roles assigned to users.

Step-by-step guide on implementing RBAC:

1. Define Roles

In Spring Security, roles are typically set up within the authorities of a UserDetails object. When creating users (either in-memory or through a user service), assign roles to them.

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth
        .inMemoryAuthentication()
        .withUser("user").password(passwordEncoder().encode("password")).roles("USER")
        .and()
        .withUser("admin").password(passwordEncoder().encode("password")).roles("ADMIN");
}

2. Configure HTTP Security with Roles :

Override the configure(HttpSecurity http) method in your WebSecurityConfigurerAdapter to define access rules based on roles.

@Override
protected void configure(HttpSecurity http) throws Exception {
    http
        .authorizeRequests()
        .antMatchers("/admin/**").hasRole("ADMIN")
        .antMatchers("/user/**").hasAnyRole("USER", "ADMIN")
        .antMatchers("/", "/public/**").permitAll()
        .anyRequest().authenticated()
        .and()
        .formLogin()
        .and()
        .logout();
}

In this configuration:

URLs under /admin/ are only accessible to users with the ADMIN role.
URLs under /user/ are accessible to users with either USER or ADMIN roles.
Public URLs are accessible without any authentication.

3. Method Security :

For more granular control, you can also secure individual methods using annotations like @PreAuthorize. Enable method security with @EnableGlobalMethodSecurity(prePostEnabled = true) in your configuration.

@PreAuthorize("hasRole('ADMIN')")
public void someAdminMethod() {
    // ...
}

4. Password Encoding :

Ensure to use a password encoder for security best practices.

@Bean
public PasswordEncoder passwordEncoder() {
    return new BCryptPasswordEncoder();
}

By following these steps, you can effectively implement role-based access control in your Spring Security configuration, ensuring that users can only access parts of the application that are relevant to their roles.

Cross-Site Request Forgery (CSRF) is a type of security vulnerability where unauthorized commands are transmitted from a user that a web application trusts. Spring Security provides built-in protection against CSRF attacks.

How CSRF Attacks Work :

In a CSRF attack, an attacker tricks a victim into executing unwanted actions on a web application where they are authenticated. For instance, if a user is logged into a banking application, an attacker could trick them into transferring money without their knowledge.

CSRF Protection in Spring Security :

Spring Security’s CSRF protection counters this by including a unique CSRF token with each request that modifies state (like POST requests). This token is checked on every submission, and if the token is not present or doesn’t match, Spring Security rejects the request.

Key Components of CSRF Protection :

CSRF Token: A unique, random value that is generated and sent by the server with each form. It is then sent back by the client with subsequent requests, ensuring the request is legitimate.
Token Validation: On receiving a request, Spring Security validates the CSRF token. If the token is missing or invalid, it denies the request, preventing potential CSRF attacks.
Integration with Forms: When using Thymeleaf or other Spring-aware templating engines, CSRF tokens are automatically included in forms.
Disabling CSRF Protection: While CSRF protection is enabled by default in Spring Security, it can be disabled for certain requests where it’s not needed, like REST APIs that are stateless.

@Override
protected void configure(HttpSecurity http) throws Exception {
    http
        .csrf().disable()
        // other configurations
}

By employing CSRF tokens, Spring Security adds an additional layer of security, safeguarding against unauthorized actions on behalf of authenticated users.

OAuth2 is an authorization framework that enables applications to obtain limited access to user accounts on an HTTP service. It works by delegating user authentication to the service hosting the user account and authorizing third-party applications to access the user account.

Key Components of OAuth2 :

Resource Owner: Typically the user.
Client: The application requesting access to the user’s account.
Resource Server: The server hosting the protected resources (user data).
Authorization Server: The server that authenticates the user and issues access tokens to the client.

OAuth2 Grant Types :

Authorization Code
Implicit
Resource Owner Password Credentials
Client Credentials

Implementing OAuth2 in Spring Boot

Spring Boot simplifies the implementation of OAuth2 authorization with Spring Security.

1. Add Dependencies :

Include the necessary Spring Security OAuth2 and OAuth2 Client dependencies in your pom.xml or build.gradle.Maven:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-oauth2-client</artifactId>
</dependency>

2. Configure Application Properties :

In application.properties or application.yml, configure the client credentials, authorization server details, and scopes.

spring.security.oauth2.client.registration.google.client-id=client-id
spring.security.oauth2.client.registration.google.client-secret=client-secret
spring.security.oauth2.client.registration.google.scope=profile,email

3. Create a Controller for Login :

Define a controller that redirects to the login page or the provider’s authorization page.

4. Secure Endpoints :

Use @EnableWebSecurity and extend WebSecurityConfigurerAdapter to secure your endpoints and redirect unauthenticated requests to the login page.

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .antMatchers("/", "/home").permitAll()
            .anyRequest().authenticated()
            .and()
            .oauth2Login();
    }
}

5. Test the Implementation :

Run your application and navigate to a secured endpoint to see the OAuth2 login process in action.

By following these steps, you can implement OAuth2 security in a Spring Boot application, leveraging the framework’s built-in support for OAuth2 client features.

Sometimes, you may need to disable Spring Security after adding its dependencies, for instance, during the development phase or for certain profiles.

Here’s how to disable spring security:

1. Create a Security Configuration Class:

Create a Java configuration class that extends WebSecurityConfigurerAdapter.

2). Override the configure Method: Override the configure(HttpSecurity http) method and disable all security measures.

import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests().anyRequest().permitAll()
            .and()
            .csrf().disable();
    }
}

3). Disable CSRF:

As shown above, disable CSRF protection by calling .csrf().disable() if your application is stateless or during development.

By following these steps, you effectively disable all Spring Security configurations in your Spring Boot application.

Interview questions

Expand a question to read the answer. Tick when you’re prepared (progress saved on this device).

0%

Customizing Actuator endpoints in Spring Boot involves modifying their default behavior or adding new ones. This can be achieved through properties settings and coding.

Here’s how to customize Spring Boot Actuator endpoints:

1. Properties Configuration :

You can use application.properties or application.yml to customize Actuator’s behavior. For instance, changing the path of an endpoint, enabling or disabling endpoints, controlling exposure over the web, etc.

management.endpoints.web.exposure.include=health,info
management.endpoint.health.show-details=always
management.endpoints.web.base-path=/management

2. Custom Health Indicators :

Create a custom health indicator by implementing the HealthIndicator interface. This allows adding application-specific health checks.

@Component
public class CustomHealthIndicator implements HealthIndicator {
    @Override
    public Health health() {
        // Custom logic to check health
        return Health.up().withDetail("CustomService", "Available").build();
    }
}

3. Expose Additional Data :

For certain endpoints like /info, you can expose additional data by adding entries to application.properties:

info.app.name=MyApplication
info.app.version=1.0.0

4. Custom Endpoints :

You can create custom endpoints by annotating a class with @Endpoint, @ReadOperation, @WriteOperation, or @DeleteOperation.

@Endpoint(id = "customEndpoint")
public class CustomEndpoint {
    @ReadOperation
    public Map<String, String> customMethod() {
        // Custom logic
        return Collections.singletonMap("key", "value");
    }
}

5. Securing Endpoints :

Ensure sensitive endpoints are secured. You can restrict access to them by setting security configurations in Spring Security.

By customizing Actuator endpoints, you gain finer control over monitoring and managing your application, tailoring Actuator to better fit your specific needs and environment.

Interview questions

Expand a question to read the answer. Tick when you’re prepared (progress saved on this device).

0%

You can package a Spring Boot application for deployment in a few standard ways, depending on how and where you plan to deploy it (server, cloud, container, etc.).

1. Executable JAR (Most Common)

Spring Boot applications are most commonly packaged as a fat/uber JAR, which contains:

Your application code
All dependencies
An embedded server (Tomcat/Jetty/Undertow)

Build with Maven

mvn clean package

Output

target/myapp-0.0.1-SNAPSHOT.jar

Run

java -jar myapp-0.0.1-SNAPSHOT.jar

Why use JAR?

Simple deployment
No external app server needed
Ideal for microservices and cloud-native apps

2. WAR File (For External Application Servers)

Use this when deploying to external servers like Tomcat, JBoss, or WebLogic.

Changes Required

1. Change packaging type in pom.xml :

<packaging>war</packaging>

2. Extend SpringBootServletInitializer :

@SpringBootApplication
public class MyAppApplication extends SpringBootServletInitializer {

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(MyAppApplication.class);
    }
}

3. Mark embedded Tomcat as provided :

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <scope>provided</scope>
</dependency>

Build

mvn clean package

Output

target/myapp.war

Why use WAR?

Required for legacy or shared application servers
Centralized server management

3. Docker Image (Modern Production Standard)

Package your Spring Boot app into a Docker container.

Dockerfile (JAR-based)

FROM eclipse-temurin:17-jdk-alpine
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

Build Image

docker build -t myapp:1.0 .

Run Container

docker run -p 8080:8080 myapp:1.0

Why Docker?

Environment consistency
Easy scaling with Kubernetes
Cloud-ready

Spring Boot uses Tomcat as its default embedded container, but it can be easily switched to Jetty, Undertow, or another supported container.

Here’s how you can change default embedded container:

1. Exclude the Default Tomcat Dependency :

First, exclude the default Tomcat container if it’s included in your Spring Boot starter.For Maven, in your pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>

For Gradle, in your build.gradle:

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-web") {
        exclude group: "org.springframework.boot", module: "spring-boot-starter-tomcat"
    }
    // ...
}

2. Add Dependency for Another Container :

Then, add the dependency for the container you want to use. For example, to use Jetty:

For Maven:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

For Gradle:

dependencies {
    implementation "org.springframework.boot:spring-boot-starter-jetty"
}

3. Rebuild Your Project :

After making these changes, rebuild your project. Spring Boot will automatically configure the new container.

By following these steps, you can switch the default embedded container in Spring Boot according to your project’s needs.

Interview questions

Expand a question to read the answer. Tick when you’re prepared (progress saved on this device).

0%

Developing RESTful APIs with Spring Boot involves more than just handling HTTP requests and responses.

Following best practices ensures your APIs are efficient, maintainable, and scalable:

Use Standard HTTP Methods: Adhere to the standard HTTP methods (GET, POST, PUT, DELETE) to ensure that your API is intuitive and consistent with RESTful principles.
Resource-Oriented URLs: Design URL paths around resources (nouns) rather than actions or verbs. For example, use /users for accessing user resources.
Statelessness: Ensure your API is stateless, meaning each request from the client contains all the information needed to process the request.
Use HTTP Status Codes: Properly use HTTP status codes to indicate the outcome of API requests (e.g., 200 OK, 404 Not Found, 500 Internal Server Error).
Implement HATEOAS (Hypermedia As The Engine Of Application State): This practice makes your API discoverable and self-descriptive by including hyperlinks to related resources in your responses.
Data Validation: Validate incoming data to ensure data integrity and to protect against invalid or malicious data.
Error Handling: Implement global error handling with @ControllerAdvice to ensure errors are handled consistently and informative error messages are returned.
Security: Secure your APIs using Spring Security, validate JWT tokens for authenticated access, and consider OAuth for authorization.
Documentation: Use tools like Swagger or Spring REST Docs to document your API, making it easier for other developers to understand and consume.
Versioning: Version your API to handle changes without breaking existing clients. This can be done via URL path, header, or media type.
Logging and Monitoring: Implement logging and monitoring to track API usage and performance, and to quickly identify and resolve issues.
Testing: Write comprehensive tests (unit, integration) for your APIs to ensure they work as expected and to catch issues early in the development process.

Following these best practices helps in building RESTful APIs with Spring Boot that are robust, easy to use, and maintain.

Exception handling is a critical aspect of building robust and user-friendly Spring Boot applications.

Here’s how you can handle exceptions effectively in Spring Boot applications:

1. Use of @ExceptionHandler :

Handle specific exceptions within a controller by using the @ExceptionHandler annotation. This annotation allows you to define methods to handle certain types of exceptions that occur within the controller.

@RestController
public class MyController {
    @ExceptionHandler(value = { CustomException.class })
    public ResponseEntity<Object> handleCustomException(CustomException ex) {
        // Handle exception and return response
    }
}

2. Global Exception Handling with @ControllerAdvice :

To handle exceptions across multiple controllers, use @ControllerAdvice. This is a global exception handler that captures exceptions thrown by methods annotated with @RequestMapping and similar.

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(value = { Exception.class })
    public ResponseEntity<Object> handleException(Exception ex) {
        // Handle general exception
    }
}

3. Custom Error Response Structure:

Define a standard error response structure for your API. This helps in returning consistent error responses.

public class ApiErrorResponse {

    private HttpStatus status;
    private String message;

    public ApiErrorResponse(HttpStatus status, String message) {
        this.status = status;
        this.message = message;
    }

    // getters and setters
}

4. Using ResponseEntity

Always wrap error responses using ResponseEntity so you can return:

Proper HTTP status codes
Structured error bodies

Example:

return ResponseEntity
        .status(HttpStatus.NOT_FOUND)
        .body(new ApiErrorResponse(HttpStatus.NOT_FOUND, "Resource not found"));

5. Logging Exceptions

Ensure all exceptions are logged properly using a logging framework (SLF4J, Logback, etc.).

Best practice:

Log stack traces for unexpected exceptions
Avoid logging sensitive data
Use different log levels (ERROR, WARN, INFO)

6. Handling Validation Errors

For request validation:

Use @Valid with request DTOs
Capture errors using BindingResult

Example:

@PostMapping("/users")
public ResponseEntity<?> createUser(@Valid @RequestBody UserDto user,
                                    BindingResult result) {
    if (result.hasErrors()) {
        return ResponseEntity
                .badRequest()
                .body(result.getAllErrors());
    }
    return ResponseEntity.ok("User created");
}

7. Custom Exceptions

Create custom exception classes for specific error scenarios.

Example:

public class ResourceNotFoundException extends RuntimeException {
    public ResourceNotFoundException(String message) {
        super(message);
    }
}

Advantages:

Improves code readability
Precise error handling
Better domain modeling

8. RESTful Exception Handling

For REST APIs:

Use appropriate HTTP status codes (400, 404, 409, 500)
Return meaningful error messages
Avoid exposing internal system details

By following these practices, you can create a robust exception handling mechanism in your Spring Boot application, improving the overall reliability and maintainability of the application.

Logging in Spring Boot is a crucial feature that allows developers to track the application’s runtime behavior, monitor its performance, and troubleshoot issues when they arise. It’s essentially about keeping a record of events, messages, and errors that occur while the application is running.

Logging Levels

Spring Boot supports different logging levels, which indicate the severity of the messages to be logged. These levels, from least to most severe, are TRACE, DEBUG, INFO, WARN, ERROR, and FATAL. Developers can configure the logging level in their application to control the verbosity of the log output, depending on their needs for debugging or monitoring.

TRACE and DEBUG provide detailed information, primarily useful for development and debugging.
INFO offers general information about the application’s runtime behavior.
WARN and ERROR indicate potential problems and actual errors, respectively, that might require attention.
FATAL represents severe errors leading to the application’s termination.

Configuration

Spring Boot allows for easy customization of logging configurations through the application.properties or application.yml files. Developers can specify the log level for the entire application or target specific packages or classes to receive more or less detailed log output.

For example:

# application.properties
logging.level.root=WARN
logging.level.org.springframework.web=DEBUG
logging.level.com.example.myapp=INFO

Enabling Cross-Origin Resource Sharing (CORS) in a Spring Boot application is crucial for allowing your web application to make requests to a server that is hosted on a different domain than your application. CORS can be enabled at various levels within a Spring Boot application: globally across all controllers, for specific controller methods, or using Spring Security for more fine-grained control.

Here’s how you can enable CORS:

1. Global CORS Configuration

You can configure CORS globally by extending the WebMvcConfigurer:

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
                .allowedOrigins("http://example.com")
                .allowedMethods("GET", "POST", "PUT", "DELETE")
                .allowedHeaders("*")
                .allowCredentials(true);
    }
}

2. Controller-Level CORS Configuration

For more specific CORS configurations, use the @CrossOrigin annotation on individual controller classes or methods:

import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {

    @CrossOrigin(origins = "http://example.com")
    @GetMapping("/example")
    public String example() {
        return "Example";
    }
}

3. CORS Configuration with Spring Security

If you’re using Spring Security, configure CORS within the Spring Security configuration. This is necessary because Spring Security’s CORS configuration takes precedence over Spring MVC’s CORS settings.

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            // Other security configurations...
            .cors().and()
            // Other security configurations...
    }
}

And define a CorsConfigurationSource bean if you need to apply more detailed CORS configuration:

import org.springframework.context.annotation.Bean;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;

@Bean
public CorsFilter corsFilter() {
    UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
    CorsConfiguration config = new CorsConfiguration();
    config.setAllowCredentials(true);
    config.addAllowedOrigin("http://example.com");
    config.addAllowedHeader("*");
    config.addAllowedMethod("*");
    source.registerCorsConfiguration("/**", config);
    return new CorsFilter(source);
}

By configuring CORS in your Spring Boot application, you ensure that your frontend applications hosted on different domains can interact with your backend securely and without issues related to cross-origin requests.

Real World Example

Imagine you’re developing a web application to display the latest news articles. The frontend is developed using React and is hosted on http://localhost:3000. The backend API, built with Spring Boot, is designed to serve news articles from http://localhost:8080.

When your frontend tries to fetch articles from the backend with a JavaScript fetch call, the browser blocks the request due to the Same-Origin Policy, as the frontend and backend are hosted on different origins.

Solution: Enabling CORS in Spring Boot

To solve this, you need to enable CORS in your Spring Boot application so that your backend can accept requests from the frontend’s origin.

Interview questions

Expand a question to read the answer. Tick when you’re prepared (progress saved on this device).

0%

Spring Boot is a highly popular choice for building microservices due to its ease of use, flexibility, and robust feature set.

Here’s how Spring Boot supports microservices development:

Quick Setup and Standalone Applications: Spring Boot’s ability to create standalone, production-grade applications quickly is crucial for microservices which are typically deployed independently.
Embedded Server Support: With embedded server support (like Tomcat, Jetty, or Undertow), microservices can be easily packaged and deployed without requiring external server setups.
Spring Cloud Integration: Spring Boot integrates seamlessly with Spring Cloud, which provides tools for common microservices patterns such as configuration management, service discovery, circuit breakers, intelligent routing, and load balancing.
Ease of Configuration: Spring Boot’s externalized configuration and profiles support simplifies managing application settings across different environments, a common scenario in microservices architecture.
Health Check and Monitoring: Spring Boot Actuator provides built-in endpoints for monitoring and managing microservices like health checks and metrics, which are essential for maintaining and troubleshooting microservices in production.
Simplified Data Access: With support for data access technologies (JPA, JDBC, etc.), and easy integration with database migration tools like Flyway or Liquibase, Spring Boot makes it easier to manage database interactions.
Lightweight Containers: Microservices in Spring Boot can be easily containerized using Docker, which is a common practice for deploying microservices in a scalable and isolated manner.
API Gateway Integration: Easily integrate with API gateways for routing, filtering, and securing microservices.
Resilience and Fault Tolerance: Integration with resilience patterns and libraries like Resilience4J or Netflix Hystrix to handle failures gracefully.
Microservices Tracing: With Spring Cloud Sleuth and Zipkin, you can trace requests across distributed microservices, which is critical for debugging in a complex microservices landscape.

Spring Boot’s comprehensive ecosystem and ease of development make it a fitting choice for implementing microservices, catering to both the simplicity required for quick development and the complexity needed for a robust production environment.

Spring Cloud is an umbrella project consisting of numerous tools and libraries for building and managing distributed systems, including microservices. It’s part of the broader Spring ecosystem and focuses on providing solutions to common patterns in distributed systems, such as configuration management, service discovery, circuit breakers, and more.

Key Aspects of Spring Cloud :

Simplified Distributed System Configuration: Spring Cloud simplifies the configuration of distributed systems through externalized configuration and shared configuration servers like Spring Cloud Config.
Service Discovery: It provides tools like Netflix Eureka for service discovery, which is essential in a microservices architecture where instances need to dynamically discover and communicate with each other.
Fault Tolerance and Resilience: Implements patterns like circuit breakers, fallbacks, and load balancing with tools like Netflix Hystrix and Ribbon to ensure resilience and fault tolerance.
API Gateway: Offers solutions for setting up API gateways, providing a single point of entry for client requests with routing and filtering capabilities.

How It Relates to Spring Boot :

Complementary Relationship: Spring Cloud builds on the ease of development provided by Spring Boot, extending its capabilities to the distributed systems domain. It leverages and complements Spring Boot’s features for developing web services and microservices.
Seamless Integration: Spring Boot applications can easily integrate with Spring Cloud features, benefiting from Spring Boot’s auto-configuration and standalone deployment model while gaining the ability to scale and manage distributed systems effectively.
Consistent Development Experience: Developers using Spring Boot will find a familiar development experience when using Spring Cloud, as it follows the same principles and programming model.

In essence, while Spring Boot simplifies building standalone applications and microservices, Spring Cloud provides a suite of tools to address the complexities of distributed systems and cloud environments.

Service discovery is a key component in microservices architecture, particularly when dealing with multiple, dynamically located services. It refers to the automatic detection of services in a network, enabling them to find and communicate with each other without hard-coded addresses.

Why Service Discovery Is Important :

In microservices architecture, services often run at varying locations and scales. Hardcoding IPs or hostnames is impractical and rigid.
Service discovery allows services to register their location and discover the location of other services, enabling fluid communication and load balancing.

Implementing Service Discovery in Spring Boot :

1). Use Spring Cloud Netflix Eureka :

One of the popular ways to implement service discovery in Spring Boot is by using Spring Cloud Netflix Eureka. It consists of two parts: Eureka Server (the service registry) and Eureka Client (the services that register themselves).

2). Setting Up Eureka Server :

Include the Eureka Server dependency in your Spring Boot application.
Annotate your main application class with @EnableEurekaServer.
Configure properties related to Eureka Server in application.properties or application.yml.

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

3). Configuring Eureka Clients :

Include the Eureka Client dependency in your microservice applications.
Annotate the main class with @EnableEurekaClient or @EnableDiscoveryClient.
Define Eureka Client properties, specifying the Eureka Server’s location.

@SpringBootApplication
@EnableEurekaClient
public class MyServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyServiceApplication.class, args);
    }
}

4). Dynamic Service Discovery :

Once set up, microservices will register with Eureka Server and discover other services through it, enabling dynamic location of service instances.

5). Load Balancing :

Integrating with client-side load balancing tools like Netflix Ribbon can further enhance service invocation by distributing the load among available instances.

Service discovery with Eureka in Spring Boot simplifies the management of microservices by handling the registration and discovery, making the network more resilient and flexible.

In a microservices architecture, services need to communicate with each other to perform various operations. Spring Boot provides several options for implementing this inter-service communication.

1. RESTful Communication :

HTTP Client Libraries: Use Spring’s RestTemplate or the newer WebClient for making HTTP calls to other services.

Service Discovery Integration: Combine with service discovery tools like Eureka for dynamically determining the URLs of service instances.

Example Usage: A service can call another service’s REST API to retrieve or send data.

@Service
public class MyService {
    private final RestTemplate restTemplate;

    public MyService(RestTemplateBuilder restTemplateBuilder) {
        this.restTemplate = restTemplateBuilder.build();
    }

    public SomeObject callAnotherService() {
        return restTemplate.getForObject("http://other-service/api/data", SomeObject.class);
    }
}

2. Asynchronous Communication with Messaging :

Message Brokers: Use message brokers like RabbitMQ or Kafka. Spring Boot integrates easily with these systems via Spring AMQP or Spring Kafka.

Loose Coupling: This method is suitable for event-driven architectures and ensures loose coupling between services.

Example: Services can communicate by sending and receiving messages without direct knowledge of each other.

3. Feign Client for Declarative REST Clients :

Spring Cloud OpenFeign: Provides an easier and more declarative way of writing REST clients. Define an interface representing the external service, and Spring creates the implementation automatically.

Example:

@FeignClient("other-service")
public interface OtherServiceClient {
    @GetMapping("/api/data")
    SomeObject getData();
}

4. Load Balancing with Ribbon :

Client-Side Load Balancer: In a scenario with multiple instances of a service, integrate with Ribbon or Spring Cloud LoadBalancer to distribute the load across instances.

Best Practices:

Circuit Breaker Pattern: Use a circuit breaker (like Resilience4J or Hystrix) to prevent failures in one service from cascading to others.
API Gateway: Use an API Gateway (like Spring Cloud Gateway or Zuul) as a single entry point for inter-service communication.

By using these methods, you can effectively manage inter-service communication in a Spring Boot microservices architecture, ensuring efficient, reliable, and scalable interactions between services.

Interview questions

Expand a question to read the answer. Tick when you’re prepared (progress saved on this device).

0%

Auto-Configuration in Spring Boot is a powerful feature that aims to automatically configure your Spring application based on the jar dependencies that you have added. It is designed to minimize the amount of configuration and boilerplate code needed to set up a Spring application.

How Auto-Configuration Works :

Dependency-Based Configuration: Spring Boot detects the libraries in the classpath and attempts to configure the necessary beans and settings automatically. For instance, if Spring Boot detects H2 database in the classpath, it will set up an in-memory database for you.
Conditional Configuration: Auto-Configuration decisions are made based on certain conditions. This might involve checking if specific classes are present or if certain beans have already been defined.

Benefits of Auto-Configuration :

Rapid Development: It speeds up the development process by reducing the need for explicit configuration.
Ease of Use: Makes it easier to get a Spring application up and running with sensible defaults.
Customization and Override: While providing default configurations, Spring Boot still allows customization and overriding of settings as per application requirements.

Common Usage :

Auto-Configuration is usually enabled by default when you use the @SpringBootApplication annotation, which includes @EnableAutoConfiguration implicitly.

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

For more granular control, you can exclude certain auto-configurations using the exclude attribute of the @EnableAutoConfiguration annotation.

Spring Boot Auto-Configuration significantly reduces the development time and effort by handling much of the routine configuration automatically, letting developers focus on building the unique aspects of their applications.

Spring Boot’s SpringApplication class provides a convenient way to bootstrap a Spring application that will be started from a main method. It sets up your application with defaults and starts the Spring ApplicationContext. It also performs classpath scanning and starts the embedded web server if your application is a web application. The SpringApplication class simplifies the boilerplate code needed to launch a Spring application, making it straightforward to run a Spring Boot application with minimal configuration.

Key Features of SpringApplication :

Simplifies Configuration: It automatically configures your Spring application based on the jar dependencies included in the project.
Application Events and Listeners: It supports application events and listeners to let you add behavior to certain states in the application lifecycle.
Customization: Offers various ways to customize its behavior through methods or by implementing specific interfaces.
Web Environment: Detects whether you are developing a web application and configures the embedded server accordingly.
Profiles: Allows you to specify active profiles to segregate parts of your application configuration.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MyApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

In this example, the @SpringBootApplication annotation is used on the main class. This single annotation is equivalent to using @Configuration, @EnableAutoConfiguration, and @ComponentScan with their default attributes. It automatically scans for components and beans in the same package (or subpackages) where the application is located, configures beans based on the classpath settings, and starts the application context.

The @SpringBootConfiguration annotation is a specialized form of the @Configuration annotation in Spring Boot, indicating that a class provides Spring Boot application configuration. It serves as a marker for configuration classes and is part of the set of annotations that Spring Boot processes to auto-configure the application.

Key Points of @SpringBootConfiguration :

Specialization of @Configuration: It inherits from the @Configuration annotation, thereby allowing the annotated class to be used for Spring Framework’s Java-based configuration.
Auto-Configuration Context: Classes annotated with @SpringBootConfiguration are considered as sources for auto-configuration by Spring Boot. This annotation is typically only applied once per application, usually on the main class that runs the Spring Boot application.
Bootstrapping: It plays a critical role in the bootstrap process of a Spring Boot application, signaling the start of auto-configuration and component scanning.

@SpringBootConfiguration Usage:

While you may not often see @SpringBootConfiguration used directly in applications (as it is implicitly included through other annotations), understanding its role is crucial for grasping how Spring Boot initializes and configures itself. The @SpringBootApplication annotation, commonly seen in the main class of a Spring Boot application, is a convenience annotation that encapsulates @SpringBootConfiguration, @EnableAutoConfiguration, and @ComponentScan annotations. Essentially, @SpringBootApplication marks the application configuration class and triggers auto-configuration and component scanning.

Example

import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication // Implicitly includes @SpringBootConfiguration
public class MyApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

In practice, by using the @SpringBootApplication annotation, you’re indirectly applying @SpringBootConfiguration, along with enabling auto-configuration and component scanning, making it straightforward to set up and run a Spring Boot application.

Scheduling tasks in a Spring Boot application allows you to run specific methods at fixed intervals or at specific times without manual intervention. This is particularly useful for routine tasks like database cleanup, sending batch emails, or running complex calculations at off-peak times.

In Spring Boot, tasks can be scheduled using the @Scheduled annotation after enabling scheduling with @EnableScheduling. Tasks can run at a fixed rate, fixed delay, or based on cron expressions, and configurations can be externalized for flexibility.

The method must be void, parameterless, and part of a Spring-managed bean. Scheduling configurations can also be externalized using application properties.

Example of @Scheduled

@EnableScheduling
@Scheduled(fixedRate = 5000)
public void runTask() {
    // executes every 5 seconds
}

The @EnableAutoConfiguration annotation in Spring Boot is a key component of its convention-over-configuration philosophy, which aims to minimize the amount of manual configuration and setup needed to get a Spring application up and running.

@EnableAutoConfiguration tells Spring Boot to automatically configure your application based on the dependencies present in your project’s classpath.

@EnableAutoConfiguration is typically used as part of the @SpringBootApplication annotation, which is a convenience annotation that combines @EnableAutoConfiguration, @ComponentScan, and @Configuration annotations. Therefore, when you use @SpringBootApplication, you’re implicitly enabling auto-configuration.

Behind the Scenes

Spring Boot has a file named spring.factories located within its auto-configure module. This file contains a list of auto-configuration classes that Spring Boot considers when @EnableAutoConfiguration is used.
During the startup process, Spring Boot reads this list and evaluates the conditions associated with each auto-configuration class. If the conditions are satisfied (for example, if a certain class is present in the classpath and a certain bean is not already registered), then that auto-configuration class is applied.

import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication // Implicitly enables auto-configuration
public class MyApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

Interview questions

Expand a question to read the answer. Tick when you’re prepared (progress saved on this device).

0%

Spring Boot provides easy integration with several caching solutions through the Spring Framework’s caching abstraction.

Here’s how to enable and use caching in a Spring Boot application:

1. Add Caching Dependencies :

First, you need to add the appropriate cache starter to your pom.xml or build.gradle file. For example, to use the simple, in-memory ConcurrentMapCacheManager, you don’t need to add any additional dependencies beyond spring-boot-starter-cache.

2. Enable Caching :

Use the @EnableCaching annotation on one of your configuration classes to enable caching support in your application.

import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableCaching
public class CacheConfig {

}

3. Use Cache Annotations :

Spring’s caching abstraction provides annotations such as @Cacheable, @CachePut, and @CacheEvict, which you can use to interact with the cache.

@Cacheable: Indicates that the result of a method call should be cached.
@CachePut: Guarantees that the method is executed and its result is placed into the cache.
@CacheEvict: Removes data from the cache.

Example of using @Cacheable:

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class MyService {
    @Cacheable("books")
    public Book findBook(String isbn) {
        // Simulate slow service call
        return new Book(isbn);
    }
}

4. Configure the Cache Manager :

Depending on the caching solution, you might need to configure a cache manager. For many applications, the default cache configuration provided by Spring Boot is sufficient.

Caching is a powerful feature that, when used appropriately, can significantly enhance the performance and scalability of Spring Boot applications. However, it’s important to choose the right cache strategy and size for your application’s needs to avoid stale data and ensure that the cache does not consume excessive memory.

The @Cacheable annotation in Spring Framework is used to mark a method for caching its return value. When a method annotated with @Cacheable is called, Spring checks whether the method has been invoked previously with the same arguments. If so, Spring bypasses the actual method invocation and returns the cached result instead. This mechanism significantly reduces the need to execute potentially expensive operations multiple times, such as database queries or complex calculations, thus improving the performance of the application.

Example of @Cacheable :

Consider a book repository where fetching a book details is a time-consuming operation, either because it involves a complex database operation or calls to an external service.

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Repository;

@Repository
public class BookRepository {

    @Cacheable("books")
    public Book findBookByIsbn(String isbn) {
        // Simulate slow service call
        return simulateSlowServiceCall(isbn);
    }
}

In this example, calling findBookByIsbn with the same isbn value multiple times will result in only one actual method invocation. Subsequent calls with the same isbn will return the cached result, thus avoiding the overhead of the slow operation.

Considerations:

Cache Eviction: To ensure the cache does not return stale data, it’s often necessary to use cache eviction annotations (@CacheEvict) to remove outdated entries from the cache.
Cache Configuration: Proper cache configuration is crucial for optimal performance and avoiding memory issues. This includes setting appropriate TTL (Time To Live) values, maximum sizes, and eviction policies.
Method Visibility: For @Cacheable to work, the annotated method must be public, and the call to the method must go through the Spring proxy. Therefore, calling the method from within the same class where it’s defined won’t result in caching.

The @Cacheable annotation is a powerful feature provided by Spring for improving application performance and scalability through caching.

Interview questions

Expand a question to read the answer. Tick when you’re prepared (progress saved on this device).

0%

Here are the list of some NoSQL databases supported by Spring Boot:

1. MongoDB

Spring Data MongoDB: Offers a model to easily work with MongoDB, a document database. It provides mapping, conversion, and query creation from methods names. Spring Boot auto-configures a MongoTemplate and repository support.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

2. Redis

Spring Data Redis: Provides easy integration with Redis, an in-memory data structure store used as a database, cache, and message broker. Spring Boot auto-configures a connection factory, template classes, and caching support.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

3. Apache Cassandra

Spring Data Cassandra: Simplifies building applications atop Apache Cassandra, a distributed NoSQL database designed to handle large amounts of data across many commodity servers. It includes template classes, repository support, and dynamic query derivation.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-cassandra</artifactId>
</dependency>

4. Couchbase

Spring Data Couchbase: Integrates with Couchbase, a document-oriented NoSQL database. It offers repository and template support, allowing for object mapping, query derivation, and template operations.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-couchbase</artifactId>
</dependency>

5. Neo4j

Spring Data Neo4j: Targets graph database use cases with Neo4j. It provides a high-level abstraction for managing graph data, including repository support, a template programming model, and dynamic query derivation.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-neo4j</artifactId>
</dependency>

6. Elasticsearch

Spring Data Elasticsearch: Connects to Elasticsearch, a distributed, RESTful search and analytics engine. It supports indexing documents, searching, and combining database capabilities with full-text search features.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>

7. Apache Geode

Spring Data for Apache Geode: Designed for integrating with Apache Geode, a data management platform that provides real-time, consistent access to data-intensive applications.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-geode</artifactId>
</dependency>

8. Apache Solr

Spring Data Solr: Facilitates the integration with Apache Solr, an open-source search platform. It provides mapping, conversion, and query creation functionalities.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-solr</artifactId>
</dependency>

Configuring Spring Boot to work with MongoDB involves a few straightforward steps.

Here’s a step-by-step guide to get you started:

1. Add Spring Boot Starter Data MongoDB Dependency

First, include the spring-boot-starter-data-mongodb dependency in your pom.xml (for Maven) or build.gradle (for Gradle) to bring in the necessary Spring Data MongoDB libraries.

Maven:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

Gradle:

implementation 'org.springframework.boot:spring-boot-starter-data-mongodb'

2. Configure MongoDB Connection

Configure your MongoDB connection details in the application.properties or application.yml file of your Spring Boot application. Here, you specify the URI of your MongoDB server, the database name, and other optional settings like authentication details.

application.properties:

spring.data.mongodb.uri=mongodb://username:password@localhost:27017/databaseName

Or, if you’re using application.yml:

spring:
  data:
    mongodb:
      uri: mongodb://username:password@localhost:27017/databaseName

Replace username, password, localhost, and databaseName with your actual MongoDB credentials and details.

3. Create Document Classes

Define your domain models as document classes using annotations from Spring Data MongoDB. These classes map to collections in your MongoDB database.

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Document
public class User {

    @Id
    private String id;

    private String name;
    private String email;

    // Constructors, Getters, and Setters
}

4. Create Repository Interfaces

Spring Data MongoDB uses repository interfaces to abstract the data layer. Define an interface for each document class, extending MongoRepository or another relevant repository interface provided by Spring Data.

import org.springframework.data.mongodb.repository.MongoRepository;

public interface UserRepository extends MongoRepository<User, String> {
    // Custom query methods can be defined here
}

5. Use Repositories in Your Application

You can now autowire these repository interfaces in your services or controllers and use them to perform CRUD operations and custom queries.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private final UserRepository userRepository;

    public List<User> findAllUsers() {
        return userRepository.findAll();
    }
 
}

Interview questions

Expand a question to read the answer. Tick when you’re prepared (progress saved on this device).

0%

Enabling WebSocket support in a Spring Boot application involves adding the necessary dependencies, configuring WebSocket endpoints, and optionally defining message handling logic.

Here’s a step-by-step guide on how to enable and use WebSockets in Spring Boot:

Step 1: Add Spring Boot Starter WebSocket Dependency

First, include the spring-boot-starter-websocket dependency in your project’s build configuration file to bring in the required libraries for WebSocket support.

For Maven, add to your pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

For Gradle, add to your build.gradle:

implementation 'org.springframework.boot:spring-boot-starter-websocket'

Step 2: Configure WebSocket Endpoint

You need to configure one or more endpoints that clients will use to connect to your WebSocket server. This can be done by implementing WebSocketConfigurer and overriding the registerWebSocketHandlers method.

Create a Configuration Class:

import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.context.annotation.Bean;

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(myWebSocketHandler(), "/ws");
    }

    @Bean
    public WebSocketHandler myWebSocketHandler() {
        return new MyWebSocketHandler();
    }
}

In this example, MyWebSocketHandler is your custom WebSocketHandler that handles incoming WebSocket messages. You need to implement this handler:

import org.springframework.web.socket.handler.TextWebSocketHandler;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;

public class MyWebSocketHandler extends TextWebSocketHandler {

    @Override
    protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
        System.out.println("Received message: " + message.getPayload());
        session.sendMessage(new TextMessage("Hello from server!"));
    }
}

Step 3: Use STOMP for Message Handling (Optional)

For more complex scenarios, like broadcasting messages to multiple clients or handling different types of messages, you can use STOMP (Simple Text Oriented Messaging Protocol) over WebSockets.

To enable STOMP, you can extend AbstractWebSocketMessageBrokerConfigurer and override the necessary methods to configure message channels and endpoints:

import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketStompConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/stomp-endpoint").withSockJS();
    }

    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.enableSimpleBroker("/topic");
        registry.setApplicationDestinationPrefixes("/app");
    }
}

This configuration enables STOMP support, allowing clients to connect to /stomp-endpoint and use destinations prefixed with /app to send messages, which can then be broadcast to subscribers of /topic destinations.

Interview questions

Expand a question to read the answer. Tick when you’re prepared (progress saved on this device).

0%

Spring Boot Interview Questions

A. Basics of Spring Boot

B. Spring Boot Starters

C. Dependency Injection and Beans

D. Configuration in Spring Boot

E. Spring Boot Annotations

F. Spring Boot Data Access

G. Spring Boot Security

H. Spring Boot Actuator

I. Spring Boot Deployment

J. Spring Boot Best Practices

K. Spring Boot Microservices

L. Spring Boot Advanced Topics

M. Spring Boot and Caching

N. Spring Boot and NoSQL Databases

O. Spring Boot and WebSockets

P. Spring Boot and Security Tokens

Create your account

Reset password

Choose a new password

A. Basics of Spring Boot

B. Spring Boot Starters

C. Dependency Injection and Beans

D. Configuration in Spring Boot

E. Spring Boot Annotations

F. Spring Boot Data Access

G. Spring Boot Security

H. Spring Boot Actuator

I. Spring Boot Deployment

J. Spring Boot Best Practices

K. Spring Boot Microservices

L. Spring Boot Advanced Topics

M. Spring Boot and Caching

N. Spring Boot and NoSQL Databases

O. Spring Boot and WebSockets

P. Spring Boot and Security Tokens

Related guides

Spring Boot Pagination with Spring Data JPA: A Complete End-to-End Guide

Why Constructor Injection is Better Than Field Injection in Spring Boot?

Swagger / OpenAPI Interview Questions