maven自定义插件 jenkis打包 jar包版本校验dependency-check-plugin:check

最新推荐文章于 2024-09-08 20:02:35 发布
最新推荐文章于 2024-09-08 20:02:35 发布
阅读量5.3k 收藏 2
点赞数
分类专栏： 项目构建-Maven
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z69183787/article/details/52981508
版权

更新校验方式，使用 maven 自带 version range api

http://blog.csdn.net/z69183787/article/details/54342057

替换了version的compareTo方法，关于Version range api详见http://maven.apache.org/ref/3.3.9/maven-artifact/apidocs/org/apache/maven/artifact/versioning/VersionRange.html。 

 

在maven 打包时 根据设定的指定jar包版本 对项目中的版本进行校验，若低于设定版本，则抛出异常：

如何在自定义插件mojo中 获取项目下的所有 依赖

How to get all dependecy in a mojo ?

http://maven.40175.n5.nabble.com/How-to-get-all-dependecy-in-a-mojo-td111541.html

 

maven 插件使用annotation 的形式自动注入参数 或 设置 插件goal

${basedir} 项目根目录
${project.build.directory} 构建目录，缺省为target
${project.build.outputDirectory} 构建过程输出目录，缺省为target/classes
${project.build.finalName} 产出物名称，缺省为${project.artifactId}-${project.version}
${project.packaging} 打包类型，缺省为jar
${project.xxx} 当前pom文件的任意节点的内容

 

maven生命周期及goal等之间的关系：http://blog.csdn.net/z69183787/article/details/52984602

maven-mojo 标注及参数：http://blog.csdn.net/z69183787/article/details/52984622

Mojo类：goal为check，执行阶段为  process-resources

/**
 * Created by Administrator on 2016/10/31.
 * @goal check
 * @phase process-resources
 * @requiresDependencyResolution compile
 */

/**
     * 插件参数
     * @parameter expression="${checklist}"
     * @required
     */

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.zs</groupId>
    <artifactId>zs-dependency-check</artifactId>
    <packaging>maven-plugin</packaging>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.apache.maven</groupId>
            <artifactId>maven-plugin-api</artifactId>
            <version>2.0</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <version>2.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.3</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.1.43</version>
        </dependency>
    </dependencies>

</project>

ArtifactPojo：

package plugin;

import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.versioning.ArtifactVersion;
import org.apache.maven.artifact.versioning.DefaultArtifactVersion;

/**
 * Created by Administrator on 2016/10/31.
 */
public class ArtifactPojo implements Comparable<Artifact>
{
    private String groupId;
    private String artifactId;
    private String version;

    public ArtifactPojo()
    {
    }

    public ArtifactPojo(String groupId, String artifactId, String version)
    {
        this.groupId = groupId;
        this.artifactId = artifactId;
        this.version = version;
    }

    public int compareTo(Artifact artifact)
    {
        if ((artifact != null) && (getGroupId().equals(artifact.getGroupId())) &&
                (getArtifactId().equals(artifact.getArtifactId())))
        {
            return new DefaultArtifactVersion(getVersion()).compareTo(new DefaultArtifactVersion(artifact.getVersion()));
        }
        return 0;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        ArtifactPojo that = (ArtifactPojo) o;

        if (!artifactId.equals(that.artifactId)) return false;
        if (!groupId.equals(that.groupId)) return false;
        if (!version.equals(that.version)) return false;

        return true;
    }

    @Override
    public int hashCode() {
        int result = groupId.hashCode();
        result = 31 * result + artifactId.hashCode();
        result = 31 * result + version.hashCode();
        return result;
    }

    public String getGroupId() {
        return this.groupId;
    }

    public void setGroupId(String groupId) {
        this.groupId = groupId;
    }

    public String getArtifactId() {
        return this.artifactId;
    }

    public void setArtifactId(String artifactId) {
        this.artifactId = artifactId;
    }

    public String getVersion() {
        return this.version;
    }

    public void setVersion(String version) {
        this.version = version;
    }

    public String toString()
    {
        return this.groupId + ":" + this.artifactId + ":" + this.version;
    }
}

CheckVersionMojo：

package plugin;

import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.project.MavenProject;
import org.apache.maven.shared.artifact.filter.collection.ArtifactFilterException;
import org.apache.maven.shared.artifact.filter.collection.FilterArtifacts;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.*;

/**
 * Created by Administrator on 2016/10/31.
 * @goal check
 * @phase process-resources
 * @requiresDependencyResolution compile
 */
public class CheckVersionMojo extends AbstractMojo {

    /**
     * @parameter expression="${project}"
     * @required
     * @readonly
     */
    private MavenProject project;
    //http://123.123.123

    /**
     * 插件参数
     * @parameter expression="${checklist}"
     * @required
     */
    private String checklist;


    @Override
    public void execute() throws MojoExecutionException, MojoFailureException {
        System.out.println("checkList := " + checklist);
        if (this.project == null) {
            throw new MojoExecutionException("Can not find a Maven project.");
        }

        if (("".equals(this.checklist)) || (null == this.checklist)) {
            getLog().info("Checklist is empty, bye.");
            return;
        }

        getLog().debug("checklist:" + this.checklist);

        if (this.checklist.startsWith("http://")) {
            this.checklist = getChecklistFromUrl(this.checklist);
            getLog().debug("get checklist from url:" + this.checklist);
        }

        Map<ArtifactPojo,Artifact> brokenArtifacts = getBrokenArtifacts();
        Artifact artifact = null;

        getLog().debug("The count of invalid artifacts: " + brokenArtifacts.size());

        if (!brokenArtifacts.isEmpty()) {
            getLog().info("The version of following files are invalid.");
            Set<ArtifactPojo> brokenArtifactsSet = brokenArtifacts.keySet();
            for (ArtifactPojo sa : brokenArtifactsSet) {
                artifact = (Artifact)brokenArtifacts.get(sa);
                getLog().error(sa.getGroupId() + ":" + sa.getArtifactId() + " required version[" + sa.getVersion() + "]," +
                        " actual version[" + artifact.getVersion() + "]");
            }
            throw new MojoFailureException("please upgrade to the specified version.");
        }
    }


    private String getChecklistFromUrl(String checklistUrl) {
        CloseableHttpClient httpclient = HttpClients.createDefault();
        HttpGet httpGet = new HttpGet(checklistUrl);
        String list = "com.alibaba:fastjson:1.2.0";
        return list;
//        try {
//            CloseableHttpResponse response = httpclient.execute(httpGet);
//            InputStream is = response.getEntity().getContent();
//            BufferedReader br = new BufferedReader(new InputStreamReader(is));
//
//            list = br.readLine();
//            list = list.replace("\"", "");
//            response.close();
//            br.close();
//        } catch (IOException e) {
//            throw new RuntimeException("Can not get checklist from `" + checklistUrl + "`", e);
//        }
//        return list;
    }

    private Set<ArtifactPojo> fromChecklist(String checklist) {
        Set simpleArtifacts = new HashSet();
        String[] toBeChecked = checklist.split(",");
        String[] splitedArray = null;
        for (int i = 0; i < toBeChecked.length; i++) {
            splitedArray = toBeChecked[i].split(":");
            if (splitedArray.length < 3)
                getLog().warn("Invalid artifact: " + toBeChecked[i] + ", available format is groupId:artifactId:verion");
            else {
                simpleArtifacts.add(new ArtifactPojo(splitedArray[0], splitedArray[1], splitedArray[2]));
            }
        }
        return simpleArtifacts;
    }

    private Map<ArtifactPojo, Artifact> getBrokenArtifacts() throws MojoExecutionException
    {
        Set simpleArtifacts = fromChecklist(this.checklist);
        Set artifacts = this.project.getArtifacts();
        System.out.println(artifacts);
        FilterArtifacts filter = new FilterArtifacts();
        filter.clearFilters();
        Set unMarkedArtifacts = null;
        try {
            unMarkedArtifacts = filter.filter(artifacts);
        } catch (ArtifactFilterException e) {
            throw new MojoExecutionException(e.getMessage(), e);
        }

        ArtifactPojo ArtifactPojo = null;
        Artifact artifact = null;

        Iterator it;
        Map brokenArtifacts = new HashMap();
        for (Iterator sait = simpleArtifacts.iterator(); sait.hasNext(); ) {
            ArtifactPojo = (ArtifactPojo)sait.next();
            for (it = unMarkedArtifacts.iterator(); it.hasNext(); ) {
                artifact = (Artifact)it.next();
                if (ArtifactPojo.compareTo(artifact) > 0)
                    brokenArtifacts.put(ArtifactPojo, artifact);
            }
        }

        return brokenArtifacts;
    }

    public MavenProject getProject() {
        return project;
    }

    public void setProject(MavenProject project) {
        this.project = project;
    }

    public String getChecklist() {
        return checklist;
    }

    public void setChecklist(String checklist) {
        this.checklist = checklist;
    }
}

运行：

mvn clean install 将插件install入本地maven仓库

校验：

mvn com.zs:zs-dependency-check:check -Dchecklist=http://dasdt=http

checklist可设置为http请求，返回

"com.xxxx.a:a-a:1.1.4,com.xxxx.b:b-b:1.6.4,groupId:artifactId:version"

该格式分割的指定版本jar包

E:\zone\practice\zs-dependency-check>mvn com.zs:zs-dependency-check:check -Dchecklist=http://123.123
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building zs-dependency-check 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- zs-dependency-check:1.0-SNAPSHOT:check (default-cli) @ zs-dependency-check ---
checkList := http://123.123
[org.apache.maven:maven-plugin-api:jar:2.0:compile, org.apache.maven.plugins:maven-dependency-plugin:jar:2.1:compile, org.apache.maven:maven-artifact:jar:2.0.9:compile, org.apache.maven:maven-project:jar:2.0.9:compile, org.apache.maven:maven-settings:j
ar:2.0.9:compile, org.apache.maven:maven-profile:jar:2.0.9:compile, org.apache.maven:maven-artifact-manager:jar:2.0.9:compile, org.apache.maven:maven-plugin-registry:jar:2.0.9:compile, org.apache.maven:maven-model:jar:2.0.9:compile, org.apache.maven:ma
ven-core:jar:2.0.9:compile, org.apache.maven:maven-plugin-parameter-documenter:jar:2.0.9:compile, xml-apis:xml-apis:jar:1.0.b2:compile, org.apache.maven.wagon:wagon-provider-api:jar:1.0-beta-2:compile, org.apache.maven:maven-repository-metadata:jar:2.0
.9:compile, org.apache.maven:maven-error-diagnostics:jar:2.0.9:compile, commons-cli:commons-cli:jar:1.0:compile, org.apache.maven:maven-plugin-descriptor:jar:2.0.9:compile, org.codehaus.plexus:plexus-interactivity-api:jar:1.0-alpha-4:compile, org.apach
e.maven:maven-monitor:jar:2.0.9:compile, classworlds:classworlds:jar:1.1:compile, org.codehaus.plexus:plexus-archiver:jar:1.0-alpha-9:compile, org.codehaus.plexus:plexus-utils:jar:1.4.6:compile, org.apache.maven.shared:file-management:jar:1.1:compile,
org.apache.maven.shared:maven-shared-io:jar:1.0:compile, org.codehaus.plexus:plexus-container-default:jar:1.0-alpha-9-stable-1:compile, org.apache.maven.shared:maven-dependency-analyzer:jar:1.1:compile, asm:asm:jar:3.0:compile, org.apache.maven.shared:
maven-dependency-tree:jar:1.2:compile, org.apache.maven.shared:maven-common-artifact-filters:jar:1.0:compile, org.apache.maven.shared:maven-plugin-testing-harness:jar:1.1:compile, org.codehaus.plexus:plexus-io:jar:1.0-alpha-1:compile, org.apache.maven.
reporting:maven-reporting-api:jar:2.0.6:compile, org.apache.maven.doxia:doxia-sink-api:jar:1.0-alpha-7:compile, org.apache.maven.reporting:maven-reporting-impl:jar:2.0.4:compile, commons-validator:commons-validator:jar:1.2.0:compile, commons-beanutils:
commons-beanutils:jar:1.7.0:compile, commons-digester:commons-digester:jar:1.6:compile, commons-collections:commons-collections:jar:2.1:compile, org.apache.maven.doxia:doxia-core:jar:1.0-alpha-7:compile, oro:oro:jar:2.0.7:compile, org.apache.maven.doxi
a:doxia-site-renderer:jar:1.0-alpha-7:compile, org.codehaus.plexus:plexus-i18n:jar:1.0-beta-6:compile, org.codehaus.plexus:plexus-velocity:jar:1.1.2:compile, plexus:plexus-utils:jar:1.0.2:compile, commons-logging:commons-logging-api:jar:1.0.4:compile,
velocity:velocity:jar:1.4:compile, org.apache.maven.doxia:doxia-decoration-model:jar:1.0-alpha-7:compile, org.apache.httpcomponents:httpclient:jar:4.3:compile, org.apache.httpcomponents:httpcore:jar:4.3:compile, commons-logging:commons-logging:jar:1.1.
3:compile, commons-codec:commons-codec:jar:1.6:compile, com.alibaba:fastjson:jar:1.1.43:compile]
[INFO] The version of following files are invalid.
<span style="color:#ff0000;"><strong>[ERROR] com.alibaba:fastjson required version[1.2.0], actual version[1.1.43]</strong></span>
[INFO] ------------------------------------------------------------------------
[INFO] BUILD FAILURE
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 1.034s
[INFO] Finished at: Mon Oct 31 17:58:12 CST 2016
[INFO] Final Memory: 11M/219M
[INFO] ------------------------------------------------------------------------
[ERROR] Failed to execute goal com.zs:zs-dependency-check:1.0-SNAPSHOT:check (default-cli) on project zs-dependency-check: please upgrade to the specified version. -> [Help 1]
[ERROR]
[ERROR] To see the full stack trace of the errors, re-run Maven with the -e switch.
[ERROR] Re-run Maven using the -X switch to enable full debug logging.
[ERROR]
[ERROR] For more information about the errors and possible solutions, please read the following articles:
[ERROR] [Help 1] http://cwiki.apache.org/confluence/display/MAVEN/MojoFailureException

git：http://git.oschina.net/zhou2404/practice

 

OkidoGreen
关注
专栏目录
Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:3.7.0
qq_45800365的博客
02-09 377
Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:3.7.0
dependency-check-plugin:用于OWASP Dependency-Check的Jenkins插件。 检查项目组件是否存在已知漏洞（例如CVE）
05-13
依赖检查Jenkins插件 依赖性检查是一种实用程序，可识别项目依赖性并检查是否存在任何已知的，公开披露的漏洞。 该工具可以是OWASP Top 10 2017：A9-使用具有已知漏洞的组件的解决方案的一部分。 该插件可以独立执行依赖性检查分析并可视化结果。 寻求新的维护者 由于时间限制，其他承诺以及Jenkins项目的价值与我自己的价值观不符，我正在寻找新的维护者。 如果有兴趣，请在上创建票证，并且/或者按照指导进行操作'有兴趣成为该插件的维护者。 用法 该插件具有三个主要组件：全局定义的工具配置，构建器和发布者。 全局工具配置 可以通过Jenkins全局工具配置安装一个或多个Dependency-Check版本。 Dependency-Check的安装可以自动执行，这将从Bintray下载并提取官方命令行界面（CLI），或者可以手动安装正式发行版，并在配置中引用安装路径。 建造者 构建
maven-dependency-versions-check-plugin, Maven 插件查找依赖版本冲突
weixin_38168547的博客
09-25 578
1、maven-dependency-versions-check-plugin, Maven 插件查找依赖版本冲突 转载于:https://www.cnblogs.com/yixiu868/p/11583582.html
依赖包安全漏洞扫描工具——Dependency-Check，2024年最新网络安全开发谈
m0_61869253的博客
08-09 989
!!!!!
Maven学习笔记(十三)-maven-dependency-plugin插件
m0_67401920的博客
04-21 2789
一、简介 maven-dependency-plugin是处理与依赖相关的插件。它有很多可用的goal，大部分是和依赖构建、分析和解决相关的goal，这部分goal可以直接用maven的命令操作，例如：mvn dependency:tree、mvn dependency:analyze但是我们最常用到的是dependency:copydependency:copy-dependencies 及dependency:unpack　　dependency:unpack-dependencies这四个。 二、使用
MavenDependencyCheck：在基于Maven的项目上运行依赖检查的自动化脚本
02-05
MavenDependencyCheck 在基于Maven的项目上运行的自动化脚本。 该脚本基本上克隆给定的存储库，并使用maven构建它们。 成功后，它将对它们进行依赖性检查并生成报告 要求 Python模块： ＆ Maven：安装说明可在找到 包含要运行的用于克隆项目的git命令 repo.conf示例命令 git clone https://github.com/elderstudios/uni-dvwa-spring.git 用法 python depcheck.py 让脚本发挥作用 经过测试并在带有Python 2.7.5的CentOS Linux版本7.6.1810（
dependency-check-maven安全漏洞扫描工具介绍
热门推荐
太空眼睛的专栏
05-03 1万+
目录dependency-check-maven安全漏洞扫描工具介绍dependency-check-maven插件重点参数解析运行命令检查单个maven工程安全漏洞检查多个maven子工程汇总一个报告扫描报告示例 dependency-check-maven安全漏洞扫描工具介绍 dependency-check官网下载地址: https://owasp.org/www-project-dependency-check 这个工具支持多种方式，本文主要介绍使用maven插件的使用方式 dependency-c
pipeline-dependency-walker-plugin:Jenkins插件，流水线步骤，使您可以在Maven作业及其所有链接的作业上执行给定的流水线步骤
05-14
Dependency Walker插件 根据[麻省理工学院执照]许可。 关于 允许您对作业及其所有链接的作业执行给定的管道步骤。 链接的作业是作业的上游，从maven依赖项派生而来。 可以使用“ 将 可视化。 使用场景 干净的构建 ...
plugin-util-api-plugin:Jenkins插件，提供可用于加速插件开发的实用程序类
04-07
Jenkins插件实用程序 该Jenkins插件提供了可用于加速插件开发的实用程序类。 如何使用插件 为了使用这个小库，向您的pom添加一个maven依赖项： < dependency> < groupId>io.jenkins.plugins < artifactId>...
缺少依赖包引起的Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:
小小探索者
10-16 1470
一、问题描述 公司要把已有的代码迁移到云道平台，以前的纯javaWeb工程中的依赖包要改成maven仓库，代码的改造方面，除了添加pom.xml文件外，也没多大变化，但是在构建war文件时，提示了好多缺少依赖包的错误，一个个添加后，最后报了这个错 [ERROR] Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:3.1:compile (default-compile) on project httpjsoncuvd
Java+IDEA+maven混淆打包
03-15
在`pom.xml`文件中，我们需要添加`maven-jar-plugin`插件来打包Java项目。以下是一个基本的配置示例： ```xml <plugin> <groupId>org.apache.maven.plugins <artifactId>maven-jar-plugin <version>3.2.0...
Dependency-Check
qq_45370296的博客
09-21 1131
安装Dependency-Check有很多种方式，如构建工具插件、持续集成/持续交付（CI/CD）集成、Docker 集成、IDE 集成、自定义脚本、REST API，我一般会使用Maven构建项目，将Dependency-Check添加为Maven插件。Dependency-Check是一个用于检测应用程序的依赖项（项目中引入的各种库、框架和软件包）中是否存在已知漏洞的工具。执行完成后，可以在生成的报告中查看依赖项的漏洞信息。Dependency-Check 插件将会执行漏洞检查，并生成相应的报告。
Maven 依赖漏洞扫描检查插件 dependency-check-maven 的使用
最新发布
小单的博客专栏
09-08 573
在现代软件开发中，开源库的使用愈加普遍，然而这些开源库中的漏洞往往会成为潜在的安全风险。如何及时的发现依赖的第三方库是否存在漏洞，就变成很重要了。本文向大家推荐一款可以进行依赖包漏洞检查的 maven 插件 dependency-check-maven。通过这个插件可以扫描出项目中是否依赖已经存在的安全漏洞包及对应版本。
java maven校验jar冲突+类冲突+存在危险的jar+jdk版本等
tof
04-13 333
java maven 类冲突 jar冲突 循环依赖 不安全jar依赖检测
本地开发环境Maven方法使用dependency-check依赖扫描
进击的小白
05-04 2279
场景 方便本地进行项目依赖组件的版本安全扫描 方案 使用dependency-check-maven组件进行工程扫描，在pom中增加dependency-check-maven依赖和插件命令 <dependencies> .... <dependency> <groupId>org.owasp</groupId> <artifactId>depen
Centos7安装DependencyCheck
糖糖的小窝
04-14 703
安装java 查看yum源的java包 yum list java* 安装java1.8jdk软件 yum -y install java-1.8.0-openjdk 查看版本，检测是否安装成功 java -version 安装 maven 下载maven yum -y install wget wget https://mirrors.tuna.tsinghua.edu.cn/apache/maven/maven-3/3.6.3/binaries/apache-maven-3.6.3-bin.t
Maven中的Plugins或者Dependencies出现报错时的就解决办法
郭宝的博客
08-23 1万+
解决办法： 1、前往C盘将.m2文件夹中的内容全部删除，然后重新更新Maven即可
devops===》dependency-check-maven项目漏洞检查
Elaina_fang✨✨✨的博客
12-24 1499
一、OWASP dependency-check-maven插件 介绍：Dependency-Check是OWASP（Open Web Application Security Project）的一个实用开源程序，用于识别项目依赖项并检查是否存在任何已知的，公开披露的漏洞。目前，已支持Java、.NET、Ruby、Node.js、Python等语言编写的程序，并为C/C++构建系统（autoconf和cmake）提供了有限的支持。而且该工具还是OWASP Top 10的解决方案的一部分。 Dependen
Java项目代码依赖包安全漏洞检测插件Dependency Check
QC班长的博客
01-11 1万+
最近在搞Java的后端项目，需要更新jar依赖包，找到了一个jar包漏洞检测的插件Dependency Check。 Dependency-Check是OWASP(Open WebApplication Security Project)的一个实用开源程序，用于识别项目依赖项并检查是否存在任何已知的，公开披露的漏洞。目前，已支持Java、.NET、Ruby、Node.js、Python等语言编写的程序，并为C/C++构建系统(autoconf和cmake)提供了有限的支持。官网地址：OWASP Depen
pom中Maven插件 配置 maven-dependency-plugin maven-surefire-plugin
06-06
maven-dependency-plugin是Maven的一个插件，它可以用来管理项目的依赖关系，包括复制、解压、打包等操作。该插件的一些常用目标包括： - dependency:copy：将依赖复制到指定的目录下； - dependency:unpack：将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值