Which annotation is primarily used in Spring Boot to mark the main class of your application?

  • @MainClass
  • @SpringBootApplication
  • @SpringBootClass
  • @SpringMain
In Spring Boot, the primary annotation used to mark the main class of your application is @SpringBootApplication. This annotation not only marks the class as the main entry point but also enables various Spring Boot features like auto-configuration, component scanning, and more. It's the starting point for your Spring Boot application.

How can application properties be overridden in Spring Boot for different environments?

  • By annotating the @OverrideProperties annotation on the class.
  • By creating multiple instances of the SpringApplication class.
  • By modifying the application.properties directly.
  • Using environment-specific property files.
Application properties in Spring Boot can be overridden for different environments by using environment-specific property files. By naming these files application-{profile}.properties (e.g., application-dev.properties for the 'dev' profile), Spring Boot can load the properties specific to the active profile, allowing you to configure different settings for each environment. This is a key feature for maintaining configurations across various deployment scenarios.

To create conditional beans within custom Auto Configuration, you can use the @_____ annotation with a specific condition.

  • ConditionalOnBean
  • ConditionalOnClass
  • ConditionalOnMethod
  • ConditionalOnProperty
To create conditional beans within custom Auto Configuration, you can use the @ConditionalOnClass annotation. This annotation allows you to specify that a particular bean should be created only if a specified class is present in the classpath. It's useful for scenarios where you want to conditionally configure beans based on the availability of certain classes.

To perform unit testing on the web layer of a Spring Boot application without loading the complete context, use the _____ annotation.

  • @SpringBootTest
  • @UnitTest
  • @WebLayerTest
  • @WebMvcTest
To perform unit testing on the web layer of a Spring Boot application without loading the complete context, you should use the @WebMvcTest annotation. This annotation focuses only on the web layer and is suitable for testing controllers.

Your Spring Boot application requires custom handling of specific exceptions, with different response bodies for each exception type. How would you implement this while ensuring that unhandled exceptions are also adequately addressed?

  • Ignore unhandled exceptions to maintain simplicity in code.
  • Rely on Spring Boot's default exception handling for all cases.
  • Use Spring Boot's @ExceptionHandler annotation on controller methods for custom exception handling.
  • Use a global exception handler and handle each exception type separately within it.
To implement custom exception handling in a Spring Boot application with different response bodies for each exception type while ensuring unhandled exceptions are addressed, you can use the @ExceptionHandler annotation on controller methods. This approach allows you to handle specific exceptions with custom logic while ensuring unhandled exceptions are still processed. Using a global exception handler may not address specific exception types adequately.

How can you optimize the JVM (Java Virtual Machine) for a Spring Boot application?

  • By disabling garbage collection.
  • By minimizing the heap size.
  • By tuning garbage collection settings.
  • By using a custom class loader.
To optimize the JVM for a Spring Boot application, you should tune garbage collection settings. Garbage collection optimization is crucial because it helps manage memory efficiently. You can adjust parameters like heap size, garbage collection algorithms, and pause times to match your application's needs. Disabling garbage collection is not a practical solution as it will lead to memory issues. Minimizing the heap size without considering application requirements can result in performance problems. Using a custom class loader may have specific use cases but isn't a general JVM optimization technique.

In Spring Boot, the _____ annotation is used to conditionally enable a configuration based on the presence of a specific property.

  • @ComponentScan
  • @ConditionalOnProperty
  • @ConfigurationProperties
  • @EnableAutoConfiguration
In Spring Boot, the "@ConditionalOnProperty" annotation is used to conditionally enable a configuration based on the presence of a specific property. This annotation allows you to configure components or beans based on the values of properties, making it a powerful tool for conditional configuration in your application.

Which of the following is true about the deleteById method of a JpaRepository?

  • It deletes an entity by its primary key.
  • It marks the entity as deleted but does not remove it from the database.
  • It deletes all entities in the repository.
  • It deletes an entity based on a custom query.
The deleteById method of a JpaRepository deletes an entity from the database by its primary key. It is a convenient method for removing specific entities based on their unique identifier. The other options do not accurately describe the behavior of this method; in particular, it does not mark the entity as deleted without removing it from the database.

Which annotation is used in Spring Security to secure methods based on role-based conditions?

  • @Permission
  • @PostAuthorize
  • @PreAuthorize
  • @Secured
The @Secured annotation in Spring Security is used to secure methods based on role-based conditions. You can specify the required roles in the annotation, and only users with those roles can access the method.

In a Spring Boot application, how would you secure microservices using OAuth2 and JWT?

  • It's not possible to secure microservices using OAuth2 and JWT in Spring Boot.
  • Secure each microservice individually by implementing OAuth2 and JWT security for each service, and use a centralized authentication server for token validation.
  • Secure microservices individually with OAuth2 and use API keys for JWT-based authentication.
  • Use a single OAuth2 authentication server to issue JWT tokens and secure all microservices with the same token.
In a Spring Boot application, to secure microservices using OAuth2 and JWT, the best practice is to secure each microservice individually. Each microservice should implement OAuth2 and JWT security, and a centralized authentication server can be used for token validation. This approach ensures that each microservice has its own security context and can enforce its own authorization rules. Securing all microservices with a single token is not recommended, as it can lead to security vulnerabilities if one microservice is compromised.