DEV Community: Tapas Pal

Functional Interface in Java

Tapas Pal — Sat, 06 Jun 2026 22:10:34 +0000

package programs;

import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Stream;

public class ContainsDuplicate {

    public static void main(String[] args) {
        List<Integer> arr = Arrays.asList(1,2,3,1,2);
        Map<Integer,Integer> map = new LinkedHashMap<>();

        for (int i = 0; i < arr.size(); i++) {
                map.put(arr.get(i), map.getOrDefault(arr.get(i), 0) + 1);
        }
        System.out.println(map.keySet()+"<value>"+map.values());
        System.out.println(map.entrySet());
        map.entrySet().stream()
                .filter(x -> x.getValue() > 1)
                .forEach(entry ->
                        System.out.println("Key->"+entry.getKey()+"::Value"+entry.getValue()));
        System.out.println("-------------------------------");
        map.entrySet().stream()
                .filter(new Predicate<Map.Entry<Integer, Integer>>() {
                    @Override
                    public boolean test(Map.Entry<Integer, Integer> integerIntegerEntry) {
                        return integerIntegerEntry.getValue() > 1;
                    }
                })
                .forEach(new Consumer<Map.Entry<Integer, Integer>>() {
                    @Override
                    public void accept(Map.Entry<Integer, Integer> integerIntegerEntry) {
                        System.out.println("Key->" + integerIntegerEntry.getKey()
                                + "::Value" + integerIntegerEntry.getValue());
                    }
                });
        System.out.println("----------Supplier---------------------");
        Supplier<Integer> supplier = new Supplier<Integer>() {
            @Override
            public Integer get() {
                return 10;
            }
        };

        Stream.generate(supplier)
                .limit(5)
                .forEach(System.out::println);

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

        String value = name.orElseGet(new Supplier<String>() {
            @Override
            public String get() {
                return "Unknown";
            }
        });
        System.out.println("----------Function---------------------");
        arr.stream().map(new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer integer) {
                return integer+2;
            }
        }).forEach(System.out::println);
        ////////
        map.entrySet().stream().map(new Function<Map.Entry<Integer, Integer>, Integer>() {
            @Override
            public Integer apply(Map.Entry<Integer, Integer> integerIntegerEntry) {
                return integerIntegerEntry.getValue();
            }
        }).forEach(System.out::println);
    }


}

7. Hibernate Spring Data JPA Q & A

Tapas Pal — Tue, 02 Jun 2026 22:16:01 +0000

6. Java new Features

Tapas Pal — Tue, 02 Jun 2026 22:15:27 +0000

**5. Java 25 LTS new Features**   -  September 2025

**4. Java 21 LTS new Features**   -  September 2023

**3. Java 17 LTS new Features**   -  September 2021

**2. Java 11 LTS new Features**   -  September 2018

**1. Java 8 LTS new Features**    -  March 2014

Lambda Expressions, a new language feature, has been introduced in this release. They enable you to treat functionality as a method argument, or code as data. Lambda expressions let you express instances of single-method interfaces (referred to as functional interfaces) more compactly.
Method references provide easy-to-read lambda expressions for methods that already have a name.
Default methods enable new functionality to be added to the interfaces of libraries and ensure binary compatibility with code written for older versions of those interfaces.
Repeating Annotations provide the ability to apply the same annotation type more than once to the same declaration or type use.
Type Annotations provide the ability to apply an annotation anywhere a type is used, not just on a declaration. Used with a pluggable type system, this feature enables improved type checking of your code.
Improved type inference.
Method parameter reflection.

Collections

Classes in the new java.util.stream package provide a Stream API to support functional-style operations on streams of elements. The Stream API is integrated into the Collections API, which enables bulk operations on collections, such as sequential or parallel map-reduce transformations.
Performance Improvement for HashMaps with Key Collisions

Concurrency

Classes and interfaces have been added to the java.util.concurrent package.
Methods have been added to the java.util.concurrent.ConcurrentHashMap class to support aggregate operations based on the newly added streams facility and lambda expressions.
Classes have been added to the java.util.concurrent.atomic package to support scalable updatable variables.
Methods have been added to the java.util.concurrent.ForkJoinPool class to support a common pool.
The java.util.concurrent.locks.StampedLock class has been added to provide a capability-based lock with three modes for controlling read/write access.

5. Collections Q & A

Tapas Pal — Tue, 02 Jun 2026 22:15:14 +0000

4. Thread and Concurrency Q & A

Tapas Pal — Tue, 02 Jun 2026 22:14:49 +0000

3. Junit 5 Interview Q&A

Tapas Pal — Tue, 02 Jun 2026 22:14:22 +0000

2. Spring Boot Q & A

Tapas Pal — Tue, 02 Jun 2026 22:14:05 +0000

1. Demystifying Comparable Vs Comparator

Tapas Pal — Tue, 02 Jun 2026 22:13:30 +0000

Q1. Difference between Comparable and comparator

Comparable = "How should this object normally be sorted?"
Comparator = "How do I want to sort it right now?"

public class Employee implements Comparable<Employee> {

    private int id;
    private String name;
    private double salary;

    public Employee(int id, String name, double salary) {
        this.id = id;
        this.name = name;
        this.salary = salary;
    }

    @Override
    public int compareTo(Employee other) {
        return Integer.compare(this.id, other.id);
    }

    @Override
    public String toString() {
        return id + " " + name;
    }
}

Output:

101 Tom
102 David
103 John

Because the class itself says:
compareTo() => sort by id

This becomes the natural ordering.
Why Comparable Can Become a Problem
Imagine HR wants:
Sort by salary
Finance wants:
Sort by employee id
Manager wants:
Sort by name

With Comparable you can only have ONE natural ordering.
You cannot implement:
compareToBySalary() compareToByName() compareToByDepartment()
Only one compareTo() exists.
That's where Comparator comes in.

Comparator - Sort by salary:

employees.sort(
    Comparator.comparing(Employee::getSalary)
);

Sort by name:

employees.sort(
    Comparator.comparing(Employee::getName)
);

Sort by id descending:

employees.sort(
    Comparator.comparing(Employee::getId)
              .reversed()
);

No need to modify Employee class.

Sort by age then name

employees.sort(
        Comparator.comparing(Employee::getAge)
                  .thenComparing(Employee::getName)
);

What Happens Internally?
Comparable:

Collections.sort(list);

Java internally calls:

obj1.compareTo(obj2);

Comparator:

Collections.sort(list, comparator);

Java internally calls:

comparator.compare(obj1, obj2);

Why? if I use Comparator it does not require to implement compare() in the Employee class but if I use Comparable interface I need to override compareTo method?

Comparable = Object Knows How To Compare Itself

public class Employee
        implements Comparable<Employee> {

    @Override
    public int compareTo(Employee other) {
        return Integer.compare(this.id, other.id);
    }
}

you are telling Java:
Every Employee knows how to compare itself with another Employee.
Then Java can do:
e1.compareTo(e2);
because the method exists inside Employee.
Comparator = Separate Comparison Object

No Comparable. No compareTo().
Now you write:

Comparator<Employee> comparator =
        Comparator.comparing(Employee::name);

Java now has an external object:

Comparator<Employee>
whose job is: compare(e1, e2)
The comparison logic is no longer inside Employee.
Why Employee Doesn't Need to Implement Comparator
Because Comparator is not part of Employee.

Comparator<Employee> byName =
        Comparator.comparing(Employee::name);

Comparator<Employee> bySalary =
        Comparator.comparing(Employee::salary);

Now you have two different comparison strategies.
Employee remains unchanged.
Why We Rarely Do This
Technically you can write:

public class Employee
        implements Comparator<Employee> {

    @Override
    public int compare(Employee e1,
                       Employee e2) {
        return e1.id - e2.id;
    }
}

But this is bad design.
Now Employee is:
An employee AND A comparison engine
Two responsibilities.
Violates the Single Responsibility Principle.

If String implementation it is using "Tom".compareTo("John") then how we able to sort List? where do it iterate ?

You write:

employees.sort( Comparator.comparing(Employee::name));

and wonder:
If Java is doing "Tom".compareTo("John"), who is iterating through the List?
The answer is:
The sorting algorithm inside List.sort() **(TimSort in modern Java) **iterates through the list and repeatedly calls the comparator.

Step 1: Your List
Suppose:

List<Employee> employees = List.of(
    new Employee(101, "Tom", 70000),
    new Employee(102, "David", 80000),
    new Employee(103, "John", 90000)
);

Initial:
[Tom, David, John]

Step 2: Create Comparator
This: Comparator.comparing(Employee::name)
creates something similar to:

Comparator<Employee> comparator =
    (e1, e2) -> e1.name().compareTo(e2.name());

Step 3: Java Starts Sorting
When you call: employees.sort(comparator);
Java internally does something like:
TimSort.sort(employees, comparator);
You don't see this code, but the sorting algorithm repeatedly asks:
comparator.compare(e1, e2)

Step 4: Actual Comparisons
Suppose the algorithm picks:

Employee(101, "Tom")
Employee(102, "David")
and calls:
comparator.compare(tom, david);
which executes:

tom.name().compareTo(david.name())

becomes: "Tom".compareTo("David")
Result:
positive number
Meaning: Tom should come after David
Next comparison: comparator.compare(tom, john);
becomes: "Tom".compareTo("John")
Result: positive number
Meaning: Tom should come after John

Next comparison:
comparator.compare(david, john);
becomes: "David".compareTo("John")
Result: negative number
Meaning: David should come before John

Final order:
David
John
Tom
Important Point - You are NOT iterating.
You only provide: Comparator
Java's sorting algorithm does the iteration.

Think of it like this:
You:
Here is the rule for comparing employees.
Java:
Thanks. I'll repeatedly apply that rule
while rearranging the list.
Similar to Collections.sort()

When you write:
Collections.sort(employees, comparator);
internally Java does something similar to:

for (...) {
    if (comparator.compare(a, b) > 0) {
        swap(a, b);
    }
}

The real algorithm is TimSort (much more sophisticated), but conceptually it's repeatedly:
compare()
compare()
compare()
compare()
swap()
compare()
...
How Many Times Is compare() Called?
For 3 employees:
Tom
David
John
you might see:

Comparator<Employee> comparator =
    (e1, e2) -> {
        System.out.println(
            "Comparing " + e1.name()
            + " and "
            + e2.name()
        );
        return e1.name().compareTo(e2.name());
    };

Output could be:

Comparing David and Tom
Comparing John and David
Comparing John and Tom
Comparing John and David

Notice:
Java chooses which elements to compare.
The sorting algorithm controls the iteration.
Your comparator only provides the comparison logic.
Senior Developer Mental Model

When you write:

Comparator.comparing(Employee::name)
think of it as generating:

(Employee e1, Employee e2)
    -> e1.name().compareTo(e2.name())

Then: employees.sort(...)

means:
Java sorting algorithm
+
Your comparison rule
=
Sorted list

The iteration is performed by the sorting algorithm (TimSort), not by Comparator, Comparable, or your Employee class.

VERY IMPORTANT OBSERVATION - DEEP DRIVE

my 
List<Employee> employees = new java.util.ArrayList<>(List.of(
                new Employee(103, "John", 90000),
                new Employee(101, "Tom", 70000),
                new Employee(104, "Tom", 80000),
                new Employee(102, "David", 80000)
        ));
and 
employees.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee o1, Employee o2) {
                System.out.println(
                        "Comparing " + o1.name()
                                + " and "
                                + o2.name()
                );
                return o1.name().compareTo(o2.name());
            }
        });
It prints : But why?
Comparing Tom and John
Comparing Tom and Tom
Comparing David and Tom
Comparing David and Tom
Comparing David and John

*This is a fantastic observation because it reveals how Java's sorting algorithm works.
*
Your list is:

[
    John,
    Tom,
    Tom,
    David
]

and your comparator prints:

Comparing Tom and John
Comparing Tom and Tom
Comparing David and Tom
Comparing David and Tom
Comparing David and John

You expected something like:

John vs Tom
Tom vs Tom
Tom vs David
...

but sorting algorithms do not compare elements in a simple left-to-right order.

What's Actually Happening?
When you call: employees.sort(comparator);
Java uses TimSort (since Java 7).

TimSort is:
Stable
Optimized for partially sorted data
Not a simple bubble sort

Therefore:

You should never assume the order of compare() calls.
The sorting algorithm decides:
Which elements to compare
How many times to compare
Whether to compare the same elements again

Let's Analyze Your Output
Initial list:

Index 0 -> John
Index 1 -> Tom
Index 2 -> Tom
Index 3 -> David

Comparison 1
Comparing Tom and John
Internally: "Tom".compareTo("John")
Result: positive
Meaning: Tom should come after John

Comparison 2
Comparing Tom and Tom
Second Tom compared with first Tom.
"Tom".compareTo("Tom")
Result: 0
Meaning: equal

Comparison 3
Comparing David and Tom
"David".compareTo("Tom")
Result: negative
Meaning: David comes before Tom

Comparison 4
Comparing David and Tom
Again!
Many developers find this surprising.
But sorting algorithms often compare the same elements multiple times.
There is no guarantee: compare(a,b) called only once

In fact:
compare(a,b)
compare(a,b)
compare(a,b)

can happen.
This is why comparators must be:

Pure
Stateless
No side effects

Comparison 5
Comparing David and John
"David".compareTo("John")
Result: negative
Meaning: David comes before John

Final Sorted List

David
John
Tom
Tom

Why Doesn't Java Compare Every Pair?
Many people think sorting does:

John vs Tom
John vs Tom
John vs David
Tom vs Tom
Tom vs David
Tom vs David

like a nested loop.
That would be: O(n²)
Java's TimSort is much smarter.

It attempts to discover ordered runs and merge them efficiently.
Therefore:
The compare sequence is implementation detail.
Very Important Interview Point
You should NEVER write logic like:

Comparator<Employee> comparator =
        new Comparator<>() {
            int count = 0;
            @Override
            public int compare(Employee e1,
                               Employee e2) {
                count++;
                if (count == 3) {
                    return 0;
                }
                return e1.name()
                        .compareTo(e2.name());
            }
        };

because Java may call:
compare()
The comparator must always return the same result for the same inputs.
If You Want to See Exactly What Is Being Compared
Add more details:

@Override
public int compare(Employee o1, Employee o2) {

    int result =
            o1.name().compareTo(o2.name());

    System.out.println(
            o1.name()
            + " vs "
            + o2.name()
            + " => "
            + result
    );
    return result;
}

Output:

Tom vs John => 10
Tom vs Tom => 0
David vs Tom => -16
David vs Tom => -16
David vs John => -6

Now you can see why Java is moving elements around.
Senior Developer Takeaway
When using:
Collections.sort(...)
or
List.sort(...)

you should think:
I provide the comparison rule.

Java decides:
- which elements to compare
- how often to compare
- in what order to compare

The sequence of compare() calls is not deterministic API behavior and may even change between Java versions because it depends on the underlying sorting implementation (currently TimSort).
---------------------------------------------------------------

Interview Q & A Non-technical

Tapas Pal — Mon, 01 Jun 2026 23:05:20 +0000

Q1. How do you handle disagreements during design discussions?
Answer:
I focus on technical facts, business requirements, and measurable outcomes rather than personal preferences. I encourage open discussion, present pros and cons of each approach, and support decisions with data, architecture principles, and operational considerations. If needed, I build a proof of concept to validate assumptions before making a final recommendation.

Q2.Have you participated in system design reviews?
Answer:
Yes. I regularly participate in design reviews where we discuss service boundaries, API contracts, database design, security requirements, deployment strategies, scalability concerns, and integration patterns. My role is to identify risks, suggest improvements, and ensure the design aligns with architectural standards and best practices.

Q3. How do you actively participate in architectural and design discussions?
I actively participate by understanding both the business requirements and technical constraints before proposing solutions. During design discussions, I evaluate different approaches, identify trade-offs, consider scalability, security, performance, maintainability, and operational impacts. I collaborate with architects, product owners, QA teams, and other developers to ensure the proposed solution aligns with the existing architecture and long-term business goals

Q4. Can you give an example of an architectural decision you influenced?
In a previous project, a service was making multiple synchronous calls to downstream systems, causing high latency and occasional timeouts. During architecture discussions, I proposed moving to an event-driven approach using Kafka for non-critical processing. We analyzed the trade-offs, updated the design, and implemented asynchronous communication. This reduced API response times significantly and improved system resilience during peak traffic.

(STAR Format)

Situation:
Our order-processing system was experiencing performance issues during peak traffic.

Task:
We needed to improve response times without redesigning the entire platform.

Action:
I analyzed the architecture and identified that synchronous communication with downstream services was causing bottlenecks. Since Kafka was already part of the ecosystem, I proposed an event-driven approach where requests were published to Kafka and processed asynchronously. I documented trade-offs, reviewed the design with architects and stakeholders, and led the implementation.

Result:
API response times decreased from several seconds to under 500 milliseconds, throughput increased significantly, and the solution was implemented without major architectural changes.
-----------------------------------------------------------------

What is Kanban in Agile?

Kanban is an Agile methodology focused on visualizing work, limiting work in progress (WIP), and continuously improving the flow of work.
Unlike Scrum, Kanban does not require fixed-length sprints. Work items are pulled through the system continuously.

When Kanban is Preferred
Kanban works well for:

Support Teams
Production Issues
Bug Fixes
Urgent Requests

Work arrives unpredictably.
-----------------------------------------------------------------

Conduct code reviews and ensure adherence to best practices and coding standards
Interviewers want to know:

How you perform code reviews
What you look for
How you provide feedback
How you maintain coding standards
How you mentor developers

How do you conduct code reviews and ensure adherence to best practices and coding standards?
I treat code reviews as an opportunity to improve code quality, maintainability, security, and team knowledge sharing. During reviews, I focus on correctness, readability, performance, security, test coverage, adherence to coding standards, and alignment with the overall architecture. I provide constructive feedback, explain the reasoning behind my suggestions, and encourage discussions rather than simply approving or rejecting changes. I also ensure that the code follows SOLID principles, clean code practices, and established team guidelines.

What Do You Look For During Code Reviews?

Code Correctness
Readability
SOLID Principles
Performance
Exception Handling
Security
Test Coverage

What coding standards do you enforce?

Meaningful naming conventions
Constructor injection
SOLID principles
Clean Code practices
Proper exception handling
Logging standards
Unit test coverage
Security best practices
Consistent formatting
Avoidance of code duplication

What would you do if a developer disagrees with your review comments?
I would discuss the concern openly and focus on the technical reasoning rather than personal preferences. If there are multiple valid approaches, I would evaluate them based on maintainability, performance, consistency, and team standards. If necessary, I would involve the team or architect to reach a consensus.

--------------------------------------------------------------
Work collaboratively with other teams to ensure seamless integration of software components

How you collaborate across teams
Communication skills
Integration experience
Handling dependencies
Working in Agile environments
Leadership and stakeholder management

I work closely with product owners, architects, QA teams, DevOps engineers, and other development teams from the early stages of a project. I participate in design discussions, define clear API contracts, identify dependencies, and ensure integration requirements are understood by all parties. I also use regular communication channels such as Agile ceremonies, technical workshops, and integration testing sessions to proactively address issues before deployment.

2. Can you give an example of a cross-team integration project?
Sample Answer (STAR)
We were developing an order processing platform that required integration between the Order, Payment, and Customer services owned by different teams.

Task
Ensure all services integrated correctly and met business requirements.

Action
I coordinated API contract discussions, documented integration requirements, defined error-handling strategies, and worked with QA teams to create end-to-end test scenarios. We also established regular integration checkpoints during development.

Result
The integration was completed successfully with minimal defects, and the solution was deployed without impacting existing services.

3. How do you manage dependencies between teams?
I identify dependencies early during backlog refinement, sprint planning, or PI planning sessions. I work with other teams to agree on delivery timelines, API contracts, and testing strategies. I also track dependencies throughout the sprint and communicate any risks or delays proactively to avoid surprises late in the delivery cycle.

4. What do you do when another team's API is not ready?
Strong Answer
I try to avoid blocking development by using mocks, stubs, or contract-based development. For example, if the API specification is available, we can create mock services using tools such as WireMock and continue development while waiting for the actual implementation.

Example:

Order Service
      |
Mock Payment Service

This reduces dependency-related delays.
5. How do you ensure API integrations are successful?
Answer
I focus on:

Clear API contracts
OpenAPI/Swagger documentation
Contract testing
Error handling
Versioning strategy
Integration testing

Example:

Order Service
      |
REST API Contract
      |
Payment Service

Both teams agree on request and response formats before development begins.

6. Have you participated in Three Amigos sessions?
Yes. I regularly participate in Three Amigos sessions involving Product Owners, Developers, and QA engineers. These discussions help clarify requirements, identify edge cases, define acceptance criteria, and ensure that integration requirements are understood before development begins.

7. How do you handle integration issues discovered late in testing?
First, I work with the relevant teams to quickly identify the root cause. Then I assess the impact, communicate the issue to stakeholders, and agree on a resolution plan. I also review why the issue was not detected earlier and improve testing, contract validation, or communication processes to prevent similar problems in the future.

What's the difference IoC and Dependency Injection?

Tapas Pal — Sat, 30 May 2026 10:01:31 +0000

Inversion of Control (IoC) and Dependency Injection (DI) are related concepts, but they are not the same thing.

Question. Is Dependency Injection the same as Inversion of Control?
Answer: No. IoC is a principle, while DI is one way to implement that principle.

1. What is Inversion of Control (IoC)?
Normally, an object creates and manages its own dependencies.
Without IoC

public class OrderService {

    private PaymentService paymentService;

    public OrderService() {
        paymentService = new PaymentService();
    }
    public void placeOrder() {
        paymentService.processPayment();
    }
}

What happens here?
paymentService = new PaymentService();
OrderService is responsible for:

Creating the dependency
Managing the dependency
Using the dependency

The control is inside OrderService
Problem
Suppose tomorrow you want:
CreditCardPaymentService instead of PaymentService
You must modify: OrderService
This creates tight coupling.

IoC Concept

With IoC: Object creation responsibility is moved outside the class.
Instead of: OrderService creates PaymentService
we do:

Someone else creates PaymentService
Someone else gives it to OrderService

Control is inverted.
That's why it is called: Inversion of Control

Real-Life Example

Imagine a restaurant.
Without IoC - You go into the kitchen and cook your own food.

Customer --> Kitchen --> Cooks food

Customer controls everything.
With IoC - You sit at the table.

Waiter brings food.

Customer <-- Waiter <-- Kitchen

Customer doesn't control food preparation.
Control has been inverted.

2. What is Dependency Injection (DI)?

Dependency Injection is a technique used to achieve IoC.
Instead of creating dependencies yourself:

new PaymentService()

someone injects them.
Example

public class OrderService {

    private PaymentService paymentService;

    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }
    public void placeOrder() {
        paymentService.processPayment();
    }
}

Now:

OrderService orderService =
        new OrderService(new PaymentService());

Dependency is injected from outside.
This is Dependency Injection.

IoC vs DI

Spring Boot Example
Let's see what Spring does internally.
Step 1: Component

@Service
public class PaymentService {

    public void processPayment() {
        System.out.println("Payment Processed");
    }
}

Step 2: Dependent Class

@Service
public class OrderService {

    private final PaymentService paymentService;

    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }
    public void placeOrder() {
        paymentService.processPayment();
    }
}

Notice: new PaymentService()
does not exist.

Step 3: Spring Starts
When application starts:

@SpringBootApplication
public class Application {
}

Spring scans:

@Service
@Component
@Repository
@Controller

classes. Spring finds:
PaymentService
OrderService

Step 4: Spring Creates Beans
Internally:

PaymentService paymentService =
        new PaymentService();

Bean created.

Stored in IoC Container.

Spring Container
      |
      +--> PaymentService Bean

Step 5: Spring Finds Dependency

Spring sees:

public OrderService(PaymentService paymentService)

It understands: OrderService needs PaymentService

Step 6: Spring Injects Dependency

Internally:

OrderService orderService =
        new OrderService(paymentService);

Spring passes the object.

This is Dependency Injection.

Internal Flow Diagram

Application Starts
       |
       V
Component Scan
       |
       V
Find PaymentService
       |
       V
Create PaymentService Bean
       |
       V
Find OrderService
       |
       V
OrderService requires PaymentService
       |
       V
Inject PaymentService Bean
       |
       V
Create OrderService Bean
       |
       V
Store in IoC Container

What is the IoC Container?

Spring's IoC Container is essentially a registry that manages objects (beans).

Simplified view:

ApplicationContext
       |
       +--> PaymentService
       |
       +--> OrderService
       |
       +--> UserService

The container:

Creates objects
Injects dependencies
Manages lifecycle
Destroys objects Types of Dependency Injection

1. Constructor Injection (Recommended)

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

Advantages:

Immutable dependencies
Easy testing
Spring recommendation

2. Setter Injection

@Service
public class OrderService {

    private PaymentService paymentService;

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

3. Field Injection
@Autowired private PaymentService paymentService;
Works, but generally discouraged because it makes testing harder.

Inversion of Control (IoC) is a design principle where the control of creating and managing objects is transferred from application code to a container or framework.

Dependency Injection (DI) is a technique used to implement IoC by supplying dependencies from outside rather than creating them inside the class.

Example:

Without DI:

PaymentService paymentService =  new PaymentService();

With DI:

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

In Spring Boot, the IoC container (ApplicationContext) creates beans and injects dependencies automatically using constructor injection, thereby implementing IoC through Dependency Injection.

How Spring does JWT verification based on RS256

Tapas Pal — Thu, 21 May 2026 05:14:36 +0000

RS256 JWT flow between two microservices, then how Spring actually validates it internally.

how Spring Security internally validates that JWT step by step.

Here's what the actual code looks like in the Inventory Service (spring-boot-starter-oauth2-resource-server):
application.yml — tell Spring where to fetch the public key:


spring:
  security:
    oauth2:
      resourceserver:
        jwt:
          jwk-set-uri: http://auth-service/oauth2/jwks

SecurityConfig.java — configure the filter chain:


@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
          .authorizeHttpRequests(auth -> auth
           .requestMatchers("/api/inventory/reserve").hasRole("ORDER_SVC")
              .anyRequest().authenticated()
          )
          .oauth2ResourceServer(oauth2 -> oauth2
              .jwt(jwt -> jwt.jwtAuthenticationConverter(jwtAuthConverter()))
          );
        return http.build();
    }

    @Bean
    public JwtAuthenticationConverter jwtAuthConverter() {
        JwtGrantedAuthoritiesConverter converter = new JwtGrantedAuthoritiesConverter();
        converter.setAuthoritiesClaimName("roles");      // map "roles" claim → GrantedAuthority
        converter.setAuthorityPrefix("ROLE_");
        JwtAuthenticationConverter jwtConverter = new JwtAuthenticationConverter();
        jwtConverter.setJwtGrantedAuthoritiesConverter(converter);
        return jwtConverter;
    }
}

InventoryController.java — the endpoint is now protected:


@RestController
@RequestMapping("/api/inventory")
public class InventoryController {

    @PostMapping("/reserve")
    @PreAuthorize("hasRole('ORDER_SVC')")
    public ResponseEntity<String> reserveStock(
            @RequestBody ReserveRequest req,
            @AuthenticationPrincipal Jwt jwt) {   // inject the parsed JWT

        String callerService = jwt.getSubject();  // "order-service"
        // proceed with reservation...
        return ResponseEntity.ok("Reserved for " + callerService);
    }
}

What does BearerTokenAuthenticationFilter do exactly in Spring Security?

What BearerTokenAuthenticationFilter does
It is a OncePerRequestFilter — guaranteed to run exactly once per request, sitting early in Spring Security's filter chain. Its entire job is to bridge the raw HTTP world (a string in a header) to Spring Security's authentication world (a typed Authentication object in the SecurityContext).

Step 1 — Token extraction via DefaultBearerTokenResolver
It reads the Authorization header and strips Bearer from the front. It also optionally checks request parameters (access_token=...) if you configure allowFormEncodedBodyParameter or allowUriQueryParameter. If no token is found at all, it just calls chain.doFilter() — the request passes through unauthenticated, and a later filter or your controller will enforce access.

Step 2 — Wraps the raw token in BearerTokenAuthenticationToken
This is a lightweight container that holds the raw JWT string and is marked as not yet authenticated (isAuthenticated() = false). Think of it as the question — "here's a token, can you validate it?"

Step 3 — Hands off to AuthenticationManager
The filter calls authenticationManager.authenticate(token). The manager routes this to JwtAuthenticationProvider, which calls NimbusJwtDecoder to do the actual RS256 verification, expiry check, issuer check, etc.

Step 4a — On success: populates SecurityContextHolder
If authentication succeeds, the provider returns a fully populated JwtAuthenticationToken (which is authenticated, carries the parsed claims, and has GrantedAuthority objects derived from your roles). The filter stores this in SecurityContextHolder.getContext().setAuthentication(...), then calls chain.doFilter() — the request proceeds to your controller, where @PreAuthorize and @AuthenticationPrincipal work because the context is populated.

Step 4b — On failure: delegates to AuthenticationEntryPoint
If the provider throws JwtValidationException (bad signature, expired, wrong issuer), the filter catches it, clears the SecurityContext (important — prevents stale auth from leaking), and calls authenticationEntryPoint.commence(...), which writes a 401 Unauthorized response with a WWW-Authenticate: Bearer error="invalid_token" header.

Key things it does NOT do
It does not do authorization — that's AuthorizationFilter further down the chain.
It doesn't decode the JWT itself — that's NimbusJwtDecoder.
It doesn't map claims to roles — that's JwtAuthenticationConverter.

The filter's job is purely: extract → wrap → delegate → store or reject.

Difference Between StackOverflowError and OutOfMemoryError in Java

Tapas Pal — Wed, 20 May 2026 05:19:17 +0000

StackOverflowError occurs when stack memory is exhausted due to
excessive method calls, typically caused by infinite or very deep
recursion. OutOfMemoryError occurs when the JVM cannot allocate
more memory, usually because heap memory is exhausted by excessive
object creation or memory leaks

Java memory mainly has:

1. Stack Memory
2. Heap Memory

JVM Memory
│
├── Stack Memory
│      ├── Method calls
│      ├── Local variables
│      └── Function frames
│
└── Heap Memory
       ├── Objects
       ├── Arrays
       └── Instance data

1. StackOverflowError

What Is It?
stack memory becomes full

Most Common Cause?
Infinite recursion

public class Main {
    static void test() {
        test();
    }
    public static void main(String[] args) {
        test();
    }
}

Final Error

Exception in thread "main"
java.lang.StackOverflowError

Stack Frames Growing and eventually stack full.

TOP
│
├── test()
├── test()
├── test()
├── test()
├── test()
│
BOTTOM

Every method call creates:

stack frame
local variables
return address

Too many frames → overflow.

Common Causes of StackOverflowError

2. OutOfMemoryError

What Is It? Occurs when?
JVM cannot allocate more memory

usually in: heap memory

Most Common Cause : Too many objects

import java.util.ArrayList;
import java.util.List;
public class Main {
    public static void main(String[] args) {
        List<int[]> list = new ArrayList<>();
        while(true) {
            list.add(new int[1000000]);
        }
    }
}

What Happens Internally?
Each loop:

creates huge array
stores in heap
references retained in list

Garbage collector cannot free memory.
Eventually: heap full

Final Error

java.lang.OutOfMemoryError:
Java heap space

Heap Growing and no space left.

Heap
│
├── Object
├── Object
├── Object
├── Object
├── Object
├── Object
│
FULL

Common Causes of OutOfMemoryError

StackOverflowError

Usually easier to debug.
Stack trace clearly shows recursion.

OutOfMemoryError
Can be very difficult:

memory leaks
object retention
cache problems
GC tuning

often require:

heap dumps
profilers
memory analyzers

Important JVM Parameters
Stack Size -Xss

Example: java -Xss2m Main
Increase stack size.

Heap Size -Xmx

Example: java -Xmx2g Main
Increase heap size.

Can StackOverflowError Cause OutOfMemoryError?

Indirectly yes sometimes.
Huge recursion may:

create many objects
trigger memory exhaustion

But normally they are distinct problems.

Why Are These Errors and Not Exceptions?

Because:

serious JVM resource exhaustion
application usually cannot safely recover

Both extend:

java.lang.Error

not: Exception

Can We Catch Them?

Technically yes:

catch(StackOverflowError e)

catch(OutOfMemoryError e)

BUT usually: bad practice

Application state may already be unstable.