【DevOps工具】在Jenkins中执行一个Java项目，并通过JaCoCo插件查看单元测试的覆盖率

一、

要在Jenkins中执行一个Java项目，并通过JaCoCo插件查看单元测试的覆盖率，您可以按照以下步骤创建一个包含Maven构建的Java项目，并编写一个适当的Jenkinsfile。

1. 创建一个Maven项目

首先，确保您的Java项目是一个Maven项目，并且pom.xml文件中包含了JaCoCo的配置。以下是一个基本的pom.xml配置示例：

<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>my-java-project</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- Your dependencies here -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- Maven Surefire Plugin to run the tests -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.22.2</version>
            </plugin>

            <!-- Jacoco Maven Plugin for code coverage -->
            <plugin>
                <groupId>org.jacoco</groupId>
                <artifactId>jacoco-maven-plugin</artifactId>
                <version>0.8.5</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>prepare-agent</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>report</id>
                        <phase>test</phase>
                        <goals>
                            <goal>report</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

2. 创建一个Jenkinsfile

然后，在项目的根目录中创建一个Jenkinsfile，该文件定义了Jenkins流水线的步骤：

pipeline {
    agent any
    tools {
        // Ensure that Maven is available
        maven 'Maven 3.6.3'
        jdk 'JDK 8'
    }
    stages {
        stage('Checkout') {
            steps {
                // Checkout the code from the source repository
                checkout scm
            }
        }
        stage('Build') {
            steps {
                // Run Maven build and tests
                sh 'mvn clean package'
            }
        }
        stage('Test') {
            steps {
                // Run the tests
                sh 'mvn test'
            }
        }
        stage('JaCoCo Report') {
            steps {
                // Generate JaCoCo coverage report
                sh 'mvn jacoco:report'
            }
        }
    }
    post {
        always {
            // Archive the results and publish the coverage report
            jacoco(execPattern: '**/target/jacoco.exec', classPattern: '**/target/classes', sourcePattern: '**/src/main/java', inclusionPattern: '**/*.class', exclusionPattern: '')
            junit '**/target/surefire-reports/*.xml'
        }
    }
}

3. 配置Jenkins任务

1. 安装JaCoCo插件：确保Jenkins已经安装了JaCoCo插件。

2. 创建新的任务：在Jenkins中创建一个新的Pipeline项目，然后配置任务使用您的Git仓库，并选择使用Jenkinsfile。

3. 运行任务：保存配置并运行任务。Jenkins会执行代码的构建、测试，并生成JaCoCo覆盖率报告。

4. 查看覆盖率报告

执行任务后，您可以在Jenkins的任务详情页面看到JaCoCo插件生成的覆盖率报告。

二、写Java代码和单元测试代码

下面是一个简单的Java项目示例，包括一个类和对应的单元测试代码。

1. Java代码

假设我们有一个简单的类 Calculator，它包含一些基本的数学运算方法。

// File: src/main/java/com/example/Calculator.java
package com.example;

public class Calculator {

    public int add(int a, int b) {
        return a + b;
    }

    public int subtract(int a, int b) {
        return a - b;
    }

    public int multiply(int a, int b) {
        return a * b;
    }

    public int divide(int a, int b) {
        if (b == 0) {
            throw new IllegalArgumentException("Division by zero is not allowed.");
        }
        return a / b;
    }
}

2. 单元测试代码

接下来，我们为这个 Calculator 类编写一些单元测试代码，确保所有方法都按照预期工作。

// File: src/test/java/com/example/CalculatorTest.java
package com.example;

import org.junit.Test;
import static org.junit.Assert.*;

public class CalculatorTest {

    private final Calculator calculator = new Calculator();

    @Test
    public void testAdd() {
        assertEquals(5, calculator.add(2, 3));
        assertEquals(0, calculator.add(-2, 2));
    }

    @Test
    public void testSubtract() {
        assertEquals(1, calculator.subtract(3, 2));
        assertEquals(-4, calculator.subtract(-2, 2));
    }

    @Test
    public void testMultiply() {
        assertEquals(6, calculator.multiply(2, 3));
        assertEquals(-4, calculator.multiply(-2, 2));
    }

    @Test
    public void testDivide() {
        assertEquals(2, calculator.divide(4, 2));
    }

    @Test(expected = IllegalArgumentException.class)
    public void testDivideByZero() {
        calculator.divide(4, 0);
    }
}

3. 项目结构

这个项目的目录结构应该如下：

my-java-project/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── com/
│   │           └── example/
│   │               └── Calculator.java
│   └── test/
│       └── java/
│           └── com/
│               └── example/
│                   └── CalculatorTest.java
└── Jenkinsfile

4. 如何运行

1. 将上述代码放入适当的文件和目录中。
2. 确保 pom.xml 已经配置好 JaCoCo 插件（前面已经提供了 pom.xml 的示例）。
3. 提交代码到您的代码库中，并确保 Jenkins 已配置好 Pipeline 项目并且指向正确的代码仓库。
4. 运行 Jenkins 任务来构建项目，执行单元测试，并生成代码覆盖率报告。

执行完这些步骤后，您可以在 Jenkins 上查看 JaCoCo 生成的测试覆盖率报告。

#三、