Sprint-Boot Scenario Based Questions for Developers

1) How can you validate two specific conditions in a YAML property file when creating a bean in Spring Boot?

In Spring Boot, validation of configuration properties can be done using the @ConfigurationProperties annotation combined with JSR-303 (Bean Validation) annotations like @Valid, @NotNull, @Min, @Max, etc.

app:
  config:
    min-age: 18
    max-age: 60        

You would create a class bound to the properties:

@Component
@ConfigurationProperties(prefix = "app.config")
@Validated
public class AppConfig {

    @Min(18)
    @Max(60)
    private int minAge;

    @Min(18)
    @Max(60)
    private int maxAge;

    // getters and setters
}        

To validate both conditions together, you can write a custom validator or combine checks within the setter or a custom method.

@PostConstruct
public void validateAgeRange() {
    if (minAge > maxAge) {
        throw new IllegalArgumentException("minAge cannot be greater than maxAge");
    }
}        

This ensures the conditions are checked when the bean is created.

2) Your Spring Boot application is experiencing performance issues under high load. What steps would you take to diagnose and resolve the problem?

To diagnose and resolve performance issues, the following steps can help:

• Profiling and Monitoring:

Use tools like Spring Boot Actuator, Prometheus, and Grafana to monitor real-time performance metrics. Enable HTTP tracing and monitor key metrics such as request count, response time, and memory usage.

• Database Optimization:

Use Spring Data JPA logging to inspect slow queries. Consider database tuning (indexing, caching).

• Thread and CPU Analysis:

Use JVM profiling tools like JVisualVM, YourKit, or JProfiler to detect CPU bottlenecks, memory leaks, and excessive garbage collection.

• Caching:

Add a caching layer with Spring Cache and store frequently accessed data in an in-memory cache (e.g., Redis, EHCache).

• Optimize Thread Pool Settings:

Fine-tune the TaskExecutor and thread pool sizes for handling concurrent requests efficiently.

• Asynchronous Processing:

Offload non-critical or I/O-heavy tasks to background threads using @Async annotation.

3) How would you scale a Spring Boot application to handle increased traffic, and what Spring Boot features can assist with this?

To scale a Spring Boot application, you can implement several strategies:

• Horizontal Scaling: Deploy multiple instances of the application behind a load balancer (AWS ELB, NGINX, etc.). Use Spring Boot's cloud-native features like Spring Cloud Netflix Eureka for service discovery and load balancing.
• Database Scaling: Implement database replication and read replicas to balance the load. Consider database sharding or switching to a distributed database (e.g., Cassandra).
• Caching: Utilize distributed caching with Spring Cache and external caches like Redis or Memcached.
• Circuit Breaker: Use Spring Cloud Circuit Breaker (or Resilience4J) to manage failures in downstream services, avoiding cascading failures.
• Containerization & Orchestration: Deploy the application using Docker containers and orchestrate with Kubernetes for auto-scaling based on load.

4) How do you manage transactions in a Spring Boot application, and what code is running internally when using the @Transactional annotation?

The @Transactional annotation is used to manage transactions declaratively in Spring Boot. It ensures that the transaction is created, committed, or rolled back depending on the outcome of the method execution.

Internally:

• Spring uses AOP (Aspect-Oriented Programming) to wrap the method annotated with @Transactional in a transactional proxy.
• PlatformTransactionManager (typically JpaTransactionManager for JPA) coordinates the transaction lifecycle.
• When the method completes successfully, the transaction is committed.
• If an unchecked exception is thrown, the transaction is rolled back.

@Service
public class UserService {
    
    @Transactional
    public void updateUser(User user) {
        // Perform database operations
    }
}        

5) How can you deploy a small Spring Boot application cost-effectively, ensuring that you only pay for server resources when the application is in use?

For cost-effective deployment:

• Use serverless platforms like AWS Lambda or Google Cloud Functions to run Spring Boot applications. These platforms charge only when the application is invoked.
• Utilize Amazon API Gateway or Azure API Management to route traffic to the serverless function.
• Alternatively, you can use AWS Fargate (for containers) or Google Cloud Run to run your Spring Boot app with per-second billing.

When multiple beans of the same type are present, you can resolve conflicts by:

• @Primary: Marks a bean as the default one.
• @Qualifier: Specifies the exact bean to use.

@Service
@Qualifier("beanOne")
public class ServiceOne { }

@Service
@Qualifier("beanTwo")
public class ServiceTwo { }

@Autowired
@Qualifier("beanOne")
private ServiceOne service;        

7) We do not want a dependency to be auto-configured by AutoConfiguration in Spring Boot Application, what steps do we need to take to achieve this requirement?

To exclude an auto-configured dependency:

• Use @SpringBootApplication annotation with the exclude attribute:

@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
public class MyApplication { }        

• Alternatively, you can use the @EnableAutoConfiguration annotation:

@EnableAutoConfiguration(exclude = {DataSourceAutoConfiguration.class})
public class MyApplication { }        

8) You are developing a Spring Boot application that handles user requests to access a set of APIs. You need to implement a logging mechanism that captures the details of incoming requests (like URL, HTTP method, and request body) before the controller processes them. How to achieve that in Spring Boot?

To log incoming requests, you can implement a HandlerInterceptor or use a Filter.

Example using HandlerInterceptor:

@Component
public class RequestLoggingInterceptor implements HandlerInterceptor {
    
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        // Log details
        System.out.println("Request URL: " + request.getRequestURL());
        System.out.println("HTTP Method: " + request.getMethod());
        return true;
    }
}        

Register it in the configuration:

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    RequestLoggingInterceptor requestLoggingInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(requestLoggingInterceptor);
    }
}        

9) In a Spring Boot application, you need to ensure that all service methods annotated with @Transactional are logged with the execution time taken by each method. How would you implement this in Spring Boot?

You can use Spring AOP to create an aspect that logs execution time:

@Aspect
@Component
public class LoggingAspect {
    
    @Around("@annotation(org.springframework.transaction.annotation.Transactional)")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object proceed = joinPoint.proceed();
        long executionTime = System.currentTimeMillis() - start;

        System.out.println(joinPoint.getSignature() + " executed in " + executionTime + "ms");
        return proceed;
    }
}        

10) How would you configure your application to ensure that access to API endpoints is restricted based on user roles, and that the role checks are applied to method-level security in your controllers or services?

For role-based security, use Spring Security. First, enable method-level security:

@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    // Security configuration
}        

Then, in your controller or service, use @PreAuthorize or @Secured:

@PreAuthorize("hasRole('ADMIN')")
@GetMapping("/admin")
public String adminOnly() {
    return "Admin content";
}        

Each of these questions dives deep into common Spring Boot use cases and scenarios, offering a great opportunity to demonstrate both foundational and advanced knowledge. They would make for a comprehensive interview guide!