Java Interview question-19

Question 181: Bean scopes — what are default bean scopes?

1. Singleton (Default Scope): The singleton scope means that a single instance of the bean is created and shared throughout the application context. Whenever a bean with the singleton scope is requested, the same instance is returned. This is the default scope for Spring Beans if no explicit scope is specified.

2. Prototype: The prototype scope means that a new instance of the bean is created every time it is requested from the application context. Each time you ask for the bean, a new instance is returned. This scope is useful when you need a new object instance every time it is injected or retrieved.

3. Request: The request scope is specific to web applications. It means that a new instance of the bean is created for each HTTP request. The bean instance is shared within a single HTTP request but not across multiple requests. This scope is typically used for beans that hold request-specific data or state.

4. Session: The session scope is also specific to web applications. It means that a new instance of the bean is created for each user session. The bean instance is shared within a single user session but not across different sessions. This scope is commonly used for beans that hold session-specific data or state.

5. Global Session: The global session scope is applicable only in a portlet context, where it represents a global application session. It is similar to the session scope but applies to the entire application rather than a specific user session. This scope is rarely used in typical Spring applications.

6. Application: The application scope is specific to web applications and represents a bean instance shared across the entire application. It is created once and shared across all requests and sessions. This scope is less commonly used and is typically associated with static or global data.

Question 182: Can we create two same beans with the same class?

In general, it is possible to create two or more bean instances of the same class in Spring. Each bean instance can have its own unique configuration and can be identified by a unique bean name or qualifier. However, by default, Spring uses the bean name as the identifier, so if you define two beans of the same class with the same bean name, it will result in an exception during application context initialization.

Question 183: Why qualifier is needed?

The @Qualifier annotation is used in Spring to resolve ambiguities when multiple beans of the same type are present in the application context. It helps to specify which specific bean should be injected or retrieved when there are multiple candidates available.

Consider a scenario where you have multiple implementations of an interface and you want to inject a specific implementation into a class. Without qualifiers, Spring would not know which implementation to use and would throw an exception due to the ambiguity.

By using the @Qualifier annotation, you can provide additional information to Spring to differentiate between the beans. It allows you to specify a unique identifier or name for a bean, which can then be used to resolve the ambiguity and accurately wire the desired bean.

Question 184: What are actuators what are all their uses and name the endpoints?

Actuators in Spring Boot are a set of production-ready management endpoints that provide various useful information and functionalities for monitoring and managing your application. Actuators allow you to gather insights into the internals of your application, perform health checks, monitor metrics, and more. These endpoints can be exposed over HTTP or JMX and provide valuable operational insights into your application.

Health: /actuator/health

• Provides information about the health status of your application. It can indicate whether the application is up and running, or if there are any potential problems.

Info: /actuator/info

• Displays custom information about your application. You can provide additional details, such as version, build information, environment details, etc.

Metrics: /actuator/metrics

• Collects and exposes various application metrics. It provides information about CPU usage, memory usage, HTTP request counts, database queries, and more. You can also obtain custom metrics specific to your application.

Loggers: /actuator/loggers

• Allows you to view and modify the logging configuration of your application at runtime. You can dynamically adjust log levels for different loggers.

Thread Dump: /actuator/threaddump

• Provides a snapshot of the current thread states in your application. This can be useful for diagnosing and troubleshooting performance or deadlock issues.

Environment: /actuator/env

• Displays the current environment properties and their values. It shows the configuration properties from various sources, such as application.properties, application.yml, environment variables, etc.

Trace: /actuator/trace

• Provides information about the recent HTTP requests made to your application. It shows details such as request method, URI, headers, and response status.

Auditevents: /actuator/auditevents

• Shows audit-related information about the events in your application. This includes details about user authentication, logins, and other security-related events.

Question 185: Circuit breakers, what is the use of it? use cases?

Circuit breakers are a design pattern used in software development to improve the resilience and fault tolerance of distributed systems. The primary purpose of a circuit breaker is to prevent cascading failures and provide graceful degradation when interacting with remote services.

Use cases of circuit breakers include:

1. Fault tolerance: Circuit breakers help handle failures and faults in distributed systems. When a remote service is experiencing issues or becomes unresponsive, the circuit breaker can break the circuit, avoiding subsequent requests and quickly returning a fallback response or error. This prevents the system from being overwhelmed by multiple requests to a failing service.

2. Fail fast: Circuit breakers allow for fast failure detection. If a remote service consistently fails to respond or exceeds predefined error thresholds, the circuit breaker can quickly detect this and open the circuit, bypassing further calls to the failing service. This avoids wasting resources and reduces the response time for clients.

3. Fallback and recovery: Circuit breakers provide the ability to define fallback logic. When the circuit is open, instead of sending requests to the failing service, the circuit breaker can return cached responses or execute alternative logic, such as returning default values or serving responses from a local cache. Once the failing service becomes healthy again, the circuit breaker can attempt to close the circuit and resume normal operations.

4. Load shedding: Circuit breakers can help manage high loads and prevent system overload. When the system is under heavy load or experiencing performance degradation, the circuit breaker can open the circuit and reject incoming requests temporarily. This allows the system to shed load and prioritize critical functionality or maintain stability during peak traffic.

Resilince4j and Hystrix are of the popular libraries to implement circuit breaker

Question 186: What is the AWS Lambda function and what are the benefits of using it?

It allows you to run your code without provisioning or managing servers. With AWS Lambda, you can execute your code in response to various events or triggers, such as changes in data, API requests, scheduled events, or even custom events.

1. Serverless Architecture: AWS Lambda follows a serverless model, which means you don’t need to worry about server provisioning, scaling, or maintenance. AWS takes care of all the infrastructure management, allowing you to focus solely on writing your code.

2. Cost-Efficiency: With AWS Lambda, you pay only for the actual compute time consumed by your code. It automatically scales your application in response to incoming requests and scales it down when there’s no activity. This pay-as-you-go pricing model helps optimize costs, as you’re not billed for idle server time.

3. Scalability and High Availability: AWS Lambda automatically scales your code in response to incoming requests. It can handle a virtually unlimited number of concurrent executions, ensuring your application can scale seamlessly as the workload increases. Additionally, Lambda functions are replicated across multiple Availability Zones within an AWS region, providing high availability and fault tolerance.

4. Event-Driven Architecture: AWS Lambda is designed for event-driven applications. It can be triggered by various events from AWS services, such as object creation in Amazon S3, database updates in Amazon DynamoDB, or messages in Amazon Simple Notification Service (SNS). This allows you to build reactive and decoupled architectures, where different components of your application can trigger and respond to events.

5. Integration with AWS Services: AWS Lambda integrates seamlessly with various AWS services, allowing you to build powerful and scalable applications. You can combine Lambda functions with services like Amazon API Gateway, Amazon S3, Amazon DynamoDB, Amazon SQS, and more to create complete serverless architectures.

6. Rapid Development and Deployment: AWS Lambda simplifies the development and deployment process. You can write your code in a supported programming language (such as Java, Python, Node.js, etc.), package it into a deployment package, and upload it to AWS Lambda. The service takes care of the rest, including scaling, deployment, and monitoring.

7. Operational Efficiency: With AWS Lambda, you don’t need to worry about server management, OS patching, or infrastructure monitoring. AWS handles all the operational tasks, allowing you to focus on writing code and delivering value to your users. You can monitor your Lambda functions using AWS CloudWatch, which provides insights into performance metrics, logs, and error rates.

Question 187: How to use multithreading in SpringBoot?

To use multithreading in Spring Boot:

1. Define Task: Implement Runnable or Callable for your task logic.

2. Configure Bean: Create a TaskExecutor bean in a configuration class.

1. Inject and Execute: Inject TaskExecutor into your service/component and use it to execute the task.

Example:

@Component
public class MyTask implements Runnable {
 @Override
 public void run() {
 // Task logic
 }
}
@Configuration
public class ThreadConfig {
 @Bean
 public TaskExecutor taskExecutor() {
 return new SimpleAsyncTaskExecutor();
 }
}
@Service
public class MyService {
 @Autowired
 private TaskExecutor taskExecutor;
 @Autowired
 private MyTask myTask;
public void executeAsyncTask() {
 taskExecutor.execute(myTask);
 }
}

Call executeAsyncTask() to run the task concurrently.

Question 188: How to use cache in spring boot?

Caching in Spring Boot can significantly improve the performance of your application by reducing the need to repeatedly fetch data from the database or perform expensive computations. Spring Boot provides integration with various caching providers, and you can easily configure and use caching in your application. Here’s a step-by-step guide on how to use caching in Spring Boot:

1. Add Dependencies:
Open your pom.xml (for Maven) or build.gradle (for Gradle) file and add the necessary dependencies for your chosen caching provider. Spring Boot supports multiple caching providers like Ehcache, Caffeine, Redis, etc. For example, if you want to use Ehcache, add the following dependency:

<! - For Maven →
 <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-cache</artifactId>
 </dependency>
 <dependency>
   <groupId>org.ehcache</groupId>
   <artifactId>ehcache</artifactId>
 </dependency>

Remember to modify the dependencies based on the caching provider you choose.

2. Enable Caching:
In your Spring Boot main class (the class annotated with @SpringBootApplication), add the @EnableCaching annotation. This annotation enables Spring’s caching infrastructure.

import org.springframework.cache.annotation.EnableCaching;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
@EnableCaching
public class YourApplication {
public static void main(String[] args) {
 SpringApplication.run(YourApplication.class, args);
 }
}

3. Configure Cache Manager:
Spring Boot auto-configures a default cache manager based on the caching provider’s availability. However, you can customize the cache manager by creating a CacheManager bean in your configuration. For example, to configure Ehcache:

import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.cache.CacheManager;
 import org.springframework.cache.ehcache.EhCacheCacheManager;
 import org.springframework.cache.annotation.EnableCaching;
@Configuration
 @EnableCaching
 public class CacheConfig {
 @Bean
 public CacheManager cacheManager() {
 return new EhCacheCacheManager(ehCacheManager());
 }
// Define your Ehcache manager bean here
 @Bean
 public EhCacheManager ehCacheManager() {
 return new EhCacheManager();
 }
 }

4. Use Caching:
To cache methods, annotate them with caching annotations like @Cacheable, @CachePut, and @CacheEvict.

-@Cacheable: This annotation indicates that the result of the annotated method should be cached. If the method is called again with the same arguments, the cached result will be returned instead of executing the method.

- @CachePut: This annotation updates the cache with the result of the method execution, regardless of whether the data is already cached.

- @CacheEvict: This annotation removes data from the cache. Use it to indicate that the cached data should be evicted after method execution.

Here’s an example of using @Cacheable:

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
@Service
public class MyService {
 @Cacheable("myCache")
 public String getCachedData(String key) {
 // Method implementation
 return someData;
 }
}

Question 189: What is @Aysnc annotation in spring-boot?

The @Async annotation in Spring Boot is used to indicate that a method should be executed asynchronously, meaning it will run in a separate thread from the caller.

This is particularly useful for methods that perform tasks that might take some time to complete, such as I/O operations, network calls, or heavy computations. By marking a method with @Async, you allow Spring to manage the asynchronous execution of that method.

Question 190: What are @primary and @ qualifiers?

Certainly, here’s a short answer about @Primary and @Qualifier annotations in Spring:

- @Primary: The @Primary annotation is used to indicate that a bean should be preferred when multiple beans of the same type are candidates for autowiring. It is primarily used to resolve ambiguity when Spring needs to inject a bean of a particular type into a component and there are multiple candidates. The bean marked with @Primary will be given precedence.

- @Qualifier: The @Qualifier annotation is used to specify a unique name or value to identify a particular bean when there are multiple beans of the same type. It is applied along with the @Autowired annotation to indicate which specific bean should be injected when multiple beans of the same type are available.