Badal Jha

Who actually runs your virtual threads?

Sun, 04 Oct 2026 00:00:00 GMT

Carriers, cores, maxPoolSize, parking, unmounting and the compensation trick the JDK uses when something blocks.

When I first read “you can create a million virtual threads”, my next thought was: run on what? A laptop with 8 cores still has 8 cores. The answer is that virtual threads don’t replace platform threads. They sit on top of a small pool of them, and most of the confusing behaviour (stalls, “why is my app slow with only 3 threads busy?”, odd thread names in dumps) comes from not knowing how that pool is managed. So let’s go through it properly.

Virtual threads need carriers

A virtual thread is a normal java.lang.Thread object, but it has no OS thread of its own. When it has work to do, the scheduler picks a platform thread and runs it there. That platform thread is called the carrier. The same virtual thread may use a different carrier next time; there is no affinity.

The default scheduler is a ForkJoinPool, which is why carriers show up in dumps as ForkJoinPool-1-worker-N. Running a virtual thread is called mounting it on a carrier. Taking it off is unmounting.

Many virtual threads, few carriers. Each carrier is a real OS thread.

Cores, parallelism and maxPoolSize

Three settings control the carrier pool, and people mix them up constantly:

Property	What it controls	Default
`jdk.virtualThreadScheduler.parallelism`	How many carriers the pool aims to keep. This is how many virtual threads can run at the same instant.	Number of CPU cores
`jdk.virtualThreadScheduler.maxPoolSize`	Hard ceiling on carriers, including temporary ones added by compensation.	256
`jdk.virtualThreadScheduler.minRunnable`	Minimum number of carriers allowed to be not blocked. It is passed straight to the pool’s constructor.	I haven’t verified this, so check your JDK

The JDK reads the first two as ForkJoinPool constructor arguments. In the source, if you set maxPoolSize lower than parallelism, parallelism gets clamped down to it.

Parallel versus concurrent

This is the part worth burning into memory. With 8 cores you can have 100,000 virtual threads alive, but at most 8 are executing at once. The rest are parked, waiting for I/O, a lock or a timer, and cost almost nothing. That’s why virtual threads shine for I/O-bound work and do nothing for CPU-bound work: if every thread is crunching numbers, 8 carriers are 8 carriers.

The scheduler also doesn’t preempt. A virtual thread that spins in while(true) never yields. Rock the JVM demonstrates this nicely: set maxPoolSize=1 and a busy-looping virtual thread starves everyone else; set it to 2 and a second carrier picks up the other thread.

Park and unmount

Here is the normal life of a virtual thread that hits a blocking call, such as a socket read, Thread.sleep, BlockingQueue.take() or a java.util.concurrent lock:

It calls the blocking method. The JDK sees it’s on a virtual thread and parks it instead of blocking the OS thread.
The thread’s stack frames are copied from the carrier’s stack into a heap object. That’s the unmount.
The carrier is now free and immediately picks another runnable virtual thread.
When the I/O completes or the timer fires, something submits the virtual thread back to the scheduler.
Some carrier (maybe a different one) mounts it again, copies the stack back, and execution continues right after the blocking call.

Per the OpenJDK notes, this friendly path covers things like Thread.sleep, Thread.join, everything blocking in java.util.concurrent, and socket accept/read/write.

Pinned: when parking can’t unmount

Sometimes a virtual thread can’t leave its carrier. JEP 444 names two cases: it is inside a synchronized block or method, or it is running a native method or foreign function. If it blocks while pinned, the carrier and the OS thread underneath are blocked too, exactly like the old days. In stack traces you may notice a frame called parkOnCarrierThread, which is the virtual thread parking the carrier itself.

Version note. JEP 491 (JDK 24) removed most of the synchronized pinning and the Object.wait limitation. On JDK 21 to 23 it’s a real concern; on 24+ it’s mostly about native frames. Check which JDK you run before you rewrite code.

Compensation

Not every non-unmountable block is a dead end. Some operations can’t release the carrier but the JDK knows they will block, so it makes up for the loss. This is compensation: the scheduler temporarily adds an extra carrier so the pool still has enough threads making progress.

Inside the JDK the mechanism is the internal class jdk.internal.misc.Blocker. Code like FileInputStream.read wraps the blocking call with Blocker.begin() and Blocker.end(...) in a try/finally. If it’s a virtual thread on a ForkJoinPool carrier, begin() goes through ForkJoinPool.ManagedBlocker, which allows an extra worker to be spun up. You can’t call Blocker from your code (it’s an internal package), but the public cousin is ForkJoinPool.managedBlock.

What compensates and what doesn’t

Blocking operation	Unmounts?	Compensates?
Socket I/O, sleep, j.u.c. locks and queues	Yes	Not needed
File I/O, `InetAddress` lookups, `Selector` selection, `Object.wait` (JDK 21 to 23)	No	Yes, via ManagedBlocker
Anything blocking while pinned (monitor or native frame)	No	No

Two things to remember. First, compensation is bounded by maxPoolSize, so lots of simultaneous file I/O can still exhaust it. Second, the “pinned means no compensation” rule is how people get real deadlocks: there’s an OpenJDK bug (JDK-8334304) where more pinned virtual threads than available carriers just hang forever, and a plain ForkJoinPool would have compensated on the same code.

Taking a thread snapshot

When something looks stuck, a thread dump is the first thing you reach for, and here the usual tools mislead you. Plain jstack or jcmd <pid> Thread.print doesn’t list virtual threads, and the carriers often look idle. The JDK’s own bug report on the deadlock above makes a point of how hard this is to see through Thread.getAllStackTraces().

The command that does include virtual threads is:

jcmd <pid> Thread.dump_to_file -format=json /tmp/threads.json

Carrier threads appear with the ForkJoinPool-1-worker-N naming. For hunting pinning specifically:

-Djdk.tracePinnedThreads=full (or short) prints a stack trace when a virtual thread blocks while pinned. It works on JDK 21 to 23; I haven’t checked whether it was kept in later releases.
Flight Recorder emits jdk.VirtualThreadPinned events. Someone in a Spring Boot issue saw 59 of them from three messages sent over a socket inside synchronized, which is a good example of how quickly it adds up.

When you read a dump, ask three questions: how many carriers exist, are all of them blocked, and what are the virtual threads waiting on? If every carrier sits in a native frame or monitor wait, you’ve found your pinning problem.

Practical takeaways

Parallelism defaults to your core count, so don’t expect virtual threads to speed up CPU work.
Don’t pool virtual threads. Create one per task; the carriers are the pool.
Keep blocking I/O out of synchronized on JDK 21 to 23. Use ReentrantLock instead, or upgrade to 24+.
Raise maxPoolSize only after a dump shows carriers are actually being exhausted.
Use Thread.dump_to_file and JFR pinning events before guessing.

Mastering Concurrency: ThreadPool in Java Explained

Sun, 09 Mar 2025 00:00:00 GMT

Today we are going to discuss about Threads and ThreadPool. Lets understand the need of multithread

Need for Multithreading in Prime Number Counting

When counting prime numbers in a specified range, a single-threaded approach checks each number sequentially, leading to slow performance for large ranges. This happens because only one CPU core is utilized at a time, making the computation inefficient.

Multithreading improves performance by:

Parallel Execution: Splitting the range into smaller parts, allowing multiple threads to check numbers simultaneously.
Efficient CPU Utilization: Utilizing multiple CPU cores instead of a single one.
Faster Processing: Reducing overall execution time by distributing the workload.

For example, if we need to count prime numbers in 1 to 1,000,000, using multiple threads can divide the range (e.g., 1-250k, 250k-500k, etc.), significantly speeding up computation compared to a single-threaded approach.

Will will se how multithreading is helping in above case but before that lets understand some core concepts of multithreading

So What is a Thread?? and how its different from a process?

So A process is an independent program execution unit with its own memory space while a thread is a lightweight unit of execution within a process that shares the same memory.

So you can think a process as you open Microsoft Word, the system creates a separate process for it. This process has its own memory space and resources, independent of other applications running on your computer.

multiple threads run simultaneously to handle different tasks efficiently. Examples include:

Auto-save Thread: Saves the document in the background while you continue typing.
Spell Check Thread: Continuously checks for spelling and grammar errors.
Rendering Thread: Handles UI updates, such as scrolling or text formatting changes.
User Input Thread: Processes keystrokes and mouse clicks.

How to create Thread in Java

In Java, there are two primary ways to create a thread:

Extending the Thread class
Implementing the Runnable interface (which Thread internally implements)

Since Thread itself implements Runnable, extending Thread is essentially another way of using Runnable. However, using Runnable is preferred as it allows better flexibility (e.g., enabling multiple inheritance)

package multithreading;

public class ThreadInJava {
    public static void main(String[] args) {
        // there are two ways to create threadss in java one is by extending Thread class another is to implement runnable class

        // Thread creation using Thread class
        Thread t1= new MyThread();
        t1.start();

        System.out.println("this is  thread : "+Thread.currentThread().getName());

        //Thread using Runnable interface

        Runnable myRunnable= new MyRunnable();
        Thread t2= new Thread(myRunnable);
        t2.start();

       System.out.println("this is  thread : "+Thread.currentThread().getName());


    }
}

class MyRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println("THis is Thread:  "+Thread.currentThread().getName());
    }
}

// although underthehood this Thread class will eventually implementing Runnable interface only
class MyThread extends Thread{

    @Override
    public void run() {
        System.out.println("this is another thread : "+Thread.currentThread().getName());
    }
}

Thread Pool

A ThreadPool is a collection of pre-created worker threads that efficiently handle multiple tasks by reusing available threads. It helps improve performance by managing resources effectively, avoiding the overhead of creating and destroying threads repeatedly.

How many threads we can create in java? So number of threads we can create depends on various factor like

CPU cores
JV memory
Task nature IO intensive or CPU intensive
Os limits

While Java theoretically allows for tens of thousands of threads, creating too many threads may lead to:

Resource exhaustion: Running out of system memory, causing the JVM to fail.
Context switching overhead: Too many threads may increase the context-switching overhead and degrade performance.

Why Use a ThreadPool?

Reduces thread creation overhead.
Manages resource utilization efficiently.
Prevents system crashes due to excessive thread creation.
Optimizes performance for concurrent tasks.

Executor and ExecutorService

Executor interface which provide only one method to invoke the task i.e execute method

void execute(Runnable command);

ExecutorService interface extends Executor interface and provide more methods to control the progress of the tasks and manage the termination of the service.

ExecutorService executorService = Executors.newFixedThreadPool(5);
Future<String> future = executorService.submit(() -> "Hello Badal"); // some operations
String result = future.get();

ExecutorService provide submit method which can both take callable and runnable. Runnable’s single method does not return any value and neither throw any exception

Callable allow us to throw an exception and return an value

@FunctionalInterface
public interface Runnable {
    /**
     * Runs this operation.
     */
    void run();
}

@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

2. ThreadPoolExecutor

ThreadPoolExecutor is an extensible threadpool implementation which manages a pool of worker threads efficiently.

Why to Use ThreadPool instead of creating Thread everytime

1. Efficient Thread Management - Reuses threads instead of creating new ones for every task.
2. Performance Optimization - Reduces thread creation overhead, improving performance.
3. Customizable Behavior - Allows fine-tuning of core threads, max threads, queue size, and rejection policies.

Whith ThreadPoolExecutor we can have more control over the thread creation and its management we can pass multiple parameters like corePoolSize, MaxPoolSize, keepAliveTime, workQueue

ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue)

Lets understand all the parameters one by one

corePoolSize

This is the number of threads that will be present when we initiate a threadpool. lets say corePoolSize=5 this means 5 thread will be created and added to threadpool initially
maximumPoolSize

It is the maximum number of thread that a threadpool can grow to.if all core threads are busy and the internal queue is full, the pool is allowed to grow up to maximumPoolSize**.**
keepAliveTIme

Time a thread(excess thread apart from corePoolSize) remains idle before terminating
unit

unit of keepAliveTime, Hour, Minute etc
workQueue

A Task Queue (also called a Work Queue) in ThreadPoolExecutor is used to hold tasks waiting to be executed when all core threads are busy.

What happens when a task is submitted toThreadPoolExecutor

When a new task is submitted to ThreadPoolExecutor:
1. If there are idle core threads (corePoolSize), the task is assigned to an available thread immediately.
2. If all core threads are busy, the task is added to the task queue (BlockingQueue).
3. If the queue is full and the number of threads is less than maximumPoolSize, a new thread is created.
4. If both the queue is full and maximumPoolSize is reached, the task is rejected based on a Rejection Policy.

Apart from above parameters we can also pass two more parameter threadFactory and RejectedExecutionHandler while creating threadpool

By default, Java’s Executors create new threads using new Thread(), but ThreadFactory allows:
1. Custom thread naming
2. Setting thread priorities
3. Creating daemon threads (threads that do not prevent JVM shutdown)
4. Applying thread-specific configurations

//constuctor
ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

public class CustomThreadFactory implements ThreadFactory {
    private final AtomicInteger threadCount = new AtomicInteger(1);
    private final String namePrefix;

    public CustomThreadFactory(String namePrefix) {
        this.namePrefix = namePrefix;
    }

    @Override
    public Thread newThread(Runnable r) {
        Thread thread = new Thread(r, namePrefix + "-Thread-" + threadCount.getAndIncrement());
        return thread;
    }
}

//create new threadpool
ExecutorService executor = new ThreadPoolExecutor(
    2, 4, 60, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(),
    new CustomThreadFactory("WorkerPool")
);

RejectedExecutionHandler → When using ThreadPoolExecutor, if a task cannot be accepted (e.g., the queue is full, and all threads are busy), the task is rejected.

The RejectedExecutionHandler interface allows you to define a custom rejection policy to decide what happens when a task is rejected.

Policy	Behavior
AbortPolicy (Default)	Throws `RejectedExecutionException`.
DiscardPolicy	Silently discards the rejected task.
DiscardOldestPolicy	Removes the oldest task in the queue and retries adding the new task.
CallerRunsPolicy	Runs the task in the calling thread instead of the pool.

ExecutorService executor = new ThreadPoolExecutor(
2, 4, 10, TimeUnit.SECONDS,
new ArrayBlockingQueue<>(2),
new ThreadPoolExecutor.AbortPolicy());

Executors in java

Executors utility class is part of the java.util.concurrent package and provides factory methods for creating different types of executor services. This class helps to simplify the process of creating and configuring thread pools, making it easier to work with concurrent tasks without having to manage thread creation and execution manually

The Executors class contains static methods that return pre-configured implementations of ExecutorService, ScheduledExecutorService, and Executor interfaces. These are some of the most commonly used executor implementations in Java for managing and executing tasks in a multi-threaded environment.

newFixedThreadPool(int nThread)
As per official documentaion: Creates a thread pool that reuses a fixed number of threads operating off a shared unbounded queue. At any point, at most nThreads threads will be active processing tasks. If additional tasks are submitted when all threads are active, they will wait in the queue until a thread is available. If any thread terminates due to a failure during execution prior to shutdown, a new one will take its place if needed to execute subsequent tasks. The threads in the pool will exist until it is explicitly shutdown.
in short Creates a thread pool with a fixed number of threads. If all threads are busy, new tasks will be queued until a thread is available. This is useful when you have a known, fixed number of tasks to process concurrently.

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

newCachedThreadPool()

As per official documentaion: Creates a thread pool that creates new threads as needed, but will reuse previously constructed threads when they are available. These pools will typically improve the performance of programs that execute many short-lived asynchronous tasks. Calls to execute will reuse previously constructed threads if available. If no existing thread is available, a new thread will be created and added to the pool. Threads that have not been used for sixty seconds are terminated and removed from the cache. Thus, a pool that remains idle for long enough will not consume any resources. Note that pools with similar properties but different details (for example, timeout parameters) may be created using ThreadPoolExecutor constructors.

Returns: the newly created thread pool

It uses synchronous queue which means there is direct handoff between producer and consumer as the size of this synchronousQueue will be 1 always

In short Creates a thread pool that creates new threads as needed, but will reuse previously constructed threads when available.

This type of pool can grow as needed but has no upper limit (except for system constraints like memory). Tasks that finish early can help process subsequent tasks.
```
 public static ExecutorService newCachedThreadPool() \{
     return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                   60L, TimeUnit.SECONDS,
                                   new SynchronousQueue<Runnable>());
 \}
```
newSingleThreadExecutor()

As per official documentaion: Creates an Executor that uses a single worker thread operating off an unbounded queue. (Note however that if this single thread terminates due to a failure during execution prior to shutdown, a new one will take its place if needed to execute subsequent tasks.) Tasks are guaranteed to execute sequentially, and no more than one task will be active at any given time. Unlike the otherwise equivalent newFixedThreadPool(1) the returned executor is guaranteed not to be reconfigurable to use additional threads.

Returns: the newly created single-threaded Executor
```
 public static ExecutorService newSingleThreadExecutor() \{
     return new FinalizableDelegatedExecutorService
         (new ThreadPoolExecutor(1, 1,
                                 0L, TimeUnit.MILLISECONDS,
                                 new LinkedBlockingQueue<Runnable>()));
 \}
```
ScheduledThreadPoolExecutor

The ScheduledThreadPoolExecutor class extends the ThreadPoolExecutor class and implements the ScheduledExecutorService interface, providing several additional methods that are specifically designed for scheduling tasks with delays or periodic execution. These methods allow for greater control over when and how tasks are executed.

Key Methods of ScheduledThreadPoolExecutor:
1. schedule(Runnable command, long delay, TimeUnit unit):
  - This method allows us to run a task once after a specified initial delay. The task is scheduled to execute after the delay has passed, and only a single execution occurs.
  - Use this When you need a one-time delayed execution of a task.

        javaCopyScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
        scheduler.schedule(() -> System.out.println("Task executed after delay"), 5, TimeUnit.SECONDS);

scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit):
- This method allows us to repeatedly execute a task with a fixed rate. The task is first delayed by the initialDelay, and then executed repeatedly at fixed intervals defined by the period.
- The period is the time between the start of each execution, meaning tasks will start at regular intervals regardless of how long each task takes to execute.
- Use this When you need periodic execution of tasks, such as in scenarios like polling or heartbeats.

        scheduler.scheduleAtFixedRate(() -> System.out.println("Task executed at fixed rate"), 2, 10, TimeUnit.SECONDS);

scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit):
- This method is simmilar to scheduleAtFixedRate, but with a small difference: it schedules tasks at a fixed delay between the end of one execution and the start of the next. The execution rate may vary depending on how long each task takes to run.
- The delay is the time between the completion of one task and the start of the next. This allows for some flexibility in the execution schedule.
- When you need repeated task executions, but want the interval between executions to be measured from the completion of the previous task, ensuring a consistent gap between tasks rather than a fixed start time.

        scheduler.scheduleWithFixedDelay(() -> System.out.println("Task executed with fixed delay"), 2, 10

We will learn More about Concurrency, Locking, ForkJoinPool etc in next article.

I hope you understood the inversion of control and dependency injection. follow me for more engaging software engineering content!

Happy Coding🚀🚀

Kubernetes Essentials: Unlocking the Power of Container Management

Mon, 19 Aug 2024 00:00:00 GMT

So what the hell is Kubernetes? We have learned about Docker and seen how it containerizes our applications, allowing them to run in isolated environments called containers. So if we already have docker and other containerization tools then what is the need of Kubernetes.

So, we will dive deep into the world of Kubernetes. Since it is vast, we will cover it step by step.

Introduction to Kubernetes, What is the need of it if we have docker already?
Architecture of Kubernetes
Working with Kubernetes Objects
Networking and persitent storage
security in kubernetes

In this article we are going to see the first two part and rest will cover in next articles.

1. Introduction to Kubernetes

So let’s explore the challenges with containerization. While Docker is a popular tool, it’s important to recognize that there are other containerization solutions like containerd. We will focus on Docker to illustrate these concepts, but the principles apply broadly across various containerization technologies.

problems with docker:

Single Host: Docker on a single host can only support as many containers as the host’s resources allow. As your application grows, this setup becomes a bottleneck, making it difficult to scale effectively.
Auto Healing: If a container fails or crashes, it won’t automatically recover on its own. DevOps engineers must manually monitor and restart failed containers, which can be time-consuming and prone to human error, especially in large-scale environments.
Auto Scaling: There is no auto scaling in case of container if the traffic increases and load increases we have to manually spin more container it will not automatically scale
Automated rollouts, scaling, and rollbacks: Kubernetes manages your application by automatically creating the desired number of replicas, distributing them across appropriate hardware, and rescheduling containers if a node fails. It allows for on-demand scaling of replicas in response to changing conditions, such as CPU usage, ensuring your application remains resilient and responsive.

These are the problems that kubernetes solve lets understand what is kubernetes and how it solved above problems.

So according to kubernetes official documentation Kubernetes also known as as K8s, is an open source system for automating deployment, scaling, and management of containerized applications. and best part is it does all of this without you having to supervise or get involved. Obviously, you have to set things up in the first place, but once you’ve done that, you sit back and let Kubernetes work its magic.

You must be thinking why it is called k8s? because there are 8 letter between k and s in kubernetes simple there is nothing important in it.

2. Architecture of Kubernetes

This is the basic kubernetes architecture. we will go through each and every component and learn about its working.

Master Node

Master Node is also called as control plane is responsible for managing whole clusture. It monitors the health check of all nodes in the cluster. It manages the information about all the nodes in a cluster, including which containers are assigned to which worker nodes. It continuously monitors both containers and nodes, and if a worker node fails, Kubernetes automatically shifts the workload from the failed node to another healthy node.

The Kubernetes master is responsible for key tasks such as scheduling, provisioning, and configuring the cluster, as well as exposing APIs to clients. The master node uses various control plane components to handle these responsibilities efficiently.

Kubernetes also simplifies many complex tasks for developers, such as service discovery, scaling, load balancing, self-healing, and leader election. This means developers no longer need to build these services into their applications, as Kubernetes handles them automatically.

Four basic component of Master Nodes are

Api server
Scheduler
Controller
Etcd

1.Api server

It acts as the main communication hub for all operations within the cluster. It exposes the Kubernetes API, which other components and external tools can use to interact with the cluster. All other component such as Scheduler, Controller will Communicate to api server before taking any action.

The API server receives and processes RESTful API requests like kubectl commands from users, administrators, and other components within the cluster.The API server serves as the gateway for interacting with the cluster’s state. It reads and writes data to the etcd database, which stores the entire cluster’s state, including information about nodes, pods, services, and configurations.The API server manages authentication and authorization, ensuring that only legitimate users or services with the right permissions can interact with the cluster.

2. Scheduler

From Code to Container: A Guide to Efficiently Publish Spring Boot on Docker🚀🚀

Tue, 02 Jan 2024 00:00:00 GMT

In this article, we will explore the process of Dockerizing a Spring Boot application and delve into techniques for reducing the image size of our docker image. So before we move further lets understand some fundamentals of what is docker and what is docker image?

Docker

Docker is a containerization platform that provides easy way to containerize your applications, which means, using Docker you can build container images, run the images to create containers and also push these containers to container regestries such as DockerHub, Quay.io and so on. Docker provides the ability to package and run an application in a loosely isolated environment called a container. The isolation and security lets you run many containers simultaneously on a given host. Containers are lightweight and contain everything needed to run the application, so you don’t need to rely on what’s installed on the host. You can share containers while you work, and be sure that everyone you share with gets the same container that works in the same way.

Image

A docker image is just a package of software it consist standalone, and executable software unit that contains all the necessary components and dependencies required to run an application. It encapsulates the application code, runtime, system libraries, and settings in a lightweight, portable, and standardized format. Docker images serve as the building blocks for containers, which are instances of running applications.

These images can be accessed on different Docker registries, including Docker Hub. Their size is intentionally kept small, containing only the essential libraries and software required to execute the application. Other components such as system libraries, file systems, and networking stacks are accessed from the host operating system, allowing the images to remain lightweight. This design ensures that Docker images are portable, efficient, and easily distributable across various environments

Now to get this image in our local system we need to install docker on our system after that we can pull the required image from dockerhub or any other docker registry. assume docker hub as github for images.

after installing docker on system execute below command in cmd

docker pull imagename:tag

in this article we are mainly focused on creating the image. so lets create a image for out springboot application

Dockerize SpringBoot application

i have created a simple springboot application springboot-docker

To Dockerize an application, we leverage a Dockerfile—a script that provides instructions for building a Docker image. Below is a brief overview of a Dockerfile and its role in the Dockerization process:

select a base Image

Start with a base image that provides the foundational operating system and environment for your application. Choose an image that aligns with your application’s requirements. this base image will be very lightway in nature
```
 FROM eclipse-temurin:17-jdk-alpine
```
create a directory
```
 RUN mkdir -p /app/source
```
select a work directory

Specify the working directory inside the container where the application code and files will be copied.
```
 WORKDIR /app/source
```
Copy the required files

copy all the necessory file
```
 COPY . .
```
Expose port

If your application exposes specific ports, use the EXPOSE instruction to inform Docker about the network ports that should be published.
```
 EXPOSE 8080
```
Run maven command to Build the project
```
 RUN ./mvnw cleane package
```
Define the Command to Run the Application:

Specify the command that Docker should execute when the container starts. This typically involves running the main executable or script for your application
```
 ENTRYPOINT ["java", "-jar", "/app/source/target/springboot-docker-0.0.1-SNAPSHOT.jar"]
```

Now we have create a basic DockerFile to dockerize our application now we just have to build our project. to build our docker application run command:

docker build -t dockerusername/app-name:tag .

for out application it will be

docker build -t badaljha/springboot-docker:latest .

Now to see the image we have create run command docker images

Now we have created our image to run the image and create the container we can use run command

docker run -it -p 8080:8080 app-name

-it tag is to run application in attach mode and -p is for port mapping

it is running now if we want we can push it to docker registry using docker push command

As we can see when we run docker images the size of our application is 412MB can we reduce the size of our image??

So the answer is yes we can optimize our dockerFile and reduce the size of our image. we can use multi stage dockerfile

Multistage Dockerfile

A multistage Dockerfile is a feature in Docker that allows you to use multiple “FROM” statements in a single Dockerfile, creating multiple build stages. Each stage represents a phase in the build process, and you can selectively copy artifacts from one stage to another. This feature is particularly useful for optimizing the final Docker image size and improving build efficiency.

The need for multistage builds becomes evident in scenarios where building an application involves several dependencies and tools, but the runtime environment requires only a subset of them. Multistage builds help create a lightweight production image containing only the necessary artifacts, reducing the overall image size.

To execute the application, there is no requirement for build tools or libraries used during the project’s construction. The essential components include the JAR file, the JDK for running the JAR, and a few necessary libraries. Adopting a multistage approach involves dividing the task into multiple stages. In the initial stage, we build our application, and in the final stage, we transport the JAR file along with the EntryPoint or CMD

Ideally you want the image to contain only the items that are required by the container to achieve its purpose. so lets build our project in first stage and share the jar file to final stage.

After making changes to the Dockerfile, let’s rebuild our project and examine whether the image size has been reduced. Executing the command 'docker build -t badaljha/springboot-docker:latest' produced the following output:”

As observed, the size of our images has been successfully reduced to 335MB from the previous 412MB. Although the current Dockerfile is effective, there are additional optimizations that can further decrease the image size. In this article, the emphasis was on demonstrating the usage of a multistage Dockerfile, prioritizing clarity over achieving the most optimal size. Future improvements can involve crafting a more efficient Dockerfile to achieve even greater size reduction.

Stay tuned for more informative articles, and see you in the next one. Follow me for more engaging software engineering content!

Happy Coding🚀🚀

Getting started with JDBC and Hibernate part-I

Fri, 29 Sep 2023 00:00:00 GMT

What do you know about JDBC and Hibernate? In this blog we are going to get fundamentals of both and how to use them to connect to a database.

Let’s assume you have created a Java project to do crud operation on Student i.e. you want to Create, Read, Update and Delete a Book from the database. So let’s create a Basic Java Project for the same.

What is JDBC?

JDBC (Java Database Connectivity) is a Java based API and a part of the Java Standard Library that provides a standardized way for Java applications to interact with relational databases. It allows Java applications to perform various database operations such as connecting to databases, executing SQL queries, and retrieving and updating data in a database.

So let’s say we have our data to save and we also have a database setup but to save the data into the database we have to make the connection between Java and database and after making the connection we will be able to save data to the database. so to make that connection Java uses JDBC.

JDBC Drivers

A JDBC driver is a platform-specific implementation of the Java Database Connectivity API which means Each DBMS has its own driver . It acts as a bridge between Java code and a particular database management system (DBMS) and you need the appropriate driver to connect to that specific DBMS.
JDBC drivers are essential for establishing communication with a database. These drivers translate Java calls into database-specific calls that the DBMS can understand.
After a driver is selected JDBC Driver Manager’s responsibility is to make a connection to the database using the driver.

There are four main types of JDBC drivers commonly referred to as Type 1, Type 2, Type 3, and Type 4. I am not going into this write now you can read about it from the documentation of jdbc.

Create a Java Project

Create a maven project

Project Structure

 BookManagementApp
 │
 ├── src
 │   └── main
 │       ├── java
 │       │   └── com
 │       │       └── badal
 │       │           └── demo
 │       │               └── BookManagement
 │       │                   ├── dao
 │       │                   │   └── BookDao.java
 │       │                   ├── entities
 │       │                   │   └── Book.java
 │       │                   ├── App.java
 │       │                   └── ...
 │       └── resources
 │           └── ...
 │
 ├── target
 │   └── ...
 │
 ├── pom.xml
 └── ...

Create a Book class

  package com.badal.demo.BookManagement.entities;

  public class Book \{
      private int id;
      private String title;
      private String author;

      public int getId() \{
          return id;
      \}

      public Book(int id, String title, String author) \{
          super();
          this.id = id;
          this.title = title;
          this.author = author;

      \}

      public void setId(int id) \{
          this.id = id;
      \}

      public String getTitle() \{
          return title;
      \}

      public void setTitle(String title) \{
          this.title = title;
      \}

      public String getAuthor() \{
          return author;
      \}

      public void setAuthor(String author) \{
          this.author = author;
      \}

      @Override
      public String toString() \{
          return "Book [id=" + id + ", title=" + title + ", author=" + author + "]";
      \}

  \}

So now we have created the Book class let’s create an instance of this Book class and try to save to to database.3

Creating an instance of Book

      package com.badal.demo.BookManagement;

      import com.badal.demo.BookManagement.entities.Book;

      public class App \{
          public static void main(String[] args) \{
              Book book1 = new Book(1, "The Great Gatsby", "F. Scott");
              System.out.print(book1);
          \}
      \}

We have created a Book instance Now how to save it to the database?

So before saving it to the database, we need a database right? so let’s create a database first. I am using MySQL here you can use any database of you preferred choice

Create a Database

after creating the Database create a table mybooks in the database.
```
 CREATE DATABASE books;

 CREATE TABLE mybooks (
     id INT AUTO_INCREMENT PRIMARY KEY,
     title VARCHAR(255) NOT NULL,
     author VARCHAR(255) NOT NULL
 );
```
Now we need to add a driver class to interact with the database.
```
 <dependency>
     <groupId>com.mysql</groupId>
     <artifactId>mysql-connector-j</artifactId>
     <version>8.0.32</version>
 </dependency>
```
The MySQL Connector/J library provides the necessary classes and methods to establish a connection between your Java application and a MySQL database server. It allows you to specify the database server’s host, port, username, and password to connect to the database.
Connect and save the Book to the Database

There are typically 4 steps
- Load the driver
  
  In your Java application, you load the JDBC driver using the Class.forName()
```
  Class.forName("com.mysql.cj.jdbc.Driver");
```
- Make the connection
  
  You establish a connection to the database using the DriverManager.getConnection() method. This method returns a Connection object that represents the connection to the database.
```
  Connection connection = DriverManager.getConnection(jdbcUrl, username, password);
```
- Execute the query
  
  With the Connection object, you create Statement or PreparedStatement objects to execute SQL queries against the database.
```
  Statement statement = connection.createStatement();
  ResultSet resultSet = statement.executeQuery("SELECT * FROM mybooks");
```
- Process The Results and Close the connection
```
             resultSet.close();
              statement.close();
              connection.close();
```
  Now lets write code to save and get the Book from DataBase to interact with database we have created a class called BookDao in which we are all the logic for database interaction

    package com.badal.demo.BookManagement.dao;

    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.SQLException;
    import java.sql.Statement;

    import com.badal.demo.BookManagement.entities.Book;

    public class BookDao {

        String url = "jdbc:mysql://localhost:3306/books";
        String username = "root";
        String password = "root";

        // create jdbc connection
        public Connection getConnection() throws ClassNotFoundException, SQLException {

            // Load the driver

            Class.forName("com.mysql.cj.jdbc.Driver");

            // get the connection

            Connection connection = DriverManager.getConnection(url, username, password);

            return connection;
        }

        public void saveBook(Book book) throws SQLException, ClassNotFoundException {
            Connection connection = this.getConnection();

            // create the statement
            Statement st = connection.createStatement();

            // run the query
            String sql = "INSERT INTO mybooks (id,title, author) VALUES (?, ?, ?)";
            PreparedStatement preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setInt(1, book.getId());
            preparedStatement.setString(2, book.getTitle());
            preparedStatement.setString(3, book.getAuthor());

            System.out.println(preparedStatement.executeUpdate());

        }

    public String getBook(int id) throws ClassNotFoundException, SQLException {
            Connection connection = this.getConnection();

            // create the statement
            Statement st = connection.createStatement();

            String query = "select title from mybooks where id=" + id;

            ResultSet rs = st.executeQuery(query);

            rs.next();

            return rs.getString(1);
        }

    }

Now lets test our code

    package com.badal.demo.BookManagement;

    import java.sql.SQLException;

    import com.badal.demo.BookManagement.dao.BookDao;
    import com.badal.demo.BookManagement.entities.Book;

    public class App {
        public static void main(String[] args) throws ClassNotFoundException, SQLException {
            Book book1 = new Book(1, "The Great Gatsby", "F. Scott");
            System.out.print(book1);
            BookDao dao = new BookDao();
            //save to db
            // dao.saveBook(book1);
             //get from db
            System.out.println("the title of book with id=1 is " + dao.getBook(1));

        }
    }

In the Next article we will continue learning about hibernate and why it is in demand now days also learn about why we need hibernate if there is jdbc available to connect to the database.

Stay tuned for more informative articles, and see you in the next one. Follow me for more engaging software engineering content!

Happy Coding🚀🚀

CORS Policy and Handling CORS in Nodejs and Spring Boot

Sun, 03 Sep 2023 00:00:00 GMT

CORS stands for Cross-Origin Resource Sharing. It is a security feature to prevent cross-origin requests to different domains. It prevents webpages from making a request to a other domain than the one that served the web page. When building an application that needs to communicate to different APIs on different domains it gives cors error. There is an SOP i.e. same origin policy which is the foundation of Cors policy according to SOP a web page can only make requests to the same origin. What is Origin Here?

An origin is defined by the combination of three components:

Scheme (or Protocol): This can be http, https, ftp, etc.
Host: This is the domain (e.g., Badal.com) or IP address.
Port: This is the port number, typically omitted for HTTP (80) and HTTPS (443).

What is CORS?

Cors is a mechanism to prevent unauthorized requests to a domain. CORS is crucial because it ensures that your data and resources are safe. If there is no CORS policy then it will be easier to make malicious requests to any domain from another domain. By enforcing CORS policies, you can control who gets access to your valuable information and resources, making the web a safer place for everyone.CORS is crucial for web security because it prevents unauthorized access to sensitive data and resources. Without CORS, malicious websites could potentially make requests to trusted domains on behalf of the user. To maintain a Secure environment, it’s essential to enforce CORS policies to ensure that only trusted domains can access your resources.

CORS Errors

when the server detects a cors policy violation, it generates a CORS error. CORS errors typically come in the form of JavaScript errors that you can see in the browser’s developer console. The most common CORS error is:

This error message indicates that a request from http://localhost:4200 to http://localhost:3000/balance-sheet has been blocked due to CORS policy violations.

CORS handling in NodeJs

To handle CORS in nodejs you have to follow the following steps:

1. Install `cors` middleware

npm install cors

2. Import the cors module in the express app and use it

const express = require('express');
const cors = require('cors');

const app = express();

// Enable CORS for all routes
app.use(cors({ origin: true }));
//other routes and middleware functions

app.listen(3000, () => {
  console.log(`Server is running on port 3000`);
});

app.use(cors({origin:true})) it is used to allow all origin to access the server resource.

Sometimes you do not want to allow all the origins to access the server resource in this case you can pass a corsOptions to this middleware function. These corsOptions can be static as mentioned below or dynamic. In dynamic options server will determine the allowed origin based on the incoming request

const express = require('express');
const cors = require('cors');

const app = express();

// Enable CORS for all routes
const options = {
  origin: ['https://test-domain1.com', 'https://test-domain2.com'], // Allow requests from origin mentioned here
  methods: 'GET,PATCH,POST,DELETE', // allow only specific http methods
  optionsSuccessStatus: 204, // Set the HTTP status code for OPTIONS requests
};

app.use(cors(corsOptions));

//other routes and middleware functions

app.listen(3000, () => {
  console.log(`Server is running on port 3000`);
});

CORS handling in Spring Boot

In spring boot you can handle CORS using various method

1.Using `@CrossOrigin` annotation

@CrossOrigin is a spring annotation used to handle cors in spring boot.

@RestController
public class BookController {

    @GetMapping("/book")
    @CrossOrigin(origins = {"https://test-domain1.com", "https://test-domain2.com"})
    public ResponseEntity<List<Book>> getBooks() {
        // Your controller logic here

    }
}

2.Using Java Configurations

@Configuration
@EnableWebMvc
public class CorsConfig implements WebMvcConfigurer {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
            .allowedOrigins("https://text-domain1.com", "https://test-domain2.com")
            .allowedMethods("GET", "POST", "PUT", "DELETE")

    }
}

3.Using application.properties file

You can directly handle cors in application.properties file or application.yaml file

# CORS configuration
spring.mvc.cors.allowed-origins=https://test-domain1.com, https://test-domain2.com
spring.mvc.cors.allowed-methods=GET,PUT,DELETE
spring.mvc.cors.allowed-headers=*

I hope this article has provided you with valuable insights into CORS and its implementation in both Node.js and Spring Boot. Stay tuned for more informative articles, and see you in the next one. Follow me for more engaging software engineering content!

Happy Coding🚀🚀

Spring Annotations

Mon, 21 Aug 2023 00:00:00 GMT

Spring uses an Inversion of control architecture and spring container or ioc container is used to inject objects. Spring container basically manages the Beans and Inject into the program whenever we want. A key aspect of Spring is its configuration, which allows developers to define and configure various components and services within the application.

Annotations in Java are metadata tags that provide additional information about code elements, such as classes, methods, fields, and parameters. Spring annotations are used within the Spring context to enhance the functionality of Spring beans and components. They are processed at runtime by Spring’s IoC container.

Let’s understand some common spring annotations

1. `@Bean` Annotation

As in xml based configuration, we used to write bean tags to define custom beans @Bean is used for the same purpose i.e. to define custom beans. By using @Bean in a configuration class, you explicitly tell Spring to create and manage a bean based on the method’s return value. This is particularly useful when you need to configure or customize the bean instance before it is added to the Spring application context.

class Car{
      start(){
             System.out.println("started");
         }
  }

@Configuration
class AppConfig{
      @Bean
       public Car car(){
             return new Car();
       }
}

Here @Configuration annotation used to mark AppConfig class as configuration class. Configuration classes play a vital role in Spring applications as they define how the application’s beans are created, configured, and wired together. They serve as an alternative to XML-based configuration, allowing developers to configure Spring beans using pure Java code.

By default, the bean name will be the same as the method name. To customize the bean name, use its’ name‘ or ‘value‘ attribute.

@Configuration
public class AppConfig {

    @Bean(name = "customBeanName") // Specify the desired bean name here
    public MyCarService myCarService() {
        return new MyCarServiceImpl();
    }
}

2. `@Component`

@Component This annotation marks a Java class as a Spring bean, allowing the Spring container to manage it. You can use @ComponentScan to specify packages for component scanning.

@Component
public class Car{
///.....
}

3.`@Service` ,`@Repository` and `@Controller`

These are specialized types of @Component annotations. They are used to distinguish between different type of beans.

@Service annotation is used for service layer. It indicates that the class plays a service role and is typically used in the service layer of the application. Service classes that contain business logic, perform data processing or interact with multiple repositories.

@Repository indicates that the class is a data repository, often for storing and retrieving data from a database. spring provides additional benefits for classes annotated with @Repository, such as exception translation (converting database-specific exceptions to Spring’s DataAccessException hierarchy) and automatic transaction management.

@Controller used in spring mvc aapplication used to handle incoming http requests. It indicates that the class is a controller responsible for processing and responding to HTTP requests.

3.`@Autowired`

@Autowired is the spring annotation that is used for automatic dependency injection. The @Autowired annotation can be applied to fields, methods, or constructors of a class to indicate that Spring should automatically wire the required dependency. When a bean with a certain type is needed, Spring searches the application context for a suitable candidate and injects it into the annotated field, method, or constructor.

//constructor injection using @Autowired
@Component
public class Bike {
    private Motercycle motercycle;

    @Autowired
    public Bike(Motercycle motercycle) {
        this.motercycle = motercycle;
    }

 }

//setter injection
@Component
public class Bike {
    private Motercycle motercycle;

    @Autowired
    public setMotercycle(Motercycle motercycle) {
        this.motercycle = motercycle;
    }

 }

//field injection
@Component
public class Bike {
    @Autowired
    private Motercycle motercycle;

 }

4.`@Qualifier`

When using @Autowired spring will search for a bean that matches the type that needs to be injected. If there are multiple beans of the same type are available, you can use the @Qualifier annotation to specify which bean should be injected.

@Service
public class CarService {
    private final PaymentService paymentService;

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

}

In this example, the creditCardPayment bean is injected into the OrderService using the @Qualifier annotation.

5.`@PostConstruct` and `@PreDestroy`

@PostConstruct: This annotation is used on a method that should be executed after a bean is initialized.
@PreDestroy: This annotation is used on a method that should be executed before a bean is destroyed.

There are more annotations @Value , @RequestMapping , @PathVariable, @RequestParam you can learn more about it in the spring official documentation.

Spring annotations have changed the way developers work with the Spring Framework. They promote cleaner, more concise code by reducing the need for XML configuration and enabling powerful features like dependency injection and aspect-oriented programming.

Checkout my previous articles

inversion of control and dependency injection

Jar and Fat Jar

I hope you understood the these spring annotations. follow me for more engaging software engineering content!

Happy Coding🚀🚀

Understanding Inversion of Control and Dependency Injection

Tue, 15 Aug 2023 00:00:00 GMT

Inversion of Control and Dependency Injection are two important concepts in the Spring Framework. They are closely related and work together to achieve loose coupling and maintainability in software applications.

Inversion of Control (IOC)

Inversion of Control is an architectural principle that tells how components interact within an application. Traditionally a class or component is responsible for creating and managing its dependencies.

class Bike{
      public Honda honda= new Honda();
  }
//or
class Bike{
      private Honda honda;
      public Bike(){
             honda=new Honda();
       }
}

In the above code approach class Bike is responsible for creating and managing Honda Object. The provided code snippet, the Bike class has a tight coupling with the Honda class

Issues with the above approach

Low Flexibility: The Bike class directly creates an instance of the Honda class using the new keyword. This creates a strong dependency between Bike and Honda, making it difficult to switch to a different motorcycle brand without modifying the Bike class
Testing is tough: Since the Bike class creates an instance of Honda internally, it’s hard to replace the Honda instance with a mock object for testing purposes. This makes unit testing challenging, as you can’t easily isolate the behavior of the Bike class from the Honda class.
Scalability Problem: If you want to introduce more features or variations of bikes (e.g., different brands or models), you’ll need to modify the Bike class, violating the Open/Closed Principle of SOLID design.

IoC promotes the idea that a class should not directly create its dependencies but should receive them from an external source. In Spring The IoC container takes responsibility for managing the lifecycle of objects, creating and wiring them together based on the configuration provided by the developer. It decouples the components from their dependencies, promoting loose coupling and making the code more flexible and maintainable.

We will learn more about spring containers or IOC containers in depth later in a different blog.

Here’s how you could improve the code using IoC principles:

class Bike {
    private Motorcycle motorcycle;

    public Bike(Motorcycle motorcycle) {
        this.motorcycle = motorcycle;
    }
}

Now, the Bike class expects a Motorcycle instance to be injected during its construction. This way, the responsibility of creating and providing the Motorcycle instance is shifted outside of the Bike class, adhering to the IoC principle.

Advantages:

High Flexibility: Above code is highly flexible because there is loose coupling between Bike and Motorcycle. The Bike class is no longer tightly coupled to a specific motorcycle brand (e.g., Honda). You can inject any implementation of the Motorcycle interface, allowing for easy swapping or extension without modifying the Bike class
Testing: During unit testing, we can provide a mock implementation of Motorcycle. to Bike class to isolate the testing of the Bike class’s behavior
Scalability: The Bike class is now open for extension (e.g., adding new brands) without modifying its existing code.

Dependency Injection(DI)

DI is a specific technique that implements IoC by managing the injection of dependencies into components. Dependency Injection is a specific implementation of IoC. It is a design pattern that allows the injection of dependencies into a class rather than the class creating or obtaining them directly.

DI promotes loose coupling between classes, as the dependencies can be easily replaced or changed without modifying the dependent class.

In the context of Spring, DI means that the Spring IoC container is responsible for resolving and injecting the dependencies into beans when they are created. This is typically done through constructor injection or setter injection.

There are three types of DI in Spring:

Constructor Injection: Constructor is used to inject the dependency in component
Setter Injection: The dependencies are set through setter methods in the dependent class.
Field Injection: The dependencies are directly injected into the dependent class’s fields using annotations.

public interface Motercycle {
    // Motercycle interface methods
}

public class Honda implements Motercycle {
    // Honda implementation of Motercycle interface
}

public class Bike {
    private Motercycle motercycle;

    // Setter for Motercycle
    public void setMotercycle(Motercycle motercycle) {
        this.motercycle = motercycle;
    }

    // Constructor
    public Bike(Motercycle motercycle) {
        this.motercycle = motercycle;
    }
}

//configuration file

<bean id="bikeReference" class="com.example.Honda">

//setter injection
<bean id="bike1" class="com.example.Bike">
    <property name="honda" ref="bikeReference" />
</bean>

//constructor injection
<bean id="bike2" class="com.example.Bike">
    <constructor-arg ref="bikeReference" />
</bean>

the constructor-arg e is used for constructor injection, the property element is used for setter injection, .

Now xml based configuration is a older approch. Spring Boot encourages the use of Java based configuration using annotations like @Configuration, @Bean, and @Autowired as it provides more flexibility and is more concise and it is less complex than xml based configuration.


@Component
public class Bike {
    private Motercycle motercycle;

    @Autowired
    public Bike(Motercycle motercycle) {
        this.motercycle = motercycle;
    }

 }

This is how we do dependency injection using java based configuration using @Autowired keyword. we use the @Autowired annotation on the constructor of the Bike class it can be also be used for setter injection. When Spring initializes the Bike Bean, it will automatically inject the appropriate implementation of the Motorcycle interface in this case, the Honda bean .

Remember, for @Autowired to work, make sure you have component scanning enabled in your Spring configuration using @ComponentScan or similar. Spring will automatically discover and inject the appropriate beans based on the declared types

@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
    // Configuration settings
}

By using Java based configuration we no longer need use xml file for the bean configuration. We will learn more about Java base configuration @Autowired , @Qualifier in another article.

In short, Inversion of Control is an architectural principle that tells how components interact within an application, while Dependency Injection is a specific implementation technique that addresses the management of component dependencies there are also other techniques like Event-Driven Architecture, Factory method pattern etc . DI is a means to achieve IoC by allowing components to receive their dependencies from an external source, resulting in more modular, flexible, and maintainable codebases. In Spring spring container also known as the IOC container provides the maintains and injects beans.

I hope you understood the inversion of control and dependency injection. follow me for more engaging software engineering content!

Happy Coding🚀🚀

Understanding JAR and Fat JAR in Spring Boot

Sat, 12 Aug 2023 00:00:00 GMT

A jar(java archive) file package all the java files, associated metadata and resources such as images and configuration in single zip file.

when you build a Spring Boot project, especially using tools like Maven or Gradle, you will often find two types of JAR files generated inside the target directory: the regular JAR and the Fat JAR (also known as Executable JAR or Uber JAR). Let’s delve into each of these:

🔹 JAR (Java Archive):

The primary purpose of a JAR file is to conveniently distribute a Java application or library. By packaging all the necessary files into a single JAR, developers can share their Java code easily, making it portable and self-contained.

Here are some key points:
👉 Packaging: JAR files can contain compiled Java bytecode (.class files), resources (images, XML files, properties files), and other files needed to run a Java application or library.
👉Compression: JAR files use compression to reduce the file size, which makes them more efficient for distribution.
👉 Manifest File: Each JAR file can have a manifest file (META-INF/MANIFEST.MF) that contains metadata about the JAR, such as the main class to be executed, classpath entries, and version information.
👉 Executable JAR: If the manifest file specifies the main class, the JAR can be executed as a standalone application using the java -jar command.
👉 Libraries: JAR files are commonly used to distribute Java libraries, which can be easily added to other Java projects by including the JAR file in the classpath.

🔹 Fat JAR (Java Archive):

In Spring Boot, a “fat JAR” refers to a type of executable JAR file that includes all the necessary classes and dependencies required to run a Spring Boot application. It is a self-contained JAR file that packages not only the application’s compiled classes but also all the third-party libraries (dependencies) that the application relies on.

when you create a Fat JAR in a Spring Boot application, it includes an embedded web server, which is typically Tomcat by default. The fat JAR contains everything needed to run the application, making it highly portable and easy to distribute and deploy.

Key Points:
🚀 Simplified deployment: With a fat JAR, you don’t need to manage external classpath settings or worry about deploying the application along with its dependencies.
🚀 Version Management: Fat JARs bundle specific versions of dependencies with the application. This helps avoid conflicts and ensures that the application runs with the intended versions of libraries, regardless of the system’s existing classpath.

How to create the fat jars:
👨‍💻 To create a fat JAR in Spring Boot, you can use either the Spring Boot Maven Plugin or the Spring Boot Gradle Plugin

In this photo Rest_Api-0.0.1-SNAPSHOT.jar is the fat jar and Rest_Api-0.0.1-SNAPSHOT.original.jar is the normal jar.

Follow for more such articles🤖🤖

Badal Jha

Who actually runs your virtual threads?

Virtual threads need carriers

Cores, parallelism and maxPoolSize

Parallel versus concurrent

Park and unmount

Pinned: when parking can’t unmount

Compensation

What compensates and what doesn’t

Taking a thread snapshot

Practical takeaways

Mastering Concurrency: ThreadPool in Java Explained

How to create Thread in Java

Thread Pool

Executor and ExecutorService

2. ThreadPoolExecutor

Why to Use ThreadPool instead of creating Thread everytime

What happens when a task is submitted toThreadPoolExecutor

Executors in java

ScheduledThreadPoolExecutor

Key Methods of ScheduledThreadPoolExecutor:

Kubernetes Essentials: Unlocking the Power of Container Management

1. Introduction to Kubernetes

2. Architecture of Kubernetes

Master Node

1.Api server

2. Scheduler

From Code to Container: A Guide to Efficiently Publish Spring Boot on Docker🚀🚀

Docker

Image

Dockerize SpringBoot application

Multistage Dockerfile

Getting started with JDBC and Hibernate part-I

What is JDBC?

JDBC Drivers

Create a Java Project

CORS Policy and Handling CORS in Nodejs and Spring Boot

What is CORS?

CORS Errors

CORS handling in NodeJs

1. Install cors middleware

2. Import the cors module in the express app and use it

CORS handling in Spring Boot

1.Using @CrossOrigin annotation

2.Using Java Configurations

3.Using application.properties file

Spring Annotations

1. @Bean Annotation

2. @Component

3.@Service ,@Repository and @Controller

3.@Autowired

4.@Qualifier

5.@PostConstruct and @PreDestroy

Understanding Inversion of Control and Dependency Injection

Inversion of Control (IOC)

Issues with the above approach

Advantages:

Dependency Injection(DI)

Understanding JAR and Fat JAR in Spring Boot

🔹 JAR (Java Archive):

🔹 Fat JAR (Java Archive):

1. Install `cors` middleware

1.Using `@CrossOrigin` annotation

1. `@Bean` Annotation

2. `@Component`

3.`@Service` ,`@Repository` and `@Controller`

3.`@Autowired`

4.`@Qualifier`

5.`@PostConstruct` and `@PreDestroy`