Jenkins使用pipeline和maven创建项目

pipeline

一丶安装插件Pipeline

定义流水线

声明式和脚本式流水线都是 DSL 语言，用来描述软件交付流水线的一部分。流水线是用一种限制形式的 Groovy 语法编写的。虽然理解 Groovy 对使用流水线有所帮助，但并不是必须的。

流水线创建有3种方式：

1.通过 Blue Ocean - 在 Blue Ocean 中设置一个流水线项目后，Blue Ocean UI 会帮你编写流水线的 Jenkinsfile 文件并提交到源代码管理系统。

2.通过经典 UI - 尽管 Jenkins 支持在经典 UI 中直接进入流水线，但通常认为最好的实践是在 Jenkinsfile 文件中定义流水线，Jenkins 之后会直接从源代码管理系统加载。

3.在源码管理系统中定义 - 你可以手动编写一个 Jenkinsfile 文件，然后提交到项目的源代码管理仓库中。

二丶创建第一个Pipeline

输入项目描述

到流水线部分，一种是自定义，另一种是源代码管理（从git拉取），先说自定义

自定义测试

在 Pipeline Script 部分输入以下代码：（后期可以将echo换成bash命令）

pipeline {

agent any

stages {

stage('Build') {

steps {

echo 'Building...'

}

}

stage('Test') {

steps {

echo 'Testing...'

}

}

stage('Deploy') {

steps {

echo 'Deploying...'

}

}

}

}

save保存后执行构建，观察项目

源代码管理

在我的gitlab中有一项叫Jenkinsfile的文件，把他拉到Jenkins上来执行

保存后执行

maven

一丶操作前准备

安装 Maven 插件

进入 Jenkins 界面，点击 Manage Jenkins ，确保已安装 Maven Integration Plugin 。

配置 JDK 环境

点击 "管理 Jenkins"->Tools（全局配置）。在 JDK部分，点击 "新增 JDK"。

名称：可以命名为 JDK 21（你可以根据实际情况选择不同的名称）。

安装路径 ：填写你本机 JDK 的安装路径。（/bin之前的路径）

配置 Maven 环境

点击 "管理 Jenkins" ->Tools，找到 Maven 部分。点击 "新增 Maven".

名称：为 Maven 配置一个名称，

安装目录：填写 Maven 安装目录路径。

源代码准备

我是提前准备了一个简单的java应用项目，主要的是src文件和pom.xml文件，Jenkinsfile是等会用流水线执行maven准备的，稍后会附带。

一键生成源代码（在自己的机器上复制执行即可）

bash 复制代码

# 先删除旧项目（如果存在）
rm -rf simple-java-app

# 创建项目根目录
mkdir -p simple-java-app/src/{main,test}/java/com/example

# 创建pom.xml
cat <<EOF > simple-java-app/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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>simple-java-app</artifactId>
    <version>1.0-SNAPSHOT</version>

    <name>Simple Java App</name>
    <description>System Info Reporter for Java 21</description>

    <properties>
        <maven.compiler.source>21</maven.compiler.source>
        <maven.compiler.target>21</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <junit.version>5.10.0</junit.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>\${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <version>\${junit.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.11.0</version>
                <configuration>
                    <release>21</release>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>3.6.0</version>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                    <archive>
                        <manifest>
                            <mainClass>com.example.Main</mainClass>
                        </manifest>
                    </archive>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>
EOF

# 创建SystemInfoService.java（修改方法权限为protected）
cat <<EOF > simple-java-app/src/main/java/com/example/SystemInfoService.java
package com.example;

import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Enumeration;
import java.util.Properties;
import java.util.StringTokenizer;

public class SystemInfoService {

    public String getHostName() {
        try {
            return InetAddress.getLocalHost().getHostName();
        } catch (UnknownHostException e) {
            return "未知主机名（原因：" + e.getMessage() + "）";
        }
    }

    public String getIpAddresses() {
        StringBuilder ipBuilder = new StringBuilder();
        try {
            Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
            while (interfaces.hasMoreElements()) {
                NetworkInterface iface = interfaces.nextElement();
                if (iface.isLoopback() || !iface.isUp()) {
                    continue;
                }

                Enumeration<InetAddress> addresses = iface.getInetAddresses();
                while (addresses.hasMoreElements()) {
                    InetAddress addr = addresses.nextElement();
                    String ip = addr.getHostAddress();
                    if (isIPv4Address(ip)) {
                        ipBuilder.append("- 网卡: ").append(iface.getDisplayName())
                                .append(" | IP: ").append(ip).append("\n");
                    }
                }
            }

            return ipBuilder.isEmpty() ? "未找到有效IPv4地址" : ipBuilder.toString();
        } catch (SocketException e) {
            return "获取IP地址失败（原因：" + e.getMessage() + "）";
        }
    }

    /**
     * 修改为protected权限，允许测试类访问
     */
    protected boolean isIPv4Address(String ip) {
        if (ip == null || ip.isEmpty()) {
            return false;
        }
        StringTokenizer st = new StringTokenizer(ip, ".");
        if (st.countTokens() != 4) {
            return false;
        }
        try {
            while (st.hasMoreTokens()) {
                int num = Integer.parseInt(st.nextToken());
                if (num < 0 || num > 255) {
                    return false;
                }
            }
            return true;
        } catch (NumberFormatException e) {
            return false;
        }
    }

    public String getSystemInfo() {
        Properties props = System.getProperties();
        return """
                【系统基础信息】
                操作系统名称: %s
                操作系统版本: %s
                架构: %s
                Java版本: %s
                Java安装路径: %s
                用户名称: %s
                当前工作目录: %s
                """.formatted(
                props.getProperty("os.name"),
                props.getProperty("os.version"),
                props.getProperty("os.arch"),
                props.getProperty("java.version"),
                props.getProperty("java.home"),
                props.getProperty("user.name"),
                props.getProperty("user.dir")
        );
    }

    public String getFullSystemReport() {
        return """
                ============================================
                主机基础信息报告
                ============================================
                主机名: %s
                --------------------------------------------
                网络IP信息:
                %s
                --------------------------------------------
                %s
                ============================================
                """.formatted(
                getHostName(),
                getIpAddresses(),
                getSystemInfo()
        );
    }
}
EOF

# 创建Main.java
cat <<EOF > simple-java-app/src/main/java/com/example/Main.java
package com.example;

public class Main {
    public static void main(String[] args) {
        SystemInfoService infoService = new SystemInfoService();
        System.out.println(infoService.getFullSystemReport());
    }
}
EOF

# 创建测试类（保持对isIPv4Address的测试）
cat <<EOF > simple-java-app/src/test/java/com/example/SystemInfoServiceTest.java
package com.example;

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class SystemInfoServiceTest {

    private final SystemInfoService service = new SystemInfoService();

    @Test
    void getHostName_ShouldNotBeEmpty() {
        String hostName = service.getHostName();
        assertFalse(hostName.isEmpty(), "主机名不应为空");
    }

    @Test
    void getIpAddresses_ShouldReturnValidFormat() {
        String ips = service.getIpAddresses();
        assertTrue(ips.contains("IP: ") || ips.contains("未找到") || ips.contains("失败"), 
                "IP地址信息格式应合法");
    }

    @Test
    void getSystemInfo_ShouldContainJavaVersion() {
        String systemInfo = service.getSystemInfo();
        assertTrue(systemInfo.contains("Java版本"), "系统信息应包含Java版本");
    }

    @Test
    void isIPv4Address_ShouldCorrectlyIdentifyIPv4() {
        assertTrue(service.isIPv4Address("192.168.1.1"), "192.168.1.1应被识别为IPv4");
        assertFalse(service.isIPv4Address("2001:0db8:85a3::8a2e:370:7334"), "IPv6不应被识别为IPv4");
        assertFalse(service.isIPv4Address("192.168.1"), "不完整的IP不应被识别为IPv4");
        assertFalse(service.isIPv4Address("256.1.1.1"), "超过255的IP不应被识别为IPv4");
    }
}
EOF

echo "项目创建完成！路径：$(pwd)/simple-java-app"
echo "使用方法："
echo "cd simple-java-app"
echo "mvn clean package"
echo "java -jar target/simple-java-app-1.0-SNAPSHOT-jar-with-dependencies.jar"

运行测试一下，显示效果

测试完成后将target目录删掉，将src目录和pom上传到自己的gitlab上

二丶使用maven创建项目

新建一个maven项目

输入项目描述后，源码管理选择git

Repository URL选择gitlab地址，（在图中标识）

Credentials选择之前配置的凭证

分支选择main（由于我们使用的是gitlab）

这里可以选择编译完成后配置，这里我们将编译完成的文件传输到另一台机器执行（前提配置了ssh密钥）

完成后保存，构建

构建完成后可以点击查看详细信息

使用pipeline运行maven

在gitlab中创建Jenkinsfile文件

下方是我的Jenkinsfile代码

bash 复制代码

pipeline {
    agent any
    tools {
        // 使用Jenkins中配置的工具（需要在Manage Jenkins > Global Tool Configuration中预先配置）
        jdk 'java21'     // 工具名称对应Jenkins中的JDK配置
        maven 'mvn'  // 工具名称对应Jenkins中的Maven配置
    }
    stages {
        stage('Build') {
            steps {
                sh 'mvn clean package -DskipTests'
            }
        }

        stage('Deploy to Tomcat') {
            steps {
                script {
                    // 将构建的文件拷贝到Tomcat的webapps目录
                    sh "scp target/simple-java-app-1.0-SNAPSHOT-jar-with-dependencies.jar root@192.168.60.100:/appjava1.jar"
                    // 重启Tomcat以便部署新的.war文件
                    sh "ssh  root@192.168.60.100 'java -jar /appjava1.jar'"
                }
            }
        }

    }
    post {
        success {
            echo "构建成功！"
        }
        failure {
            echo "构建失败，请查看Maven日志"
        }
    }
}

创建一个pipeline项目

流水线处选择git，存放Jenkinsfile文件的仓库

保存后进行构建，查看信息