DEV Community: Aman Gupta

The Art of Clean Code: Java Style and Conventions

Aman Gupta — Tue, 26 Sep 2023 12:03:13 +0000

Introduction

Welcome to our journey through the world of Java code style and conventions! 🚀

In the realm of software development, writing top-notch code is like creating a masterpiece. It's all about adhering to consistent rules and guidelines to craft code that's not just correct, but also elegant, readable, and easy to maintain.

In this guide, we're going to take you on an interactive adventure where you'll discover the secrets of writing Java code that stands out. Buckle up as we explore essential principles and techniques that will transform your code into a work of art. 🎨💻

Ready? Let's dive in! 🏊‍♂️🌊

Benefits of Following Java Best Practices

Following Java best practices for code style and conventions brings several benefits to developers and projects. First and foremost, it improves code readability, making it easier for both yourself and others to understand and navigate the codebase. Consistent code style also helps with collaboration, as everyone can work on the code seamlessly without tripping over different formatting preferences.

Moreover, adhering to best practices enhances code maintainability. When code follows a standard structure and naming conventions, it becomes easier to locate specific elements, identify potential issues, and make modifications. It also helps in writing efficient and bug-free code, as proper formatting and naming conventions can catch potential errors early on.

By adopting Java best practices for code style and conventions, you not only make your code easier to work with but also contribute to a positive and productive development environment. Plus, who doesn't want to be known as the person who writes clean and professional code?

Naming Conventions and Variable Declarations

Naming Conventions for Classes, Interfaces, and Packages

Imagine you're organizing your toy collection. You want to make sure you can quickly find each toy when you need it, right? Well, naming classes, interfaces, and packages in coding is a bit like giving your toys clear labels.

Here are some tips to make sure your code names make sense:

Use Descriptive Names: Instead of naming something "Thing1" or "Stuff," choose a name that explains what it does. For example, if you have a piece of code that calculates the total price of items in a shopping cart, you might call it calculateTotalPrice.
Start with a Capital Letter: Just like you write your name with a capital letter at the beginning, in code, class and interface names should also start with a capital letter. For example, "Car" instead of "car."
Camel Case: Camel case means that if your name has more than one word, you start each new word with a capital letter, like calculateTotalPrice instead of calculatetotalprice.
Lowercase for Packages: When you organize your toys into boxes, you give the boxes names, right? In coding, we do something similar with packages. Use lowercase letters for package names and follow a convention like com.example.package.

Variable Naming and Declaration Guidelines

Imagine you have a bunch of jars, and you want to put different things in them. It would be confusing if you labeled the jars with random letters or codes, right? Instead, you'd use labels that tell you exactly what's inside each jar.

In coding, it's similar when you create variables (like jars) to store information. Here are some tips:

Use Descriptive Names: When you create a variable, give it a name that says what it holds. For example, if you're storing a person's age, you could call it "personAge" instead of just "x."
Avoid Short Names: Don't use super short names or weird abbreviations that nobody can understand. Imagine if your jar label said "A" instead of "Cookies" – that wouldn't help anyone!
Include Data Type: Sometimes, it's a good idea to add the type of information the variable holds in its name. For instance, if it's a number, you can use something like "countInt" or if it's a name, "nameString." This way, it's even clearer.

Constants and Enumerations Naming Conventions

Imagine you have some special values in your code that never change, like the maximum number of something. It's like having a super important rule written down.

Use Uppercase Letters: When you write these special values, use BIG letters to make them stand out. So instead of saying "maximumSize," you write "MAX_SIZE."
Add Underscores Between Words: If your special value has more than one word, put an underscore (_) between them. It's like putting a dash between words for clarity. For example, "MAX_SIZE" instead of "MAXSIZE."
Enums (Special Lists): If you have a list of special values, each value should also follow the BIG letters and underscore rule. But put each value on a separate line, like this:

  public enum Color {
    RED,
    GREEN,
    BLUE
}

Avoid Abbreviations: Don't use short forms or abbreviations unless everybody knows what they mean. So, instead of "MAX_SZ," use "MAX_SIZE" to make sure everyone understands.

Formatting and Indentation Best Practices

Code Formatting Guidelines

When you write code, it's like writing a story. To make sure everyone can easily read and understand your code, follow these rules:

Use Spaces for Indentation: Imagine your code as a set of building blocks. Each time you go deeper into a block (like inside a loop or a function), use four spaces to indent it. This makes it neat and organized.
Braces Get Their Own Lines: Think of curly braces '{' and '}' like bookends. Put them on separate lines, and make sure they line up nicely. It's like how you'd place bookends neatly on a shelf.
Spaces Around Symbols: Imagine code symbols (+, -, =) as traffic signs. Give them some space. For example, write "x = 5" instead of "x=5". It's like leaving room around road signs for better visibility.

Indentation and Line Length Recommendations

Indentation Is Like Stacking Blocks: Keep your code organized by stacking blocks of code neatly. Each level should be four spaces. This helps others understand where things belong.
Line Length Is Like Writing on a Page: Make sure your lines of code are not too long, like a sentence that goes on and on. Try to keep them between 80 to 120 characters, so you don't have to scroll left and right to read the code.

Aligning Code and Using White Spaces

Aligning Is Like Lining Up Soldiers: When you have things that should match or look similar, make sure they line up. For example, if you have a list of names, they should all start at the same spot, like soldiers in a formation.
Blank Lines Are Like Paragraphs: Just like in a book, you use blank lines to separate different sections of your code. It's like having paragraphs so that readers can understand where one idea ends and the next begins. By following these guidelines, your code becomes like a well-organized book that's easy for others to read and understand.

Comments and Documentation Guidelines

Importance of Comments and Documentation

Comments and documentation provide valuable information about the code's purpose, functionality, and usage. They serve as a guide for developers and future maintainers, helping them understand the code and make informed decisions. Taking the time to write clear comments and documentation can save hours of confusion and frustration.

Writing Clear and Concise Comments

When you write comments in your code, think of them as helpful notes to yourself and others who might read your code later. Here's how to make your comments useful:

Focus on "Why" More than "How": Instead of explaining exactly how your code works (because that should be clear from the code itself), focus on why you made certain choices. This helps readers understand the reasons behind your code.
Avoid Overdoing It: Don't put comments everywhere. Only comment on things that are complex or might not be obvious to someone reading your code. Too many comments can clutter your code and make it hard to read.
Document Assumptions: If your code relies on certain assumptions or has limitations, it's essential to mention them in your comments. This prevents misunderstandings.

Documenting JavaDoc Tags and Usage

JavaDoc is like a special way of writing comments that can automatically generate documentation for your code. Here's how to use it effectively:

Use JavaDoc Tags: When you write comments for classes and methods, use special tags (like @ param, @return, @throws) to provide extra information. These tags help users of your code understand what inputs are expected, what gets returned, and what exceptions might be thrown.
Be Consistent: If you're creating a public interface that others will use, make sure your JavaDoc comments are consistent and clear. Think of it as a contract between you (the developer) and anyone who uses your code.
Keep It Up-to-Date: Whenever you change your code, remember to update your JavaDoc comments too. This ensures that the documentation always matches the code.

Error Handling,Exceptions and Logging

Error Handling Practices

Error handling is like preventing problems before they become big headaches. In Java, here's what you should do:

Catch Specific Errors: When something goes wrong, don't just catch any error. Catch the specific one that fits the situation.
Deal with Errors Nicely: Don't just ignore errors; handle them gracefully. This means you should do something useful when things go awry, not just pretend they didn't happen.
Give Helpful Error Messages: If something goes wrong, tell people what happened in a way they can understand. This helps with troubleshooting.
Don't Nest Too Much: Avoid putting errors within errors within errors (try-catch blocks inside each other). It makes your code hard to read. Remember, errors happen, but how you handle them can make a big difference.

Exception Handling Best Practices

Think of exceptions like unexpected guests. Here's how to handle them in Java:

Use Checked Exceptions Carefully: Only use them when it makes sense in your program. They're like RSVP guests - you expect them.
Use Unchecked Exceptions for Checks: For things like checking if a password is correct, use unchecked exceptions. It's like uninvited guests who show up without notice.
Avoid Exceptions in Constructors: Constructors should be trouble-free entry points. Don't let them throw surprises.
Fail Fast, Fail Loudly: If something's wrong, let it be known early and clearly. Don't wait until the party is ruined.

Proper Logging and Error Reporting

Logging is like taking notes at an event to understand what's happening. Do it right:

Use Reliable Logging Tools: Pick a good tool (like Log4j or SLF4J) to keep track of what's going on.
Control Log Amount: Set the amount of information you log - not too little, not too much.
Write Useful Log Messages: Make sure your log messages are clear and have the right details.
Report Critical Issues: Tell the right people when something serious goes wrong. By doing these things, you can keep your application from becoming a chaos party.

Object-Oriented Design Principles

Encapsulation and Information Hiding

Encapsulation is like keeping your stuff organized in boxes. In Java, it's about organizing your code neatly:

Private Members: Keep most of your code's details private. It's like hiding your stuff in a box. Only show what's necessary.
Getters and Setters: If someone needs something from your box, give it to them through a controlled way, like using a "getter" or "setter."
Limit Visibility: Don't let everyone see everything. Keep some things hidden unless there's a good reason to show them.
Loose Coupling, High Cohesion: Your code should be like a puzzle with pieces that fit well together but aren't too stuck. It helps make your code easier to manage.

Inheritance and Polymorphism Guidelines

Inheritance and polymorphism are like family relationships in code:

Composition Over Inheritance: Think of it like building new LEGO creations instead of just using existing LEGO sets. Create new things when needed.

LEGO

Abstract Classes and Interfaces: Use them to define common rules or behaviors that different parts of your code should follow.
Be Careful with Overrides: When you change how something works in a family tree, be sure it doesn't cause unexpected surprises.
Polymorphism: Write code that can adapt and change, like being flexible with different LEGO pieces.

Composition and Interface Segregation

Composition is like creating complex structures from simple parts:

Composition Over Inheritance: Build your code by putting together small, simple pieces rather than inheriting from big, complicated ones.
Focused Interfaces: Make sure each interface does one clear job, like a tool for a specific task.
Split Big Interfaces: If a tool has too many functions, break it into smaller, more specialized tools. It's like having a toolbox with many compartments.
Dependency Injection: Assemble your code using parts and tools, like putting together a LEGO set.

By following these principles, your code becomes like a well-organized collection of boxes, LEGO creations, and specialized tools, making it easier to manage and maintain.

Testing and Debugging Strategies

Writing Effective Unit Tests

Unit tests are like superheroes for your code. Here's how to use them well in Java:

Focused Tests: Write tests that check one specific thing at a time. It's like a superhero with a single superpower.
Testing Framework: Use a testing tool (like JUnit or TestNG) to make testing easier and organized.
Positive and Negative Tests: Test things that should work (positive) and things that shouldn't (negative). Cover all possibilities.
Automate Your Tests: Make your tests run automatically, so you can catch issues early.

By writing these effective unit tests, you'll save your code from evil bugs.

Debugging Techniques and Tools

Debugging is like being a detective for code problems. Here's how to do it well in Java:

Step-by-Step and Breakpoints: Examine your code step by step, like a detective following clues. Use breakpoints to pause the code where you want to investigate.
Console and Debuggers: Print important information to the console or use a debugger tool to inspect your code as it runs.
Stack Traces and Errors: Look at error messages and stack traces to figure out what went wrong.
Debugging Tools: Use special tools and features in your coding environment to help you find issues faster.

With these techniques and tools, you'll become a code detective and solve cases of mysterious bugs.

Code Coverage and Test Automation

Code coverage and test automation are like having backup dancers for your code's performance:

High Code Coverage: Try to test as much of your code as possible. It's like making sure your dancers hit every move.
Code Coverage Tools: Use tools like JaCoCo or Cobertura to measure how well your tests cover your code.
Automate Everything: Make your tests run automatically. This saves time and ensures consistency.
Different Types of Tests: Use different types of tests (unit, integration, end-to-end) to check your code from all angles.

With code coverage and test automation, your code will perform flawlessly on the quality assurance stage.

Code Review and Collaboration Practices

Importance of Code Reviews

Think of code reviews as quality checks for your code. In Java, they're important because:

Early Issue Detection: They help find and fix problems before they cause trouble in your software.
Knowledge Sharing: They let team members learn from each other's code.
Coding Standards: They make sure everyone follows the same coding rules and best practices.
Teamwork: They promote working together, leading to better code.

Embracing code reviews means building a strong foundation for your Java projects.

Conducting Effective Code Reviews

Effective code reviews are like helpful conversations, not critiques. Here's how to do them well:

Focus on Code, Not People: Don't blame individuals. Look at the code's strengths and weaknesses.
Give Specific Feedback: Point out exactly what needs improvement and why.
Timely Reviews: Don't make others wait. Keep the process moving.
Encourage Discussion: Let reviewers and authors talk and learn from each other.

With effective code reviews, your code gets better over time.

Collaborative Development and Version Control

Collaboration and version control are like a dance where everyone stays in sync:

Use Version Control (like Git): It helps manage code changes and lets people work together.
Branching and Merging: Have a plan for how to work on different parts of the code and combine them.

These practices ensure everyone works together smoothly, just like synchronized dancers.

Conclusion

In conclusion, following these best practices for coding, testing, and collaboration in Java leads to more efficient, maintainable, and reliable software. By adhering to these guidelines, developers can create high-quality Java applications that meet industry standards and foster productive teamwork.

It's been great connecting with you! If you have any more questions or need assistance in the future, feel free to reach out me. Goodbye, and have a wonderful day!

Java Collections Framework - A Quick and In-Depth Look (Part - 2)

Aman Gupta — Wed, 20 Sep 2023 17:27:14 +0000

Introduction

Welcome to Part 2 of our series on the Java Collections Framework! In this continuation, we'll explore more advanced aspects of this essential framework, diving into key interfaces and classes that make data management in Java both efficient and powerful. Get ready to level up your Java skills and expand your toolkit for handling collections and data structures.

We have discussed there List and Queue Interfaces and if you haven't read first part then you read it here.

Set Interface

The Set interface represents an unordered collection of unique elements. Unlike lists, sets do not allow duplicate values, making them ideal for scenarios where you need to ensure distinct elements. The Set interface includes several methods for adding, removing, and checking the presence of elements. Popular implementations of the Set interface are HashSet, LinkedHashSet, and TreeSet, each with its own characteristics and use cases. By using Set, you can efficiently manage collections of elements without worrying about duplicates, making it a valuable tool in Java programming.

HashSet

HashSet provides a collection of unique elements without any specific order. This means that you can store elements in a HashSet, and it will automatically ensure that duplicates are not allowed. It is highly efficient for checking the presence of elements and adding or removing elements from the set. While elements are not stored in a particular sequence, this data structure is particularly useful when you need to maintain a collection of items where uniqueness is a priority, and the order of elements doesn't matter.

Here's an example of how to use a HashSet:

import java.util.HashSet;

public class HashSetExample {
    public static void main(String[] args) {
        HashSet<String> fruits = new HashSet<>();

        // Adding elements
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");

        // Attempting to add a duplicate element (it won't be added)
        fruits.add("Apple");

        // Iterating through the set
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
    }
}

In this example, "Apple" is added only once, demonstrating HashSet's uniqueness property. When you iterate through the HashSet, the order of elements may not be the same as they were added, highlighting its unordered nature.

LinkedHashSet

LinkedHashSet combines the features of both HashSet and LinkedHashMap, offering a collection of unique elements with predictable iteration order. Unlike HashSet, LinkedHashSet maintains the order in which elements were inserted into the set. This means that when you iterate over a LinkedHashSet, the elements will be returned in the order they were added. This can be useful in situations where you need both uniqueness and a specific order for your elements.

Let's consider a library catalog system. In this scenario, you want to maintain a list of books in a way that allows you to keep track of unique titles while preserving the order in which the books were added to the catalog. You decide to use a LinkedHashSet to store the book titles. As new books arrive at the library, you add their titles to the LinkedHashSet. Because LinkedHashSet maintains the insertion order, you can easily browse the catalog in the order the books were acquired, making it convenient for library staff to locate and manage the collection efficiently.

Here's a simple Java program that demonstrates the usage of a LinkedHashSet:

import java.util.LinkedHashSet;

public class LinkedHashSetExample {
    public static void main(String[] args) {
        // Create a LinkedHashSet to store unique elements while preserving insertion order
        LinkedHashSet<String> fruitsSet = new LinkedHashSet<>();

        // Adding elements to the LinkedHashSet
        fruitsSet.add("Apple");
        fruitsSet.add("Banana");
        fruitsSet.add("Cherry");
        fruitsSet.add("Banana"); // Adding a duplicate element

        // Display the elements of the LinkedHashSet
        System.out.println("Fruits in the LinkedHashSet:");
        for (String fruit : fruitsSet) {
            System.out.println(fruit);
        }

        // Check if a specific element exists in the LinkedHashSet
        String searchFruit = "Cherry";
        if (fruitsSet.contains(searchFruit)) {
            System.out.println(searchFruit + " is in the LinkedHashSet.");
        } else {
            System.out.println(searchFruit + " is not in the LinkedHashSet.");
        }

        // Remove an element from the LinkedHashSet
        String removedFruit = "Banana";
        boolean isRemoved = fruitsSet.remove(removedFruit);
        if (isRemoved) {
            System.out.println(removedFruit + " has been removed from the LinkedHashSet.");
        } else {
            System.out.println(removedFruit + " was not found in the LinkedHashSet.");
        }
    }
}

This program creates a LinkedHashSet named fruitsSet, adds several fruits (including a duplicate), displays the elements while preserving insertion order, checks for the existence of a specific fruit, and removes an element from the LinkedHashSet. It illustrates the key features of LinkedHashSet, including uniqueness and order preservation.

TreeSet

A TreeSet is a sorted collection in Java that implements the Set interface. Unlike a HashSet, which does not guarantee any specific order of elements, a TreeSet maintains elements in sorted order. This sorting is typically in ascending order, but you can customize it by providing a comparator during TreeSet creation. TreeSet uses a Red-Black Tree data structure internally for efficient sorting and retrieval operations.

Here's a brief example to demonstrate the usage of a TreeSet:

import java.util.TreeSet;

public class TreeSetExample {
    public static void main(String[] args) {
        // Create a TreeSet to store integers in sorted order
        TreeSet<Integer> numbers = new TreeSet<>();

        // Add elements to the TreeSet
        numbers.add(5);
        numbers.add(2);
        numbers.add(8);
        numbers.add(1);

        // Display the elements in sorted order
        System.out.println("Numbers in ascending order:");
        for (int num : numbers) {
            System.out.println(num);
        }

        // Remove an element from the TreeSet
        int removedNumber = 2;
        boolean isRemoved = numbers.remove(removedNumber);
        if (isRemoved) {
            System.out.println(removedNumber + " has been removed.");
        } else {
            System.out.println(removedNumber + " was not found.");
        }
    }
}

In this example, a TreeSet named numbers is created to store integers. When elements are added, the TreeSet automatically sorts them in ascending order. The program also demonstrates the removal of an element from the TreeSet. TreeSet is useful when you need a sorted collection of unique elements in your Java application.

Map Interface

The Map interface in Java represents a collection of key-value pairs, where each key is unique and maps to a specific value. It allows for efficient data retrieval based on keys, making it useful for tasks like looking up values by identifiers. Java provides various implementations of the Map interface, such as HashMap, TreeMap, and LinkedHashMap, each suited for different use cases. Maps are commonly used to store and manage data where the relationship between keys and values is critical. They enable quick and direct access to values based on their associated keys, enhancing the efficiency of data retrieval and manipulation in Java programs.

Imagine you're managing a restaurant. You can use a Map to represent your menu. Each item on the menu has a unique identifier (like an item code or name), and the Map associates this identifier with the item's details, such as its name, description, price, and availability. When customers place orders, you can efficiently look up menu items and calculate the total bill by referencing the Map. This application of the Map interface simplifies order processing and enhances customer service in the restaurant business.

Map doesn't allow duplicate keys, but you can have duplicate values. HashMap and LinkedHashMap allow null keys and values, but TreeMap doesn't allow any null key or value.
Here are the common methods of the Map interface with their descriptions:

Method	Description
put(K key, V value)	Associates the specified value with the specified key in this map.
get(Object key)	Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
remove(Object key)	Removes the mapping for the specified key from this map if present.
containsKey(Object key)	Returns true if this map contains a mapping for the specified key.
containsValue(Object value)	Returns true if this map maps one or more keys to the specified value.
size()	Returns the number of key-value mappings in this map.
isEmpty()	Returns true if this map contains no key-value mappings.
clear()	Removes all of the mappings from this map.
keySet()	Returns a Set view of the keys contained in this map.
values()	Returns a Collection view of the values contained in this map.
entrySet()	Returns a Set view of the mappings contained in this map.

HashMap

A HashMap in Java is a fundamental data structure that facilitates the storage and retrieval of data using key-value pairs. It is a part of the Java Collections Framework and provides efficient access to values based on their associated keys. HashMaps use a hash function to compute an index into an array where the values are stored, making retrieval swift even for large datasets. They do not allow duplicate keys and permit one null key along with multiple null values. Java developers frequently use HashMaps to implement data structures like dictionaries and associative arrays, where data is organized and accessed by unique keys, enabling efficient and fast data retrieval in various applications.

Here's a simple example of how to use a HashMap in Java:

import java.util.HashMap;

public class HashMapExample {
    public static void main(String[] args) {
        // Create a HashMap
        HashMap<String, Integer> ageMap = new HashMap<>();

        // Add key-value pairs
        ageMap.put("Alice", 25);
        ageMap.put("Bob", 30);
        ageMap.put("Charlie", 22);

        // Retrieve values by key
        int aliceAge = ageMap.get("Alice"); // Returns 25

        // Check if a key exists
        boolean containsKey = ageMap.containsKey("David"); // Returns false

        // Iterate over key-value pairs
        for (String name : ageMap.keySet()) {
            int age = ageMap.get(name);
            System.out.println(name + "'s age is " + age);
        }
    }
}

In this example, we create a HashMap called ageMap, add key-value pairs, retrieve values by keys, check for the existence of keys, and iterate over the entries. HashMap is a versatile and widely used data structure in Java for various applications where you need to associate keys with values efficiently.

HashTable

A HashTable is similar to a HashMap but has several differences. A HashTable is a synchronized collection, which means it is thread-safe and can be used in multi-threaded applications without the need for external synchronization. It uses a hash function to map keys to values, allowing for efficient key-value retrieval. However, HashTable has become somewhat outdated, and it is recommended to use HashMap in most cases, as it offers similar functionality but is not synchronized, making it more efficient for single-threaded applications. Additionally, HashTable does not allow null keys or values, whereas HashMap permits one null key and multiple null values.

Imagine you have a magical book, and you want to keep a record of famous landmarks in different countries. This book has pages for each country, and you can write down the famous place in that country on its respective page.Whenever you want to know the famous landmark for a particular country, you simply open your magical book to the corresponding page, and there it is, just like how a HashTable lets you quickly retrieve values (landmarks) associated with specific keys (countries).

Here's a simplified representation:

import java.util.Hashtable;

public class LandmarksExample {
    public static void main(String[] args) {
        // Create a HashTable to store country-landmark pairs
        Hashtable<String, String> landmarks = new Hashtable<>();

        // Add country-landmark pairs
        landmarks.put("India", "Taj Mahal");
        landmarks.put("France", "Eiffel Tower");
        landmarks.put("China", "Great Wall of China");
        landmarks.put("USA", "Statue of Liberty");

        // Retrieve and print landmarks
        String landmarkIndia = landmarks.get("India");
        String landmarkFrance = landmarks.get("France");
        String landmarkChina = landmarks.get("China");
        String landmarkUSA = landmarks.get("USA");

        System.out.println("Famous Landmarks:");
        System.out.println("India: " + landmarkIndia);
        System.out.println("France: " + landmarkFrance);
        System.out.println("China: " + landmarkChina);
        System.out.println("USA: " + landmarkUSA);
    }
}

In this example, the HashTable stores country-landmark pairs, allowing you to retrieve the famous landmark for each country.

LinkedHashMap

A LinkedHashMap in Java is a class that combines the features of a hash table and a linked list to store key-value pairs. It maintains the order of elements based on the insertion sequence, allowing predictable iteration. This means that when you iterate through a LinkedHashMap, the elements are returned in the order in which they were added. It provides efficient access to elements via hashing and preserves the order of insertion, making it useful for scenarios where you need both quick access to elements and a predictable iteration order.

A LinkedHashMap in Java can be compared to a numbered list of tasks you need to accomplish in a day. Each task (an entry) is associated with a unique number (the order of insertion), and you want to maintain the order of tasks as you complete them. As you go about your day, you keep track of your tasks in this list. If you finish one task, you cross it off, and if you add a new one, you simply append it to the end of the list. This way, your tasks are not only organized but also executed in the order you added them. Similarly, a LinkedHashMap maintains the order of key-value pairs based on the insertion sequence, allowing you to access and manipulate them in a predictable order.

Here's a simple Java program that demonstrates how to use a LinkedHashMap to store and retrieve country-capital pairs:

import java.util.LinkedHashMap;
import java.util.Map;

public class LinkedHashMapExample {
    public static void main(String[] args) {
        // Create a LinkedHashMap to store country-capital pairs
        LinkedHashMap<String, String> countryCapitalMap = new LinkedHashMap<>();

        // Add country-capital pairs
        countryCapitalMap.put("India", "New Delhi");
        countryCapitalMap.put("USA", "Washington, D.C.");
        countryCapitalMap.put("China", "Beijing");
        countryCapitalMap.put("France", "Paris");

        // Retrieve and print the capitals of selected countries
        String capitalOfIndia = countryCapitalMap.get("India");
        String capitalOfUSA = countryCapitalMap.get("USA");

        System.out.println("Capital of India: " + capitalOfIndia);
        System.out.println("Capital of USA: " + capitalOfUSA);

        // Iterate through the LinkedHashMap and print all country-capital pairs
        System.out.println("All Country-Capital Pairs:");
        for (Map.Entry<String, String> entry : countryCapitalMap.entrySet()) {
            String country = entry.getKey();
            String capital = entry.getValue();
            System.out.println(country + " - " + capital);
        }
    }
}

TreeMap

A TreeMap is a class in Java that implements the Map interface and extends the AbstractMap class. It is part of the Java Collections Framework and provides a Red-Black tree-based implementation of the Map interface. TreeMap stores its elements in a sorted and balanced tree structure, which allows for efficient operations like insertion, deletion, and retrieval of elements.

A TreeMap in Java is like an organized library catalog where books (values) are sorted and arranged by their genres (keys). This data structure automatically keeps genres in alphabetical order, making it easy to find and manage books within each category efficiently. When you add a new book to the library, you simply place it in the correct genre's section in the TreeMap. This sorting and organization make TreeMap a valuable tool for tasks requiring ordered data, ensuring quick and effective access to information.

Here's a simple example of how a TreeMap can be used to store and retrieve key-value pairs:

import java.util.*;

public class TreeMapExample {
    public static void main(String[] args) {
        // Create a TreeMap to store age-name pairs
        TreeMap<Integer, String> ageNameMap = new TreeMap<>();

        // Add age-name pairs to the TreeMap
        ageNameMap.put(25, "John");
        ageNameMap.put(30, "Alice");
        ageNameMap.put(22, "Bob");
        ageNameMap.put(28, "Eve");

        // Retrieve and print the names of people by their ages
        System.out.println("Name of person with age 25: " + ageNameMap.get(25));
        System.out.println("Name of person with age 30: " + ageNameMap.get(30));

        // Iterate through the TreeMap and print all age-name pairs in ascending order of age
        System.out.println("All Age-Name Pairs:");
        for (Map.Entry<Integer, String> entry : ageNameMap.entrySet()) {
            int age = entry.getKey();
            String name = entry.getValue();
            System.out.println("Age: " + age + ", Name: " + name);
        }
    }
}

In this example, we create a TreeMap named ageNameMap to store age-name pairs. The keys are ages (integers), and the values are names (strings). We add pairs using the put method and retrieve the names of people by their ages using the get method. When we iterate through the TreeMap, it automatically returns the age-name pairs in ascending order of age due to its sorting mechanism.

We've seen how Set implementations like HashSet, LinkedHashSet, and TreeSet cater to different needs, from unsorted uniqueness to sorted order. Similarly, Map implementations like HashMap, LinkedHashMap, and TreeMap offer varying approaches to key-value mapping, with differences in performance and ordering.

Stay tuned for the next installment as we continue this exciting journey through the world of Java collections!

Thanks for reading blog post.
If you have any queries or doubts, feel free to connect with me on Instagram. I'm here to help you with any questions you may have regarding Java or any other topic. Keep learning and exploring, and don't hesitate to reach out whenever you need assistance or clarification. Happy coding!

Java Collections Framework - A Quick and In-Depth Look (Part - 1)

Aman Gupta — Mon, 18 Sep 2023 11:30:03 +0000

Introduction

Hey folks, the Collections Framework is a really important thing in Java. Think of it as a treasure chest where you can store and manage your data. It includes interfaces like Collection, Map, and Iterator. Inside the Collection interface, you'll find interfaces like List, Set, and Queue, which organize data based on different properties.

For example, if you want to store data together, you can use List. If you need unique values, go for Set. And if you want to prioritize elements, Queue is your choice.

After that, there are classes like ArrayList, Vector, LinkedList, PriorityQueue, HashSet, LinkedHashSet, TreeSet that implement these interfaces.

So, the Collections Framework is a powerful tool that helps you with data management. Learning it is crucial if you're into Java coding.

Why do we need to use Java Collections

Now, picture this: when you're coding, you often need to store data or perform operations on it, like searching, deleting, or modifying. That's where the Collections Framework comes into play. It saves you the hassle of creating your own data structures because all these things are already available.

Imagine you're preparing for an interview or participating in a coding contest. Now, let's say you have a problem where you need to shift the element of nth index of an array to its right for m times. Doing this work using a loop can make it complex, time-consuming, and performance-inefficient. So Java Collections not only saves you time, but the data structures and algorithms involved are highly optimized. This means they work really efficiently.

Collections Hierarchy

The Java Collections Framework features a structured hierarchy that facilitates a quick understanding of the relationships between classes and interfaces.

Collections Methods

The Java Collections Framework provides a wide range of methods to manipulate and work with collections of objects.

Here is some methods are listed below:

Method	Return Type	Parameter	Description
add(E e)	boolean	E e	Adds an element to the collection.
addAll(Collection<? extends E> c)	boolean	Collection<? extends E> c	Adds all elements from another collection to the current collection.
remove(Object o)	boolean	Object o	Removes the first occurrence of the specified element from the collection.
removeAll(Collection<?> c)	boolean	Collection<?> c	Removes all elements in the current collection that are also in another collection.
size()	int	N/A	Returns the number of elements in the collection.
iterator()	Iterator	N/A	Returns an iterator to iterate through the elements.
isEmpty()	boolean	N/A	Checks if the collection is empty.
contains(Object o)	boolean	Object o	Checks if the collection contains a specified element.
containsAll(Collection<?> c)	boolean	Collection<?> c	Checks if the collection contains all elements from another collection.
clear()	void	N/A	Removes all elements from the collection.

Now we will see one by one every Interfaces.

Iterator Interface

An iterator in Java is an interface that provides a way to access elements of a collection (like lists, sets, or maps) one at a time, without exposing the underlying details of the collection's structure. It allows you to traverse through the elements in a collection sequentially in forward direction only.

It has some important methods:

hasNext(): Checks if there are more elements to iterate over and returns a boolean value.
next(): Returns the next element in the collection.
remove(): Removes the last element returned by next().

Here is a small program to demostrate use of Iterator




import java.util.ArrayList;
import java.util.Iterator;

public class IteratorExample {
    public static void main(String[] args) {
        // Create an ArrayList to store student names
        ArrayList<String> studentList = new ArrayList<>();

        // Add student names to the ArrayList
        studentList.add("Aman");
        studentList.add("Virat");
        studentList.add("Rohit");
        studentList.add("Jasprit");

        // Create an iterator to go through the student names
        Iterator<String> iterator = studentList.iterator();

        // Use a while loop to iterate through the ArrayList
        while (iterator.hasNext()) {
            // Get the next student name from the iterator
            String studentName = iterator.next();

            // Check if the student's name is "Jasprit"
            if (studentName.equals("Jasprit")) {
                // If it is "Jasprit," remove this student from the list
                iterator.remove();
                System.out.println("Removed student: " + studentName);
            } else {
                // Print the current student name to the console
                System.out.println("Student Name: " + studentName);
            }
        }

        // Print the updated list after removing "Jasprit"
        System.out.println("Updated Student List: " + studentList);
    }
}

List Interface

The List interface represents an ordered collection of elements. It allows duplicate elements and provides methods to access, insert, update, and remove elements at specific positions within the list.The classes ArrayList, LinkedList, Vector, and Stack implements the List Interface.

Here is some common methods used in list interface :

Method	Description
add(E element)	Appends the specified element to the end.
add(int index, E element)	Inserts the element at the specified position.
get(int index)	Returns the element at the specified position.
set(int index, E element)	Replaces the element at the specified position.
remove(int index)	Removes the element at the specified position.
indexOf(Object o)	Returns the index of the first occurrence.
lastIndexOf(Object o)	Returns the index of the last occurrence.
subList(int from, int to)	Returns a view of a portion of the list.

ArrayList

An ArrayList in Java is a dynamic and ordered collection that can grow or shrink in size as needed. It is used to store and manage a list of elements. ArrayList allows for easy insertion, retrieval, and removal of elements, making it a versatile data structure for working with collections of data in Java programs. It provides the benefits of an array with the added flexibility of automatic resizing, making it a popular choice for many programming tasks.

Think of an ArrayList in Java like having a list of items you need for a trip – you can add more stuff as you remember, remove things if you change your mind, and easily find an item by just knowing its place in the list. So, an ArrayList is like your trusty bag for storing and managing a bunch of items, and it's super handy when you're working with lots of data in your Java programs.

Here is a program to demonstrate ArrayList in Java:



import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ArrayListExample {
    public static void main(String[] args) {
        // Create an ArrayList of integers
        List<Integer> numbers = new ArrayList<>();

        // Add elements to the list
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);

        // Access elements by index
        int secondNumber = numbers.get(1); // Accessing the second element (20)

        // Update an element
        numbers.set(0, 15); // Replacing the first element (10) with 15

        // Remove an element
        numbers.remove(2); // Removing the third element (30)

        // Check if an element is in the list
        boolean containsTwenty = numbers.contains(20); // false

        // Returns the size of the list
        int size = numbers.size(); // Size is now 2

        // Create an iterator
        Iterator<Integer> iterator = numbers.iterator();

        // Print the elements of the list 
        while (iterator.hasNext()) {
            int number = iterator.next();
            System.out.println(number);
        }
    }
}

LinkedList

A Linked List is a linear data structure in Java that consists of a sequence of elements, where each element points to the next one in the sequence. It's made up of nodes, where each node holds both data and a reference (or link) to the next node in the list. Unlike an array, a Linked List can efficiently insert or remove elements at any position in the list, making it a flexible choice for certain data manipulation tasks.Linked Lists are often used when dynamic data storage and efficient insertions and deletions are required in Java programs.

Imagine a train with multiple compartments, each connected to the next through a small door. These compartments can represent a real-life example of a linked list. Each compartment (node) holds passengers (data) and has a door (pointer) that connects it to the next compartment. Passengers can easily enter or leave any compartment, and the train conductor can add or remove compartments when needed. This linked structure allows for efficient operations, such as adding a new compartment in the middle of the train or removing a specific compartment, making it a useful concept for tasks that involve dynamic data management, like a train ride with ever-changing passenger counts.

Here is a program to demonstrate LinkedList:




import java.util.Scanner;

// Define a Node class to represent elements in the linked list
class Node {
    int data;    // Data stored in the node
    Node next;   // Reference to the next node

    // Constructor to initialize a node with data
    Node(int data) {
        this.data = data;
        this.next = null; // Initially, the next node is set to null
    }
}

public class LinkedListExample {
    public static Node insert(Node head, int data) {
        // Function to insert a new node at the end of the linked list
        if (head == null) {
            // If the linked list is empty, create a new node and set it as the head
            return new Node(data);
        }
        Node current = head;
        while (current.next != null) {
            // Traverse the list to find the last node
            current = current.next;
        }
        // Create a new node with the given data and add it to the end of the list
        current.next = new Node(data);
        return head;
    }

    public static Node delete(Node head, int data) {
        // Function to delete a node with the specified data from the linked list
        if (head == null) {
            // If the linked list is empty, nothing to delete
            return null;
        }
        if (head.data == data) {
            // If the head node contains the data, update the head to the next node
            return head.next;
        }
        Node current = head;
        while (current.next != null && current.next.data != data) {
            // Traverse the list to find the node to be deleted
            current = current.next;
        }
        if (current.next != null) {
            // Update the next reference to skip the node to be deleted
            current.next = current.next.next;
        }
        return head;
    }

    public static void display(Node head) {
        // Function to display the elements of the linked list
        Node current = head;
        while (current != null) {
            // Traverse the list and print each element
            System.out.print(current.data + " -> ");
            current = current.next;
        }
        System.out.println("null");
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Node head = null; // Initialize the linked list as empty

        while (true) {
            // Display menu options
            System.out.println("Linked List Operations:");
            System.out.println("1. Insert");
            System.out.println("2. Delete");
            System.out.println("3. Display");
            System.out.println("4. Quit");
            System.out.print("Enter your choice: ");
            int choice = scanner.nextInt();

            switch (choice) {
                case 1:
                    // Insert operation
                    System.out.print("Enter element to insert: ");
                    int insertData = scanner.nextInt();
                    head = insert(head, insertData);
                    break;
                case 2:
                    // Delete operation
                    System.out.print("Enter element to delete: ");
                    int deleteData = scanner.nextInt();
                    head = delete(head, deleteData);
                    break;
                case 3:
                    // Display operation
                    display(head);
                    break;
                case 4:
                    // Exit the program
                    System.out.println("Exiting program.");
                    scanner.close();
                    return;
                default:
                    // Invalid choice
                    System.out.println("Invalid choice. Try again.");
            }
        }
    }
}

Vector

A Vector in Java is a dynamic, resizable array-like data structure.It's similar to an ArrayList but is synchronized, which means it is thread-safe. Vectors can grow or shrink in size as needed, making them suitable for situations where the size of the collection may change dynamically. They are primarily used when you need a collection that can be accessed by multiple threads without the risk of data corruption.

Think of a Vector like a line of people waiting for their turn to do something. People can join the line at the end, and others can leave from the front. The Vector keeps everyone in an orderly queue and makes sure there are no clashes if multiple people try to join or leave at the same time. It's like a well-organized waiting line, ensuring fairness and order.

Here is a program to demonstrate Vector:




import java.util.Vector;

public class VectorExample {
    public static void main(String[] args) {
        // Create a Vector to store integers
        Vector<Integer> numbers = new Vector<>();

        // Add elements to the Vector
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);

        // Access elements by index
        int secondNumber = numbers.get(1); // Accessing the second element (20)

        // Update an element
        numbers.set(0, 15); // Replacing the first element (10) with 15

        // Remove an element
        numbers.remove(2); // Removing the third element (30)

        // Check if an element is in the Vector
        boolean containsTwenty = numbers.contains(20); // true

        // Print the size of the Vector
        int size = numbers.size(); // Size is now 2

        // Print the elements of the Vector
        for (int number : numbers) {
            System.out.println(number);
        }
    }
}

Stack

A stack in Java is a linear data structure that follows the Last-In-First-Out (LIFO) principle. It is the subclass of Vector and operates like a collection of items where you can only add or remove elements from the top, similar to a stack of plates. Elements are added to the top of the stack and removed from the top as well. This means that the last element added to the stack is the first one to be removed. Stacks are often used for tasks that require keeping track of the order of elements, such as managing function calls in recursion, undo functionality in applications, or browser history navigation.

Think of a stack like a stack of trays in a cafeteria. You add trays to the top, and when someone wants a tray, they take the one from the top. It's a "Last-In-First-Out" (LIFO) system. In programming, it's similar; you add and remove items from the top of the stack, often used for tracking function calls, undo operations, or backtracking in algorithms, ensuring the last item added is the first to be processed or removed.

Here's a simple Java program that demonstrates the basic operations of a stack (push, pop, and peek):



import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();

        // Push elements onto the stack
        stack.push("Apple");
        stack.push("Banana");
        stack.push("Cherry");

        // Print the stack
        System.out.println("Stack: " + stack);

        // Pop an element from the stack
        String poppedElement = stack.pop();
        System.out.println("Popped Element: " + poppedElement);
        System.out.println("Updated Stack: " + stack);

        // Peek at the top element without removing it
        String topElement = stack.peek();
        System.out.println("Top Element: " + topElement);
        System.out.println("Stack after Peek: " + stack);
    }
}

Now we will look into Queue Interface.

Queue Interface

The Queue interface in Java represents a collection that holds elements in a linear order and allows adding elements at one end (enqueue) and removing elements from the other end (dequeue). It follows the "first-in-first-out" (FIFO) principle, similar to a real-world queue. Queues are often used for tasks like managing tasks in a printer queue or processing tasks in a concurrent system.

PriorityQueue Class

The PriorityQueue class in Java is an implementation of the Queue interface that provides a priority-based ordering of elements. Elements in a PriorityQueue are ordered based on their natural order or according to a specified comparator. The element with the highest priority (according to the defined order) is always at the front and will be the first to be removed when dequeued. This makes PriorityQueue suitable for tasks like task scheduling, job processing, or managing elements with priorities.

Here's a brief example of using a PriorityQueue with integers:



import java.util.PriorityQueue;

public class PriorityQueueExample {
    public static void main(String[] args) {
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();

        // Enqueue elements with different priorities
        priorityQueue.add(20);
        priorityQueue.add(10);
        priorityQueue.add(30);

        // Print the priority queue
        System.out.println("Priority Queue: " + priorityQueue);

        // Dequeue elements (highest priority first)
        int dequeuedElement = priorityQueue.poll();
        System.out.println("Dequeued Element: " + dequeuedElement);
        System.out.println("Updated Priority Queue: " + priorityQueue);
    }
}

In this example, we create a PriorityQueue of integers, enqueue elements with varying priorities, and then dequeue elements. The PriorityQueue automatically orders elements in ascending order by default (lowest value first).

Deque Interface

The Deque (pronounced as "deck") interface in Java stands for "Double Ended Queue." It is a linear collection that supports adding and removing elements from both ends, i.e., both the front and the rear. A Deque interface extends the Queue interface, adding methods for operations at both ends of the queue, making it versatile for various data manipulation scenarios.

You can use a Deque in situations where you need to efficiently insert or remove elements from the front and rear of a collection, such as implementing stacks, queues, or double-ended queues. Java provides several implementations of the Deque interface, including ArrayDeque and LinkedList.

ArrayDeque

An ArrayDeque in Java is a double-ended queue (Deque) implemented as a resizable array. It allows you to add and remove elements from both ends efficiently, making it a versatile choice for various data structure operations. Unlike a traditional array, an ArrayDeque can dynamically resize itself to accommodate elements as they are added. This data structure is often used in scenarios where you need a queue or stack-like behavior, and it provides constant time (O(1)) performance for basic operations like adding and removing elements from both ends.

Here's a brief example of using a ArrayDeque:



import java.util.ArrayDeque;
import java.util.Deque;

public class DoubleEndedQueueExample {
    public static void main(String[] args) {
        Deque<String> printerQueue = new ArrayDeque<>();

        // Add print jobs to the rear of the queue
        printerQueue.offer("Document1.pdf"); // Rear
        printerQueue.offer("Document2.pdf");
        printerQueue.offer("Document3.pdf");

        // Print jobs are processed from the front of the queue
        String currentJob = printerQueue.poll(); // Front
        System.out.println("Printing: " + currentJob);

        // Add an urgent print job to the front of the queue
        printerQueue.offerFirst("UrgentDocument.pdf"); // Front

        // Print remaining jobs
        while (!printerQueue.isEmpty()) {
            currentJob = printerQueue.poll();
            System.out.println("Printing: " + currentJob);
        }
    }
}

In this example, we use an ArrayDeque as a Deque to manage a double-ended queue for print jobs. We add jobs to the rear using offer() and to the front using offerFirst(). Print jobs are processed from the front using poll(). This demonstrates the versatility of the Deque interface for handling data from both ends.

In this blog, we've explored the foundational elements of the Java Collections Framework, focusing on the List and Queue interfaces. We've seen how this powerful framework simplifies data management by providing a wide range of ready-made data structures and algorithms. The List interface allows us to work with ordered collections, while the Queue interface is ideal for managing items in a First-In-First-Out (FIFO) manner.

Stay tuned for our next blog, where we'll dive deeper into other aspects of the Java Collections Framework, expanding your knowledge and empowering you to tackle a wider array of data management challenges.

Do let me know if you have any queries in comments or you can DM me on Instagram.

Also you can see my blog on Building a Role-Based Access Control System with JWT in Spring Boot here.

Thanks for reading.
Happy Coding 😇

Building a Role-Based Access Control System with JWT in Spring Boot

Aman Gupta — Tue, 12 Sep 2023 11:30:11 +0000

Introduction

Welcome to my blog, where we'll embark on an exciting journey into the realm of web application security! If you're new to the world of Spring Boot or just beginning to explore the intricacies of authentication and authorization, you've come to the right place. In this inaugural article, I'm thrilled to share my take on a topic that resonates with developers of all levels: Building a Role-Based Access Control System with JWT in Spring Boot.

In this blog series, we'll dive deep into the world of Spring Security and explore how JSON Web Tokens (JWT) can amplify its capabilities. I'll guide you step by step, from laying the foundation with a solid Spring Boot setup, all the way to implementing role-based access control using JWT tokens.

In this blog, we'll cover the following topics:

Creating Different Roles and Assigning it to Users
Registering Users and Administrators
Generating JWT Tokens and Authentication
Performing Role-Based Actions

Prerequisites
Before we dive into the exciting world of building a role-based access control system with JWT in Spring Boot, let's ensure that you have the necessary tools and environment ready. Here's what you'll need to get started:

Java Development Kit (JDK): Make sure you have a compatible version of JDK installed on your machine. Spring Boot usually works well with JDK 8 or higher.

Integrated Development Environment (IDE): Choose an IDE that suits your preferences. IntelliJ IDEA and Eclipse are popular choices for Spring Boot development.

Maven or Gradle: You'll need either Maven or Gradle as a build tool to manage your project dependencies.

Setting up the Environment:
Spring Boot Project Initialization: Create a new Spring Boot project using either Spring Initializr web tool here or your IDE's project creation wizard.

Here is my setup you can follow:
Project: Maven
Spring Boot Version:2.7.3 (if not available then use 3.1.3 then change it later in pom.xml)
Java Version:17
Dependencies:
1.Spring Data JPA
2.Spring web
3.Spring Security
4.MySQL Driver
5.JSON WEB TOKEN

You will not find JSON web Token there you have to add it manually

<dependency>
     <groupId>io.jsonwebtoken</groupId>
     <artifactId>jjwt</artifactId>
     <version>0.9.1</version>
</dependency>

Here is full pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.alpha</groupId>
    <artifactId>alpha</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>alpha</name>
    <description>Demo project for Spring Boot Role based Authentication using JWT </description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

application.properties

jwt.token.validity=18000
jwt.signing.key=YourSignInKey
jwt.authorities.key=roles
jwt.token.prefix=Bearer
jwt.header.string=Authorization

spring.datasource.url=jdbc:mysql://localhost:3306/yourdb
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update
spring.user.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect
server.port=8080

This is a configuration file for a Spring Boot application.

The first line sets the validity duration for JSON Web Tokens (JWT) to 18000 seconds (5 hours).
The second line specifies the signing key to be used for generating and validating JWTs.
The third line defines the key for extracting authorities/roles from a JWT.
The fourth line sets the prefix for JWT tokens to "Bearer".
The fifth line specifies the header string to be used for JWT tokens in HTTP requests.
The next few lines configure the MySQL database connection for the application, including the URL, username, and password.
The line spring.jpa.show-sql=true enables the display of SQL statements executed by Hibernate.
The line spring.jpa.hibernate.ddl-auto=update configures Hibernate to automatically update the database schema based on the entity classes.
The line spring.user.datasource.driver-class-name=com.mysql.jdbc.Driver specifies the driver class for the user datasource.
The line spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect sets the Hibernate dialect for MySQL.
The last line sets the server port to 8080.

"As you can see, here is the clear folder structure."

src
└── main
    ├── java
    │   └── com
    │       └── alpha
    │           ├── config (Package)
    │           │   ├── JwtAuthenticationFilter.java
    │           │   ├── PasswordEncoder.java
    │           │   ├── TokenProvider.java
    │           │   ├── UnauthorizedEntryPoint.java
    │           │   └── WebSecurityConfig.java
    │           ├── controller (Package)
    │           │   └── UserController.java
    │           ├── dao (Package)
    │           │   ├── RoleDao.java
    │           │   └── UserDao.java
    │           ├── model (Package)
    │           │   ├── AuthToken.java
    │           │   ├── LoginUser.java
    │           │   ├── Role.java
    │           │   ├── User.java
    │           │   └── UserDto.java
    │           ├── service (Package)
    │           │   ├── impl
    │           │   │   ├── RoleServiceImpl.java
    │           │   │   └── UserServiceImpl.java
    │           │   ├── RoleService.java
    │           │   └── UserService.java
    │           └── AlphaApplication.java
    └── resources
        └── application.properties

Let's get started!

Now we will start with understanding the config package

Spring Security is a powerful and highly customizable security framework provided by the Spring Framework for Java applications. Its primary purpose is to handle authentication, authorization, and various security aspects in web and enterprise applications. Spring Security is often used to secure web applications, RESTful APIs, and other components of a software system.

Authentication:
Authentication is the process of confirming the identity of a person or entity. It ensures that the person or entity is who they claim to be before granting access to something. It's like checking someone's ID before allowing them to enter a secure area.
Imagine a professional cricket match. Before a player can step onto the field, they must prove their identity. They do this by showing their official player card with their name, photo, and a unique ID number. The match officials, like the umpires and team captains, examine the card to ensure it matches the player's appearance and is on the list of authorized players. Once confirmed, the player is authenticated and allowed to participate in the game.

Authorization:
Authorization comes after authentication and determines what actions or resources an authenticated person or entity is allowed to access or perform. It specifies the level of access and control based on roles, permissions, or rules.

Once a cricket player is authenticated and on the field, authorization kicks in. Each player has a specific role (e.g., batsman, bowler, fielder) with associated actions they can perform. For example, a bowler is authorized to bowl, a batsman is authorized to bat, and a wicketkeeper is authorized to keep wickets. The coach or captain may have special authorization to make strategic decisions during the match, like changing the batting order or field placements.

lets move on to our config files one by one

CORSFilter :
CORSFilter class is responsible for handling CORS-related settings in a web application. It intercepts incoming HTTP requests, adds the necessary CORS headers to the response, and then allows the request to continue processing using chain.doFilter(req, res). This filter helps control and secure how resources on the server are accessed by different origins in a web application.

package com.alpha.config;

import javax.servlet.*;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;


public class CORSFilter implements Filter {

    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
        HttpServletResponse response = (HttpServletResponse) res;
        response.setHeader("Access-Control-Allow-Origin", "*");
        response.setHeader("Access-Control-Allow-Credentials", "true");
        response.setHeader("Access-Control-Allow-Methods", "POST, GET, PUT, OPTIONS, DELETE");
        response.setHeader("Access-Control-Max-Age", "3600");
        response.setHeader("Access-Control-Allow-Headers", "X-Requested-With, Content-Type, Authorization, Origin, Accept, Access-Control-Request-Method, Access-Control-Request-Headers");
        chain.doFilter(req, res);
    }

    public void init(FilterConfig filterConfig) {}

    public void destroy() {}

}

This class implements the Filter interface, which is part of the Java Servlet API. Filters are used to perform actions on HTTP requests and responses as they pass through the application.

doFilter method :- This method is required when implementing the Filter interface. It is called for each incoming HTTP request. Inside this method, the code is responsible for adding necessary CORS headers to the HTTP response. CORS headers are used to control and define the policy for cross-origin requests. They specify who can access the resources of a web page and what operations are permitted from different origins. The code in this method sets various CORS headers, such as Access-Control-Allow-Origin, Access-Control-Allow-Methods, and others. These headers dictate which domains are allowed to access the resources, which HTTP methods are permitted, and other CORS-related policies.

The init method is used for initialization tasks that the filter may need when it's first created.

The destroy method is called when the filter is being removed or shut down.

WebSecurityConfig
This class is responsible for configuring security settings, such as authentication, authorization, and request filtering, in a Spring Boot web application. It also integrates custom components, like the JwtAuthenticationFilter, to handle specific security
requirements. This configuration is a common setup for securing RESTful APIs or web applications using Spring Security.

package com.alpha.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

import javax.annotation.Resource;

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Resource(name = "userService")
    private UserDetailsService userDetailsService;

    @Autowired
    private PasswordEncoder encoder;

    @Autowired
    private UnauthorizedEntryPoint unauthorizedEntryPoint;

    @Override
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService).passwordEncoder(encoder.encoder());
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.cors().and().csrf().disable()
                .authorizeRequests()
                .antMatchers("/users/authenticate", "/users/register").permitAll()
                .anyRequest().authenticated()
                .and()
                .exceptionHandling().authenticationEntryPoint(unauthorizedEntryPoint).and()
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);

        http.addFilterBefore(authenticationTokenFilterBean(), UsernamePasswordAuthenticationFilter.class);
    }

    @Override
    @Bean
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    @Bean
    public JwtAuthenticationFilter authenticationTokenFilterBean() throws Exception {
        return new JwtAuthenticationFilter();
    }
}

@Configuration: Indicates that this class contains configuration settings for the application.
@EnableWebSecurity: Enables Spring Security features for the web application.
@EnableGlobalMethodSecurity(prePostEnabled = true): Enables method-level security annotations such as @PreAuthorize and @PostAuthorize.

@Resource: Injects the UserDetailsService bean, likely responsible for user-related operations.
@Autowired: Injects instances of PasswordEncoder and UnauthorizedEntryPoint beans, which are used for password hashing and handling unauthorized access, respectively.

configure(AuthenticationManagerBuilder auth) Method:

This method configures the authentication manager.
It specifies that the userDetailsService bean should be used for user authentication and sets the password encoder.

configure(HttpSecurity http) Method:

This method configures the HTTP security settings.
It includes settings for CORS (Cross-Origin Resource Sharing), CSRF (Cross-Site Request Forgery), and URL permissions.
It specifies which URLs are accessible without authentication ("/users/authenticate" and "/users/register") and requires authentication for all other requests.
It sets an authentication entry point for handling unauthorized access and defines the session management policy as STATELESS.
The addFilterBefore method adds a custom JwtAuthenticationFilter before the UsernamePasswordAuthenticationFilter to handle JWT (JSON Web Token) authentication.

authenticationManagerBean() Method:

This method declares an AuthenticationManager bean, which is used for user authentication.

JwtAuthenticationFilter Bean:

This method declares a bean for the JwtAuthenticationFilter, which is a custom filter used for JWT-based authentication.

TokenProvider
This class is responsible for handling JWTs in a Spring Boot application's security flow. It can generate tokens, extract user information from tokens, validate tokens, and create authentication tokens for users based on the information stored in the JWTs.

package com.alpha.config;

import io.jsonwebtoken.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;

import java.io.Serializable;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.function.Function;
import java.util.stream.Collectors;

@Component
public class TokenProvider implements Serializable {

    @Value("${jwt.token.validity}")
    public long TOKEN_VALIDITY;

    @Value("${jwt.signing.key}")
    public String SIGNING_KEY;

    @Value("${jwt.authorities.key}")
    public String AUTHORITIES_KEY;

    public String getUsernameFromToken(String token) {
        return getClaimFromToken(token, Claims::getSubject);
    }

    public Date getExpirationDateFromToken(String token) {
        return getClaimFromToken(token, Claims::getExpiration);
    }

    public <T> T getClaimFromToken(String token, Function<Claims, T> claimsResolver) {
        final Claims claims = getAllClaimsFromToken(token);
        return claimsResolver.apply(claims);
    }

    private Claims getAllClaimsFromToken(String token) {
        return Jwts.parser()
                .setSigningKey(SIGNING_KEY)
                .parseClaimsJws(token)
                .getBody();
    }

    private Boolean isTokenExpired(String token) {
        final Date expiration = getExpirationDateFromToken(token);
        return expiration.before(new Date());
    }

    public String generateToken(Authentication authentication) {
         String authorities = authentication.getAuthorities().stream()
                .map(GrantedAuthority::getAuthority)
                .collect(Collectors.joining(","));

        return Jwts.builder()
                .setSubject(authentication.getName())
                .claim(AUTHORITIES_KEY, authorities)
                .setIssuedAt(new Date(System.currentTimeMillis()))
                .setExpiration(new Date(System.currentTimeMillis() + TOKEN_VALIDITY*1000))
                .signWith(SignatureAlgorithm.HS256, SIGNING_KEY)
                .compact();
    }

    public Boolean validateToken(String token, UserDetails userDetails) {
        final String username = getUsernameFromToken(token);
        return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
    }

    UsernamePasswordAuthenticationToken getAuthenticationToken(final String token, final Authentication existingAuth, final UserDetails userDetails) {

        final JwtParser jwtParser = Jwts.parser().setSigningKey(SIGNING_KEY);

        final Jws<Claims> claimsJws = jwtParser.parseClaimsJws(token);

        final Claims claims = claimsJws.getBody();

        final Collection<? extends GrantedAuthority> authorities =
                Arrays.stream(claims.get(AUTHORITIES_KEY).toString().split(","))
                        .map(SimpleGrantedAuthority::new)
                        .collect(Collectors.toList());

        return new UsernamePasswordAuthenticationToken(userDetails, "", authorities);
    }

}

@Component: Marks this class as a Spring component, allowing it to be automatically scanned and registered as a bean in the Spring application context.

getUsernameFromToken(String token): This method extracts the username (subject) from a JWT token.
getExpirationDateFromToken(String token): Retrieves the expiration date from a JWT token.
getClaimFromToken(String token, Function claimsResolver): A generic method to extract claims from a JWT token.
getAllClaimsFromToken(String token): Parses and retrieves all claims (payload) from a JWT token.
isTokenExpired(String token): Checks whether a JWT token has expired based on its expiration date.
generateToken(Authentication authentication): Generates a new JWT token based on the provided Authentication object. It includes the subject (username), authorities, issuance time, and expiration time.
validateToken(String token, UserDetails userDetails): Validates a JWT token against the provided UserDetails. It checks if the token's subject matches the user's username and if the token is not expired.
getAuthenticationToken(final String token, final Authentication existingAuth, final UserDetails userDetails): This method parses a JWT token to create an Authentication object containing the user's authorities. It's used for authenticating users based on JWT tokens.

JwtAuthenticationFilter
JwtAuthenticationFilter is responsible for intercepting incoming requests, extracting JWTs from request headers, and authenticating users based on the tokens. It ensures that authenticated users have their security context set, allowing them to access protected resources within the application.

package com.alpha.config;

import io.jsonwebtoken.ExpiredJwtException;
import io.jsonwebtoken.SignatureException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.annotation.Resource;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class JwtAuthenticationFilter extends OncePerRequestFilter {

    @Value("${jwt.header.string}")
    public String HEADER_STRING;

    @Value("${jwt.token.prefix}")
    public String TOKEN_PREFIX;

    @Resource(name = "userService")
    private UserDetailsService userDetailsService;

    @Autowired
    private TokenProvider jwtTokenUtil;

    @Override
    protected void doFilterInternal(HttpServletRequest req, HttpServletResponse res, FilterChain chain) throws IOException, ServletException {
        String header = req.getHeader(HEADER_STRING);
        String username = null;
        String authToken = null;

        if (header != null && header.startsWith(TOKEN_PREFIX)) {
            authToken = header.replace(TOKEN_PREFIX, "");

            try {
                username = jwtTokenUtil.getUsernameFromToken(authToken);
            } catch (IllegalArgumentException e) {
                logger.error("Error occurred while retrieving Username from Token", e);
            } catch (ExpiredJwtException e) {
                logger.warn("The token has expired", e);
            } catch (SignatureException e) {
                logger.error("Authentication Failed. Invalid username or password.");
            }
        } else {
            logger.warn("Bearer string not found, ignoring the header");
        }

        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            UserDetails userDetails = userDetailsService.loadUserByUsername(username);

            if (jwtTokenUtil.validateToken(authToken, userDetails)) {
                UsernamePasswordAuthenticationToken authentication = jwtTokenUtil.getAuthenticationToken(authToken, SecurityContextHolder.getContext().getAuthentication(), userDetails);
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(req));
                logger.info("User authenticated: " + username + ", setting security context");
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
        }

        chain.doFilter(req, res);
    }
}

This class extends OncePerRequestFilter, which ensures that this filter is applied only once per request.
doFilterInternal Method:This method is the core of the filter and is called for each incoming HTTP request.
The method first checks if a JWT is present in the request header and if it starts with the defined token prefix ("Bearer ").
If a valid token is found, it attempts to extract the username from the token using the TokenProvider class.
It catches exceptions for various token-related errors, such as token expiration (ExpiredJwtException) and invalid signatures (SignatureException), and logs them.
If a valid username is obtained from the token and there is no existing authentication context, it loads the user details from the UserDetailsService based on the username.
It then validates the token against the user details using the TokenProvider. If the token is valid, it creates an UsernamePasswordAuthenticationToken containing the user details and sets the authentication details.
Finally, it sets the authenticated user's security context using SecurityContextHolder.
After handling authentication, the filter continues the request processing by invoking chain.doFilter(req, res).

BCryptPasswordEncoder
This bean can be used throughout the application for securely hashing and verifying passwords, especially in the context of user authentication and security. It's a common practice to configure and manage password encoding components like this in Spring applications to enhance security.

package com.alpha.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

@Configuration
public class PasswordEncoder {

    @Bean
    public BCryptPasswordEncoder encoder(){
        return new BCryptPasswordEncoder();
    }
}

BCryptPasswordEncoder is a popular password hashing library in the Spring Security framework. It's used to securely hash and verify passwords.
In this configuration, the BCryptPasswordEncoder bean is created and returned by the encoder() method. This bean can then be injected into other parts of the application, such as Spring Security configurations, to handle password encoding and decoding.

UnauthorizedEntryPoint
UnauthorizedEntryPoint class is responsible for handling unauthorized access to protected resources in a Spring Security-enabled application. When an unauthenticated user attempts to access a protected resource, this class sends an HTTP response with a status code of 401, indicating that the request lacks valid authentication. This response informs the client that they need to provide proper authentication credentials to access the resource.

package com.alpha.config;

import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.Serializable;


@Component
public class UnauthorizedEntryPoint implements AuthenticationEntryPoint, Serializable {

    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException {
        response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Unauthenticated");
    }

}

This class implements the AuthenticationEntryPoint interface, which is part of Spring Security. The AuthenticationEntryPoint interface is responsible for handling authentication-related exceptions, particularly unauthorized access.

The commence method is the main method of this class, and it's called when an authentication exception occurs during an HTTP request.
It takes three parameters:

1.HttpServletRequest request: Represents the incoming HTTP
request.
2.HttpServletResponse response: Represents the HTTP response
that will be sent back to the client.
3.AuthenticationException authException: Represents the
authentication exception that occurred, typically due to
unauthorized access.
In this method, it sends an HTTP response with a status code of 401 Unauthorized and a message of "Unauthenticated." This is a standard response for indicating that the request lacks valid authentication credentials or authorization.

okay lets start with our model classes

User
The User class represents a user entity with attributes like username, password, email, phone, name, and roles. It also defines a many-to-many relationship with the Role entity, allowing users to have multiple roles.

package com.alpha.model;

import com.fasterxml.jackson.annotation.JsonIgnore;

import javax.persistence.*;
import java.util.Set;

@Entity
public class User {

    @Id
    @GeneratedValue(strategy= GenerationType.IDENTITY)
    private long id;

    @Column
    private String username;

    @Column
    @JsonIgnore
    private String password;

    @Column
    private String email;

    @Column
    private String phone;

    @Column
    private String name;

    @ManyToMany(fetch = FetchType.EAGER, cascade = CascadeType.ALL)
    @JoinTable(name = "USER_ROLES",
            joinColumns = {
            @JoinColumn(name = "USER_ID")
            },
            inverseJoinColumns = {
            @JoinColumn(name = "ROLE_ID") })
    private Set<Role> roles;

    public long getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Set<Role> getRoles() {
        return roles;
    }

    public void setRoles(Set<Role> roles) {
        this.roles = roles;
    }
}

This defines a many-to-many relationship between the User entity and the Role entity. Users can have multiple roles, and roles can be associated with multiple users.
The @ManyToMany annotation indicates a many-to-many relationship.
The fetch = FetchType.EAGER attribute specifies that roles should be eagerly fetched when loading a user.
The cascade = CascadeType.ALL attribute specifies that if operations like persist, merge, remove, etc., are performed on a User entity, the same operations should be cascaded to its associated Role entities.
The @JoinTable annotation is used to define the name of the join table that holds the relationship between users and roles. It specifies the columns used for joining the tables.

Role
the Role class represents a user role entity with attributes like name and description. It is designed to be persisted in a database table and can be associated with users through a many-to-many relationship, as indicated by the User entity's relationship mapping that references Role.

package com.alpha.model;

import javax.persistence.*;

@Entity
public class Role {

    @Id
    @GeneratedValue(strategy= GenerationType.IDENTITY)
    private long id;

    @Column
    private String name;

    @Column
    private String description;

    // Getter for id
    public long getId() {
        return id;
    }

    // Setter for id
    public void setId(long id) {
        this.id = id;
    }

    // Getter for name
    public String getName() {
        return name;
    }

    // Setter for name
    public void setName(String name) {
        this.name = name;
    }

    // Getter for description
    public String getDescription() {
        return description;
    }

    // Setter for description
    public void setDescription(String description) {
        this.description = description;
    }
}

the Role class represents a user role entity with attributes like name and description. It is designed to be persisted in a database table and can be associated with users through a many-to-many relationship, as indicated by the User entity's relationship mapping that references Role.

AuthToken

package com.alpha.model;

/**
 * Represents an authentication token.
 */
public class AuthToken {
    private String token;

    /**
     * Constructs a new AuthToken object.
     */
    public AuthToken() {
    }

    /**
     * Constructs a new AuthToken object with the specified token.
     * 
     * @param token the authentication token
     */
    public AuthToken(String token) {
        this.token = token;
    }

    /**
     * Returns the authentication token.
     * 
     * @return the authentication token
     */
    public String getToken() {
        return token;
    }

    /**
     * Sets the authentication token.
     * 
     * @param token the authentication token to be set
     */
    public void setToken(String token) {
        this.token = token;
    }
}

LoginUser

package com.alpha.model;

public class LoginUser {
    private String username;
    private String password;

    // Getters and Setters for username
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }

    // Getters and Setters for password
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
}

UserDto

package com.alpha.model;

public class UserDto {

    private String username;
    private String password;
    private String email;
    private String phone;
    private String name;


    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public User getUserFromDto(){
        User user = new User();
        user.setUsername(username);
        user.setPassword(password);
        user.setEmail(email);
        user.setPhone(phone);
        user.setName(name);

        return user;
    }

}

DAO is a Spring Data JPA repository interface typically used for performing CRUD (Create, Read, Update, Delete) operations on the entity class. Let's break down its key components:

UserDao

package com.alpha.dao;

import com.alpha.model.User;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserDao extends CrudRepository<User, Long> {
    User findByUsername(String username);
}

RoleDao

package com.alpha.dao;

import com.alpha.model.Role;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface RoleDao extends CrudRepository<Role, Long> {
    Role findRoleByName(String name);
}

You can use JPARepository also.

Service Layer

We will now proceed to define service interfaces for our User and Role services. These service interfaces will serve as blueprints for the actual service implementations and will encapsulate the core business logic.

As a best practice, using interfaces for service definitions promotes separation of concerns and allows for easy switching of implementations, such as when using mocking frameworks for testing.
RoleService

package com.alpha.service;

// Importing the Role model
import com.alpha.model.Role;

// Declaring the RoleService interface
public interface RoleService {
    // Method to find a Role by its name
    Role findByName(String name);
}

UserService

package com.alpha.service;

import com.alpha.model.User;
import com.alpha.model.UserDto;

import java.util.List;

public interface UserService {

    // Saves a user
    User save(UserDto user);

    // Retrieves all users
    List<User> findAll();

    // Retrieves a user by username
    User findOne(String username);

    User createEmployee(UserDto user);

}

Now we will implement our service logic
RoleServiceImpl

package com.alpha.service.impl;

import com.alpha.dao.RoleDao;
import com.alpha.model.Role;
import com.alpha.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service(value = "roleService")
public class RoleServiceImpl implements RoleService {

    @Autowired
    private RoleDao roleDao;

    @Override
    public Role findByName(String name) {
        // Find role by name using the roleDao
        Role role = roleDao.findRoleByName(name);
        return role;
    }
}

UserServiceImpl

package com.alpha.service.impl;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import com.alpha.dao.UserDao;
import com.alpha.model.Role;
import com.alpha.model.User;
import com.alpha.model.UserDto;
import com.alpha.service.RoleService;
import com.alpha.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;

@Service(value = "userService")
public class UserServiceImpl implements UserDetailsService, UserService {

    @Autowired
    private RoleService roleService;

    @Autowired
    private UserDao userDao;

    @Autowired
    private BCryptPasswordEncoder bcryptEncoder;

    // Load user by username
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userDao.findByUsername(username);
        if(user == null){
            throw new UsernameNotFoundException("Invalid username or password.");
        }
        return new org.springframework.security.core.userdetails.User(user.getUsername(), user.getPassword(), getAuthority(user));
    }

    // Get user authorities
    private Set<SimpleGrantedAuthority> getAuthority(User user) {
        Set<SimpleGrantedAuthority> authorities = new HashSet<>();
        user.getRoles().forEach(role -> {
            authorities.add(new SimpleGrantedAuthority("ROLE_" + role.getName()));
        });
        return authorities;
    }

    // Find all users
    public List<User> findAll() {
        List<User> list = new ArrayList<>();
        userDao.findAll().iterator().forEachRemaining(list::add);
        return list;
    }

    // Find user by username
    @Override
    public User findOne(String username) {
        return userDao.findByUsername(username);
    }

    // Save user
    @Override
    public User save(UserDto user) {

        User nUser = user.getUserFromDto();
        nUser.setPassword(bcryptEncoder.encode(user.getPassword()));

        // Set default role as USER
        Role role = roleService.findByName("USER");
        Set<Role> roleSet = new HashSet<>();
        roleSet.add(role);

        // If email domain is admin.edu, add ADMIN role
        if(nUser.getEmail().split("@")[1].equals("admin.edu")){
            role = roleService.findByName("ADMIN");
            roleSet.add(role);
        }

        nUser.setRoles(roleSet);
        return userDao.save(nUser);
    }

    @Override
    public User createEmployee(UserDto user) {
        User nUser = user.getUserFromDto();
        nUser.setPassword(bcryptEncoder.encode(user.getPassword()));

        Role employeeRole = roleService.findByName("EMPLOYEE");
        Role customerRole = roleService.findByName("USER");

        Set<Role> roleSet = new HashSet<>();
        if (employeeRole != null) {
            roleSet.add(employeeRole);
        }
        if (customerRole != null) {
            roleSet.add(customerRole);
        }

        nUser.setRoles(roleSet);
        return userDao.save(nUser);
    }
}

lets create our controller class

The initial step for a user is to complete the registration process. At a minimum, users are required to provide a username and password. By invoking the service method to save the user, this essential step is completed.

To access the application's APIs securely, users must include a server-generated JWT (JSON Web Token). All the necessary groundwork for this has been laid out in our TokenProvider. We utilize the generateToken method and include the resulting token in the response, ensuring secure access to the APIs.
UserController
UserController class handles user-related HTTP requests, including registration and authentication. It also demonstrates role-based access control for specific resources. The actual business logic for user operations is delegated to the UserService and TokenProvider components.

package com.alpha.controller;

import com.alpha.config.TokenProvider;
import com.alpha.model.AuthToken;
import com.alpha.model.LoginUser;
import com.alpha.model.User;
import com.alpha.model.UserDto;
import com.alpha.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@CrossOrigin(origins = "*", maxAge = 3600)
@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private AuthenticationManager authenticationManager;

    @Autowired
    private TokenProvider jwtTokenUtil;

    @Autowired
    private UserService userService;

    /**
     * Generates a token for the given user credentials.
     *
     * @param loginUser The user's login credentials.
     * @return A response entity containing the generated token.
     * @throws AuthenticationException if authentication fails.
     */
    @RequestMapping(value = "/authenticate", method = RequestMethod.POST)
    public ResponseEntity<?> generateToken(@RequestBody LoginUser loginUser) throws AuthenticationException {
        final Authentication authentication = authenticationManager.authenticate(
                new UsernamePasswordAuthenticationToken(
                        loginUser.getUsername(),
                        loginUser.getPassword()
                )
        );
        SecurityContextHolder.getContext().setAuthentication(authentication);
        final String token = jwtTokenUtil.generateToken(authentication);
        return ResponseEntity.ok(new AuthToken(token));
    }

    /**
     * Saves a new user.
     *
     * @param user The user to be saved.
     * @return The saved user.
     */
    @RequestMapping(value="/register", method = RequestMethod.POST)
    public User saveUser(@RequestBody UserDto user){
        return userService.save(user);
    }

    /**
     * Returns a message that can only be accessed by users with the 'ADMIN' role.
     *
     * @return A message that can only be accessed by admins.
     */
    @PreAuthorize("hasRole('ADMIN')")
    @RequestMapping(value="/adminping", method = RequestMethod.GET)
    public String adminPing(){
        return "Only Admins Can Read This";
    }

    /**
     * Returns a message that can be accessed by any user.
     *
     * @return A message that can be accessed by any user.
     */
    @PreAuthorize("hasRole('USER')")
    @RequestMapping(value="/userping", method = RequestMethod.GET)
    public String userPing(){
        return "Any User Can Read This";
    }

    @PreAuthorize("hasRole('ADMIN')")
    @RequestMapping(value="/create/employee", method = RequestMethod.POST)
    public User createEmployee(@RequestBody UserDto user){
        return userService.createEmployee(user);
    }

    @PreAuthorize("hasRole('ADMIN')")
    @RequestMapping(value="/find/all", method = RequestMethod.GET)
    public List<User> getAllList(){
        return userService.findAll();
    }

    @PreAuthorize("hasRole('ADMIN')")
    @RequestMapping(value="/find/by/username", method = RequestMethod.GET)
    public User getAllList(@RequestParam String username){
        return userService.findOne(username);
    }
}

These methods demonstrate role-based access control using Spring Security's @PreAuthorize annotation. adminPing can be accessed only by users with the 'ADMIN' role, while userPing can be accessed by users with the 'USER' role.

Before testing your apis you need to add some roles into your db

INSERT INTO role (id, description, name) VALUES (1, 'Admin role', 'ADMIN');
INSERT INTO role (id, description, name) VALUES (2, 'Employee role', 'EMPLOYEE');
INSERT INTO role (id, description, name) VALUES (3, 'User role', 'USER');

Finally you can test your apis in postman
I have created collection for postman

Here is the whole code is in my github

If you find any doubt feel free to contact me on Instagram
Thanks for reading !
Happy Coding !