Understanding Microservices Architecture and Java Best Practices in Infosys Interviews

In a recent interview for a Java position at Infosys, the candidate discussed their experience with microservices architecture, Java design patterns, and best practices in software development. This blog post summarizes the key points from that conversation, providing insights into modern software architecture and Java programming.

Microservices Architecture

Transition from Monolithic to Microservices

The candidate described their project architecture as a microservices-based system, having transitioned from a monolithic architecture. In this architecture, multiple microservices revolve around specific business functionalities, enhancing modularity and scalability.

API Gateway

The entry point to the microservices is managed through an API Gateway, specifically using Zuul. All incoming requests are routed through this gateway, which directs them to the appropriate microservice. Key features implemented in the API Gateway include:

• Authentication and Authorization: The gateway authenticates users and checks their permissions for various operations.
• Rate Limiting: To manage excessive requests, the gateway implements rate limiting, returning a 429 status code when limits are exceeded.
• Response Aggregation: When a client request requires data from multiple microservices, the API Gateway combines responses from these services before sending a cumulative result back to the client.

Discovery Service

For service discovery, the candidate mentioned using Consul, having previously utilized Netflix Eureka. Each microservice registers with the discovery server upon startup, allowing other services to discover their URLs when needed.

Load Balancing and Database Management

The architecture also includes a load balancing mechanism, and each microservice operates with its own database. The candidate highlighted a combination of relational databases and MongoDB, showcasing the flexibility of using different database types based on service requirements.

Communication Between Microservices

Synchronous and Asynchronous Communication

The candidate explained two primary communication methods between microservices:

• Synchronous Communication: Initially using RestTemplate, the architecture has transitioned to Feign Client for synchronous calls, where the calling service waits for a response.
• Asynchronous Communication: Utilizing Kafka, microservices can send events without waiting for a response, allowing for more efficient processing.

Java Design Patterns and Principles

Understanding SOLID Principles

The candidate demonstrated knowledge of design patterns and the SOLID principles:

• Single Responsibility Principle: Each class should have one responsibility.
• Open/Closed Principle: Classes should be open for extension but closed for modification.
• Liskov Substitution Principle: Subtypes should be substitutable for their base types without affecting program correctness.
• Interface Segregation Principle: Interfaces should be specific to avoid forcing classes to implement unnecessary methods.
• Dependency Inversion Principle: High-level modules should not depend on low-level modules; both should depend on abstractions.

Project Structure in Spring Boot

When asked about structuring a Spring Boot application for an employee management system, the candidate outlined the following layers:

1. Controller Layer: Handles API requests and responses.
2. Service Layer: Contains business logic and transaction management.
3. Repository Layer: Interacts with the database using JPA.

The candidate emphasized the use of annotations such as @RestController, @Service, and @Repository to define these layers clearly.

Database Connection and Performance Optimization

Connecting to the Database

The candidate explained that database connection details are specified in the application.properties file, including host, port, username, and password. Spring Boot's auto-configuration simplifies the setup process.

Performance Optimization Techniques

To address performance issues with slow APIs, the candidate suggested:

• Checking network latency and API logic.
• Optimizing SQL queries by ensuring proper indexing on columns used in filtering and joining.

Understanding Indexes and Joins

The candidate clarified the purpose of indexes in databases, which speed up data retrieval by allowing the database to avoid full table scans. They also discussed different types of joins, including inner joins and outer joins, explaining how they function in SQL queries.

Java Features and Exception Handling

Java 8 Features

The candidate highlighted several features introduced in Java 8, such as:

• Functional programming capabilities with lambda expressions and streams.
• The introduction of the Optional class to handle null values more effectively.

Exception Handling

The candidate explained exception handling in Java using try-catch blocks and the distinction between checked and unchecked exceptions. They also discussed the use of the finally block for resource cleanup, noting that it may not execute in certain scenarios, such as JVM termination.

Conclusion

The interview provided a comprehensive overview of microservices architecture, Java programming principles, and best practices in software development. Understanding these concepts is crucial for developers looking to excel in modern software environments, particularly in roles that require expertise in microservices and Java technologies.