DEV Community: Anupam Tarai

Implement a Global Handler for UserNotFoundException

Anupam Tarai — Sun, 01 Sep 2024 01:20:36 +0000

Overview

This implementation enhances the exception handling mechanism within the Journal REST API application by defining a custom exception, UserNotFoundException, and implementing a global exception handler to manage this exception effectively. The goal is to centralize exception handling, improving code maintainability and consistency.

Got to Issue

Tasks

1. Define `UserNotFoundException`

Create a custom exception class named UserNotFoundException.

2. Implement Global Exception Handler

Implement a global exception handler to manage the UserNotFoundException.

3. Refactor Existing Code

Refactor the existing controller code to remove local handling of UserNotFoundException.

How to Contribute

Fork the repository: Journal-Rest-API

Clone the repository:

git clone https://github.com/yourusername/Journal-Rest-API.git
cd Journal-Rest-API

Create a new branch:

git checkout -b enhance-exception-handling

Make your changes and commit them:

git add .
git commit -m "Enhance exception handling and implement global exception handler for UserNotFoundException"

Push to the branch:

git push origin enhance-exception-handling

Create a pull request: Go to the repository on GitHub and create a pull request.

Conclusion

By enhancing the exception handling mechanism and implementing a global exception handler, we can improve the maintainability and consistency of the codebase. I welcome contributions from the community to help me achieve this goal.

Feel free to reach out if you have any questions or need further assistance. Happy coding!

Enhance Your Debugging Skills by Contributing to the Journal REST API

Anupam Tarai — Wed, 28 Aug 2024 11:03:26 +0000

Hello, fellow developers!

Are you looking to improve your debugging skills while contributing to an open-source project? Our Journal REST API project is the perfect opportunity for you to dive into a real-world Spring Boot application, debug issues, and make meaningful contributions.
Contribute to the Journal REST API on GitHub

About the Journal REST API

The Journal REST API is a Spring Boot application designed to manage journal entries for users. It provides endpoints for creating, reading, updating, and deleting journal entries, as well as user management functionalities. The project prioritizes security and privacy with encrypted data transmission and robust access controls.

Why Contribute?

Contributing to open-source projects is a fantastic way to improve your coding skills, learn new technologies, and collaborate with other developers. Here are some specific benefits of contributing to our project:

Enhance Your Debugging Skills: Debugging is a crucial skill for any developer. By contributing to our project, you'll get hands-on experience with debugging a real-world application.
Learn Spring Boot: If you're new to Spring Boot, this project is an excellent way to get familiar with its features and best practices.
Collaborate and Share Knowledge: Working on open-source projects allows you to collaborate with other developers, share knowledge, and learn from each other.

Contribution Guidelines

Fork the repository: Click the "Fork" button at the top right of the repository page. Journal REST API Repository
Clone your fork: Clone your forked repository to your local machine.
Create a new branch: Create a new branch for your changes.
```
git checkout -b my-feature-branch
```
Make your changes: Make your changes to the codebase.
Commit your changes: Commit your changes with a descriptive commit message.
```
git commit -m "Description of my changes"
```
Push your changes: Push your changes to your forked repository.
```
git push origin my-feature-branch
```
Submit a pull request: Go to the original repository and submit a pull request.

Conclusion

I welcome contributions from developers of all skill levels. Whether you're a seasoned Spring Boot developer or just getting started, there's something for everyone in this project. By contributing, you'll not only improve your debugging skills but also help make the Journal REST API better for everyone.

If you have any questions or need help, feel free to reach out. Thank you!

Thread In Java

Anupam Tarai — Sat, 22 Jun 2024 15:22:08 +0000

A thread is a small part of a process capable of execute independently.
Java supports multithreading, allowing a process to be divided into multiple threads. These threads can be scheduled by the CPU to execute in parallel, improving the performance of the application.

Creation of a Thread

We can create a thread by extending the 'Thread' class or implementing the 'Runnable' interface. Override the run method inside the thread.

CODE

class A extends Thread{ //A is a thread that extends "Thread" class
    public void run(){ //Override the run method
        for (int i=0; i<10; i++){
        System.out.println("AAAA");
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

class B implements Runnable{ //B is a thread that impliments "Runnable" interface
    public void run(){ //Override the run method
        for (int i=0; i<10; i++){
            System.out.println("BB");
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

public class Server {
   public static void main(String[] args){
        A a = new A();
        B b = new B();
        Thread Tb = new Thread(b); // we need to pass that runnable into the costructor of thread class to create a thread
        a.start();
       try {
           Thread.sleep(10);
       } catch (InterruptedException e) {
           throw new RuntimeException(e);
       }
       Tb.start();

    }
}

Output:
AAAA
AAAA
BB
BB
AAAA
AAAA
BB
AAAA
BB
BB
AAAA
BB
AAAA
AAAA
BB
BB
AAAA
BB
AAAA
BB

Here we have two classes, A and B, both representing threads. When we start the threads using the start method, both threads begin executing in parallel.

Methods in the Thread Class

start(): Starts the thread's execution; the JVM calls the thread's run method.
run(): Contains the code to be executed by the thread.
join(): Waits for the thread to die. If called on a thread, the calling thread will wait until the thread on which join was called finishes.
sleep(long millis): Causes the current thread to sleep for the specified number of milliseconds.
interrupt(): Interrupts the thread, causing it to stop its current task and handle the interruption (if it checks for interruptions).

CONCLUSION

Threads are helpful in large applications that require more time and resources to execute. By dividing such applications into multiple threads and executing them in parallel, the performance of the application can be significantly increased.

Please comment below if I have made any mistakes or if you know any additional concepts related to this topic.

Thread and Process

Anupam Tarai — Fri, 21 Jun 2024 02:46:54 +0000

What is a Thread? Let's understand it.

As we know, every computational device has a CPU, in which all the operations or code executions are done. Some CPUs can execute only one process at a time, which is known as a single-core CPU. In modern computers, CPUs are multi-core. Multi-core CPUs allow the execution of multiple code blocks or multiple processes simultaneously.

A thread is the smallest unit of a process. Mordern OS supports multithreading. It divides the process into smaller units/thread to execute multiple parts of the process concurrently, maximizing CPU utilization.

Process VS Thread

Process

A process is a independent program in execution.
It has it's own memory space, computer resource and execution context.
Each process is operate/execute in isolation from other processes.
Processes are managed by operating system and have their own address space, Which means they do not share memory directly with other processes.

Thread

A thread is a smaller unit of a process. It is sometimes referred to as a "lightweight process."
Threads within the same process share the same memory space and resources. This allows for easier communication and data sharing between threads.

Key Differences

Memory and Resource Allocation

Process: Each process has its own memory space and resources. Inter-process communication (IPC) mechanisms like pipes, sockets, or shared memory are needed for processes to communicate.
Thread:Threads within the same process share the same memory space and resources. This makes inter-thread communication faster and more efficient, as they can directly access shared data.

Isolation:

Process: Processes are isolated from each other. A crash in one process typically does not affect others.
Thread:Threads are not isolated. A crash in one thread can potentially bring down the entire process.

Creation and Context Switching:

Process: Creating and context switching between processes is more expensive in terms of time and system resources because it involves switching the entire memory space and resources.
Thread:Creating and context switching between threads is faster and more efficient since threads share the same memory space and resources.

Communication:

Process:Processes require explicit IPC mechanisms to communicate, which can be complex and slower.
Thread: Threads can communicate directly through shared memory, making inter-thread communication faster and simpler.

Concurrency:

Process: Processes can run concurrently, but they require more system resources. Useful for running separate applications or tasks that do not need to share data.
Thread: Threads allow for more fine-grained concurrency within a single application, enabling better utilization of multi-core processors for parallel tasks.

Use Cases:

Processes:

Suitable for running independent applications.
Useful when tasks need strong isolation for security or stability.
Examples: Web servers, database servers, separate programs.

Threads:

Ideal for tasks that require shared data or resources.
Useful for parallelism within a single application to improve performance.
Examples: Multi-threaded applications like web browsers, games, or parallel computations.

Conclusion

Processes offer strong isolation but are more resource-intensive and slower in context switching.
Threads provide faster context switching and efficient communication but require careful management to avoid issues like race conditions and deadlocks due to shared resources.

Please comment below if I have made any mistakes or if you know any additional concepts related to this topic.

DEV Community: Anupam Tarai

Implement a Global Handler for UserNotFoundException

Overview

Tasks

1. Define UserNotFoundException

2. Implement Global Exception Handler

3. Refactor Existing Code

How to Contribute

Conclusion

Enhance Your Debugging Skills by Contributing to the Journal REST API

About the Journal REST API

Why Contribute?

Contribution Guidelines

Conclusion

Thread In Java

Creation of a Thread

CODE

Methods in the Thread Class

CONCLUSION

Thread and Process

What is a Thread? Let's understand it.

Process VS Thread

Process

Thread

Key Differences

Conclusion

1. Define `UserNotFoundException`