A study guide for Java code formatting tools (PMD, Checkstyle)

1. Preface

In the journey of Java development, writing neat and standardized code is the goal that every developer pursues. Neat code is not only easy to read and understand by yourself, but also convenient for teamwork to reduce potential mistakes. However, in the actual development process, the code can easily become chaotic due to factors such as tight time and different developers' habits. At this time, the two Java code formatting tools, PMD and Checkstyle, became our saviors. This article will explore in-depth the functions, usage of PMD and Checkstyle and how they can help us make our code look fresh. Through detailed code examples, we will have a more comprehensive and in-depth understanding of these two tools.

2. Detailed explanation of PMD tools

(I) Introduction to PMD

PMD is an open source Java code static analysis tool that can detect potential performance problems in the code, unused variables, duplicate code, etc. PMD analyzes the source code and applies a series of rules to find possible problems, which cover multiple aspects such as code style, best practices, and error tendencies.

(II) Installation and configuration of PMD

Installation: You can access the official PMD website (/), download the appropriate version. After decompression, add the bin directory of PMD to the system environment variable PATH on the command line for easier subsequent use.

Configuring Rule Files: PMD uses XML files to define rule sets. We can choose the appropriate rule set according to the needs of the project, such as java - basic, java -unusedcode, etc. For example, create a pmd - file:

<?xml version="1.0" encoding="UTF-8"?>
<ruleset name="Custom PMD Ruleset"
         xmlns="/ruleset/2.0.0"
         xmlns:xsi="http:///2001/XMLSchema-instance"
         xsi:schemaLocation="/ruleset/2.0.0 /ruleset_2_0_0.xsd">
    <description>
        Custom PMD Rule Set
    </description>
    <rule ref="rulesets/java/"/>
    <rule ref="rulesets/java/"/>
</ruleset>

(III) PMD usage and code examples

1. Use PMD in the command line: In the project root directory, open the command line and run the following command:

• pmd -d Source Code Directory -R Path/to/ -f text -language java
• For example: pmd -d src -R -f text -language java
• This will analyze the Java source code in the src directory, detect it according to the rules in pmd -, and output the results in text format.

2. Code instance displays the role of PMD

Suppose there is the following code (example code 1):

public class PMDExample {
    private int count;

    public PMDExample(int count) {
         = count;
    }

    public void process() {
        int unusedVariable = 10; // Unused variables        for (int i = 0; i < count; i++) {
            ("Processing...");
        }
    }
}

When analyzing this code with PMD, it reports that "unusedVariable" is an unused variable that violates the rules in the unusedcode rule set. We can fix this by deleting the variable to make the code more tidy.

Fixed code (Sample code 2):

public class PMDExample {
    private int count;

    public PMDExample(int count) {
         = count;
    }
    public void process() {
        for (int i = 0; i < count; i++) {
            ("Processing...");
        }
    }
}

3. Detailed explanation of Checkstyle tool

(I) Checkstyle Introduction

Checkstyle is a tool that helps developers check whether Java code complies with code style specifications. It can check the indentation, bracket style, variable naming specification, comment specification, etc. of the code. By using Checkstyle, you can ensure that the code style of the entire project team is consistent and improve the readability and maintainability of the code.

(II) Installation and configuration of Checkstyle

Installation: You can also use the Checkstyle official website (/) Download the installation package, after decompression, add the bin directory to the system environment variable PATH.

Configure the check rule file: Checkstyle Use XML files to define check rules. We can customize the rule files according to the actual needs of the project. For example, create a checkstyle - file:

<?xml version="1.0"?>
<!DOCTYPE module PUBLIC "-//Puppy Crawl//DTD Check Configuration 1.3//EN" "/dtds/config_1_3.dtd">
<module name="Checker">
    <module name="TreeWalker">
        <module name="Indentation">
            <property name="basicOffset" value="4"/>
            <property name="braceAdjustment" value="0"/>
        </module>
        <module name="ConstantName"/>
        <module name="LocalVariableName"/>
        <module name="ParameterName"/>
        <module name="MethodName"/>
        <module name="TypeName"/>
    </module>
</module>

(III) Use of Checkstyle and code examples

The command line uses Checkstyle: In the project root directory, execute the command line:

checkstyle -c path/to/ source code directory

For example: checkstyle -c src

This checks the code in the src directory according to the rules in checkstyle - and outputs where it does not comply with the specification.

Code examples show the effect of Checkstyle

Sample Code 3 (not compliant with the specification):

public class CheckstyleExample
{
public void myMethod(int param){
    int myVariable=10;
    if(param>0)
    {
        ("Value is positive");}
    }
}

After checking with Checkstyle, you will find many problems, such as inconsistent class names and file names (if the file name is not), method names and parameter names do not follow camel nomenclature, incorrect indentation, inconsistent brace styles, etc.

Fixed code (Sample code 4):

public class CheckstyleExample {
    public void myMethod(int parameter) {
        int myVariable = 10;
        if (parameter > 0) {
            ("Value is positive");
        }
    }
}

4. The difference and combination of PMD and Checkstyle

(I) Difference

Different concerns: PMD focuses on potential logic problems, performance problems, unused code, etc. in the code, and focuses on the quality analysis of the code; while Checkstyle focuses on the style and format of the code to ensure that the code complies with predetermined coding specifications.

Differences in rule types: PMD's rules are mostly related to code structure and logic, such as detecting unnecessary object creation, avoiding the use of specific control processes, etc.; Checkstyle's rules mainly revolve around the appearance of the code, such as indentation, annotation format, naming conventions, etc.

(II) Combined use

In actual projects, in order to fully ensure the quality and style of the code, PMD and Checkstyle are usually used in combination. This not only allows you to discover potential problems from the logical level, but also ensures code specifications from the format level. For example, you can integrate PMD and Checkstyle plug-ins in the project's build process (such as Maven or Gradle builds), set up appropriate rule files, automatically perform code analysis and checking at each build, promptly identify problems and ask developers to fix them.

For example, add the following configuration to a file in a Maven project:

<build>
    <plugins>
        <!-- PMD Plug-in configuration -->
        <plugin>
            <groupId></groupId>
            <artifactId>maven-pmd-plugin</artifactId>
            <version>3.18.1</version>
            <configuration>
                <rulesets>
                    <ruleset>path/to/</ruleset>
                </rulesets>
            </configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>check</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
        <!-- Checkstyle Plug-in configuration -->
        <plugin>
            <groupId></groupId>
            <artifactId>maven-checkstyle-plugin</artifactId>
            <version>3.2.3</version>
            <configuration>
                <configLocation>path/to/</configLocation>
            </configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>check</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

5. Summary

PMD and Checkstyle are code formatting and quality analysis tools in the Java field, providing a powerful help in creating clean, standardized, and high-quality code. Through in-depth understanding and reasonable use of them, we can effectively improve the readability, maintainability and performance of our code. In actual development, it is recommended that the project team formulate an appropriate set of rules based on their own situation and integrate PMD and Checkstyle inspections into the development process, so that every developer can benefit from these tools and jointly maintain the code quality of the project. Let’s embrace PMD and Checkstyle, say goodbye to the cluttered code, and welcome a new era of neat, elegant code!

This is the article about this study guide for Java code formatting tools (PMD, Checkstyle). For more related Java code formatting content, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!