1. Problem Statement​

Imagine you are integrating with an external KYB (Know Your Business) API. The API can return two types of responses:

Success response:

{
  "data": {
    "businessId": "123",
    "status": "verified"
  }
}

Error response:

{
  "errors": [
    { "type": "not_found", "message": "Business profile not found" }
  ]
}

Sometimes, the API returns a mix you don’t want:

{
  "data": null,
  "errors": [{ "type": "not_found", "message": "Business profile not found" }]
}

Returning both data and errors together is confusing and not ideal.

2. Why Mapping Directly to a Single DTO Fails​

If you map the response directly to a single DTO like KybResponse, you may end up with:

public class KybResponse {
    private Data data;
    private List<ErrorResponse> errors;
}

If data is null but errors exist, your controller might accidentally return a response with both data and errors, which is misleading for clients.

3. Designing Clean Response Models​

To solve this, create two clear models:

Error model:

public class ErrorResponse {
    private String type;
    private String message;

    // getters & setters
}

API response model:

import com.fasterxml.jackson.annotation.JsonInclude;

@JsonInclude(JsonInclude.Include.NON_NULL)
public class KybResponse {
    private Data data;
    private List<ErrorResponse> errors;

    // getters & setters
}

@JsonInclude(JsonInclude.Include.NON_NULL) ensures null fields are not serialized, preventing responses from containing both data and errors.

4. Service Layer Responsibility​

The service layer should:

1. Call the external API.
2. Inspect the response.
3. Throw exceptions if errors exist.
4. Return data only if successful.

Example:

@Service
public class KybService {

    private final RestTemplate restTemplate;

    public KybService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    public Data getBusiness(String businessId) {
        KybResponse response = restTemplate.getForObject(
                "https://external-api.com/kyb/" + businessId,
                KybResponse.class
        );

        if (response.getErrors() != null && !response.getErrors().isEmpty()) {
            throw new KybException(response.getErrors());
        }

        return response.getData();
    }
}

5. Custom Exception Implementation​

Define a custom exception to encapsulate API errors:

public class KybException extends RuntimeException {
    private final List<ErrorResponse> errors;

    public KybException(List<ErrorResponse> errors) {
        super("KYB API returned errors");
        this.errors = errors;
    }

    public List<ErrorResponse> getErrors() {
        return errors;
    }
}

6. Exception Handling Approaches​

1. Try-catch in controller – works but clutters the controller, not recommended.
2. @ExceptionHandler in controller – better, but still limited.
3. @RestControllerAdvice – centralized global handling, recommended.

7. Global Exception Handler​

Implement a global handler for KybException:

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(KybException.class)
    public ResponseEntity<Map<String, List<ErrorResponse>>> handleKybException(KybException ex) {
        Map<String, List<ErrorResponse>> errorBody = Map.of("errors", ex.getErrors());
        return ResponseEntity.badRequest().body(errorBody);
    }
}

This keeps controllers clean and ensures consistent error responses.

8. Final Controller​

Now the controller only focuses on successful responses:

@RestController
@RequestMapping("/kyb")
public class KybController {

    private final KybService kybService;

    public KybController(KybService kybService) {
        this.kybService = kybService;
    }

    @GetMapping("/{businessId}")
    public Data getKyb(@PathVariable String businessId) {
        return kybService.getBusiness(businessId);
    }
}

No error handling logic is inside the controller anymore.

9. Final API Outputs​

Success response:

{
  "businessId": "123",
  "status": "verified"
}

Error response:

{
  "errors": [
    { "type": "not_found", "message": "Business profile not found" }
  ]
}

Notice there’s no overlap of data and errors.

10. Best Practices​

• Never return data and errors together.
• Keep controllers thin, services smart.
• Centralize exception handling.
• Use a consistent API response format.

11. Optional Improvements​

• Add timestamp, status, and path in error responses.
• Map different error types to proper HTTP status codes.
• Introduce a generic ApiResponse<T> for more consistency.

Example enhanced error response:

{
  "timestamp": "2026-03-17T12:30:00Z",
  "status": 400,
  "errors": [
    { "type": "not_found", "message": "Business profile not found" }
  ],
  "path": "/kyb/123"
}

I have seen Java evolve from the early JDK days to modern cloud native architectures. But if there is one release that fundamentally changed how Java is written, it is Java 8.

Before Java 8, Java was powerful but verbose. Writing simple operations on collections required boilerplate loops, anonymous classes, and a lot of ceremony.

Then Java 8 arrived.

And suddenly Java developers were talking about:

• Functional programming
• Lambdas
• Streams
• Optional
• Immutable date APIs

From an interviewer’s perspective, Java 8 became a major filter. Candidates who truly understood it stood out immediately.

This guide walks through everything a strong backend engineer must know about Java 8.

Why Java 8 Was a Game Changer

Before Java 8, Java lacked features that other languages already had:

• Functional programming
• Clean collection processing
• Immutable date APIs
• Asynchronous computation primitives

Developers had to write verbose code for simple tasks.

Example: Filtering a list before Java 8

List<Integer> evenNumbers = new ArrayList<>();

for(Integer num : numbers){
    if(num % 2 == 0){
        evenNumbers.add(num);
    }
}

With Java 8:

List<Integer> evenNumbers =
numbers.stream()
       .filter(n -> n % 2 == 0)
       .collect(Collectors.toList());

Less code. More expressive. Easier to parallelize.

Problems with Pre Java 8 Java

1. Boilerplate Code​

Anonymous classes were everywhere.

Collections.sort(list, new Comparator<Integer>() {
    public int compare(Integer a, Integer b){
        return a - b;
    }
});

Java 8 simplified this drastically.

2. No Functional Programming Support​

Languages like Scala and JavaScript already supported:

• first class functions
• lambda expressions
• function composition

Java lacked these features until Java 8.

Functional Programming in Java

Functional programming focuses on:

• pure functions
• immutability
• higher order functions

Java introduced functional programming through:

• Lambdas
• Functional interfaces
• Streams API

Lambda Expressions

A lambda expression represents an anonymous function.

Syntax​

(parameters) -> expression

Example:

(a, b) -> a + b

Used with functional interfaces.

Example with comparator:

Collections.sort(list, (a, b) -> a - b);

Functional Style Programming​

Instead of telling the computer how to do something, you describe what needs to happen.

Imperative:

for(int i : list){
   if(i > 10) result.add(i);
}

Functional:

list.stream()
    .filter(i -> i > 10)
    .collect(Collectors.toList());

Behind The Scenes Compilation​

A common interview question:

Are lambda expressions anonymous classes?

No.

Java compiles lambdas using invokedynamic bytecode instruction and LambdaMetafactory.

Advantages:

• better performance
• reduced class generation
• improved memory usage

Interview Question​

Q: What is the difference between lambda and anonymous class?

Key differences:

1. Lambdas do not create a new scope for this
2. Lambdas are compiled using invokedynamic
3. Anonymous classes generate class files

Functional Interfaces

A functional interface contains exactly one abstract method.

Example:

interface Calculator {
    int add(int a, int b);
}

@FunctionalInterface​

Optional annotation.

@FunctionalInterface
interface MyFunction {
    void execute();
}

Compiler ensures only one abstract method exists.

Built in Functional Interfaces​

Java provides several interfaces in java.util.function.

Important ones interviewers expect you to know:

Example:

Predicate<Integer> isEven = n -> n % 2 == 0;

Custom Functional Interface​

@FunctionalInterface
interface Greeting {
    void sayHello(String name);
}

Usage:

Greeting g = name -> System.out.println("Hello " + name);

Interview Trap​

Question:

Is Runnable a functional interface?

Yes.

Runnable r = () -> System.out.println("Running");

Method References

Method references allow referencing methods directly.

Syntax:

ClassName::methodName

Static Method Reference​

Integer::parseInt

Example:

list.stream()
    .map(Integer::parseInt)
    .collect(Collectors.toList());

Instance Method Reference​

String::toLowerCase

Constructor Reference​

User::new

Example:

Supplier<User> supplier = User::new;

Streams API

Streams process collections in a functional style pipeline.

What Problem Streams Solve​

Before Java 8:

• iteration was external
• logic mixed with data traversal

Streams introduced internal iteration.

External vs Internal Iteration​

External:

for(int i : list)

Internal:

list.stream().filter(...)

Lazy Evaluation​

Intermediate operations execute only when terminal operation runs.

Example:

list.stream()
    .filter(x -> x > 5)
    .map(x -> x * 2)
    .collect(Collectors.toList());

Stream Pipeline​

Source -> Intermediate Operations -> Terminal Operation

Example:

List -> filter -> map -> collect

Intermediate Operations

filter​

list.stream()
    .filter(x -> x > 10)

map​

Transforms elements.

list.stream()
    .map(x -> x * 2)

flatMap​

Flattens nested structures.

list.stream()
    .flatMap(List::stream)

distinct​

Removes duplicates.

stream.distinct()

sorted​

stream.sorted()

limit​

stream.limit(5)

skip​

stream.skip(3)

peek​

Used for debugging.

stream.peek(System.out::println)

Terminal Operations

collect​

stream.collect(Collectors.toList())

reduce​

Used for aggregation.

int sum = list.stream()
              .reduce(0, Integer::sum);

findFirst​

stream.findFirst()

anyMatch​

stream.anyMatch(x -> x > 10)

allMatch​

stream.allMatch(x -> x > 0)

noneMatch​

stream.noneMatch(x -> x < 0)

count​

stream.count()

min / max​

stream.max(Integer::compareTo)

Collectors in Depth

Collectors transform streams into collections.

toList​

stream.collect(Collectors.toList())

toSet​

stream.collect(Collectors.toSet())

toMap​

stream.collect(Collectors.toMap(
    User::getId,
    User::getName
));

groupingBy​

Map<String, List<User>> users =
users.stream()
     .collect(Collectors.groupingBy(User::getDepartment));

partitioningBy​

Map<Boolean, List<Integer>> result =
list.stream()
    .collect(Collectors.partitioningBy(n -> n % 2 == 0));

joining​

String result =
list.stream()
    .collect(Collectors.joining(","));

counting​

Collectors.counting()

summarizingInt​

IntSummaryStatistics stats =
list.stream()
    .collect(Collectors.summarizingInt(Integer::intValue));

Optional Class

Optional represents a container that may or may not contain a value.

Why Optional Was Introduced​

Java suffered heavily from:

NullPointerException

Optional forces developers to handle absence of value.

Example​

Optional<String> name = Optional.of("Java");

map vs flatMap​

map transforms inside Optional.

flatMap avoids nested Optional.

orElse vs orElseGet vs orElseThrow​

orElse(value)

always evaluates.

orElseGet(supplier)

lazy execution.

orElseThrow()

throws exception.

Default Methods in Interfaces

Java 8 allows methods with implementation inside interfaces.

Example:

interface Vehicle {

 default void start(){
   System.out.println("Starting");
 }
}

Diamond Problem​

If two interfaces define the same default method:

Class must override it.

Static Methods in Interfaces

Interfaces can contain static methods.

Example:

interface MathUtil {

 static int add(int a,int b){
   return a+b;
 }
}

Call using:

MathUtil.add(1,2);

New Date Time API (java.time)

Old APIs:

• Date
• Calendar

Problems:

• mutable
• thread unsafe
• confusing

LocalDate​

LocalDate.now()

LocalTime​

LocalTime.now()

LocalDateTime​

LocalDateTime.now()

ZonedDateTime​

Supports timezones.

ZonedDateTime.now()

Duration​

Used for time based difference.

Period​

Used for date difference.

Formatting​

DateTimeFormatter formatter =
DateTimeFormatter.ofPattern("dd-MM-yyyy");

Parallel Streams

Parallel streams allow parallel processing.

list.parallelStream()

Internal Working​

Uses ForkJoinPool.commonPool().

Work divided across threads.

When NOT to Use​

• IO operations
• small collections
• shared mutable state

Nashorn JavaScript Engine

Java 8 introduced Nashorn to run JavaScript inside JVM.

Example:

ScriptEngine engine =
new ScriptEngineManager().getEngineByName("nashorn");

Type Inference Improvements

Java 8 improved type inference for generics and lambdas.

Java 8 forEach

list.forEach(System.out::println);

Base64 Encoding

Java 8 added Base64 utilities.

Base64.getEncoder().encodeToString(data);

CompletableFuture

CompletableFuture enables asynchronous programming.

Example:

CompletableFuture.supplyAsync(() -> {
    return "Hello";
}).thenApply(String::toUpperCase)
  .thenAccept(System.out::println);

Real Interview Coding Questions

Find duplicate elements​

list.stream()
    .collect(Collectors.groupingBy(
        Function.identity(),
        Collectors.counting()))
    .entrySet()
    .stream()
    .filter(e -> e.getValue() > 1)

Convert List to Map​

Map<Integer, User> map =
users.stream()
     .collect(Collectors.toMap(
         User::getId,
         Function.identity()
     ));

Top Java 8 Interview Questions

1. What is a functional interface
2. Difference between map and flatMap
3. Difference between stream and parallel stream
4. What is lazy evaluation
5. What happens when multiple terminal operations are used
6. Difference between Optional.of and Optional.ofNullable
7. Difference between reduce and collect
8. What is invokedynamic
9. What is method reference
10. When should you use Optional

Common Java 8 Interview Mistakes

1. Overusing parallel streams
2. Using streams for simple loops
3. Misusing Optional as field variables
4. Ignoring immutability
5. Not understanding lazy evaluation

Java 8 Interview Cheat Sheet

Core concepts interviewers check:

• Functional interfaces
• Lambda expressions
• Streams pipeline
• Optional
• Method references
• Default methods
• CompletableFuture
• Date Time API
• Collectors
• Parallel streams

If a developer understands these deeply, they can handle nearly every Java 8 interview question.

One day a junior developer asked a simple question.

“Why do we need a whole class just to run a small piece of logic?”

He was referring to this.

class TaskRunner implements Runnable {
    @Override
    public void run() {
        System.out.println("Processing task...");
    }
}

new Thread(new TaskRunner()).start();

For experienced Java developers, this looked normal. But for someone coming from modern languages, it looked… excessive.

Just to execute a small block of code, we needed a full class.

And this pattern was everywhere.

Sorting collections. Running background tasks. Writing callbacks. Handling events.

Everything required interfaces, anonymous classes, and verbose implementations.

Then Java 8 arrived. And things changed.

The Real Problem Java Was Trying to Solve​

Before Java 8, Java lacked a concise way to pass behavior as data.

If we wanted to pass logic into a method, we usually had to create an anonymous class.

Example: sorting a list.

Before Java 8:

Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return a.compareTo(b);
    }
});

A lot of code… for a very simple comparison.

Java needed a simpler way to represent small pieces of behavior.

That is where Functional Interfaces come in.

What is a Functional Interface?​

A Functional Interface is simply an interface that contains exactly one abstract method.

That’s it.

Example:

@FunctionalInterface
public interface Calculator {
    int calculate(int a, int b);
}

Because there is only one abstract method, Java can represent this interface using a lambda expression.

The @FunctionalInterface annotation is optional, but extremely useful. It tells the compiler:

"This interface is intended to have only one abstract method."

If someone accidentally adds another method, the compiler will throw an error.

This protects the design.

Why Functional Interfaces Enabled Lambdas​

Java needed a target type for lambda expressions.

That target type is a Functional Interface.

Example:

Calculator add = (a, b) -> a + b;

The lambda (a, b) -> a + b becomes the implementation of the single method inside Calculator.

Without Functional Interfaces, lambdas would have no type to map to.

That is why these two concepts were introduced together.

Some Functional Interfaces You Use Every Day​

The Java standard library already provides many powerful functional interfaces.

Let’s look at a few.

Runnable

Runnable task = () -> System.out.println("Running task");

new Thread(task).start();

What used to require a full class now fits in one line.

Comparator

Sorting became much cleaner.

Before Java 8 we saw the verbose version.

Now:

names.sort((a, b) -> a.compareTo(b));

Or even better:

names.sort(String::compareTo);

Predicate

Used for conditions and filtering.

Predicate<Integer> isEven = n -> n % 2 == 0;

System.out.println(isEven.test(10));

Function

Transforms data.

Function<String, Integer> length = str -> str.length();

System.out.println(length.apply("Java"));

Consumer

Consumes a value without returning anything.

Consumer<String> printer = msg -> System.out.println(msg);

printer.accept("Hello Java");

These simple interfaces power most of the functional style in modern Java.

Where Functional Interfaces Shine: Streams​

Streams would not exist without Functional Interfaces.

Example:

List<Integer> numbers = List.of(1,2,3,4,5,6);

numbers.stream()
       .filter(n -> n % 2 == 0)
       .map(n -> n * n)
       .forEach(System.out::println);

Behind the scenes:

filter uses Predicate map uses Function forEach uses Consumer

Streams are essentially pipelines built using Functional Interfaces.

Why This Matters in Modern Backend Systems​

In microservices and backend systems, we constantly deal with:

• event processing
• asynchronous workflows
• reactive pipelines
• stream transformations
• callback based APIs

Functional Interfaces make these patterns much cleaner.

Instead of designing dozens of small classes, we pass behavior directly.

This leads to:

Less boilerplate More expressive code Easier parallel processing Cleaner APIs

Many modern frameworks rely heavily on this style.

Spring, Reactor, CompletableFuture, and even internal enterprise platforms.

Common Mistakes Developers Make​

After reviewing hundreds of codebases, a few mistakes appear repeatedly.

1. Creating unnecessary custom functional interfaces

Java already provides many in java.util.function.

Always check before creating your own.

2. Writing overly complex lambdas

Lambdas should stay small and readable.

If logic becomes large, move it to a method.

3. Ignoring method references

Sometimes this:

list.forEach(x -> System.out.println(x));

Can simply be:

list.forEach(System.out::println);

Cleaner and more expressive.

4. Forgetting functional interfaces can have default methods

They can contain:

• default methods
• static methods

They just cannot have more than one abstract method.

A Small Insight From Years of Java Architecture​

The biggest shift Java 8 introduced was not lambdas.

It was a change in thinking.

We moved from:

“Everything must be an object.”

To:

“Sometimes behavior itself is the object.”

Functional Interfaces are the bridge that made that transition possible while keeping Java strongly typed and backward compatible.

It was one of the smartest design decisions the Java language team ever made.

Core Java Essentials​

OOP Concepts

• Encapsulation, Inheritance, Polymorphism, Abstraction
• abstract class vs interface, final keyword
• Overloading vs Overriding

Collections Quick Reference

• ArrayList vs LinkedList (Random access vs insertion efficiency)
• HashMap (bucket-based, collisions via linked list/tree)
• Set vs List vs Map
• Concurrent: ConcurrentHashMap, CopyOnWriteArrayList

Streams & Lambdas

List<Integer> nums = Arrays.asList(1,2,3);
nums.stream().filter(n -> n%2==0).forEach(System.out::println);

• Intermediate vs Terminal operations
• map, reduce, collect, parallel streams

Concurrency Utilities

• synchronized, ReentrantLock, volatile, AtomicInteger
• Executors: Thread pools (Executors.newFixedThreadPool)
• CountDownLatch, CyclicBarrier, Semaphore, ThreadLocal

JVM & Memory

• Heap, Stack, Method Area, PC Register
• GC types: Minor, Major, G1, CMS
• References: Strong, Weak, Soft, Phantom

Design Patterns

• Singleton, Factory, Builder, Observer, Strategy, Template, Command, Facade, Prototype, Adapter

Advanced Java

• Reflection: Class.forName(), Method.invoke()
• Generics: List<String> list
• Optional: Optional.ofNullable(x).ifPresent(...)
• I/O & NIO: Files.readAllLines(path)
• Records: record User(String name, int age){}
• Pattern matching: if(obj instanceof String s)

Spring Framework Essentials​

Dependency Injection

• Constructor (preferred), Setter, Field
• @Component, @Service, @Repository, @Controller
• Bean scopes: singleton, prototype, request, session, application

AOP

• Cross-cutting: Logging, Transactions, Security
• Annotations: @Aspect, @Before, @After, @Around

@Around("@annotation(LogExecutionTime)")
public Object logTime(ProceedingJoinPoint jp){...}

Spring MVC

• @Controller vs @RestController
• Validation: @Valid, BindingResult
• Exception handling: @ControllerAdvice, @ExceptionHandler
• Path variables: @PathVariable, request params: @RequestParam

Spring Data JPA

• Repositories: JpaRepository, CrudRepository
• Custom queries: @Query("SELECT u FROM User u WHERE u.age>:age")
• Transactions: @Transactional (propagation, isolation, readOnly)
• Lazy vs Eager fetching, N+1 problem

Spring Security

• AuthenticationManager, UserDetailsService, PasswordEncoder
• JWT, OAuth2, @PreAuthorize for method-level security

Event-driven

• ApplicationEventPublisher + @EventListener
• Async events: @Async + TaskExecutor

Spring Boot & Microservices​

Spring Boot Basics

• Auto-configuration, Starters, Profiles
• @SpringBootApplication = @Configuration + @EnableAutoConfiguration + @ComponentScan

Actuator & Monitoring

• Endpoints: /health, /metrics, /beans
• Integration: Prometheus, Grafana

Testing

• Unit: JUnit + Mockito
• Integration: @SpringBootTest
• Web: @WebMvcTest
• Repository: @DataJpaTest

REST API Best Practices

• HTTP verbs, resource-based URIs, versioning
• DTOs, centralized exception handling, pagination, sorting

Microservices

• Service discovery: Eureka
• Feign clients, circuit breakers (Resilience4J)
• Event-driven messaging: Kafka, RabbitMQ
• Stateless services, caching, configuration management

Security & Production

• JWT authentication, OAuth2
• Method-level authorization
• Thread pools, retries, rate-limiting, fallback strategies
• Logging, monitoring, metrics

Common Pitfalls & Interview Tips​

• Avoid circular dependencies; use setter injection if necessary
• Lazy loading across services → DTOs or projections
• Always encode passwords; never trust client-side tokens
• Proper transactional boundaries; avoid self-invocation issues
• Isolate unit tests; use integration tests for end-to-end verification
• Use thread pools wisely; avoid unbounded threads
• Explain trade-offs in design: sync vs async, caching, DB fetch strategies

Part 1: Core Java Deep Dive

1. Java Basics Refresher – Data Types, Loops, Strings, Exception Handling
2. Object-Oriented Programming – Inheritance, Polymorphism, Encapsulation, Abstraction
3. Collections Framework – Lists, Sets, Maps, Queues, Advanced usage, Performance considerations
4. Streams & Functional Programming – Streams, Lambdas, Method references, Parallel streams
5. Concurrency & Multithreading – Thread lifecycle, Executors, Synchronization, Locks, Concurrent collections
6. JVM Internals – Class loading, Memory model, Heap vs Stack, Garbage Collection, GC tuning
7. Design Patterns – Singleton, Factory, Builder, Observer, Strategy, Dependency Injection patterns
8. Advanced Java Topics – Reflection, Generics, Annotations, Serialization, I/O & NIO, Optional usage

Part 2: Spring Framework Mastery

1. Dependency Injection – Constructor, Setter, Field Injection, @Component, @Service, @Repository distinctions
2. Spring Bean Lifecycle & Scopes – Singleton, Prototype, Request, Session
3. Aspect-Oriented Programming – @Aspect, @Before, @After, @Around, Real-world logging & security
4. Spring MVC – Controllers, RequestMapping, PathVariables, REST best practices
5. Spring Data JPA – Repositories, Transactions, JPQL, Criteria API
6. Spring Security – Authentication, Authorization, JWT, OAuth2, Role-based access control
7. Event-driven Spring – ApplicationEventPublisher, Async events, Messaging

Part 3: Spring Boot & Microservices

1. Spring Boot Fundamentals – Auto-configuration, Starters, Properties, Profiles
2. Spring Boot Actuator & Monitoring – Health, Metrics, Logging, Micrometer integration
3. Spring Boot Testing – Unit tests, Integration tests, @MockBean, @WebMvcTest
4. REST API Design – Exception handling, HATEOAS, versioning, pagination, performance
5. Spring Boot Microservices – Service discovery (Eureka), REST clients (Feign, RestTemplate), Circuit breakers, Resilience4J
6. Event-driven Microservices – Kafka/RabbitMQ integration, Async processing
7. Security & Production Hardening – JWT, OAuth2, rate-limiting, request validation, logging

Section 1: Java Basics​

Q1: What are the main features of Java? Answer: Java is platform-independent, object-oriented, secure, robust, multi-threaded, and supports automatic memory management. It runs on the JVM, making it “write once, run anywhere.” Tip: Always mention strong typing and backward compatibility when discussing features in interviews.

Q2: Difference between JDK, JRE, and JVM? Answer:

• JDK: Java Development Kit – tools for development (javac, jar).
• JRE: Java Runtime Environment – JVM + standard libraries, for running Java apps.
• JVM: Java Virtual Machine – runs bytecode, handles memory, class loading, and garbage collection.

Q3: How does Java achieve platform independence? Answer: Java compiles source code into bytecode, which the JVM interprets or JIT-compiles on any platform.

Q4: Explain the difference between primitive and reference types. Answer: Primitives store actual values, have fixed memory, and are faster. References point to objects in the heap. Example:

int x = 10;          // primitive
String s = "Java";   // reference

Q5: What are wrapper classes and autoboxing? Answer: Wrapper classes (Integer, Double) allow primitives to be used as objects. Autoboxing automatically converts primitives to wrapper objects and vice versa.

Integer x = 10;      // autoboxing
int y = x;           // unboxing

Section 2: Object-Oriented Programming (OOP)​

Q6: Explain the four pillars of OOP in Java. Answer:

• Encapsulation: Hide data using private fields and getters/setters.
• Inheritance: Reuse and extend classes.
• Polymorphism: Ability to take multiple forms (method overloading & overriding).
• Abstraction: Hide implementation details using abstract classes or interfaces.

Q7: Difference between abstract class and interface? Answer:

• Abstract class: Can have fields, concrete & abstract methods, single inheritance.
• Interface: Only method signatures (Java 8+ supports default/static methods), multiple inheritance allowed. Tip: Mention interfaces for designing flexible APIs.

Q8: Explain method overloading vs overriding. Answer:

• Overloading: Same method name, different parameters. Compile-time polymorphism.
• Overriding: Subclass provides specific implementation for parent method. Runtime polymorphism.

Q9: What is final keyword in Java? Answer: Used to declare constants, prevent method overriding, or class inheritance.

Q10: Difference between == and .equals()? Answer: == compares references; .equals() compares object content (if overridden).

Section 3: Collections Framework​

Q11: Difference between List, Set, Map? Answer:

• List: Ordered, allows duplicates (ArrayList, LinkedList).
• Set: No duplicates, unordered (HashSet, LinkedHashSet, TreeSet).
• Map: Key-value pairs, keys unique (HashMap, TreeMap).

Q12: Difference between ArrayList and LinkedList? Answer:

• ArrayList: Fast random access, slower insert/delete.
• LinkedList: Fast insert/delete, slower random access.

Q13: Explain HashMap internal working. Answer:

• Uses array of buckets + linked lists or tree nodes (Java 8+).
• Key’s hashCode determines bucket. Collisions handled via linked list or red-black tree.

Q14: Difference between HashMap and ConcurrentHashMap? Answer:

• HashMap: Not thread-safe.
• ConcurrentHashMap: Thread-safe, uses lock striping.

Q15: Difference between Comparable and Comparator? Answer:

• Comparable: Implemented by class, natural order (compareTo).
• Comparator: External class, custom ordering (compare).

Q16: Explain fail-fast and fail-safe iterators. Answer:

• Fail-fast: Detects concurrent modification, throws ConcurrentModificationException (ArrayList iterator).
• Fail-safe: Works on copy, doesn’t throw exception (ConcurrentHashMap iterator).

Q17: When to use LinkedHashMap? Answer: When insertion order or access order must be preserved, e.g., LRU cache.

Q18: Difference between TreeMap and HashMap? Answer:

• TreeMap: Sorted by keys, log(n) access, implements NavigableMap.
• HashMap: Unordered, O(1) access.

Section 4: Streams & Functional Programming​

Q19: What is a Stream in Java 8? Answer: A sequence of elements supporting aggregate operations (filter, map, reduce) in a functional style. Streams are lazy and can be parallelized.

Q20: Difference between intermediate and terminal operations? Answer:

• Intermediate: Returns another stream (filter, map) – lazy evaluation.
• Terminal: Produces result (collect, forEach) – triggers processing.

Q21: Example of parallel stream.

List<Integer> nums = Arrays.asList(1,2,3,4,5);
int sum = nums.parallelStream().mapToInt(Integer::intValue).sum();

Q22: Functional interfaces in Java 8? Answer: Predicate, Function, Consumer, Supplier, UnaryOperator, BinaryOperator. Tip: Prepare examples of lambda usage in interviews.

Q23: Method references example.

List<String> names = Arrays.asList("Alice","Bob");
names.forEach(System.out::println);

Section 5: Concurrency & Multithreading​

Q24: Difference between process and thread? Answer:

• Process: Independent, own memory, heavyweight.
• Thread: Lightweight, shares process memory, faster communication.

Q25: How do you create a thread in Java?

// Extend Thread
class MyThread extends Thread {
    public void run() { System.out.println("Running"); }
}
// Implement Runnable
class MyTask implements Runnable {
    public void run() { System.out.println("Task"); }
}

Q26: What is thread safety? Answer: Multiple threads accessing shared resources without causing inconsistent state. Achieved via synchronized blocks, locks, atomic classes.

Q27: Explain volatile keyword. Answer: Ensures visibility of changes to variables across threads; doesn’t guarantee atomicity.

Q28: Difference between synchronized and ReentrantLock? Answer:

• synchronized: Simpler, intrinsic lock, no tryLock.
• ReentrantLock: More flexible, supports tryLock, fairness, multiple conditions.

Q29: Explain ExecutorService usage.

ExecutorService executor = Executors.newFixedThreadPool(5);
executor.submit(() -> System.out.println("Task executed"));
executor.shutdown();

Q30: Difference between Callable and Runnable? Answer:

• Runnable: Returns nothing, cannot throw checked exceptions.
• Callable: Returns value, can throw exception, used with Future.

Section 6: JVM Internals & Memory Management​

Q31: Explain JVM memory model. Answer:

• Heap: Objects, GC-managed.
• Stack: Method calls, local primitives.
• Method area: Class metadata, constants.
• PC Register & Native method stack: Thread execution and native code.

Q32: What is garbage collection (GC)? Answer: Automatic memory cleanup for unreachable objects. Main collectors: Serial, Parallel, CMS, G1.

Q33: Difference between minor and major GC? Answer:

• Minor GC: Cleans young generation. Fast.
• Major/Full GC: Cleans old generation. Expensive.

Q34: Explain strong, weak, soft, phantom references. Answer: Used to control object reachability and GC behavior. Example: WeakHashMap uses weak keys.

Q35: What is JVM tuning? Answer: Adjusting heap size, GC strategy, thread stack size for performance-critical applications.

Section 7: Design Patterns​

Q36: Explain Singleton pattern and its thread-safe implementation.

public class Singleton {
    private static volatile Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized(Singleton.class) {
                if (instance == null) instance = new Singleton();
            }
        }
        return instance;
    }
}

Q37: Builder pattern use-case.

public class User {
    private String name; private int age;
    private User(Builder b) { name = b.name; age = b.age; }
    public static class Builder {
        private String name; private int age;
        public Builder setName(String name){ this.name=name; return this; }
        public Builder setAge(int age){ this.age=age; return this; }
        public User build(){ return new User(this); }
    }
}

Q38: Factory pattern example.

interface Shape { void draw(); }
class Circle implements Shape { public void draw() { System.out.println("Circle"); } }
class ShapeFactory {
    public static Shape getShape(String type) {
        if(type.equals("circle")) return new Circle();
        return null;
    }
}

Q39: Observer pattern scenario. Used in event-driven systems: listeners notify subscribers of changes (e.g., stock price updates).

Q40: Strategy pattern use-case. Used to define algorithms that can be swapped at runtime (e.g., payment gateway selection).

Section 8: Advanced Java Concepts

Q41: What is Reflection in Java and when is it used? Answer: Reflection allows inspection and manipulation of classes, methods, fields, and constructors at runtime. Useful in frameworks like Spring for dependency injection and testing. Example:

Class<?> clazz = Class.forName("com.example.MyClass");
Method m = clazz.getMethod("myMethod");
m.invoke(clazz.getDeclaredConstructor().newInstance());

Pitfall: Reflection bypasses compile-time checks and can impact performance.

Q42: Explain Generics in Java. Why are they important? Answer: Generics provide type safety at compile-time and reduce casting.

List<String> names = new ArrayList<>();
names.add("Alice"); // type-safe

Without generics, you’d need casts which are error-prone.

Q43: Difference between checked and unchecked exceptions? Answer:

• Checked: Must be declared or caught (IOException).
• Unchecked: Runtime exceptions, can be ignored (NullPointerException).

Q44: Explain Java Annotations and custom annotation example. Answer: Annotations provide metadata for classes, methods, or fields.

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface LogExecutionTime {}

Tip: Explain usage in Spring AOP and validation.

Q45: Serialization and deserialization in Java? Answer: Serialization converts objects to bytes for storage or network transfer. Must implement Serializable. Deserialization reconstructs the object. Pitfall: Always manage serialVersionUID to avoid version mismatch.

Q46: Difference between == and equals() in Collections context? Answer: Hash-based collections use hashCode() and equals() to store and retrieve objects. Implement both properly to avoid incorrect behavior in HashMap or HashSet.

Q47: Explain Optional in Java 8+. Answer: Optional prevents NullPointerException by explicitly representing absence of value.

Optional<String> name = Optional.ofNullable(getName());
name.ifPresent(System.out::println);

Q48: Difference between String, StringBuilder, and StringBuffer? Answer:

• String: Immutable, slower for concatenation.
• StringBuilder: Mutable, not thread-safe, fast.
• StringBuffer: Mutable, thread-safe, slower than StringBuilder.

Q49: What are lambda expressions and why are they used? Answer: Provide a concise way to represent functional interfaces. Reduce boilerplate and enhance readability.

List<Integer> nums = Arrays.asList(1,2,3);
nums.forEach(n -> System.out.println(n));

Q50: Explain method references and constructor references.

// Method reference
List<String> names = Arrays.asList("Alice","Bob");
names.forEach(System.out::println);

// Constructor reference
Supplier<List<String>> listSupplier = ArrayList::new;

Section 9: I/O & NIO​

Q51: Difference between FileReader/FileWriter and BufferedReader/BufferedWriter? Answer: Buffered classes wrap basic readers/writers to improve performance with internal buffers.

Q52: What is Java NIO? Answer: New I/O provides non-blocking, channel-based API. Useful for high-performance network/server applications.

Q53: Explain Channels and Buffers. Answer:

• Buffer: Container for data.
• Channel: Connection to I/O device, reads/writes buffers efficiently.

Q54: Example of reading a file using NIO.

Path path = Paths.get("file.txt");
List<String> lines = Files.readAllLines(path);

Section 10: Exception Handling​

Q55: Difference between throw and throws? Answer:

• throw: Used to throw an exception object.
• throws: Declares exceptions a method may throw.

Q56: How does try-with-resources work? Answer: Automatically closes resources implementing AutoCloseable.

try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    System.out.println(br.readLine());
}

Q57: Explain custom exception creation.

class MyException extends Exception {
    public MyException(String message) { super(message); }
}

Tip: Useful to convey domain-specific errors in enterprise applications.

Section 11: Advanced Concurrency​

Q58: Explain CountDownLatch and CyclicBarrier.

• CountDownLatch: One-time countdown to start or end threads.
• CyclicBarrier: Reusable barrier for threads to wait until all reach a point.

Q59: Difference between Semaphore and ReentrantLock.

• Semaphore controls permits for resources.
• ReentrantLock is exclusive lock with more flexibility.

Q60: Explain ThreadLocal. Stores thread-specific variables, useful for per-thread DB connections or user context.

Q61: What are atomic classes? Classes like AtomicInteger provide lock-free thread-safe operations. Example:

AtomicInteger counter = new AtomicInteger(0);
counter.incrementAndGet();

Q62: Executors vs Thread creation? Executors manage thread pool, avoid creating excessive threads manually, control lifecycle, and allow scheduling.

Section 12: Remaining Design Patterns​

Q63: Prototype pattern example. Used to clone objects efficiently.

public class Prototype implements Cloneable {
    public Prototype clone() throws CloneNotSupportedException {
        return (Prototype) super.clone();
    }
}

Q64: Adapter pattern use-case. Converts interface of one class to another expected by client. Example: Integrating legacy payment system with modern interface.

Q65: Facade pattern example. Provides simplified interface over complex subsystem. Example: Spring’s JdbcTemplate abstracts JDBC complexity.

Q66: Decorator pattern scenario. Enhances functionality dynamically (e.g., InputStream decorators like BufferedInputStream, DataInputStream).

Q67: Chain of Responsibility pattern. Used in request processing chains, e.g., Spring MVC HandlerInterceptor chain.

Q68: Command pattern example. Encapsulates request as object. Used in task scheduling and undo operations.

Q69: Observer vs EventListener in Java. Observer: classic pattern. EventListener: Java-specific interface for GUI or event-driven programming.

Q70: Strategy vs Template Method. Strategy: runtime behavior swapping. Template: fixed steps with customizable hooks.

Section 13: Java 8+ Features​

Q71: Stream reduction and collect example.

List<Integer> nums = Arrays.asList(1,2,3,4);
int sum = nums.stream().reduce(0, Integer::sum);
List<String> names = Stream.of("Alice","Bob").collect(Collectors.toList());

Q72: Optional chaining example.

Optional<User> user = findUser();
String email = user.map(User::getEmail).orElse("notfound@example.com");

Q73: Default methods in interfaces.

interface Logger {
    default void log(String msg) { System.out.println(msg); }
}

Q74: Java 9 Modules – purpose? Encapsulation of packages and better dependency control for large applications.

Q75: Var keyword in Java 10. Type inference for local variables.

Q76: Record classes in Java 16+. Compact immutable data carriers.

record User(String name, int age) {}

Q77: Sealed classes (Java 17). Restrict subclassing for better maintainability.

Q78: Pattern matching with instanceof.

if(obj instanceof String s) {
    System.out.println(s.length());
}

Q79: Text blocks (Java 15). Multi-line string literals:

String html = """
    <html>
        <body>Hello</body>
    </html>
""";

Q80: Records + Streams combined example.

List<User> users = List.of(new User("Alice",25), new User("Bob",30));
List<String> names = users.stream().map(User::name).collect(Collectors.toList());

Section 1: Dependency Injection (DI)​

Q1: What is Dependency Injection and why is it important? Answer: DI decouples object creation from usage. It promotes loose coupling, easier testing, and maintainability. Spring supports:

• Constructor injection: Preferred for mandatory dependencies.
• Setter injection: Optional dependencies.
• Field injection: Quick, but harder to test.

Example:

@Service
public class OrderService {
    private final PaymentService paymentService;

    @Autowired
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

Tip: Always explain trade-offs and testing implications.

Q2: Difference between @Component, @Service, @Repository, @Controller?

• @Component: Generic stereotype.
• @Service: Business logic layer.
• @Repository: Data access, converts SQL exceptions to Spring exceptions.
• @Controller: Presentation layer for MVC web apps.

Q3: Bean scopes in Spring?

• Singleton: One instance per container (default).
• Prototype: New instance each injection.
• Request: Per HTTP request.
• Session: Per HTTP session.
• Application: Global per ServletContext.

Q4: Lazy vs Eager initialization?

• Eager: Instantiated at startup.
• Lazy: Instantiated when first requested. Useful for optimizing startup time.

Section 2: Spring Bean Lifecycle​

Q5: How does Spring manage bean lifecycle?

• Instantiation → Dependency Injection → Post-construct initialization → Ready → Pre-destroy → Destruction.
• Key interfaces: InitializingBean, DisposableBean, BeanPostProcessor, @PostConstruct, @PreDestroy.

Q6: Explain circular dependency resolution in Spring.

• Spring can resolve circular dependencies for singleton beans via setter injection but not with constructor injection.
• Real-world scenario: Two services referencing each other must use setter injection to avoid BeanCurrentlyInCreationException.

Section 3: Aspect-Oriented Programming (AOP)​

Q7: What is AOP and why is it used?

• Separates cross-cutting concerns like logging, security, and transactions.
• Key annotations: @Aspect, @Before, @After, @Around, @AfterReturning, @AfterThrowing.

Q8: Example: Logging method execution time

@Aspect
@Component
public class LoggingAspect {
    @Around("@annotation(LogExecutionTime)")
    public Object logTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        System.out.println("Execution time: " + (System.currentTimeMillis() - start) + "ms");
        return result;
    }
}

Tip: In interviews, explain proxy-based implementation (JDK vs CGLIB).

Q9: Difference between @Aspect and BeanPostProcessor

• AOP: Dynamic proxies for method interception.
• BeanPostProcessor: Hook into bean initialization lifecycle. Both can handle cross-cutting logic, but use-case differs.

Section 4: Spring MVC​

Q10: Explain Spring MVC architecture.

• DispatcherServlet → Controllers → Services → Repositories → View Resolver.
• Handles request mapping, validation, and response rendering.

Q11: Difference between @Controller and @RestController

• @Controller: Returns view names, requires @ResponseBody for JSON.
• @RestController: Implicitly adds @ResponseBody, used for REST APIs.

Q12: How does Spring handle form validation?

• Use @Valid or @Validated on request objects with JSR-303 annotations like @NotNull, @Size.
• Example:

@PostMapping("/create")
public ResponseEntity<?> createUser(@Valid @RequestBody UserDto user, BindingResult result) {
    if(result.hasErrors()) return ResponseEntity.badRequest().body(result.getAllErrors());
    return ResponseEntity.ok(userService.create(user));
}

Q13: Explain path variables and request params.

@GetMapping("/users/{id}")
public User getUser(@PathVariable Long id, @RequestParam(required=false) String filter) { }

Q14: Exception handling in Spring MVC

• Use @ControllerAdvice with @ExceptionHandler to centralize exception handling.

Section 5: Spring Data JPA​

Q15: What is Spring Data JPA?

• Simplifies repository layer using JpaRepository or CrudRepository.
• Provides methods like save(), findAll(), deleteById() automatically.

Q16: Custom queries using @Query

@Query("SELECT u FROM User u WHERE u.age > :age")
List<User> findUsersOlderThan(@Param("age") int age);

Q17: Transaction management

• Use @Transactional. Key attributes: propagation, isolation, readOnly.
• Pitfall: Avoid transactional methods calling private methods (self-invocation bypasses proxy).

Q18: Difference between save() and saveAndFlush()

• save(): Persist entity, may delay flush.
• saveAndFlush(): Immediately flush to DB.

Q19: Lazy vs Eager fetching

• Lazy: Loaded on demand, avoids unnecessary queries.
• Eager: Loaded immediately, may lead to performance issues.
• Interview Tip: Explain N+1 problem and solution with @EntityGraph.

Section 6: Spring Security​

Q20: How does Spring Security work?

• Filters authenticate requests, authorize based on roles, secure endpoints, support OAuth2/JWT.
• Core components: AuthenticationManager, UserDetailsService, PasswordEncoder.

Q21: Example: Securing REST APIs with JWT

• Authenticate → generate JWT → send to client → validate JWT in filter for each request.

Q22: Password encoding

@Bean
public PasswordEncoder passwordEncoder() {
    return new BCryptPasswordEncoder();
}

Q23: Role-based vs Method-level security

• @PreAuthorize("hasRole('ADMIN')") for method-level access control.
• Pitfall: Always encode passwords, avoid storing plain text.

Section 7: Event-Driven Design in Spring​

Q24: How does Spring handle events?

• Use ApplicationEventPublisher and @EventListener.
• Example:

@Component
public class OrderPublisher {
    @Autowired ApplicationEventPublisher publisher;
    public void publish(Order order) {
        publisher.publishEvent(new OrderCreatedEvent(this, order));
    }
}
@Component
public class OrderListener {
    @EventListener
    public void handle(OrderCreatedEvent event) { /* send notification */ }
}

Q25: Asynchronous events

• Annotate listener with @Async and configure TaskExecutor for non-blocking processing.

Q26: Difference between synchronous and asynchronous events

• Synchronous: Listener executes in same thread.
• Asynchronous: Executes in separate thread, better for decoupling and performance.

Section 8: Spring Best Practices & Pitfalls​

1. Prefer constructor injection over field injection.
2. Avoid circular dependencies; use setter injection or @Lazy.
3. Keep services stateless for thread safety.
4. Use @Transactional carefully; understand propagation and rollback rules.
5. Always handle exceptions centrally with @ControllerAdvice.
6. Avoid eager loading large associations in entities; prefer DTOs or projections.

Section 1: Spring Boot Fundamentals​

Q1: What is Spring Boot and why use it? Answer: Spring Boot simplifies Spring application setup by providing auto-configuration, embedded servers, opinionated defaults, and production-ready features. It reduces boilerplate and accelerates microservice development.

Q2: Explain auto-configuration in Spring Boot.

• Spring Boot detects classes on the classpath and configures beans automatically.
• Example: spring-boot-starter-web automatically sets up DispatcherServlet, Jackson, and embedded Tomcat.
• Pitfall: Conflicting dependencies can lead to unexpected bean creation.

Q3: What are Spring Boot Starters?

• Predefined dependencies that simplify setup.
• Examples: spring-boot-starter-web, spring-boot-starter-data-jpa, spring-boot-starter-security.

Q4: Profiles in Spring Boot

• Support environment-specific configuration (application-dev.yml, application-prod.yml).
• Activate via spring.profiles.active=dev.

Q5: Difference between @SpringBootApplication and @EnableAutoConfiguration

• @SpringBootApplication combines: @Configuration, @EnableAutoConfiguration, @ComponentScan.

Section 2: Spring Boot Actuator & Monitoring​

Q6: What is Spring Boot Actuator?

• Provides production-ready endpoints to monitor and manage applications.
• Common endpoints: /health, /metrics, /env, /loggers.

Q7: How to customize actuator endpoints?

management:
  endpoints:
    web:
      exposure:
        include: health, metrics, beans

Q8: Integrating with Prometheus & Grafana

• Expose /actuator/prometheus and configure Prometheus to scrape metrics.
• Pitfall: Avoid exposing sensitive endpoints in production.

Section 3: Spring Boot Testing​

Q9: Types of Spring Boot tests

• Unit Tests: Test classes in isolation using JUnit + Mockito.
• Integration Tests: @SpringBootTest loads context for real interactions.
• Web Layer Tests: @WebMvcTest for controller testing.

Q10: Example – Unit Test with MockBean

@SpringBootTest
class OrderServiceTest {
    @MockBean
    PaymentService paymentService;
    
    @Autowired
    OrderService orderService;
    
    @Test
    void processOrder() {
        Mockito.when(paymentService.pay()).thenReturn(true);
        assertTrue(orderService.processOrder());
    }
}

Q11: Test tips for interviews

• Always isolate external dependencies.
• Use @DataJpaTest for repository testing.
• Cover both positive and negative scenarios.

Section 4: REST API Design & Best Practices​

Q12: Key principles

• Use proper HTTP verbs (GET, POST, PUT, DELETE).
• Resource-based URIs: /users/{id}/orders.
• Versioning: /api/v1/users.
• Consistent error handling with @ControllerAdvice.

Q13: Pagination & Sorting

Page<User> findAll(Pageable pageable);

Q14: HATEOAS (optional)

• Add hypermedia links to REST responses to guide clients.

Q15: Security considerations

• Validate input, use DTOs instead of entities, encode passwords, avoid exposing sensitive fields.

Section 5: Spring Boot Microservices​

Q16: What is a microservice?

• Small, independently deployable service, focused on a single business capability.
• Benefits: Scalability, decoupling, maintainability.

Q17: Key Spring Cloud tools

• Service Discovery: Eureka
• Configuration: Spring Cloud Config
• API Gateway: Spring Cloud Gateway
• Circuit Breaker: Resilience4J

Q18: Example – Service Discovery with Eureka

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication { }

• Microservice registers itself with Eureka using @EnableEurekaClient.

Q19: Inter-service communication

• REST (RestTemplate, WebClient)
• Feign Client: Declarative REST

@FeignClient(name="payment-service")
public interface PaymentClient {
    @GetMapping("/pay")
    boolean pay();
}

Q20: Circuit breaker example (Resilience4J)

@CircuitBreaker(name="paymentService", fallbackMethod="fallbackPay")
public boolean pay() { ... }
public boolean fallbackPay(Throwable t) { return false; }

Section 6: Event-Driven Microservices​

Q21: Why event-driven?

• Decouples services, improves scalability, ensures eventual consistency.

Q22: Spring + Kafka example

// Producer
@Autowired KafkaTemplate<String, Order> kafkaTemplate;
kafkaTemplate.send("orders", order);

// Consumer
@KafkaListener(topics="orders")
public void consume(Order order) { process(order); }

Q23: Async processing

• Use @Async with ThreadPoolTaskExecutor for non-blocking execution.
• Pitfall: Thread pools must be tuned for load; unbounded threads can crash services.

Section 7: Security in Microservices​

Q24: JWT Authentication

• Stateless, signed token containing user info and roles.
• Example flow: Login → generate JWT → client sends in Authorization: Bearer header → validate JWT in filter.

Q25: OAuth2 & OpenID Connect

• Used for SSO and token-based authentication.
• Pitfall: Never trust client-side tokens without validation.

Q26: Securing endpoints

http
  .authorizeHttpRequests(auth -> auth
      .requestMatchers("/admin/**").hasRole("ADMIN")
      .anyRequest().authenticated())
  .oauth2ResourceServer().jwt();

Section 8: Production & Performance Best Practices​

1. Keep services stateless.
2. Externalize configuration using Spring Cloud Config.
3. Enable logging and monitoring (Actuator + Prometheus).
4. Tune JVM and thread pools for high throughput.
5. Use DTOs, avoid lazy-loading pitfalls across microservice boundaries.
6. Apply caching (Redis, Caffeine) for frequently accessed data.
7. Implement retries, rate-limiting, and fallback strategies for resilience.