Java SB MicroS Backend Interview Preparation (PDF 350+ Q)

Explore functional interfaces in Java, defined by a single abstract method, with flexible static and default methods, illustrated by Runnable and their role as references for lambda expressions.

Learn method references in Java 8 as a reusable alternative to lambdas, using the double colon syntax to refer to existing static methods for a functional interface.

Override a default interface method in Java 8 by keeping the same signature, using public visibility, and providing your own implementation, while removing the default keyword in the class.

Java 8 introduced static methods in interfaces, enabling interface-level utilities callable as InterfaceName.method. This avoids object creation and reduces memory and performance overhead.

Learn the difference between predicates and functions in Java, where predicates return boolean and use test, while functions return a value with apply; both are in java.util.function.

Learn how to chain functions in Java 8 with andThen and compose. See how doubling followed by cubing differs from cubing followed by doubling.

Explore the supplier functional interface in java, which supplies a value without input via the get method, and contrast it with consumer while noting that chaining is not applicable.

Explore how BiConsumer, BiFunction, and BiPredicate handle two inputs, their methods (accept vs apply), and why BiSupplier has no two-argument form, with practical examples.

Understand that Java 8 provides only predicate, consumer, function, and supplier for one or two inputs; there are no tri or quad variants.

Map each object in a stream to its square with a map operation (i -> i), avoid filtering, and print the results to demonstrate java 8 stream capabilities.

Demonstrate processing a Java stream by filtering or mapping and collecting results into a list, set, map, or concurrent map using the collect method.

Master counting elements in Java streams using the count method, whether on raw, filtered, or mapped streams, and understand its interview relevance for Spring Boot microservices.

Explore processing stream elements with the sorted method to achieve natural ordering, including filtering and sorting examples, and a preview of comparator-based custom sorting.

Learn how Java streams' forEach method applies a lambda expression to every element without returning a value, enabling per-element operations on streams.

Learn how Java 8 short-circuit operations in streams optimize performance, using limit, find first, find any, any match, all match, and none match to stop early.

Using collectors.toMap to build key-value pairs, handle duplicate keys with two-, three-, and four-argument overloads, including a merge function, and selecting map types like hash map, linked hash map, or tree map.

Convert a list to a map using Collectors.toMap() in a stream, mapping each person's id to their name, yielding a concise, readable key-value result without extra loops.

Explore Java map.computeIfAbsent for absent or present keys, automatically create an empty list when needed, and add values in a single line, showcasing the collection framework at its smartest level.

Configure hibernate.cfg.xml with database properties and dialect to initialize session factories, and use a mapping file like employee.hbm.xml to map classes to tables with id and properties.

Create a hibernate application end-to-end by defining a pojo, adding a mapping file and configuration, establishing a database connection, and implementing data access to persist and retrieve data.

Explain the difference between open session and current session in Hibernate. Current session returns context session and closes with session factory; open session creates a session that must be closed.

Explore rapid application development as a modified waterfall that speeds delivery via prototyping. Learn RAD's five phases—business modeling, data modeling, process modeling, application generation, turnover—and Spring Boot's coding-time advantage.

Disable the default embedded web server in a Spring Boot app by setting spring.main.web-application-type to none in application.properties, allowing you to use your own web server.

Learn how to disable a specific auto-configuration class in spring boot by using the exclude option. This approach prevents automatic configuration, such as the data source auto-configuration, from loading.

Explain actuator endpoints in Spring Boot microservices to aid interview preparation for Java backend developers.

Explore how Spring Boot 2.2+ disables HTTP trace by default and how to enable it with an in-memory HTTP trace repository, exposing traces at the actuator httptrace endpoint.

Configure the management server port to 8090 in a Spring Boot app, keeping the application on 8080 and actuator endpoints accessible at 8090.

Package your spring boot application as jar or war by configuring the packaging tag in pom.xml and using the spring boot maven plugin to bundle dependencies.

Learn global exception handling in Spring Boot using controller advice. Centralize error handling, map to HTTP status codes, and provide meaningful messages.

Demonstrate how @SpringBootApplication combines @Configuration, @EnableAutoConfiguration, and @ComponentScan to boot a Spring Boot app, scanning base packages and creating beans in the Spring container.

Annotate a class with @Configuration to declare it as the source of all beans for the application context, and let component scanning create those beans, including the main class.

Enable auto-configuration automatically configures beans from dependencies, including embedded Tomcat and Spring MVC, and can adapt when a custom Servlet Web Server Factory is used.

@service marks a class as business logic and a Spring component, enabling it to become a bean in the Spring container and be auto-wired into controllers.

Recognize @Repository as a specialized component for the data access layer that creates a repository bean to perform database operations and rethrow platform-specific JDBC exceptions as Spring's unified unchecked exceptions.

Learn to implement enterprise validations in spring boot with hibernate validator annotations and deliver user-friendly 400 bad request messages via a global exception handler.

Create a custom annotation and validator in Spring Boot to enforce unique email addresses by querying the repository from a constraint validator and applying it on a DTO field.

Test the employee service implementation using Spring Boot test and Mockito. Mock the repository to return a stub employee for getEmployeeById, ensuring decode is returned instead of code.

Learn how mocking with Mockito avoids hardcoding and test database setup, lets you mock repositories at runtime, control return values and exceptions with when/then, and use annotations to simplify tests.

Learn why mocking is essential in unit tests to speed up JUnit runs, avoid slow calls and side effects, and safely simulate external systems, microservices, databases, and CI/CD pipelines.

Learn microservices as a loosely coupled architecture of independently developed and deployed services, such as citizen service and vaccination center service, using polyglot stacks and different languages while staying decoupled.

Explore the advantages of microservice architecture—tech diversity, focused teams, independent deployable units, and per-service security—alongside disadvantages like complex inter-service communication, deployment overhead, and higher resource needs.

Assess when to adopt microservices by weighing time to market, scalability, and cost on the cloud, and avoid for simple apps.

Microservices break the application into smaller, independently deployable services, easing new feature introduction. They enable decentralized data ownership per service, black-box interfaces, and polyglot, API gateway-driven security.

Learn how microservices communicate, using synchronous REST API for quick responses and asynchronous messaging with brokers, topics, and queues. Explore producer–consumer patterns with Kafka, RabbitMQ, and ActiveMQ.

Design and implement microservices starting with a monolithic minimum viable product, define bounded contexts, plan synchronous and asynchronous communication, and enable system integration testing with CI/CD.

Implement load balancing and horizontal scaling to distribute traffic across multiple service instances. Enable auto scaling, caching, database scaling, and asynchronous processing to maintain performance under high user load.

Explore fault-tolerant messaging in Java backend by examining how standby broker replicas enable asynchronous failover when the message broker goes down and stored messages risk loss.

Explore async communication models: point-to-point with queues and publish-subscribe with topics, highlighting producers, consumers, and message brokers, and how persistence and deletion ensure microservice resilience with RabbitMQ and ActiveMQ.

Learn when to use synchronous versus asynchronous communication in a microservices architecture, starting with synchronous design from scratch and migrating to asynchronous channels as the system stabilizes.

Explore how the saga design pattern ensures data consistency across the order, payment, and inventory services, comparing orchestrator and choreography approaches along with outbox patterns, idempotency, and dead-letter queues.

Identify common microservices anti-patterns, such as distributed monoliths, god services, shared databases, and tight coupling, and learn practical strategies to design loosely coupled, independently deployable microservices.

Explore how to maintain session state across microservices using jwt tokens, centralized stores, sticky sessions, header propagation, and distributed caching, with pros and cons.

Design idempotent APIs by using a client request id to detect repeats, preventing double charges in payments and duplicate orders, and recording a database snapshot for reliable retries.

Learn a three-phase approach to zero-downtime schema changes: expand, migrate, and contract, using versioned scripts via Flyway or Liquibase.

Explore creational design patterns as methods to create objects in Java, including factory method, abstract factory, prototype, and singleton patterns, with the simple example of using new.

Explore how the factory design pattern hides object creation behind a factory class. It returns doctor, engineer, or teacher instances via a getProfession method, using a profession interface.

Examine how the prototype design pattern uses a cache and clone method to create duplicate objects, reducing costly new object creation and database calls.

Learn how structural design patterns assemble system parts flexibly, ensuring changes in one component don’t affect others, and extendibility with proxy, flyway, basic, composite, adapter, and decorator patterns.

Explore how the proxy design pattern provides a substitute for a real object and enforces access through authentication and security checks.

Explore proxy design patterns in Java backend development, including access control, caching proxies for large responses, and logging proxies to track requests and unauthorized access.

Explore how the saga design pattern handles failures by sequencing local transactions across order, payment, and delivery services, using revert events and compensating transactions to revert changes.

Coordinate sagas with a centralized orchestrator that issues commands, manages state, and executes local transactions, while using a compensation transaction for failures.

Explore the CQRS design pattern, which separates read from write operations in microservices. Learn why splitting read and write into separate services can boost performance, scalability, and security.

Understand why CQRS separates read and write responsibilities to improve scalability in read-heavy systems, and how denormalized read models enable fast access while normalized write models ensure data integrity.

Apply CQRS by separating command and query microservices with distinct SQL write and NoSQL or Vue DB read databases, then synchronize asynchronously using Kafka, and evaluate when CQRS is appropriate.

Demonstrates how CQRS splits writes and reads: a command service validates and updates data and publishes events to Kafka, while a query service serves reads from its updated database.

Pair CQRS with event sourcing to enable logging and auditing across microservices. Event sourcing stores each event, publishes to Kafka, and lets query services update the database after validations.

Explore CQRS code implementation with command and query microservices, using MySQL with JPA for writes, MongoDB for reads, and Kafka events for decoupled, scalable data handling.

Cqrs offers independent scalability, optimized performance, fast reads and writes, and security, but trades off eventual consistency, dirty reads, and increased complexity with Kafka and event handlers.

Use cqrs when reads outnumber writes, such as in social media or e-commerce, and you need scaling or read queries; avoid it for simple apps or transactions requiring strong consistency.

Explore real-world cqrs use cases with high reads and low writes, such as ecommerce order history versus processing, product display versus update, and social media feed retrieval.

Explore the open-closed principle, which requires software components to be open for extension but closed for modification, ensuring new functionality without altering existing code.

Explore the open/closed principle by extending the employee class to add training areas without modifying existing code, preserving backward compatibility through inheritance and overriding methods.

Learn how the interface segregation principle prevents clients from implementing unused methods by splitting interfaces into online and offline subsets, enabling tailored, minimal implementations.

Explore the dependency inversion principle by shifting from concrete dependencies to abstraction, using dependency injection via XML to decouple modules and enable easy substitution of components.

Install Zookeeper and Kafka locally, then build a Spring Boot project with a producer, a consumer, and a REST controller to publish messages to a topic.