Forem: Kailash Nirmal

Deep Dive: Maven Build Lifecycle & the Truth About -DskipTests

Kailash Nirmal — Thu, 05 Mar 2026 10:26:05 +0000

A practical breakdown of what Maven does behind the scenes

Introduction

Why Every Java Developer Should Understand mvn clean install? Well
Every Java developer types mvn clean installdozens of times a day. But how many of us actually know what happens behind the scenes?

So let's check out :)

First of all, mvn clean install executes two Maven lifecycle phases in sequence.

clean Lifecycle

Maven first runs the clean lifecycle, which has 3 phases:

install Lifecycle (Default Lifecycle)

Then Maven runs the default lifecycle up to the install phase, executing every phase in order:

Diagram for Better Understanding :

Does it skip tests?

No — by default, mvn clean install does NOT skip tests. The test phase runs automatically.

To skip tests, you have two options:

# Skip test EXECUTION (but still compiles tests)
mvn clean install -DskipTests

# Skip test COMPILATION + execution entirely
mvn clean install -Dmaven.test.skip=true

Conclusion

mvn clean installruns the clean lifecycle first, then the default lifecycle up to install
Tests are a core part of the lifecycle and run by default — never skipped unless you explicitly ask
-DskipTests is a Maven build property (not a JVM property) consumed by the Surefire Plugin
-DskipTests skips execution only — test classes are still compiled
Use -Dmaven.test.skip=true when you want the fastest possible build

Disclaimer: This blog is based on my personal understanding and learning. There may be variations in the actual flow depending on your Maven version or project configuration. I encourage you to verify with the official Maven documentation. I hope this was helpful in your learning journey!

Thank you so much for taking the time to read this blog. I hope it added some value to your learning journey!
With regards,
JavaCharter | Kailash
Happy Coding! ☕💻

How to Write a Clean, Professional README.md (A Practical Guide for Developers)

Kailash Nirmal — Thu, 15 Jan 2026 10:44:28 +0000

Hello Everyone! 👋
Hope you all are doing great — and Happy New Year 2026! 🎉
This is my very first blog of 2026, and I’m really excited to share it with you all.
I decided to write this blog because I recently faced a few unexpected challenges while working on a ENVIRONMENT_SETUP.md document inside my STS IDE. When I clicked on the Preview tab, some parts of my Markdown were not rendering the way I expected — titles were broken, bold text didn’t appear, XML was escaped, and new lines didn’t show correctly.
If you’ve ever edited Markdown directly inside an IDE and wondered why the preview looks strange… trust me, you’re not alone!

A good README.md is the face of your project. It tells readers what your project is, how to set it up, how to use it, and why it matters. Whether you’re working on open-source, enterprise codebases, or internal tools, a clear README saves time for your team, future contributors, and even your future self.
In this guide, I’ll walk you through how to write a clean, professional README using Markdown — including titles, bold text, code blocks, XML formatting, line breaks, and preview screenshots from any standard IDE or Markdown viewer.

1. Start With a Strong Title

Use a single # at the top for the main project title:

This will render as a big, bold page title.
Example (rendered):

My Awesome Project

2. Use Headings to Structure the Document

Rendered:

Installation

Prerequisites

Headings help readers quickly scan your documentation.

3. Use Bold Text for Important Highlights

For bold text without creating a heading, wrap the text with **:

Rendered:

This is bold text

4. Use Code Blocks to Show Commands, XML, JSON, YAML, etc.

This is one of the most important parts of a README.

then

5. How to Write XML in README (Without Breaking It)

6. How to Add a New Line in Markdown

Markdown ignores single newlines. Here are correct ways to force them:

a) Two spaces at the end of a line

Line 1␣␣
Line 2

b) Use

Line 1

Line 2

c) Blank line (paragraph break)

Line 1

Line 2

7. Use Lists for Steps or Bullet Points

8. Show File Paths, Commands, or One‑Line Code Using Inline Code

Use backticks ` around short snippets.

10. Write a Clean Structure (Recommended Format)

11. Previewing Your README

Most IDEs support Markdown preview:

VS Code:
Ctrl + Shift + V → Open Preview
IntelliJ / STS / WebStorm:
Built-in Markdown preview panel
GitHub/GitLab:
Automatically renders README.md

Always preview your README before committing.

Final Thoughts

A good README is a small investment with a huge return.
It improves collaboration, reduces onboarding time, and makes your project more usable and understandable.
By mastering simple Markdown tricks — headings, bold text, line breaks, XML blocks — you instantly level up the professionalism of your documentation.

Thanks,
Kailash
JavaCharter
Happy Coding!!

My Experience with Azure Certification Renewal: Key Topics, Sample Questions, and Tips

Kailash Nirmal — Wed, 03 Dec 2025 05:35:53 +0000

Introduction

Recently, I completed the renewal exam for my Azure certification, and I wanted to share my experience to help others prepare. The renewal process is free, online, and focuses on validating your knowledge of the latest Azure features and best practices.

In this blog, I’ll cover:

What’s included in the renewal exam
Key areas you should focus on
A few sample questions with explanations
Tips to prepare effectively

What’s Included in the Renewal Exam?

The renewal exam is scenario-based and tests your practical understanding of Azure services. It’s not about memorizing definitions—it’s about applying concepts to real-world situations.
Topics covered in my renewal exam included:

Azure App Configuration (feature flags, labels)
Application Insights (sampling, metrics, availability tests)
Azure Container Apps & Container Instances
Azure Functions (C#, Python triggers and bindings)
Azure Storage & Cosmos DB (soft delete, partition keys, consistency levels)
Identity and Security (Managed Identity, RBAC)

Sample Questions and Explanations

Azure App Configuration – Feature Flags

Question:

You need to implement a feature flag in Azure App Configuration. Which two properties are required?

Name
List of filters
Labels
Keys and values

Answer:

Name
List of filters.

Feature flags require a unique name and conditions (filters) to determine when the feature is enabled.

Application Insights – Reduce Telemetry

Question

Your app sends large telemetry volumes, and Application Insights is throttling data. How do you reduce traffic while maintaining statistical accuracy?

Sampling
Distributed tracing
Metric alerts
Log search alerts

Answer:

Sampling

Adaptive sampling reduces telemetry volume while preserving representative data.

Azure Container Instances – SMB Access

Question:

You need to access data from a container using SMB protocol. What should you use?

YAML file
Container group
Azure File share
Environment variable

Answer:

Azure File share.

Azure Files supports SMB and can be mounted inside containers.

Tips for Success

Focus on practical scenarios: Understand how services work together (e.g., Managed Identity with Azure SQL).
Review documentation: Microsoft Learn and official docs are your best resources.
Practice with real examples: Try configuring feature flags, enabling sampling, or mounting Azure File shares.
Don’t memorize—understand: The exam checks applied knowledge, not rote learning.

Final Thoughts

The renewal exam is a great way to stay current with Azure. It’s free, quick, and ensures you’re up to date with best practices. I’ve attached my result screenshot below to share my achievement and motivate others to renew their certifications.

Screenshot for my result

Thanks,
Kailash
JavaCharter

Hope this was helpful!!

Integrating Checkstyle into Your Maven Project for Clean and Consistent Code

Kailash Nirmal — Tue, 10 Jun 2025 12:21:21 +0000

🧩 Introduction

Inconsistent code style can slow down collaboration in teams of 10+ developers, costing hours in reviews.

In modern software development, a clean and consistent codebase isn’t just nice to have—it’s a necessity. Inconsistent formatting, missing Javadoc, or poorly structured code can slow down collaboration, introduce bugs, and make maintenance a nightmare, especially in large teams or long-term projects. This is where Checkstyle comes into picture!

🔍 What is Checkstyle?

Checkstyle is a static code analysis tool for Java that helps developers follow coding standards. It automatically checks your code against a set of rules and flags any violations, such as incorrect indentation, naming conventions, or missing documentation.

🧠 Why is Code Style Important?

In large teams, developers often have different coding habits. Without a unified style:

Code becomes harder to read and maintain.
Merge conflicts increase.
Bugs are more likely to slip through.

By enforcing a consistent style, teams can:

Improve code readability.
Reduce onboarding time for new developers.
Enhance collaboration and maintainability.

⚙️ Why Use Maven Plugins?

Maven is a powerful build automation tool. By integrating Checkstyle as a Maven plugin, you can:

Automatically run style checks during the build process.
Fail builds on style violations.
Integrate code quality checks into CI/CD pipelines.

🛠️ Step-by-Step Guide to Integrating maven-checkstyle-plugin

✅ Step 1: Add the Plugin to Your pom.xml

Insert the following configuration inside the section of your pom.xml:

This configuration ensures that Checkstyle runs during the validate phase and fails the build if any violations are found.

✅ Step 2: Choose or Create a Checkstyle Configuration

You can use a predefined configuration like:

google_checks.xml
sun_checks.xml

Or create your own custom rules file. Example rules include:

Maximum line length
Naming conventions
Javadoc requirements

Place this file in your project’s root or src/main/resources directory.

✅ Step 3: Run the Plugin

You can run Checkstyle in two ways:

Option 1: During Build

mvn validate
This runs the plugin as part of the Maven lifecycle and shows violations in the console.

This will trigger the plugin and display any violations in the console.

Option 2: Generate a Detailed Report

mvn checkstyle:checkstyle

This generates a full HTML report.

📄 Where is the Report Generated?

After running mvn checkstyle:checkstyle, the report is generated at:

target/site/checkstyle.html

Open this file in a browser to view a detailed, formatted report of all style violations.

✅ Step 4: Review and Fix Violations

If failsOnError is set to true, the build will fail on violations. Review the console output, fix the issues, and re-run the build.

💡 Tips for Advanced Usage

Custom Rules: Tailor the rules to match your team’s coding standards.
IDE Integration: Use Checkstyle plugins for IntelliJ IDEA or Eclipse for real-time feedback.
CI/CD Integration: Add mvn validate to your pipeline to enforce checks automatically.

✅ Benefits of Using Checkstyle

Enforces consistent code formatting.
Catches potential issues early.
Improves code readability and maintainability.
Reduces technical debt over time.

🏁 Conclusion

Integrating maven-checkstyle-plugin into your Maven project is a simple yet powerful way to enforce coding standards and maintain a high-quality codebase. With just a few lines in your pom.xml, you can automate style checks and ensure your team writes clean, consistent, and maintainable code.

I hope this post was helpful.

Happy Coding!!

Thanks,
Kailash
JavaCharter

Understanding Tags in Git and Their Importance on GitHub

Kailash Nirmal — Tue, 04 Mar 2025 07:13:36 +0000

Introduction:

Hello Developers. I hope you all are enjoying the coding. Tags in Git are an essential feature that allows developers to mark specific points in their project history as important. This article explores what tags are, how to create and manage them, and why they are crucial for effective version control on platforms like GitHub.

What Are Tags?

Tags are references to specific commits in a Git repository. Unlike branches, which are mutable and can change over time, tags are intended to be immutable markers that capture a snapshot of your project at a particular point. They are commonly used to denote release versions (e.g., v1.0.0, v2.1.0) or significant milestones in the development process.

Types of Tags:

Lightweight Tags:

A lightweight tag is essentially a bookmark to a specific commit. It does not carry any additional information.
Created using the command

git tag <tag-name>

Annotated Tags:

Annotated tags are stored as full objects in the Git database. They include the tagger's name, email, date, and a message, similar to a commit.

Created using the command:

git tag -a <tag-name> -m "Tag message"

Why Are Tags Important?

Tags serve several important purposes in software development:

1.Versioning:

Tags provide a clear and organized way to version releases of your software. They allow users and developers to easily identify stable versions of the code.

2.Release Management:

Tags facilitate release management by marking significant milestones, such as beta versions, major updates, or patches.

3.Easy Access to Previous States:

Tags allow developers to quickly check out previous versions of the codebase. This is particularly useful for debugging or reverting to earlier states.

4.Collaboration:
In collaborative environments, tags help team members understand the progression of the project and the context of each release.

5.Integration with CI/CD Pipelines:

Tags can trigger deployment processes in Continuous Integration/Continuous Deployment (CI/CD) pipelines, ensuring that specific versions are deployed automatically.

How to Create and Manage Tags on GitHub

Step 1: Create a Tag Locally

To create a new tag in your local repository, follow these steps:

Open your terminal and navigate to your Git repository.
Ensure you are on the branch you want to tag (e.g., master):

git checkout master

Create an annotated tag:

git tag -a "v1.0.0" -m "Release version 1.0.0"

Step 2: Push the Tag to GitHub

After creating a tag, push it to your remote repository on GitHub:

git push origin v1.0.0

Step 3: View Tags on GitHub

Navigate to your GitHub repository in a web browser.
Click on the "Code" tab, then go to the "Releases" section to see all tags listed.
Click on any tag to view details about the associated commit and changes.

Step 4: Delete Tags (if necessary)

If you need to delete a tag, you can do so with the following commands:

Delete the tag locally:

git tag -d v1.0.0

Delete the tag from the remote repository:

git push --delete origin v1.0.0

Best Practices for Using Tags

Use semantic versioning (e.g., MAJOR.MINOR.PATCH) for consistency.
Write meaningful messages when creating annotated tags to provide context.
Regularly review and clean up obsolete tags to keep your repository organized.

I hope you guys learnt something new today in your development activities.

Happy Coding!

Thanks,
Kailash
JavaCharter

Understanding .gitignore: A Guide for Developers

Kailash Nirmal — Thu, 30 Jan 2025 07:22:57 +0000

Introduction:

As developers, we often find ourselves managing a variety of files in our projects. Not all of these files are meant to be shared with others, especially when working with version control systems like Git. This is where the .gitignore file comes into play. In this article, we'll explore what .gitignore is, why it's important, and how to use it effectively in your Git projects.

What is .gitignore?

The .gitignore file is a plain text file that tells Git which files or directories to ignore in a project. By listing specific files or patterns in this file, you can prevent them from being tracked by Git. This is particularly useful for files that are generated automatically, such as compiled code, log files, and temporary files that do not need to be shared with others.

Why is .gitignore Important?

Using a .gitignore file is crucial for several reasons:

Keep Your Repository Clean: Ignoring unnecessary files helps keep your repository tidy and focused on the source code that matters. This makes it easier for collaborators to understand the project structure.
Prevent Sensitive Information from Being Tracked: If your project contains configuration files with sensitive information (like API keys or passwords), adding these files to .gitignore prevents them from being accidentally committed to the repository.
Reduce Repository Size: By ignoring large files or directories that are not needed for version control, you can keep the size of your repository manageable.
Avoid Merge Conflicts: Ignoring files that are automatically generated (like compiled binaries) helps prevent unnecessary merge conflicts when multiple people are working on the same project.

How to Use .gitignore

Creating a .gitignore File

Location: The .gitignore file should be placed in the root directory of your Git repository.
Naming: Make sure to name the file .gitignore (with a dot at the beginning) so that Git recognizes it as a configuration file.

Writing Rules in .gitignore

The syntax for writing rules in a .gitignore file is straightforward. Here are some common patterns:

Ignore Specific Files: To ignore a specific file, simply write its name:

Ignore All Files of a Type: To ignore all files with a certain extension, use the asterisk * wildcard:

Ignore a Directory: To ignore an entire directory, add a forward slash / before the directory name:

Ignore All Files in a Directory: To ignore all files within a specific directory, use:

Example .gitignore File

Here’s an example of a .gitignore file for a Java project:

Common Issues and Debugging

When working with .gitignore, you might encounter some common issues:

Files Already Tracked: If a file was already added to the repository before being added to .gitignore, it will still be tracked. To untrack it, use:

Conclusion:

The .gitignore file is a powerful tool for managing your Git repository effectively. By understanding how to utilize it, you can keep your project clean, protect sensitive information, and ensure that only necessary files are tracked. Whether you are working on a small personal project or a large team collaboration, mastering .gitignore will streamline your development workflow.

By following the guidelines in this article, you can avoid common pitfalls and take full advantage of the benefits that .gitignore provides. Happy coding!

Thanks,
JavaCharter
Kailash Nirmal

Understanding CEO Fraud: A Growing Threat to Organisations

Kailash Nirmal — Mon, 06 Jan 2025 10:50:18 +0000

CEO fraud, also known as Business Email Compromise (BEC), is a type of cybercrime where an attacker impersonates a company's CEO or another high-ranking executive to trick employees into transferring money or sensitive information. This sophisticated form of fraud typically leverages social engineering tactics to create a sense of urgency and authority.

Mechanisms of CEO Fraud:
Email Spoofing: Attackers often craft emails that appear to come from a legitimate executive’s email address. These emails usually request urgent financial transactions or sensitive data.
Fake Invoices: Fraudsters may send invoices that look official, prompting the finance department to process payments without verifying their legitimacy.
Urgent Requests: These scams often involve messages that seem urgent, pushing employees to act quickly and bypass standard verification processes.

Examples of CEO Fraud:

Ubiquiti Networks (2015): This IT services company fell victim to a CEO fraud scheme where the scammers impersonated the company’s CEO and requested a transfer of $46.7 million. The fraud case involved a series of convincing emails that led to the transfer before the company realized it had been duped.
FACC (2016):The Austrian aerospace supplier was another victim; it lost approximately €50 million when attackers impersonated its CEO. The scammers created an intricate web of fraudulent communications that led to sizeable unauthorized payments.
Hewlett Packard Enterprises (HPE) (2019): HPE was targeted in a CEO fraud incident where an employee was convinced to transfer money for an urgent acquisition. The scam was sophisticated, involving fake emails and plausible scenarios that led to the impersonation of senior executives.

Preventive Measures:

To mitigate risks associated with CEO fraud, organizations should:
Implement Email Verification Techniques: Encourage employees to verify requests for transactions or sensitive information through a secondary channel (e.g., phone call).
Educate Employees: Conduct regular training sessions on recognizing potential scams and understanding the signs of email phishing.
Enhance Cybersecurity Infrastructure: Employ advanced security features in email systems, such as multi-factor authentication and threat detection tools.

Conclusion:
CEO fraud poses significant financial and reputational risks to organizations. By fostering a culture of awareness and implementing robust verification processes, companies can better protect themselves from falling victim to these deceptive schemes.

I hope this was helpful.

Thanks,
Kailash
JavaCharter

Understanding BCrypt: The Secure Way to Hash Passwords

Kailash Nirmal — Thu, 12 Dec 2024 09:07:59 +0000

In today's digital age, protecting our personal information is more crucial than ever, and one of the most important measures is securing our passwords. One way to achieve this is by using a technique called hashing, and a popular method for hashing passwords is BCrypt. Let’s break this down in simple terms.

What is BCrypt?

BCrypt is a special algorithm designed to convert plain-text passwords into a secure, unreadable format. This process is known as "hashing." When we hash a password, we transform it into a string of characters that does not resemble the original password in any way. The main advantage of hashing is that it makes it nearly impossible for someone who obtains the hashed value to figure out the original password.

Why Use BCrypt?

Here are some important features that make BCrypt a preferred choice for password hashing:

1 Unique Salt: Each time a password is hashed, BCrypt generates a random value called a "salt." This salt is added to the password before hashing. Even if two users have the same password, the salts will ensure that their hashed outputs are different. This prevents attackers from using precomputed lists (called rainbow tables) to crack passwords.

2 Adjustable Work Factor: BCrypt allows you to set the "work factor," which determines how computationally intensive the hashing process is. As computers become faster, you can increase this factor to make it harder for attackers to crack passwords.

3 One-Way Function: Hashing is a one-way function, meaning you can't reverse the hashed output to get the original password back. This is essential for security because even if an attacker gains access to your hashed passwords, they cannot easily retrieve the original passwords.

How Does It Work?

Imagine you have a plain password, like "mySecretPassword". When you use BCrypt, here's what happens:

1 Salt Generation: BCrypt creates a unique random salt.
2 Hashing: It combines your password with the salt and processes it through the BCrypt algorithm, producing a hashed password.
3 Storage: The hashed password (along with the salt) is then stored in the database.

When a user attempts to log in, the process is reversed. The entered password is hashed again using the same salt, and the new hash is compared to the stored hash. If they match, the login is successful!

Example Using Spring Boot

Let’s see how we can implement BCrypt in a simple Spring Boot application to hash and verify passwords.

Step 1: Add Dependency

First, make sure to include the Spring Security dependency in your pom.xml file:

<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-security</artifactId></dependency>

Step 2: Hash a Password

Here’s how you can hash a password using BCrypt in a Spring Boot application:

import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;

@Service
public class PasswordService {
    private final BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();

    public String hashPassword(String rawPassword) {
        return passwordEncoder.encode(rawPassword);
    }

    public boolean verifyPassword(String rawPassword, String hashedPassword) {
        return passwordEncoder.matches(rawPassword, hashedPassword);
    }
}

Step 3: Using the Service

Now, you can use this PasswordServiceto hash and verify passwords. Here's a simple example in a controller:

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api")
public class UserController {
    private final PasswordService passwordService;

    public UserController(PasswordService passwordService) {
        this.passwordService = passwordService;
    }

    @PostMapping("/register")
    public String register(@RequestParam String password) {
        String hashedPassword = passwordService.hashPassword(password);
        // Store hashedPassword in the database
        return "User registered with hashed password: " + hashedPassword;
    }

    @PostMapping("/login")
    public String login(@RequestParam String password, @RequestParam String storedHashedPassword) {
        boolean isMatch = passwordService.verifyPassword(password, storedHashedPassword);
        return isMatch ? "Login successful!" : "Invalid credentials.";
    }
}

In this example:

When a user registers, their plain password is hashed and stored.
During login, the entered password is verified against the stored hashed password.

Conclusion

BCrypt is a powerful and secure way to hash passwords that helps keep our personal information safe. By automatically generating salts and allowing for adjustable security measures, it stands out as a robust choice in the world of password management.
With its one-way hashing capability, even if someone gains unauthorized access to our stored passwords, they won't be able to retrieve the originals. By implementing BCrypt in our applications, we can significantly enhance the security of user credentials and protect sensitive information.

I hope this has enhanced your understanding of BCrypt.

Happy Coding

Happy Learning

Thanks,
Kailash
JavaCharter

Understanding File Path Formats in Windows and Java for Cross-Platform Compatibility

Kailash Nirmal — Fri, 15 Nov 2024 09:25:45 +0000

In the development world, handling file paths correctly is crucial for ensuring applications function seamlessly across different operating systems. This article will explore the differences between using backslashes (\) and forward slashes (/)in file paths, particularly in the context of Windows and Java applications. We will discuss best practices for choosing the appropriate format based on the environment in which your application runs and provide practical examples to illustrate how to implement these principles effectively.

File Path Formats in Windows

Backslash `( \ )`

In Windows operating systems, the backslash (\) is the standard path separator. This is the conventional way to represent file paths.

Example:

String downloadDir = "C:\\logs2\\";

Forward Slash `( / )`:

Interestingly, the forward slash (/) is recognise as a path separator in Java and certain other programming languages, allowing developers to write cross-platform compatible code. Java utilises forward slashes internally for paths, which fosters consistent behaviour regardless of the operating system.

Example:

String downloadDir = "C:/logs2/";

Best Practices for Storing Paths

When deciding which path format to use, consider the following guidelines:

For Windows-Only Applications: If your application is designed to run exclusively on Windows, using backslashes is generally preferred. This aligns with Windows conventions and can help minimize confusion.

Example Code:

String downloadDir = "C:\\logs2\\";

For Cross-Platform Compatibility: If your application needs to run on various operating systems, such as Windows, Linux, and macOS, it is common practice to utilize forward slashes. This approach ensures that your code remains compatible across different environments.

Example Code:

String downloadDir = "C:/logs2/";

Java Path Handling

Java provides built-in classes such as Pathand Filesthat can handle both backslashes and forward slashes correctly, regardless of how the paths are declared in your code. However, when displaying paths or passing them to external systems (e.g., shell commands, scripts), it is advisable to adhere to the standard that aligns with the target environment.

Summary :

In summary, both backslashes and forward slashes serve their purposes depending on the operating system and requirements of your application. If your application will operate solely on Windows, using backslashes may be more conventional. However, for better portability and cross-platform compatibility in Java environments, it is recommended to use forward slashes.

I hope this information was helpful. This article aims to provide clarity on how to effectively manage file paths in your applications to ensure maximum compatibility and efficiency.

Thanks,
Kailash
JavaCharter

The Importance of Using Interfaces for JpaRepository(Java Persistence API) in Spring Data JPA

Kailash Nirmal — Fri, 18 Oct 2024 07:10:19 +0000

Hello Programmers and beautiful people,

Have You Ever Thought About Why We Use Interfaces for JpaRepository in Spring Data JPA?

In modern application development, especially when it comes to data access layers, the architecture and design patterns we choose significantly impact maintainability, testability, and overall code quality. One prevalent practice in Spring Data JPA is the use of interfaces for
JpaRepository instead of concrete classes. But why is this approach so beneficial?

This article explores the reasoning behind using interfaces and the numerous advantages they offer.

Abstraction

At the core of software development lies the principle of abstraction. By defining an interface for the repository, developers create a contract that specifies what methods are available without dictating how those methods should be implemented. This abstraction allows different parts of an application to interact with the data layer without needing to understand the underlying implementation details. It promotes a clean separation of concerns, which is essential for building scalable software.

Flexibility with Multiple Implementations

One compelling reason to use interfaces is the flexibility it affords. In certain scenarios, you may need different implementations of a repository for various data sources (e.g., relational databases, NoSQL databases, or in-memory data structures). By relying on an interface, developers can create multiple implementations while maintaining consistent behavior across the application. This capability is invaluable in environments that require adaptability as requirements evolve.

Enhanced Dependency Injection

The Spring Framework excels at Dependency Injection (DI), and using interfaces aligns perfectly with this feature. When repositories are defined as interfaces, Spring can manage the concrete implementations automatically. This enables developers to switch implementations effortlessly without altering the calling code. If a change in the data source is required, such as migrating from one database to another, only the implementation needs to be updated while the application remains untouched.

Promoting Extensibility

With interfaces, extending functionality becomes straightforward. Developers can create new repository interfaces that add custom query methods or extend existing ones without affecting the original repository structure. This extensibility ensures that, as new business requirements arise, developers can respond quickly without needing to refactor existing code extensively.

Improved Testability

Testing is a fundamental component of software development, and interfaces enhance this aspect significantly. By allowing for the creation of mock implementations during unit testing, developers can isolate tests from the actual data layer. This isolation leads to more reliable tests, as changes in the data access code do not impact other components of the application. With interfaces, mocking and verifying behaviors in tests become seamless, thereby increasing the robustness of the testing strategy.

Reducing Boilerplate Code:

One of the most notable advantages of using interfaces with Spring Data JPA is the reduction of boilerplate code. Spring Data automatically generates the implementation of the repository interface at runtime, liberating developers from writing repetitive CRUD (Create, Read, Update, Delete) operations. This feature not only boosts productivity but also minimizes human error, ensuring that common patterns are consistently followed.

Conclusion

The practice of utilizing interfaces for JpaRepository
within Spring Data JPA is not merely a stylistic choice; it encompasses various principles and benefits that enhance software development. With improved flexibility, reduced boilerplate code, and an emphasis on testability and maintainability, using interfaces fosters a cleaner, more efficient architecture for data access layers. As software systems continue to evolve and grow in complexity, adopting this practice will serve developers well in building robust, adaptable applications.

I hope this information was helpful and knowledgable.

Regards,
Kailash Nirmal
JavaCharter

Learn about Interface JpaRepository:
https://docs.spring.io/spring-data/jpa/docs/current/api/org/springframework/data/jpa/repository/JpaRepository.html

Reference Document :
https://docs.spring.io/spring-data/jpa/docs/1.5.0.RELEASE/reference/html/jpa.repositories.html

GitHub Repository :

https://github.com/spring-projects/spring-data-jpa/blob/main/spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/JpaRepository.java

Exploring the New Features of Java 23

Kailash Nirmal — Thu, 10 Oct 2024 11:24:27 +0000

Dear Developers, Programming Enthusiasts, and Learners,

Java Development Kit (JDK) 23 has officially been released (2024/09/17 General Availability) marking another significant milestone in the evolution of the Java programming language. This latest update introduces a plethora of exciting features and enhancements aimed at improving developer experience, performance, and modularity.

In this article, I’ll share some of the major highlights of JDK 23, which I’ve gathered through my research.

While I have not yet had the opportunity to try my hands on Java 23, I believe it's important to stay updated with these advancements
.

Major Highlights of JDK 23 :

1. Module Import Declarations (Preview)
JDK 23 introduces the ability to succinctly import all packages exported by a module, simplifying the reuse of modular libraries. This feature allows developers to avoid the clutter of multiple import statements and makes it easier for beginners to use third-party libraries without navigating complex package hierarchies.

2. Markdown Documentation Comments
With this new feature, JavaDoc comments can now be written in Markdown, enhancing readability and ease of writing. This allows developers to combine Markdown syntax with HTML and JavaDoc tags, improving the documentation experience and extending the Compiler Tree API to facilitate tools that analyze Markdown content.

3. Generational Z Garbage Collector (ZGC)
The default mode for the Z Garbage Collector has been switched to generational mode, which enhances Java application performance by collecting young objects more frequently. The previous non-generational mode has been deprecated, paving the way for improved garbage collection strategies in future releases.

4. Vector API (Eighth Incubation)
The Vector API allows developers to express vector computations that compile reliably at runtime to optimal vector instructions on supported CPU architectures. It aims to provide a clear and concise API while ensuring performance on x64 and AArch64 architectures, aligning with Project Valhalla.

5. Stream Gatherers (Second Preview)
Stream Gatherers enhance the existing Stream API by allowing custom intermediate operations to be defined, making stream pipelines more flexible and expressive. This feature empowers developers to manipulate streams of infinite size in ways that were previously difficult.

6. Class-File API (Preview)
The new Class-File API provides an interface for processing class files that aligns with the Java Virtual Machine specification. This API will facilitate the migration of JDK components to a standard API, ultimately helping to remove the internal ASM library from JDK.

7. Support for Primitive Types in Patterns, Instanceof, and Switch
This feature enhances Java's pattern matching capabilities by allowing primitive type patterns in all contexts. It simplifies coding by making it easier to safely handle checks and casts for primitive types, thus improving the language's usability.

8. Flexible Constructor Bodies (Second Preview)
Flexible constructor bodies allow developers to initialize fields in a class before invoking any constructor, providing greater freedom in expressing constructor behavior while maintaining the guarantee of a top-down instantiation order.

9. Implicitly Declared Classes and Instance Methods (Second Preview)
This enhancement aims to simplify the learning curve for beginners by allowing the easy creation of single-class programs. It automatically imports essential methods for console I/O and public classes from the
java.base
module, facilitating a smoother learning experience.

10. Primitive Types in Patterns
This feature allows Java developers to use primitive types in pattern matching contexts, enhancing safety and flexibility in code.

11. String Templates (Dropped)
While string templates aimed to complement string literals and text blocks by embedding expressions, this feature was dropped from JDK 23 for further evaluation and potential redesign.

12. Future Plans and Support
JDK 23 is a non-LTS release, supported for only six months, in contrast to JDK 21, which is an LTS version. Oracle has also announced ongoing plans for Java in 2024, focusing on broader improvements and extending Java's capabilities to various programming models.

Conclusion :

JDK 23 is rich with features and enhancements that aim to refine the Java development experience. As I continue to explore this version, I look forward to testing these features firsthand and sharing my insights with you.

Note to Readers

I want to emphasize that the information presented in this article may not be exhaustive or perfectly accurate, as it has been collected from a variety of sources. I apologize for any inaccuracies or omissions. This article is based on my readings and understanding of JDK 23, and while I strive to provide accurate information, I encourage you to experiment and explore these features firsthand to gain deeper insights.

Thank you for your understanding, and I hope you find this information helpful as you navigate the latest updates in Java!

Thanks,
Kailash
JavaCharter

Dockerizing your Java Spring Boot application with Maven, along with a PostgreSQL database

Kailash Nirmal — Wed, 11 Sep 2024 09:10:43 +0000

Dockerizing a Spring Boot application involves creating a Docker image that contains your application and its dependencies. This allows you to package your application in a way that it can be easily shared and run on any machine with Docker installed. Below are step-by-step instructions for Dockerizing your Maven-based Spring Boot application and running it in a Docker container.

Step 1: Install Docker

First, ensure that Docker is installed on your local machine. You can download it from the official Docker website. Follow the installation instructions for your operating system.

If you are done with step 1 then follow the step 2

Step 2: Create a Dockerfile

In the root directory of your Spring Boot application (where your pom.xml file is located), create a file named Dockerfile without any file extension. This file will define the Docker image.

Here’s a simple example of what your Dockerfile might look like:

Note : You may encounter few issues here. Try to resolve. It shouldn't be big. For example > ERROR [internal] load metadata for docker.io/library/maven:3.8.6-openjdk-17

Step 3: Build the Docker Image

Open a terminal (command prompt or shell) and navigate to the directory that contains your Dockerfile. Run the following command to build the Docker image:

docker build -t your-image-name .

Replace your-image-name with a name you want to give your Docker image.

Step 4: Verify the Docker Image

After the build completes, verify that your image was created successfully:

docker images

You should see your image listed in the output.

Step 5: Run the Docker Container

Now you can run your Docker container using the following command:

docker run -p 8080:8080 your-image-name

This command maps port 8080 of the container to port 8080 of your host machine. Replace your-image-name with the name you used when building the image.

Step 6: Test Your Application

You can access your Spring Boot application by opening a web browser and navigating to http://localhost:8080. If everything is set up correctly, you should see your application running.

Step 7: Export the Docker Image

To share the Docker image with the other team who doesn't have internet access, you can save the image as a tar file:

docker save -o your-image-name.tar your-image-name

This will create a tarball of your Docker image that can be transferred to the other team's VM.

Step 8: Load the Docker Image on the Target Machine

Once the other team has received the your-image-name.tar file, they can load the image into their Docker environment using the following command:

docker load -i your-image-name.tar

Step 9: Run the Docker Container on the Target Machine

After loading the image, the other team can run the container with the same command:

docker run -p 8080:8080 your-image-name

Step 10: Access the Application

The application should now be accessible at http://localhost:8080 on the target machine.

Additional Notes

Database Configuration: If your application uses PostgreSQL, you may need to set up a PostgreSQL container or ensure that the database is accessible from the application. You can create a Docker Compose file to manage multiple containers (e.g., one for your app and one for PostgreSQL).

Environment Variables: If your application requires environment variables (for database configuration, etc.), you can pass them to the Docker container using the -e flag in the docker run command.

Volume Mounting: If the application needs to persist data or requires access to local files, consider using Docker volumes.

By following these steps, you should be able to successfully Dockerize your Spring Boot application and share it with the other team.

Thanks,
Kailash
JavaCharter

Forem: Kailash Nirmal

Deep Dive: Maven Build Lifecycle & the Truth About -DskipTests

A practical breakdown of what Maven does behind the scenes

Diagram for Better Understanding :

Does it skip tests?

Conclusion

How to Write a Clean, Professional README.md (A Practical Guide for Developers)

1. Start With a Strong Title

My Awesome Project

2. Use Headings to Structure the Document

Installation

Prerequisites

3. Use Bold Text for Important Highlights

4. Use Code Blocks to Show Commands, XML, JSON, YAML, etc.

5. How to Write XML in README (Without Breaking It)

6. How to Add a New Line in Markdown

7. Use Lists for Steps or Bullet Points

8. Show File Paths, Commands, or One‑Line Code Using Inline Code

10. Write a Clean Structure (Recommended Format)

11. Previewing Your README

Final Thoughts

My Experience with Azure Certification Renewal: Key Topics, Sample Questions, and Tips

Introduction

What’s Included in the Renewal Exam?

Sample Questions and Explanations

Tips for Success

Final Thoughts

Screenshot for my result

Integrating Checkstyle into Your Maven Project for Clean and Consistent Code

📄 Where is the Report Generated?

Understanding Tags in Git and Their Importance on GitHub

Types of Tags:

Why Are Tags Important?

How to Create and Manage Tags on GitHub

Best Practices for Using Tags

Understanding .gitignore: A Guide for Developers

Introduction:

What is .gitignore?

Why is .gitignore Important?

How to Use .gitignore

Writing Rules in .gitignore

Example .gitignore File

Conclusion:

Understanding CEO Fraud: A Growing Threat to Organisations

Understanding BCrypt: The Secure Way to Hash Passwords

What is BCrypt?

Why Use BCrypt?

How Does It Work?

Understanding File Path Formats in Windows and Java for Cross-Platform Compatibility

Backslash ( \ )

Forward Slash ( / ):

Summary :

The Importance of Using Interfaces for JpaRepository(Java Persistence API) in Spring Data JPA

Abstraction

Flexibility with Multiple Implementations

Enhanced Dependency Injection

Promoting Extensibility

Improved Testability

Reducing Boilerplate Code:

Conclusion

Exploring the New Features of Java 23

Major Highlights of JDK 23 :

Note to Readers

Dockerizing your Java Spring Boot application with Maven, along with a PostgreSQL database

Backslash `( \ )`

Forward Slash `( / )`: