Coding Questions

1. Explain the difference between == and equals() in Java.

o == checks for reference equality (whether two references point to the same object).
o equals() checks for value equality (whether two objects are meaningfully equivalent).
2. How does Java handle memory management and garbage collection?
o Java uses an automatic garbage collection mechanism to manage memory, freeing up space by
destroying objects that are no longer in use.
3. What is the purpose of the @SpringBootApplication annotation?
o It is a convenience annotation that combines @Configuration, @EnableAutoConfiguration, and
@ComponentScan with their default attributes.
4. How does Spring Boot auto-configuration work?
o Spring Boot auto-configuration automatically configures your Spring application based on the jar
dependencies you have added. It attempts to guess and configure beans that you are likely to
need.
5. How do you design a microservices architecture?
o Identify and define each microservice around a specific business capability.
o Ensure each microservice is independently deployable.
o Use APIs for communication between microservices.
o Implement service discovery, load balancing, and fault tolerance.
6. How do you handle concurrency in Java?
o Use synchronization techniques such as synchronized blocks, Locks, and concurrent data structures
from java.util.concurrent package.
7. Implement a linked list in Java.

java
Copy code
class Node {
int data;
Node next;
Node(int data) {
this.data = data;
this.next = null;
}
}

class LinkedList {
Node head;
void insert(int data) {
Node newNode = new Node(data);
if (head == null) {
head = newNode;
} else {
Node temp = head;
while (temp.next != null) {
temp = temp.next;
}
temp.next = newNode;
}
}
}

8. Explain the differences between SQL and NoSQL databases.

o SQL databases are relational, use structured query language, and are table-based.
o NoSQL databases are non-relational, can store unstructured data, and include document, key-
value, graph, and column-family databases.
9. How do you perform CRUD operations in Spring Data JPA?
 o Define a repository interface that extends JpaRepository.
o Use methods like save(), findById(), findAll(), deleteById() to perform CRUD operations.

Technical Questions

1. Explain the Singleton design pattern with an example.

o The Singleton pattern ensures a class has only one instance and provides a global point of access
to it.

java
Copy code
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}

2. How do you create a RESTful API in Spring Boot?

o Annotate your controller classes with @RestController.
o Map HTTP requests to handler methods using @RequestMapping or @GetMapping, @PostMapping, etc.
o Use @RequestBody for request payloads and @ResponseBody for responses.
3. How does OAuth2 and JWT work for securing RESTful APIs?
o OAuth2 is an authorization framework that allows applications to obtain limited access to user
accounts.
o JWT (JSON Web Token) is used to securely transmit information between parties as a JSON
object.
4. What are the common security vulnerabilities in web applications and how do you prevent them?
o Common vulnerabilities include SQL injection, Cross-Site Scripting (XSS), and Cross-Site Request
Forgery (CSRF).
o Prevent them by using parameterized queries, escaping user input, and implementing CSRF
tokens.
5. How do you write unit tests in Java using JUnit?
o Use @Test annotation to denote test methods.
o Use assertions like assertEquals(), assertTrue(), and assertNotNull() to validate outcomes.

Behavioral Questions

1. Describe a time when you had to work closely with a team to complete a project.
o In my last project at TCS, I collaborated with a team of five developers to build a digital banking
platform. We used agile methodologies and conducted daily stand-ups to ensure smooth
communication and progress tracking.
2. How do you handle conflicts within your team?
o I address conflicts by promoting open communication, understanding each team member’s
perspective, and finding a compromise that aligns with the project goals.
3. Tell me about a challenging bug you faced and how you resolved it.
o I encountered a memory leak in a Java application caused by unclosed resources. I used profiling
tools to identify the issue and ensured all resources were properly closed in the finally block.
4. How do you manage your time and ensure you meet project deadlines?
 o I prioritize tasks based on their urgency and importance, break down larger tasks into
manageable chunks, and use tools like Jira to track progress and deadlines.

Work Experience Questions

1. Can you describe a project where you used Spring Boot and microservices?
o I worked on a project to develop a cloud-based inventory management system using Spring Boot
and microservices. Each service managed a specific function like inventory, orders, and users,
and communicated via REST APIs.
2. What were the main challenges you faced in your recent projects and how did you overcome them?
o One challenge was ensuring the scalability of our microservices. I overcame this by implementing
load balancing and optimizing the services to handle increased traffic efficiently.
3. How have you utilized cloud platforms like Azure or Google Cloud in your projects?
o I used Microsoft Azure for deploying and managing our application infrastructure, setting up
CI/CD pipelines, and using Azure services like Azure SQL Database and Azure Functions.
4. Explain a scenario where you implemented CI/CD pipelines.
o I implemented CI/CD pipelines using Azure Pipelines to automate the build, test, and deployment
processes for our Java application, ensuring faster and more reliable releases.

Additional Questions and Answers

1. How do you ensure high availability and scalability in your applications?

o I use load balancing, horizontal scaling, and redundancy strategies to ensure high availability. For
scalability, I design applications to scale out by adding more instances as needed.
2. What new features in the latest Java version have you found most useful?
o I find the introduction of pattern matching for instanceof, records, and the switch expressions in
Java 16 very useful as they make the code more concise and readable.
3. How do you approach learning new technologies or frameworks?
o I start with official documentation and tutorials, build small projects to apply what I’ve learned,
and participate in online communities to stay updated with best practices.
o
4. . How do we create a thread-safe singleton class in Java?
5. To create a thread-safe singleton class in Java, we want to ensure that only one instance of the class is
created, even if multiple threads try to instantiate it simultaneously. We achieve this by using a private
constructor and a double-checked locking mechanism with the synchronized keyword. Here’s how we can do
it:
6. java
7. Copy code
8. public class Singleton {
9. private static volatile Singleton instance;
10.
11. private Singleton() {}
12.
13. public static Singleton getInstance() {
14. if (instance == null) {
15. synchronized (Singleton.class) {
16. if (instance == null) {
17. instance = new Singleton();
18. }
19. }
20. }
21. return instance;
22. }
23. }
24. This approach uses a private constructor to prevent direct instantiation and checks if the instance is null
before and after acquiring the lock to minimize synchronization overhead.

25. 2. How do we reverse a string in Java?

26. To reverse a string in Java, we can use the StringBuilder class, which provides a convenient method for
reversing strings. Here’s a simple method to achieve this:
27. java
28. Copy code
29. public class ReverseString {
30. public static String reverse(String str) {
31. return new StringBuilder(str).reverse().toString();
32. }
33.
34. public static void main(String[] args) {
35. System.out.println(reverse("hello")); // Output: "olleh"
36. }
37. }
38. This method leverages StringBuilder’s reverse() method to easily reverse the characters in the string.

39. 3. How do we secure a Spring Boot application using Spring Security?

40. To secure a Spring Boot application, we use Spring Security to configure which endpoints are accessible
and which require authentication. We can set up an in-memory user store for simplicity. Here’s a basic
configuration example:
41. java
42. Copy code
43. @Configuration
44. @EnableWebSecurity
45. public class SecurityConfig extends WebSecurityConfigurerAdapter {
46. @Override
47. protected void configure(HttpSecurity http) throws Exception {
48. http
49. .authorizeRequests()
50. .antMatchers("/public/**").permitAll()
51. .anyRequest().authenticated()
52. .and()
53. .formLogin().permitAll();
54. }
55.
56. @Autowired
57. public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
58. auth.inMemoryAuthentication()
59. .withUser("user").password("{noop}password").roles("USER");
60. }
61. }
62. This configuration allows access to endpoints under /public/** without authentication, while other requests
require authentication.

63. 4. How do we handle transactions in a Spring Boot application?

64. To handle transactions in a Spring Boot application, we use the @Transactional annotation to ensure that a
series of database operations are executed as a single transaction. If any operation fails, all changes are
rolled back. Here’s an example:
65. java
66. Copy code
67. @Service
68. public class MyService {
69. @Autowired
70. private MyRepository repository;
71.
72. @Transactional
73. public void performTransaction() {
74. repository.save(new Entity());
75. // Additional transactional operations
76. }
77. }
78. By annotating the method with @Transactional, we ensure that all operations within this method are part of
one transaction.

79. 5. How do we implement service discovery in microservices?

80. For microservices to find each other without hardcoding addresses, we can use a service discovery tool
like Eureka. Eureka allows microservices to register themselves and discover other services dynamically.
Here’s a simple configuration for a Eureka client:
81. java
82. Copy code
83. @Configuration
84. @EnableEurekaClient
85. public class EurekaClientConfig {
86. @Bean
87. public DiscoveryClient discoveryClient() {
88. return new DiscoveryClient();
89. }
90. }
91. This setup enables our microservices to use Eureka for service discovery.

92. 6. How do we design a RESTful API for a microservice?

93. To design a RESTful API for a microservice that handles user data, we use @RestController to define the
controller and @RequestMapping to specify the URL path. For example:
94. java
95. Copy code
96. @RestController
97. @RequestMapping("/api/users")
98. public class UserController {
99. @GetMapping("/{id}")
100. public User getUser(@PathVariable Long id) {
101. return userService.findById(id);
102. }
103. }
104. This controller maps HTTP GET requests to /api/users/{id} and returns user data based on the ID.

105. 7. How do we create a Docker image for a Spring Boot application?

106. To package a Spring Boot application into a Docker image, we need to create a Dockerfile that specifies the
base image, copies the JAR file, and sets the command to run the application. Here’s a sample Dockerfile:
107. dockerfile
108. Copy code
109. FROM openjdk:11
110. ARG JAR_FILE=target/*.jar
 111. COPY ${JAR_FILE} app.jar
112. ENTRYPOINT ["java","-jar","/app.jar"]
113. This Dockerfile uses OpenJDK 11, copies the JAR file into the image, and sets the command to run the
Spring Boot application.

114. 8. How do we run a Docker container from an image?

115. To run our Docker image as a container and expose port 8080, we use the docker run command. Here’s how
we do it:
116. bash
117. Copy code
118. docker run -d -p 8080:8080 my-spring-boot-app
119. This command starts the container and maps port 8080 on the container to port 8080 on the host.

120. 9. How do we deploy a Spring Boot application to Kubernetes?

To deploy a Spring Boot application on Kubernetes, we create a Deployment YAML file that specifies the number of
replicas and the container details. Here’s a sample YAML file:

121. yaml
122. Copy code
123. apiVersion: apps/v1
124. kind: Deployment
125. metadata:
126. name: spring-boot-app
127. spec:
128. replicas: 3
129. selector:
130. matchLabels:
131. app: spring-boot-app
132. template:
133. metadata:
134. labels:
135. app: spring-boot-app
136. spec:
137. containers:
138. - name: spring-boot-app
139. image: my-spring-boot-app:latest
140. ports:
141. - containerPort: 8080
142. This configuration sets up a deployment with 3 replicas of our Spring Boot application.

143. 10. How do we define a Kubernetes Service?

144. To expose our application to other services in Kubernetes, we create a Service YAML file. Here’s an
example:
145. yaml
146. Copy code
147. apiVersion: v1
148. kind: Service
149. metadata:
150. name: spring-boot-service
151. spec:
152. selector:
153. app: spring-boot-app
154. ports:
155. - protocol: TCP
156. port: 80
157. targetPort: 8080
158. type: LoadBalancer
159. This Service configuration exposes our application on port 80 and maps it to port 8080 in the container.

160. 11. How do we design a scalable microservices architecture for an e-commerce application?
161. To build a scalable architecture for an e-commerce platform, we break down the application into
individual services such as User, Product, and Order. We use an API Gateway to handle incoming requests
and route them to the appropriate service. Each service has its own database to ensure isolation. Service
discovery with Eureka allows services to find each other dynamically, and Kubernetes manages load
balancing and scaling.

162. 12. How do we diagnose and resolve performance issues in a Spring Boot application?
163. When diagnosing and resolving performance issues in a Spring Boot application, we use profiling tools like
VisualVM to identify bottlenecks. We improve logging with the ELK Stack (Elasticsearch, Logstash, Kibana)
for better monitoring and implement caching with Redis to reduce database load. Optimizing database
queries and using connection pooling can enhance performance, and we can scale the application
horizontally by adding more instances using Kubernetes.