Maven的依赖详解和打包方式
设置maven
maven下载与安装教程： https://blog.csdn.net/YOL888666/article/details/122008374
1. 在File->settings->搜索maven
2. Mavan home directory--设置maven安装包的bin文件夹所在的位置
3. User settings file--设置setting文件所在的位置
4. Local repository--设置本地仓库（来用存储项目下载的依赖包，可以随便配置个目录，建议就在maven安装目录下新增个文件夹repository）
IDEA有自带的maven为什么还要下载Mavan
1、如果你是新手的话，建议自行配置maven，有助于你更好的学习和理解maven，毕竟IDE会屏蔽很多细节，不利于新手学习。
2、idea自带的maven在它自己的路径和配置中，为避免升级（无论升级idea还是想升级maven）时发生莫名其妙的问题，自定义配置更能少遇到错误。
3、不依赖IDEA，你也可以在其他的IDE上开发。如果你恰好还要同时用eclipse，独立出来会更好管理，可在两个环境间共享配置和仓库。
4、idea自带的maven配置文件和仓库都在C盘，而且C盘一般不要放东西，自行配置maven，不仅可以自由管理配置文件和仓库的位置，而且可以任意换maven的版本。
SpringBoot项目pom.xml的正常配置
1、springboot项目首先继承spring-boot-starter-parent
2、引入父级springboot相关的依赖默认会使用父级中的版本号
3、其它非父级springboot中的依赖资源必须都要指定具体的版本号
<?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/>
</parent>
<groupId>com.cn</groupId>
<artifactId>TestDemo</artifactId>
<packaging>jar</packaging> <!-- 打包方式，默认jar，还有war包-->
<dependencies>
<!--springBoot-web相关依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
<version>2.0.3.RELEASE</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.19</version>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.4.0</version>
</dependency>
<!-- Lombok 工具 -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.14</version>
</dependency>
<dependency>
<groupId>org.springframework.plugin</groupId>
<artifactId>spring-plugin-core</artifactId>
<version>2.0.0.RELEASE</version>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.8.5</version>
</dependency>
</dependencies>
<build>
<finalName>${project.artifactId}</finalName>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>2.1.1.RELEASE</version>
<configuration>
<fork>true</fork> <!-- 如果没有该配置，devtools不会生效 -->
</configuration>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
dependency 依赖属性详情
<!-- 该元素描述了项目相关的所有依赖，这些依赖组成了项目构建过程中的一个个环节，它们自动从项目定义的仓库中下载。要获取更多信息,请看项目依赖机制-->
<dependencies>
<dependency>
<groupId>org.apache.maven</groupId><!-- 依赖的group ID -->
<artifactId>maven-artifact</artifactId><!-- 依赖的artifact ID -->
<version>3.8.1</version><!-- 依赖的版本号。在 Maven 2 里,也可以配置成版本号的范围 -->
<type>jar</type><!-- 依赖类型,默认类型是jar.它通常表示依赖的文件扩展名 -->
<classifier></classifier><!-- 依赖的分类器。分类器可以区分属于同一个 POM,但不同构建方式的构件，分类器名被附加到文件名的版本号后面。例如,如果你想要构建两个单独的构件成 JAR , 一个使用 Java 1.4 编译器,另一个使用 Java 6 编译器,你就可以使用分类器来生成两个单独的 JAR 构件 -->
<scope>test</scope><!-- 依赖范围。在项目发布过程中,帮助决定哪些构件被包括进来。欲知详情请参考依赖机制。常用取值如下所示
- compile:默认范围,用于编译
- provided:类似于编译,但支持你期待 jdk 或者容器提供,类似于 classpath
- runtime:在执行时需要使用
- test:用于 test 任务时使用
- system:需要外在提供相应的元素,通过 systemPath 来取得
- systemPath:仅用于范围为 system,提供相应的路径
- optional:当项目自身被依赖时,标注依赖是否传递。用于连续依赖时使用 -->
<systemPath></systemPath><!-- 仅供 scope 为 system 范围使用。注意,不鼓励使用这个元素,并且在新的版本中该元素可能被覆盖掉。该元素为依赖规定了文件系统上的路径。需要绝对路径而不是相对路径。推荐使用属性匹配绝对路径,例如 ${java.home} -->
<!-- 当计算传递依赖时,从依赖构件列表里,列出被排除的依赖构件集，即告诉 maven 你只依赖指定的项目,不依赖下面的依赖。此元素主要用于解决版本冲突问题 -->
<exclusions>
<exclusion>
<artifactId>spring-core</artifactId>
<groupId>org.springframework</groupId>
</exclusion>
</exclusions>
<optional>true</optional><!-- 可选依赖,如果你在项目 B 中把 C 依赖声明为可选,你就需要在依赖于 B 的项目（例如项目 A）中显式的引用对 C 的依赖。可选依赖阻断依赖的传递性 -->
</dependency>
</dependencies>
当项目中使用 CXF + Spring 做 webservice 调用时，部分 dependency 的 type 属性取值为 pom。
因为阿里云中央仓库中 central/org/apache/cxf/apache-cxf/2.5.3/ 下的文件列表中没有 jar 文件。
SpringBoot如何管理依赖的版本？
创建好的项目，找到它的pom.xml文件,里面可以看一个parent属性，代码如下。
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.3.RELEASE</version>
<relativePath/> <!-- 设定一个空值将始终从仓库中获取，不从本地路径获取 -->
</parent>
MAVEN构建jar包时候查找顺序：relativePath元素中的地址>本地仓库>远程仓库
点进去其实你会发现他也是继承于spring-boot-dependencies
如果你不想使用spring-boot-starter-parent，你依然可以通过使用spring-boot-dependencies的scope=import利用依赖管理的便利。
<groupId>com.cn</groupId>
<artifactId>hviger</artifactId>
<version>${hviger.version}</version>
<!--父pom需要添加<packaging>pom</packaging>-->
<packaging>pom</packaging>
<name>project-parent</name>
<description>父级依赖管理模块</description>
<!--指定了当前POM模型的版本，对于Maven2及Maven3来说，它只能是4.0.0 -->
<modelVersion>${hviger.modelVersion}</modelVersion>
<!-- 版本管理 -->
<properties>
<hviger.version>1.0.1</hviger.version> <!-- 当前项目版本 -->
<hviger.modelVersion>4.0.0</hviger.modelVersion>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<java.version>1.8</java.version>
<swagger.version>3.0.0</swagger.version>
<mybatis-plus.boot.version>3.4.0</mybatis-plus.boot.version>
<pagehelper.boot.version>1.4.1</pagehelper.boot.version>
<fastjson.version>1.2.79</fastjson.version>
<lombok.version>1.18.14</lombok.version>
<hutool.version>5.7.7</hutool.version>
</properties>
<!-- 依赖声明 -->
<!-- 父pom声明依赖时<dependencies>外要嵌套<dependencyManagement>才能被子pom继承到 -->
<dependencyManagement><!-- 这个元素并不会真的引入依赖，只会标明依赖和版本，因此必须使用子模块来继承才能使用 -->
<dependencies>
<!-- SpringCloud的jar包依赖 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Dalston.SR1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!-- SpringBoot的依赖配置-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.5.10</version>
<type>pom</type> <!-- 依赖类型,默认类型是jar，它通常表示依赖的文件扩展名 -->
<scope>import</scope> <!-- 把父模块中的依赖包导入进来 -->
</dependency>
<!-- 子模块管理起来，可以相互引用 -->
<dependency>
<groupId>com.cn</groupId>
<artifactId>cn-admin</artifactId>
<version>${hviger.version}</version>
</dependency>
<dependency>
<groupId>com.cn</groupId>
<artifactId>cn-system</artifactId>
<version>${hviger.version}</version>
</dependency>
<dependency>
<groupId>com.cn</groupId>
<artifactId>cn-common</artifactId>
<version>${hviger.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
<!-- 父pom需要用<modules>方式注明有哪些子模块 -->
<modules>
<module>cn-admin</module>
<module>cn-system</module>
<module>cn-common</module>
</modules>
Maven的继承和Java的继承一样，只能单继承，无法实现多继承。因为所有的jar包都混合在一起了，jar包分类就不在清晰了。
于是我们用另外一种方式实现多模块继承，就是使用<dependencyManagement>方式导入了SpringCloud和SpringBoot的两个父模块的jar包依赖。
<type>pom</type>
<scope>import</scope>
注意：这种方式只能用在<dependencyManagement></dependencyManagement>中
定义父级pom的意义：
- 继承父pom可以避免多个子pom使用相同技术(相同依赖)时出现依赖版本冲突问题;
- 当子pom再引用父pom的依赖，只用写groupId和artifactId就行了，不用再指定版本号version
子模块引用父级模块
<!-- 子pom需要通过<parent></parent>指定父项目，声明依赖时就默认会用父pom中的版本了 -->
<parent>
<artifactId>hviger</artifactId>
<groupId>com.cn</groupId>
<version>${hviger.version}</version><!-- 这里会报红，禁止在模块父定义中使用属性，可以不用管，也可以在Idea设置下即可 -->
</parent>
<modelVersion>${hviger.modelVersion}</modelVersion>
<artifactId>cn-common</artifactId><!-- 定义了当前maven项目在组中唯一的ID -->
<!-- 子pom默认会使用父pom中的依赖版本，如果这里再定义version就不会使用父pom里的版本了-->
<dependencies>
<!-- Spring框架基本的核心工具 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
</dependency>
<!-- SpringWeb模块 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
</dependency>
<!-- spring security 安全认证 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
</dependencies>
内置属性使用
<properties>
<!--这里定义一个my.version的属性在下面的地方可以直接${my.version}引用这个属性-->
<my.version>1.1.0</my.version>
</properties>
<dependencies>
<dependency>
<groupId>xxx.xxxx</groupId>
<artifactId>xxxx</artifactId>
<version>${my.version}</version>
</dependency>
</dependencies>
引用外部jar包
方式一：dependency 本地jar包
<dependency>
<groupId>com.im</groupId> <!--自定义-->
<artifactId>sdk</artifactId> <!--自定义-->
<version>1.0</version> <!--自定义-->
<scope>system</scope> <!--system，类似provided，需要显式提供依赖的jar以后，Maven就不会在Repository中查找它-->
<systemPath>${basedir}/src/main/resources/lib/sdk-1.0.jar</systemPath> <!-- 项目中的lib路径，也可以指定具体的磁盘路径-->
</dependency>
方式二：编译阶段指定外部lib
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.3.2</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
<compilerArguments>
<extdirs>lib</extdirs><!--指定外部lib-->
</compilerArguments>
</configuration>
</plugin>
方式三：将外部jar打入本地maven仓库
mvn install:install-file -Dfile=sdk-1.0.jar -DgroupId=com.im -DartifactId=sdk -Dversion=1.0 -Dpackaging=jar
引入jar包：
<dependency>
<groupId>com.im</groupId>
<artifactId>sdk</artifactId>
<version>1.0</version>
</dependency>
解决JAR包冲突的三种方式
当项目所依赖的多个项目均依赖于某个相同项目名和组名的jar包，但是这些项目所依赖的jar版本号不相同时，就会导致jar包冲突，因此需要学会解决jar冲突。
1）第一声明优先原则：坐标出现在较上面的位置的jar包优先声明，先声明的jar包的依赖包能够先进入项目中
2）路径近者优先原则：直接依赖包的路径比传递依赖包近，那么最终导入项目的jar包是路径近的直接依赖包
注：maven导入jar包的一些概念：
直接依赖：项目中直接导入的jar包就是该项目的直接依赖包。
传递依赖：项目中没有直接导入的jar包，可以通过项目直接依赖包传递到项目中去
3）直接排除法：排除某个jar包下的依赖包，通过配置标签来实现，不用声明版本号
排查JAR包冲突，最有效方式就是Idea安装 Maven Helper 插件
查找和排除冲突依赖项的简便方法，为包含当前文件或根模块的模块运行/调试maven目标的操作，运行/调试当前测试文件的操作
打开项目的pom文件,会多出 Dependency Analyzer 的tab页
打包项目的几种方式
1、spring-boot-maven-plugin（springboot)
打jar包所有依赖都在jar包
打包原理：把依赖的 jar 打包到 jar 包的 lib 目录。
<build>
<finalName>${project.artifactId}</finalName><!-- 打包的jar名称 -->
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
2、maven-assembly-plugin
打jar包所有依赖都在jar包（spring框架下有问题）
打包方式：mvn package assembly:single
高级打包方式，支持自定义的打包结构，比如sql/shell等，也可以定制依赖项等
打包后会在target目录下生成一个xxx-jar-with-dependencies.jar文件，这个文件不但包含了自己项目中的代码和资源，还包含了所有依赖包的内容。所以可以直接通过java -jar来运行。
<build>
<finalName>${project.artifactId}</finalName><!-- 打包的jar名称 -->
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-assembly-plugin</artifactId>
<version>3.4.2</version>
<configuration>
<archive>
<manifest>
<mainClass>com.cn.WebApplication</mainClass><!-- 指定启动类 -->
</manifest>
</archive>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
</configuration>
<!-- 这块配置表示可以直接通过mvn package来打包，在执行package打包时，执行assembly:single -->
<executions>
<execution>
<id>make-assembly</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
3、maven-jar-plugin（排除了依赖）
默认的打包插件，用来打普通项目Jar包，需建立lib目录里来存放需要的依赖包。
这种方式生成jar包有个缺点，就是生成的jar包太多不便于管理，上面两种方式只生成一个jar文件，包含项目本身的代码、资源以及所有的依赖包。
<build>
<finalName>${project.artifactId}</finalName><!-- 打包的jar名称 -->
<plugins>
<!-- 配置打包，并配置MainClass，但不将依赖包打包，会出现找不到依赖的异常 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>3.3.0</version>
<configuration>
<archive>
<manifest>
<addClasspath>true</addClasspath>
<!-- MANIFEST.MF 中 Class-Path -->
<classpathPrefix>lib/</classpathPrefix>
<mainClass>com.cn.WebApplication</mainClass>
</manifest>
</archive>
</configuration>
</plugin>
<!-- 配置依赖包 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<executions>
<execution>
<id>copy-dependencies</id>
<phase>package</phase>
<goals>
<goal>copy-dependencies</goal>
</goals>
<configuration>
<!-- 将依赖包打包至target下的lib目录 -->
<outputDirectory>${project.build.directory}/lib</outputDirectory>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
4、maven-shade-plugin (推荐)
shade 是把依赖的 class 打包进 jar，将依赖的jar包打包到当前jar包，成为fat JAR包。
shade可以指定或排除哪些项目依赖项，还可以配置为自动删除项目未使用的所有依赖类，从而最大限度地减少产生的jar文件的大小。
因为现在大多项目是基于springboot搭建的，没有特别情况就按springboot自带的方式一打包即可。
如果springboot需要集成maven-shade-plugin插件打包，方式如下：
<build>
<finalName>${project.artifactId}</finalName><!-- 打包的jar名称 -->
<plugins>
<!-- shade打包插件 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>3.2.4</version>
<!-- springboot本身就带有自己的打包插件spring-boot-maven-plugin，如果再引用Shade打包插件会导致一些冲突。-->
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>2.0.3.RELEASE</version>
</dependency>
</dependencies>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
<configuration>
<!-- 自动移除项目中没有使用到的依赖，以此来最小化jar包的体积,建议maven-shade-plugin的版本为3.2.4，低版本会报错-->
<minimizeJar>true</minimizeJar>
<!-- 默认为 false，这避免了并行构建的构建冲突，而无需将 dependency-reduced 的 POM 移动到其他目录。 -->
<keepDependenciesWithProvidedScope>true</keepDependenciesWithProvidedScope>
<!-- 默认值为true，则依赖项保留在 pom 中，但其 scope 为 provided；如果为 false，则删除依赖项。 -->
<createDependencyReducedPom>true</createDependencyReducedPom>
<!-- 在打包时将jar包中的一些内容排除，防止重复引用打包失败 -->
<filters>
<filter>
<artifact>*:*</artifact>
<excludes>
<exclude>META-INF/*.SF</exclude>
<exclude>META-INF/*.DSA</exclude>
<exclude>META-INF/*.RSA</exclude>
</excludes>
</filter>
</filters>
<!-- 使用artifactSet排除不需要的依赖，指定 groupId:artifactId 的标识-->
<artifactSet>
<excludes>
<exclude>junit:junit</exclude>
<exclude>jmock:*</exclude>
<exclude>*:xml-apis</exclude>
<exclude>org.apache.maven:lib:tests</exclude>
<exclude>log4j:log4j:jar:</exclude>
</excludes>
</artifactSet>
<transformers>
<!--处理多个jar包中存在重名的配置文件的合并-->
<transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
<resource>META-INF/spring.handlers</resource>
</transformer>
<transformer implementation="org.springframework.boot.maven.PropertiesMergingResourceTransformer">
<resource>META-INF/spring.factories</resource>
</transformer>
<transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
<resource>META-INF/spring.schemas</resource>
</transformer>
<transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
<!--java -jar 默认启动的主类-->
<transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
<mainClass>com.cn.WebApplication</mainClass>
</transformer>
</transformers>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
SpringBoot项目打包成war包
第一步：修改打包类型，添加如下依赖
<packaging>war</packaging>
第二步：在spring-boot-starter-web依赖下排除掉spring boot内置的tomcat
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>
第三步：添加servlet依赖
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
第四步：添加maven-war-plugin打包插件，实现一些自定义配置
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<version>3.1.0</version>
<configuration>
<failOnMissingWebXml>false</failOnMissingWebXml>
<warName>${project.artifactId}</warName>
</configuration>
</plugin>
</plugins>
</build>
第五步，增加下面这个类，或直接在启动类继承SpringBootServletInitializer类
/**
* web容器中进行部署
*/
public class WebServletInitializer extends SpringBootServletInitializer
{
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application)
{
return application.sources(WebApplication.class);
}
}
SpringBoot 在打包部署的时候打包成 jar 和 war 有什么不同?
Maven的依赖详解和打包方式的更多相关文章
- elasticSearch+spring 整合 maven依赖详解
摘自:http://www.mayou18.com/detail/nTxPQSyu.html [Elasticsearch基础]elasticSearch+spring 整合 maven依赖详解 Ma ...
- 【maven】maven pom文件详解
maven pom文件详解 最近配置maven中的pom文件,maven中有些属性不太清楚,在这里记录一下 <project xmlns="http://maven.apache.or ...
- JavaScript---Dom树详解,节点查找方式(直接(id,class,tag),间接(父子,兄弟)),节点操作(增删改查,赋值节点,替换节点,),节点属性操作(增删改查),节点文本的操作(增删改查),事件
JavaScript---Dom树详解,节点查找方式(直接(id,class,tag),间接(父子,兄弟)),节点操作(增删改查,赋值节点,替换节点,),节点属性操作(增删改查),节点文本的操作(增删 ...
- (十)Maven依赖详解
1.何为依赖? 比如你是个男的,你要生孩子,呸呸呸...男的怎么生孩子,所以你得依赖你老婆,不过也不一定咯,你也可以依赖其她妹子. 我们在平时的项目开发中也是同理,你需要依赖一些东西才能实现相应的功能 ...
- Maven 教程（10）— Maven依赖详解
原文地址:https://blog.csdn.net/liupeifeng3514/article/details/79545022 1.何为依赖? 比如你是个男的,你要生孩子,呸呸呸…男的怎么生孩子 ...
- maven pom文件详解
http://www.blogjava.net/hellxoul/archive/2013/05/16/399345.html http://blog.csdn.net/houpengfei111/a ...
- Maven基础知识详解
1. 简介 Maven在Java领域的应用已经非常广泛了,有了Maven的存在是的开发人员在搭建.依赖.扩展和打包项目上变得非常简单. 2. Windows安装Maven 下载安装包 http ...
- Maven POM.xml详解[转]
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/20 ...
- 史上最全maven pom.xml详解
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/20 ...
- .Net 缓存依赖详解
缓存命名空间的讲解流程 16.1 System.Web.Caching简介 本节从缓存命名空间的总体简介和组成结构入手,从整体上对System.Web.Caching进行概述. 16.1.1 Sy ...
随机推荐
- 一文搞懂 ARM 64 系列: ADC
1 指令语法 adc <Xd>, <Xn>, <Xm> 2 指令语义 adc就是带「进位」加法,指令中的c就是英文carry. 整个指令等价于: (Xd, _) = ...
- mac升级node
sudo npm cache clean -f //清除nodejs的cache sudo npm install -g n //使用npm安装n模块 npm view node versions / ...
- LLM实战：LLM微调加速神器-Unsloth + LLama3
1. 背景 五一结束后,本qiang~又投入了LLM的技术海洋中,本期将给大家带来LLM微调神器:Unsloth. 正如Unsloth官方的对外宣贯:Easily finetune & tra ...
- Vue3.x+springboot集成pageoffice
说明:由于pageoffice浏览器是ie内核,vue3不兼容ie.所以需要把页面放在后端 一,前端项目: 1.index.html页面引用pageoffice.js <script type= ...
- Kubernetes:kubelet 源码分析之探针
0. 前言 kubernetes 提供三种探针,配置探针(Liveness),就绪探针(Readiness)和启动(Startup)探针判断容器健康状态.其中,存活探针确定什么时候重启容器,就绪探针确 ...
- centos7下启动Django项目报错（sqlite错误）
报错内容如下: [root@localhost project]# python3 manage.py runserver Watching for file changes with StatRel ...
- Android 13 - Media框架（8）- MediaExtractor
关注公众号免费阅读全文,进入音视频开发技术分享群! 上一篇我们了解了 GenericSource 需要依赖 IMediaExtractor 完成 demux 工作,这一篇我们就来学习 android ...
- 关于ICMP隧道一点理解（起于修改wien-qq的记住密码）
起 使用linux半年多以来,一直有一个我很需要但我无法完美解决的东西困扰这我-----(linux QQ) 目前我的解决方案是GitHub上的一个第三方QQ(有关ICMP隧道的搭建见 承,转) 但是 ...
- 使用python批量获取excel的sheet名称
这个脚本的重用是批量读取excel并获取每个excel的所有sheet名输出到一个文件中. 环境:python 3.7.3 1 # -*- coding:utf-8 -*- 2 3 ''' 4 本代码 ...
- 箭头函数中的this指向
// 箭头函数中的this指向 // 如果是箭头函数,this指向是,父级程序的,this的指向 // 如果父级程序是一个函数,函数也是有t ...