精华内容
下载资源
问答
  • 主要介绍了IDEA 2020.1 版自动导入MAVEN依赖的方法(新版MAVEN无法自动导入/更新POM依赖、MAVEN设置自动更新、自动更新快捷键),需要的朋友可以参考下
  • 用于分析Maven依赖关系升级机会的Python3脚本。 它是用Java编写的和和的替代方法。 至少,对于简单的依赖关系升级机会。 它不是纯Python,它仍然在后台运行Maven的dependency:tree 。 该脚本由贡献而开发。 脚本...
  • Maven依赖优化

    2020-11-11 16:21:19
    虽然说对于项目的运行没有什么障碍,但是对于后期的jar依赖的版本维护会很痛苦的,每次改升级某个JAR包版本的时候,还需要全局搜索并依次修改其版本。可想而知,这种方法是最笨且失误率是最大的。 Maven依赖优化 ...
    前言

    先谈谈自身的项目经验,每次在接手二次开发项目的时候,笔者都能发现一个明显却又广泛被忽视的问题:maven依赖很杂乱,甚至多有冗余的嫌疑;虽然说对于项目的运行没有什么障碍,但是对于后期的JAR依赖的版本维护会很痛苦的,每次升级某个依赖版本的时候,还需要全局搜索并依次修改其版本。可想而知,这种方法是最笨且失误率是最大的。

    Maven依赖优化
    排除无用重复的基础JAR包

    每个jar包可能会依赖多个基础jar包,在工程中可能存在不同的jar包的基础jar相互重复,也就是我们经常见到的omitted for duplicate,这种情况可能会影响工程的正常启动;严重的会使JAR提供的功能丧失。所以排除无用重复的JAR包是很有必要的。

    • 举个栗子,类似灰色的JAR都是重复的
      在这里插入图片描述

    • 真实案例场景分析

    笔者在某次集成redis的时候,发现一旦接入redis依赖,系统的日志都没有了;经过一番排查,最终发现是日志JAR包冗余了,于是乎移除redis中的日志基础依赖,系统日志就自然出来,这就是上述笔者提到的,严重的会影响系统某一项基础功能。

    • JAR排除的解决方案
    展开全文
  • Maven依赖管理总结

    千次阅读 2018-11-06 16:28:09
    本文主要总结Maven依赖管理中依赖范围和依赖冲突的解决。 依赖范围 依赖是maven项目引用的资源架包,依赖范围就是这些资源架包在maven项目中的作用范围,反过来说,maven项目通过依赖范围来控制何时引用资源架包。...

    前言

    Maven作为当下最流行的项目管理工具,其中核心功能就是依赖管理。本文主要总结Maven依赖管理中依赖范围和依赖冲突的解决。

    依赖范围

    依赖是maven项目引用的资源架包,依赖范围就是这些资源架包在maven项目中的作用范围,反过来说,maven项目通过依赖范围来控制何时引用资源架包。之前有介绍maven的默认生命周期,(compile,test,package,install,deploy)。maven的依赖范围用scope关键字表示,恰好也是五种,虽然不是和生命周期完整对应的,但是基于生命周期划分的。
    在这里插入图片描述
    通过下表可以知道依赖范围表示的作用域。

    依赖范围对于编译执行环境有效对于测试执行环境有效对于运行时执行环境有效例 子
    compilespring-core
    test××junit
    provided×servlet-api
    runtime×JDBC驱动
    system×本地的,Maven仓库之外的类库

    compile:依赖范围默认值是compile,这是最常用的,如果maven项目中引入一个依赖,没有添加scope依赖范围,那么默认的就是compile,表示maven项目在编译,测试,运行阶段都需要引用该依赖。
    test:表示该依赖包只和测试相关,测试代码的编译和运行会引用该依赖。
    provided:表示maven项目只在编译和测试时引用该依赖,如果将项目打包运行时,则不会引入该依赖,如servlet-api,这是web项目常用的架包,在项目编译和测试时都需要用到该架包,如果项目需要运行,则需要将项目部署到tomcat或其他web服务器上,但是tomcat中自带了servlet-api,如果maven项目中引入了servlet-api,那么会和tomcat中的servlet-api产生冲突,所以可以使用provided限定servlet-api,让maven项目在打包时不再引入servlet-api.

    runtime和system是不常用的。runtime表示在测试和运行阶段需要引入该依赖,在编译阶段不引入该依赖,如JDBC的驱动包,因为JDBC驱动是通过反射机制加载的,所以不参与项目编译过程。system的作用域和provided类似,表示引用仓库之外的依赖,需要通过systemPath指定本地依赖的路径,除了特殊情况基本不使用。

    传递依赖冲突的解决

    先了解一下传递依赖以及什么情况下会产生冲突。
    传递依赖,如果项目A需要引入依赖包B,依赖包B又引入了依赖包C,那么B是A的直接依赖,C是A的传递依赖。如果项目A还需要引入依赖包D,依赖包D也引用了依赖包C,当依赖包B引用的C和依赖包D引用的C版本不同时,则发生了依赖冲突。
    通过实例说明:一下是Spring的架构图(4.X版本的官方参考文档,5.X版本的没找到,地址:https://docs.spring.io/spring/docs/4.3.21.BUILD-SNAPSHOT/spring-framework-reference/htmlsingle/#overview-modules)
    在这里插入图片描述

    现在项目中使用到AOP和Messaging两个模块,在pom.xml文件中引入两个模块的架包坐标信息。

    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-aop</artifactId>
    			<version>4.3.7.RELEASE</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-messaging</artifactId>
    			<version>4.1.7.RELEASE</version>
    		</dependency>
    

    由下面的依赖层次结构图可知这两个模块都依赖于spring-core和spring-beans核心架包,这里只看spring-beans架包。
    在这里插入图片描述
    由上图可知,项目(A)依赖spring-aop(B)和spring-messaging(D)两个架包,而spring-aop(B)又依赖于spring-beans ( C),spring-messaging(D)也依赖于spring-banes( C),但是两个依赖的C版本不一样,spring-messaging引入的spring-beans:4.1.7.RELEASE后面括号中提示因为和4.3.7版本冲突而忽略了,也就是说spring-beans:4.1.7并没有被项目(A)引用。
    在这里插入图片描述
    查看此时项目中引用的maven依赖,spring-beans的版本是4.3.7.
    以上情况是因为maven具有自调节的maven传递依赖的冲突解决。
    总结一下maven传递依赖冲突解决方案:

    1.Maven自调节原则

    1.1 第一声明优先原则

    在pom.xml文件中引入两个模块 AOP 和 Messaging 的架包坐标信息,先声明的是AOP模块,当AOP和Messaging的依赖包发生冲突时,项目只会引入AOP模块底下的冲突依赖包,Messaging的冲突依赖包则会被排除。
    将AOP和Messaging的声明信息调换一下位置:

    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-messaging</artifactId>
    			<version>4.1.7.RELEASE</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-aop</artifactId>
    			<version>4.3.7.RELEASE</version>
    		</dependency>
    

    在pom.xml文件中声明Messaging模块,或者先加入spring-messaging架包,那么项目中会引入spring-messaging下的冲突架包。
    在这里插入图片描述

    1.2 路径近者优先原则

    这个就比较好理解了,就是直接依赖优先于传递依赖,当然会存在多层依赖,当多层依赖发生冲突时,maven的依赖管理会优先引入依赖层级最少的冲突依赖。如:
    在这里插入图片描述
    项目直接引入spring-aop(4.3.7版本),项目引入的spring-messaging架包的依赖 spring-context,spring-context又依赖于spring-aop(4.1.7版本),那么项目肯定会优先引入AOP的4.3.7版本,因为这个依赖路径最短。

    因为Maven具有自调节依赖冲突解决原则,所以项目中不会发生依赖冲突的错误,但是如果想要自定义选择依赖包的版本,可以用以下方法。

    2.排除依赖

    排除依赖顾名思义就是将不需要的依赖排除,这也是依赖冲突的一种解决方案。

    如,项目A依赖于B,B依赖于C,项目A依赖于D,D依赖于C,如果在项目A的pom.xml中先定义B,根据maven自调节的第一声明优先原则,那么D依赖的C就会被默认排除。此时,如果使用关键字exclusion在B中排除C,那么C自然不会再发生冲突了,因为B依赖的C被排除了,项目A会引入D依赖的C。

    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-messaging</artifactId>
    			<version>4.1.7.RELEASE</version>
    			<exclusions>
    				<exclusion>
    					<groupId>org.springframework</groupId>
    					<artifactId>spring-beans</artifactId>
    				</exclusion>
    			</exclusions>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-aop</artifactId>
    			<version>4.3.7.RELEASE</version>
    		</dependency>
    

    在这里插入图片描述
    spring-messaging中使用exclusion关键字排除spring-beans依赖包,可以看到依赖层级中,spring-messaging依赖中没有spring-beans,所以项目中引入的是spring-aop底下的spring-beans(4.3.7版本)。这就是排除依赖的使用。

    3.版本锁定(重点)

    所谓版本锁定就是指定依赖包的版本,这种依赖冲突的解决方案是目前实际项目中使用的最多的。
    版本锁定使用< dependencyManagement >节点

    	<dependencyManagement>
    		<dependencies>
    			<dependency>
    				<groupId>org.springframework</groupId>
    				<artifactId>spring-core</artifactId>
    				<version>4.3.2.RELEASE</version>
    			</dependency>
    			<dependency>
    				<groupId>org.springframework</groupId>
    				<artifactId>spring-aop</artifactId>
    				<version>4.3.2.RELEASE</version>
    			</dependency>
    			<dependency>
    				<groupId>org.springframework</groupId>
    				<artifactId>spring-context</artifactId>
    				<version>4.3.2.RELEASE</version>
    			</dependency>
    			<dependency>
    				<groupId>org.springframework</groupId>
    				<artifactId>spring-messaging</artifactId>
    				<version>4.3.2.RELEASE</version>
    			</dependency>
    			<dependency>
    				<groupId>org.springframework</groupId>
    				<artifactId>spring-beans</artifactId>
    				<version>4.3.2.RELEASE</version>
    			</dependency>
    			<dependency>
    				<groupId>org.springframework</groupId>
    				<artifactId>spring-expression</artifactId>
    				<version>4.3.2.RELEASE</version>
    			</dependency>
    		</dependencies>
    	</dependencyManagement>
    	<dependencies>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-messaging</artifactId>
    			<version>4.1.7.RELEASE</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-aop</artifactId>
    			<version>4.3.7.RELEASE</version>	
    		</dependency>
    	</dependencies>
    

    需要说明的是< dependencyManagement >节点仅仅起指定依赖包版本的作用。依赖包的引入仍然是由以下内容确定,如果pom.xml引入依赖包的节点设置了< version >,那么项目中则会引入该版本,如果在< dependencyManagement >节点指定了依赖包的版本,引入依赖包的节点可以不用设置版本。

    	<dependencies>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-messaging</artifactId>
    			<version>4.1.7.RELEASE</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-aop</artifactId>
    			<version>4.3.7.RELEASE</version>	
    		</dependency>
    	</dependencies>
    

    如下图所示 :spring-messaging和spring-aop版本分别是4.1.7和4.3.7,而其他的版本都指定为4.3.2版本。如果将依赖包的坐标信息中的< version >去掉,那么spring-messaging和spring-aop的版本也会变为< dependencyManagement >设定的4.3.2版本。
    在这里插入图片描述
    为了项目版本依赖管理的统一和方便升级,版本信息通常使用OGNL表达式表示,如下:

    	<properties>
    		<spring-version>4.3.2.RELEASE</spring-version>
    	</properties>
    	<dependencyManagement>
    		<dependencies>
    			<dependency>
    				<groupId>org.springframework</groupId>
    				<artifactId>spring-core</artifactId>
    				<version>${spring-version}</version>
    			</dependency>
    			<dependency>
    				<groupId>org.springframework</groupId>
    				<artifactId>spring-aop</artifactId>
    				<version>${spring-version}</version>
    			</dependency>
    			<dependency>
    				<groupId>org.springframework</groupId>
    				<artifactId>spring-context</artifactId>
    				<version>${spring-version}</version>
    			</dependency>
    			<dependency>
    				<groupId>org.springframework</groupId>
    				<artifactId>spring-messaging</artifactId>
    				<version>${spring-version}</version>
    			</dependency>
    			<dependency>
    				<groupId>org.springframework</groupId>
    				<artifactId>spring-beans</artifactId>
    				<version>${spring-version}</version>
    			</dependency>
    			<dependency>
    				<groupId>org.springframework</groupId>
    				<artifactId>spring-expression</artifactId>
    				<version>${spring-version}</version>
    			</dependency>
    		</dependencies>
    	</dependencyManagement>
    	<dependencies>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-messaging</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-aop</artifactId>
    		</dependency>
    	</dependencies>
    

    spring-version是一个自定义的常量名,可以设定值为依赖包的版本,然后在
    < dependencyManagement >中引用该值,如果项目需要升级依赖包的版本,只需要改变该常量值即可。

    传递依赖范围

    如A依赖于B,B依赖于C,A传递依赖于C,依赖范围关系如下:
    在这里插入图片描述
    之后会总结Maven项目拆分的相关知识,再说明对于传递依赖范围的理解。

    展开全文
  • Maven依赖详细理解

    千次阅读 2019-06-08 15:26:38
    Maven依赖理解1 简介2 依赖的配置3 依赖的范围4 传递性依赖4.1 传递性依赖和依赖调解5 依赖调解6 可选依赖7 总结 1 简介  在Maven项目中,有一个核心文件pom.xml。POM项目对象模型定义了项目的基本信息,用于描述心...

    1 简介

     在Maven项目中,有一个核心文件pom.xml。POM项目对象模型定义了项目的基本信息,用于描述心目如何构建,声明项目依赖。
     没有任何的实际Java代码,我们就能顶一个Maven项目的POM,这体现了Maven的一大优点,它能让项目对象模型最大程度地与实际代码相互独立,即解耦,或者正交性。这在很大程度上避免了Java代码和POM代码的相互影响。比如当项目需要升级版本时,只需要修改POM,而不需要更待Java代码;而在POM稳定之后,日常的Java代码开发工作基本不涉及POM的修改。
    下面的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>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.0.3.RELEASE</version>
            <relativePath/> <!-- lookup parent from repository -->
        </parent>
    
    
        <groupId>com.example</groupId>
        <artifactId>screenshot</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>screenshot</name>
        <description>Demo project for Spring Boot</description>
        <packaging>war</packaging>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <!-- 移除嵌入式tomcat插件 -->
                <exclusions>
                    <exclusion>
                        <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-starter-tomcat</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
            </dependency>
    
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>3.1.0</version>
                <scope>provided</scope>
            </dependency>
    
        </dependencies>
    
        <build>
            <finalName>screenshot</finalName>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <source>${java.version}</source>
                        <target>${java.version}</target>
                        <skip>true</skip>
                        <encoding>UTF-8</encoding>
                        <compilerArguments>
                            <extdirs>${project.basedir}/src/main/resources/lib</extdirs>
                        </compilerArguments>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>3.1.0</version>
                    <configuration>
                        <webResources>
                            <resource>
                                <directory>src/main/resources/lib</directory>
                                <targetPath>WEB-INF/lib</targetPath>
                                <includes>
                                    <include>**/*.jar</include>
                                </includes>
                            </resource>
                            <resource>
                                <directory>src/main/java/com/cetc52/screenshot/sdk</directory>
                                <targetPath>WEB-INF/sdk</targetPath>
                            </resource>
                        </webResources>
                        <failOnMissingWebXml>false</failOnMissingWebXml>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    
    </project>
    

    在POM文件中标签下的每个即表示该项目的一个直接依赖。

    2 依赖的配置

     从上述的简单pom.xml文件中,可以看到Maven项目的依赖声明如下:

    <project>
    	<dependencies>
                <dependency>
                      <groupId>org.springframework.boot</groupId>
                      <artifactId>spring-boot-starter</artifactId>
    				  <type></type>
    				  <scope></scope>
    				  <optional></optional>
    				  <exclusions>
    				    	<exclusion>…</ exclusion>
    				    	<exclusion>…</ exclusion>
    				  </exclusions>
                </dependency>
        </dependencies>
    </project>
    

    根元素project下的dependencies可以包含一个或者多个dependency元素,以声明一个或多个项目依赖。

    1. groupId, artifactId, version具体含义同Maven坐标,对于任何一个依赖,使用Maven坐标机制找打准确的依赖。
    2. type依赖的类型,对英语项目坐标定义的packaging,大部分情况下,元素不必填写,默认为jar
    3. scop依赖范围
    4. optional标记依赖是否可选
    5. exclusions用来排除传递依赖

    3 依赖的范围

    Maven在编译项目、测试项目、以及运行项目时使用三套classpath。编译时classpath为src/main/resources,测试时classpath为src/test/resources,在运行时classpath则为target/classes。
    依赖范围就是用来控制依赖与这三种classpath(编译classpath、测试classpath、运行classpath)的关系。
    在这里插入图片描述
    不考虑import依赖范围,其他各种依赖范围与三种classpath的关系参见Maven依赖范围与classpath、依赖传递如图:
    在这里插入图片描述

    4 传递性依赖

     Maven在帮助开发人员根据POM下载依赖时,会自动解析Maven项目的依赖,包括直接在POM文件中定义的直接依赖,以及每个依赖依赖的其他依赖。这个过程会自动进行,不需要手动干预。
    spring-core有一个依赖commons-logging依赖。

    <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      <version>1.2</version>
    </dependency>
    

     该依赖没有声明依赖范围,那么其依赖范围就是默认的compile。因此依赖图示如下:
    在这里插入图片描述
     通过传递性依赖机制,Maven项目就不需要考虑它依赖了什么,也不用担心引入多余的依赖。Maven会解析各个直接的POM,将那些必要的间接依赖以传递性依赖的形式引入到当前项目中。

    4.1 传递性依赖和依赖调解

     假设A依赖B,B依赖C,我们说A对于B是第一直接依赖,B对于C是第二直接依赖。A对于C是传递性依赖。第一直接依赖的范围和第二直接依赖的范围决定了传递性依赖的范围。下表中,最左边表示第一直接依赖范围,最上边为第二直接依赖范围,中间的交叉单元格则表示传递性依赖范围。
    在这里插入图片描述
     通过查看上图,可以发现这样的规律,当第二直接依赖的范围为compile的时候,传递性依赖范围与第一直接依赖的范围一致。当第二直接依赖的范围为test的时候,依赖不会传递;当第二直接依赖的范围为是provided的时候,只传递第一直接依赖范围也为provided的依赖,且传递性依赖范围同样为provided;当第二直接依赖的范围是runtime的时候,传递性依赖的范围与第一直接依赖一致,但compile例外,此时传递性依赖的范围为runtime

    5 依赖调解

     大部分情况下,我们只需要关心项目的直接依赖是什么,而不用考虑这些依赖会引入什么传递性依赖,当传递性依赖造成问题的时候,则需要清楚的知道该传递性依赖是从那条依赖路径引入的。
    在这里插入图片描述

    6 可选依赖

     一种场景是A–>B, B–>X(可选),B–>Y(可选),如果这三个依赖的范围都是compile,那么X、Y、就是A的compile范围传递性依赖。然而由于这里X、Y是可选依赖,依赖不会传递。换句话说X、Y不会对A有任何影响。
    项目B实现了两个特性,其中一项特性依赖X,另一项特性依赖Y,而且两个特性是互斥的。
    在这里插入图片描述
    在这里插入图片描述
     上述图片中,使用表示依赖是可选的。它们zhi 对当前项目B产生影响,当其他项目需要依赖B的时候,这两个依赖不会传递,因此,当项目A依赖于项目B的时候,如果其实际使用MySQL数据库,那么在项目A中就必须显式的声明mysql-connector-java这个依赖。
     在理想的情况下,是不应该使用可选依赖的。使用可选依赖的原因是一个项目实现了多个特性,在面向对象设计中,存在单一职责原则,意为一个类应该只有一个原则,而不是糅合太多的功能,这个原则在规划Maven项目的时候同样适用。

    7 总结

     本文章总结了Maven实战p62—p68的内容。主要内容包括Maven项目中依赖声明的格式,依赖范围的含义传递性依赖和依赖范围,以及依赖调解的两个原则。最后对于可选依赖的使用进行了简要的阐述,希望能够通过该文档增加对依赖理解的深度。

    8 下载

    Maven 依赖详细理解.pdf

    																20196717:22:55端午第一天于马塍路36
    展开全文
  • 常用Java maven依赖

    2019-10-07 21:02:27
    springboot+mybatis升级版 https://mp.baomidou.com/guide/ < dependency > < groupId > com . baomidou < / groupId > < artifactId > mybatis - plus - boot - starter < / artifactId > < version >...
    1. org.apache.commons.lang3: java.long相关的工具类封装
    <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.3.2</version>
        </dependency>
    
    1. Json相关类库
    <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.61</version>
    </dependency>
    
    <!-- https://mvnrepository.com/artifact/org.codehaus.jackson/jackson-core-asl -->
    <dependency>
        <groupId>org.codehaus.jackson</groupId>
        <artifactId>jackson-core-asl</artifactId>
        <version>1.9.13</version>
    </dependency>
    
    1. Google的java库
    <!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>23.0</version>
    </dependency>
    
    1. TestNg测试框架
    <!-- https://mvnrepository.com/artifact/org.testng/testng -->
    <dependency>
        <groupId>org.testng</groupId>
        <artifactId>testng</artifactId>
        <version>6.14.3</version>
        <scope>test</scope>
    </dependency>
    
    1. selenium相关
    <dependency>
                <groupId>org.seleniumhq.selenium</groupId>
                <artifactId>selenium-api</artifactId>
                <version>3.14.0</version>
            </dependency>
            <dependency>
                <groupId>org.seleniumhq.selenium</groupId>
                <artifactId>selenium-support</artifactId>
                <version>3.14.0</version>
            </dependency>
            <dependency>
                <groupId>org.seleniumhq.selenium</groupId>
                <artifactId>selenium-chrome-driver</artifactId>
                <version>3.14.0</version>
            </dependency>
    6. 日志log4j
    
    <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-log4j12</artifactId>
                <version>1.7.25</version>
            </dependency>
    
    1. apache HttpClient
    <!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient -->
    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpclient</artifactId>
        <version>4.5.10</version>
    </dependency>
    
    1. Lombok简化代码书写,不用额外书写getter和setter等方法
    <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.10</version>
        <scope>provided</scope>
    </dependency>
    
    1. springboot+mybatis升级版 https://mp.baomidou.com/guide/
    <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.2.0</version>
        </dependency>
    
    展开全文
  • 1.依赖 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>${springframework.version}</version> <type>...
  • Maven依赖jar的自动升级配置

    千次阅读 2016-12-06 10:43:56
    Maven应用 Maven自动依赖最新的jar包
  • MAVEN依赖的优先原则

    2021-01-20 17:14:00
    MAVEN依赖的优先原则 ...
  • idea更新maven依赖

    万次阅读 2017-11-15 18:09:43
    IntelljIdea 自动载入Maven依赖的功能很好用,但有时候会碰到问题,导致pom文件修改却没有触发自动重新载入的动作,此时需要手动强制更新依赖。  如下: 手动删除Project Settings里面的Libraries内容;在Maven ...
  • idea解决maven依赖冲突

    千次阅读 2020-06-19 16:25:25
    最近在一个老spring项目上面需要适配一个新功能,过程中也需要升级spring的版本,然后最后就导致maven依赖包很乱,同一个包存在多个版本,本文就记录下使用idea解决maven依赖冲突,同时记录下assembly打包插件的...
  • 我们在平时的项目开发中也是同理,你需要依赖一些东西才能实现相应的功能,但相应的功能或许也可以依赖其它的东西实现,比如数据库操作吧,你可以依赖hibernate,但你也可以通过mybatis来做。 这就是所谓的依赖关系...
  • maven 构建依赖树 熟悉发行版和快照依赖关系的Maven和Gradle用户可能不了解TeamCity快照依赖关系,或者假定他们与Maven相关(这是不正确的)。 熟悉工件和快照相关性的TeamCity用户可能不知道,除了TeamCity提供的...
  • maven 依赖版本控制和更新问题

    千次阅读 2019-12-09 18:00:34
    之前我们说过Maven的版本分为快照和稳定版本,快照版本使用在开发的过程中,方便于团队内部交流学习。而所说的稳定版本,理想状态下是项目到了某个比较稳定的状态,这个稳定包含了源代码和构建都要稳定。 maven中的...
  • 标题 方法一 如一下博客做法去解决 https://blog.csdn.net/u010003835/article/details/78480626 方法二 更改依赖包版本,可行 比如
  • SpringBoot2.0以后MAVEN依赖问题

    千次阅读 2020-04-22 15:55:41
    SpringBoot2.0以后MAVEN依赖问题,这里呢我记录一个自己踩的坑“Exception in thread "main" java.lang.NoClassDefFoundError: org/springframework/core/ErrorCoded。”=缺少spring-boot-starter-jdbc依赖。 项目...
  • IDEA中Maven依赖包报错的问题解决方案汇总

    千次阅读 多人点赞 2020-06-12 13:05:28
    IDEA中Maven依赖报错的问题解决方案汇总 最近配置maven,下载依赖各种报错问题特别恼火,真的是很烦,百度了三天,网上各种搜解决方案,问了老师,同学,博主都最后终于。所以写个博客让大家避免再踩我踩过的坑。 我...
  • Maven更新依赖

    千次阅读 2018-12-14 15:26:22
    IntelljIdea 自动载入Maven依赖的功能 Import Maven projects automatically表示 IntelliJ IDEA 会实时监控项目的 pom.xml文件,进行项目变动设置。 Automatically download在 Maven 导入依赖包的时候是否自动...
  • 在日常开发中,maven依赖经常会产生冲突,一般没什么问题,项目可以正常运行,但是如果是因为maven依赖导致的项目不能跑了,很多人都会束手无策,然后上百度搜一大堆东西,最后花费很长时间才解决。所以了解依赖产生...
  • Maven的坐标与依赖

    千次阅读 2018-11-01 23:14:03
    (尊重劳动成果,转载请注明出处:https://blog.csdn.net/qq_25827845/article/details/83628045冷血之心的博客) 关注微信公众号(文强的技术小屋),学习更多技术知识,...Maven的坐标与依赖 Maven的生命周期...
  • idea右侧maven依赖飘红解决办法

    千次阅读 2021-02-08 14:11:53
    idea右侧maven依赖飘红解决办法 记一次实际项目中遇到的idea右侧maven飘红得问题,场景是其他公司交付的项目(包括依赖,我是直接和我本地的依赖合并了),该解决办法同样适用于其他场景 这里借用一下图片 但本地...
  • 但是依赖包一直更新不下来,reimport几次了都不行 检查m2的配置文件,使用的是阿里云的镜像没问题。 最后懒得排查了,直接在项目pom中单独加入阿里云镜像算了 <!-- 不知道为什么在maven的settings.xml中...
  • 1 坐标和依赖配置 2 依赖范围 3 传递性依赖 4 依赖调节 5 可选依赖 6 排除依赖 7 归类依赖 8 优化依赖 1 坐标和依赖配置 Maven坐标的元素包括groupId、artifactId、version、packaging、classifier groupId...
  • maven项目关系依赖

    2021-05-22 10:04:28
    3、maven项目依赖关系 3.1、简单来说就是连个项目之间可以相互依赖,并且使用彼此的jar包依赖文件。 我们简单举个例子,就是在项目ebuy-1中引入依赖文件,在项目ebuy-2中引用项目ebuy-1。 3.2、简单测试一下mysql...
  • 记一次maven依赖不能更新的解决

    千次阅读 2018-10-24 18:55:51
    代码结构大致是A是最顶级模块,B和C是A的子模块,D是C的子模块,B依赖D,ABCD都是0.0.1-SNAPSHOT版本。 在B的pom文件里,有D和C的依赖引用。 更新D的接口(添加了一个参数,变成2个参数)后,重新install D的模块...
  • 【IDEA】IntelliJ IDEA更新maven依赖

    千次阅读 2020-12-12 16:30:22
    IntelliJ IDEA自动载入Maven依赖的功能很好用,但有时候会碰到问题,导致pom文件修改却没有触发自动重新载入的动作,此时需要手动强制更新依赖。 方法: 方法一: ①、右键单击项目; ②、在弹出菜单中选择Maven|Re...
  •      <groupId>org.springframework  <artifactId>spring-web  <version>4.3.14.RELEASE ...-- 升级子项目org.springframework版本号排除父引用 --> ...升级版本号报错Duplicate ...去掉子项目相同maven依赖
  • Maven 依赖机制的帮助下自动下载所有必需的依赖库,并保持版本升级。    详细解释: 让我们看一个案例研究,以了解它是如何工作的。假设你想使用 Log4j 作为项目的日志。这里你要做什么? 1.在传统方式 访问 ...
  • 之前介绍过Maven依赖调节机制。 依赖调节是为了解决版本不一致的问题(multiple versions),并采取就近原则(nearest definition)。 举例来说,A项目通过依赖传递依赖了两个版本的D: A -> B -> C -> ( D ...
  • 或者比如 a.class使用b.class, a依赖b类 1.4 为了改进项目的开发和管理,maven应运而生 maven可实现以下作用: (1)maven可以管理jar文件 (2)自动下载jar和他的文档,源代码 (3)管理jar直接的依赖, a.jar需要b....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,805
精华内容 11,122
关键字:

maven依赖的依赖需要升级