Spring Boot Multiple Choice Questions (MCQs) and Answers

Port conflicts

Memory leaks

Slow boot times

Version incompatibility

Storing configurations inside the container

Using external configuration files

Hard-coding configurations in the application

Using default configurations

Using the FROM directive

Using the BASE directive

Using the IMAGE directive

Using the SOURCE directive

COPY

ADD

PASTE

INSERT

Using multi-stage builds

Using a single layer for all commands

Using uncompressed layers

Using larger base images

Incorrect network settings

Incompatible software versions

Unsupported database drivers

Faulty application code

Checking the Docker container logs

Verifying the container's network settings

Ensuring the correct application port is exposed

All of the above

Building synchronous, blocking web apps

Building reactive, non-blocking web apps

Automated testing of web apps

Building microservices

It provides a reactive library for implementing reactive APIs

It is a build tool

It is a dependency management system

It handles only synchronous operations

By speeding up data flow

By limiting data flow based on consumer capacity

By encrypting data

By automatically storing excess data in the cloud

Increased security of data transmissions

Simplification of code

Ability to handle large numbers of concurrent data streams efficiently

Reduced memory usage

Using Mono.just()

Using Mono.create()

Using Mono.single()

Using Mono.async()

Flux.merge()

Flux.combine()

Flux.join()

Flux.zip()

onErrorReturn()

onErrorContinue()

onErrorStop()

onErrorHandle()

Checking the network connections

Verifying the reactive chain for blocking calls

Increasing server resources

Reducing the number of API calls

Utilizing traditional debugging techniques

Incorporating logging and tracing frameworks like Sleuth

Using system-level monitoring tools

All of the above

To inject dependencies conditionally

To integrate third-party services

To enable conditional configuration based on the environment

To create asynchronous methods

By allowing beans to be loaded based on specific conditions

By automatically configuring beans

By enhancing the security of the application

By optimizing performance

It allows configurations to be changed at runtime without redeployment

It simplifies the codebase

It speeds up the boot process

It reduces memory usage

It serves as a central server for managing external properties across all environments

It locally caches application properties

It encrypts application configurations

It manages version control for properties

By using the @PropertySource annotation

By modifying the spring.config.name property

By using the @Value annotation

By renaming the properties file

By using @Primary annotation on data source beans

By using @Conditional on data source configurations

By creating multiple application.properties files

By manually switching the bean in the context

Using Spring MVC controllers

Using Netflix Zuul as an API gateway

Using Spring Data REST

Using the @RequestMapping annotation

Bean definition conflicts

Environmental properties

The condition's logic

Classpath issues

Check the property file's location and format

Increase logging level to debug

Rebuild the application

Change the Spring Boot version

Deploying as a WAR to an external Tomcat server

Deploying as a standalone JAR

Deploying using FTP

Deploying via SSH

Enhanced security features

Scalability and easy version control

Reduced memory usage

Automated data backups

It provides version management.

It automates the application deployment process.

It manages database migrations.

It optimizes performance.

Automatic scaling

Built-in cloud-native features

Automatic resource allocation

All of the above

It provides continuous integration support.

It monitors the health and performance of the application post-deployment.

It manages application scaling.

It enhances security protocols.