maven配置

发表于 | 分类于

一：maven中plugins讲解

​ maven 项目是通过 maven-compiler-plugin 插件来对 Java 代码编译的，如果不指定 JDK 版本，maven-compiler-plugin 会自动使用一个默认的版本，该版本可能与你使用的 IDE 所使用的 JDK 版本不一致，这种情况可能会导致代码无法通过 maven 的编译，例如：在 IDE 指定 JDK 1.8 ，coding 的时候使用了JDK 1.8 的特性，而 maven-compiler-plugin 默认的 JDK 版本为 1.5，此时 JDK 1.5 是不可能将带有 JDK 1.8 特性的代码编译通过的。此类问题的出现可通过在 pom 文件中指定 JDK 版本来避免

maven-compiler-plugin：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>2.3.2</version>
            <configuration>
            	//将会使用指定的 JDK 版本对源代码进行编译（针对编译运行环境） 
                <source>1.8</source>
                //将会使用指定的 JDK 版本将 java 文件编译为 class 文件（针对编译运行环境）
                <target>1.8</target>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>

maven-jar-plugin

maven-jar-plugin 这个插件通常用法是将maven工程打成 jar 包 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

<plugin>
           <groupId>org.apache.maven.plugins</groupId>
           //maven-jar-plugin 这个插件通常用法是将maven工程打成 jar 包
           <artifactId>maven-jar-plugin</artifactId>
           <configuration>
               <excludes>
                   <exclude>*.**</exclude>
                   <exclude>*/*.xml</exclude>
               </excludes>
               <archive>
                   <manifest>
                   //是否要把第三方jar放到manifest的classpath中
                       <addClasspath>true</addClasspath>
                       //生成的manifest中classpath的前缀，因为要把第三方jar放到lib目录下，
                        所以classpath的前缀是lib
                       <classpathPrefix>lib/</classpathPrefix>
                       //使用唯一的版本
                       <useUniqueVersions>false</useUniqueVersions>
                       //执行的主程序路径
                       <mainClass>com.xhwl.massage.CentMassageApplication</mainClass>
                   </manifest>
                   //但是如果还依赖了pom中定义的dependency之外的外部jar包，
                   maven-jar-plugin不会把这些jar包的依赖信息放在MANIFEST中
                   ，这会导致jar包运行时出现找不到指定类的错误。次数配置manifestEntries,
                   class-path即可
                   <manifestEntries>
                       <Class-Path>./resources/</Class-Path>
                   </manifestEntries>
               </archive>
              //jar包输出地址
               <outputDirectory>${project.build.directory}</outputDirectory>
           </configuration>
       </plugin>

maven-dependency-plugin

​ maven-dependency-plugin是处理与依赖相关的插件。它有很多可用的goal，大部分是和依赖构建、分析和解决相关的goal，这部分goal可以直接用maven的命令操作，例如：mvn dependency:tree、mvn dependency:analyze 但是我们最常用到的是 dependency:copy dependency:copy-dependencies 及dependency:unpack 　　dependency:unpack-dependencies 这四个。

dependency:copy：将一系列在此插件内列出的artifacts ，将他们copy到一个特殊的地方，重命名或者去除其版本信息。这个可以解决远程仓库存在但是本地仓库不存在的依赖问题，copy操作可以用来将某个（些）maven artifact(s)拷贝到某个目录下。添加phase和goal如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

<build>  
    <plugins>  
        <plugin>  
            <groupId>org.apache.maven.plugins</groupId>  
            <artifactId>maven-dependency-plugin</artifactId>  
            <version>2.8</version>  
            <executions>  
                <execution>  
                    <phase>package</phase>  
                    <goals>  
                        <goal>copy</goal>  
                    </goals>  
                </execution>  
            </executions>  
        </plugin>  
    </plugins>

比如把junit拷到libs目录下 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

<plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <version>2.8</version>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>copy</goal>
                    </goals>
                    <configuration>
                        <artifactItems>
                            <artifactItem>
                                <groupId>junit</groupId>
                                <artifactId>junit</artifactId>
                                <version>4.11</version>
                                <outputDirectory>${project.build.directory}/libs</outputDirectory>
                            </artifactItem>
                        </artifactItems>
                    </configuration>
                </execution>
            </executions>

dependency:unpack ：unpack和copy类似，只不过它会把拷来的包解开，例如： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

<plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <version>2.8</version>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>unpack</goal>
                    </goals>
                    <configuration>
                        <artifactItems>
                            <artifactItem>
                                <groupId>org.slf4j</groupId>
                                <artifactId>slf4j-log4j12</artifactId>
                                <version>1.7.7</version>
                            </artifactItem>
                            <artifactItem>
                                <groupId>junit</groupId>
                                <artifactId>junit</artifactId>
                                <version>4.11</version>
                                <outputDirectory>${project.build.directory}/libs</outputDirectory>
                            </artifactItem>
                        </artifactItems>
                        <outputDirectory>lib</outputDirectory>
                    </configuration>
                </execution>
            </executions>

执行mvn package打包命令之后,slf4j复制到lib目录下,junit复制到libs目录下

unit和slf4j-log4j12拷完以后，放到lib和libs下的不再是Jar包，还是Jar包里的内容

copy-dependencies 和 unpack-dependencies

copy 和 unpack操作是由要拷某个包，这个包需要具体指定要拷哪个包，与当前工程的依赖没有关系。copy-dependencies和它有点类似，但是它是用来拷当前工程的依赖包的，典型的，例如我们有一个web应用，当打成war包的时候，它所有的依赖也需要被打到应用中

maven-source-plugin

在很多情况下，需要对于Maven工程的源代码进行源文件的打包，可以利用source插件来完成。利用Maven的Source插件,对Maven工程的源码进行打jar包。 这样我们就可以直接看到相关源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20


<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-source-plugin</artifactId>
    <version>3.0.0</version>
    <configuration>
        <attach>true</attach>
    </configuration>
    <executions>
        <execution>
            <phase>compile</phase>
            <goals>
                <goal>jar</goal>
            </goals>
        </execution>
    </executions>
</plugin>


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120


<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>2.3.2</version>
            <configuration>
            	//将会使用指定的 JDK 版本对源代码进行编译（针对编译运行环境） 
                <source>1.8</source>
                //将会使用指定的 JDK 版本将 java 文件编译为 class 文件（针对编译运行环境）
                <target>1.8</target>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            //maven-jar-plugin 这个插件通常用法是将maven工程打成 jar 包
            <artifactId>maven-jar-plugin</artifactId>
            <configuration>
                <excludes>
                    <exclude>*.**</exclude>
                    <exclude>*/*.xml</exclude>
                </excludes>
                <archive>
                    <manifest>
                    //是否要把第三方jar放到manifest的classpath中
                        <addClasspath>true</addClasspath>
                        //生成的manifest中classpath的前缀，因为要把第三方jar放到lib目录下，
                         所以classpath的前缀是lib
                        <classpathPrefix>lib/</classpathPrefix>
                        //使用唯一的版本
                        <useUniqueVersions>false</useUniqueVersions>
                        //执行的主程序路径
                        <mainClass>com.xhwl.massage.CentMassageApplication</mainClass>
                    </manifest>
                    //但是如果还依赖了pom中定义的dependency之外的外部jar包，
                    maven-jar-plugin不会把这些jar包的依赖信息放在MANIFEST中
                    ，这会导致jar包运行时出现找不到指定类的错误。次数配置manifestEntries,
                    class-path即可
                    <manifestEntries>
                        <Class-Path>./resources/</Class-Path>
                    </manifestEntries>
                </archive>
               //jar包输出地址
                <outputDirectory>${project.build.directory}</outputDirectory>
            </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>
                        <outputDirectory>
                            ${project.build.directory}/lib/
                        </outputDirectory>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    
        <plugin>
        	//https://blog.csdn.net/u012501054/article/details/88397182 参考这个博客
            <artifactId>maven-resources-plugin</artifactId>
            <executions>
                <execution>
                    <id>copy-resources</id>
                    <phase>package</phase>
                    <goals>
                        <goal>copy-resources</goal>
                    </goals>
                    <configuration>
                        <resources>
                            <resource>
                                <directory>src/main/resources</directory>
                            </resource>
                        </resources>
                        <outputDirectory>${project.build.directory}/resources</outputDirectory>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    
        <plugin>
            <groupId>org.springframework.boot</groupId>
            //参考这个https://www.cnblogs.com/jpfss/p/11098740.html
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <includes>
                    <include>
                        <groupId>null</groupId>
                        <artifactId>null</artifactId>
                    </include>
                </includes>
                <layout>ZIP</layout>
                <addResources>true</addResources>
                <outputDirectory>${project.build.directory}</outputDirectory>
            </configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>repackage</goal>
                    </goals>
                    <configuration>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>


二：maven依赖中的scope作用

举例如下：


org.springframework.boot
spring-boot-starter-tomcat
provided

scope的值有以下几种可能，进行分情况讲解：
compile
默认就是compile，什么都不配置也就是意味着compile。compile表示被依赖项目需要参与当前项目的编译，当然后续的测试，运行周期也参与其中，是一个比较强的依赖。打包的时候通常需要包含进去。默认的scope,在部署的时候将会打包到lib目录下，项目在编译，测试，运行阶段都需要

test
scope为test表示依赖项目仅仅参与测试相关的工作，在编译和运行环境下都不会被使用，更别说打包了。

runntime
runntime这个scope，仅仅适用于运行环境，在编译和测试环境下都不会被使用

provided
provided适合在编译和测试的环境，他和compile很接近，但是provide仅仅需要在编译和测试阶段，同样provide将不会被打包到lib目录下。

system
从参与度来说，也provided相同，不过被依赖项不会从maven仓库抓，而是从本地文件系统拿，一定需要配合systemPath属性使用。

scope的依赖传递
A–>B–>C。当前项目为A，A依赖于B，B依赖于C。知道B在A项目中的scope，那么怎么知道C在A中的scope呢？答案是：
当C是test或者provided时，C直接被丢弃，A不依赖C；
否则A依赖C，C的scope继承于B的scope。

为什么需要区分这些scope
可以用来限制dependency的范围可以在不同的环境下打包不同的jar包，比如junit测试类的jar包不需要在编译运行的时候，就可以设置scope为test。

最后还有一个true是什么意思，怎么用的呢？


org.springframework.boot
spring-boot-devtools
true

例如上面的例子，在SpringBoot官网文件中你可以得到解释就是，true的话，其他项目依赖此项目也不会进行传递，只能本项目使用。

第一步在需要打包的pom文件中，添加如下参数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

<distributionManagement>
    <repository>
        <id>xx</id>
        <url>http://localhost:8081/repository/</url>
    </repository>
    <snapshotRepository>
        <id>xxx</id>
        <url>http://localhost:8081/repository/</url>
    </snapshotRepository>
</distributionManagement>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-deploy-plugin</artifactId>
            <configuration>
                <skip>false</skip>
            </configuration>
        </plugin>
    </plugins>
</build>


注：其中的repository下的id和url要和maven中的setting.xml中的配置一致。如下画红线部分：

然后再执行maven中的deploy

这个时候Jar已经上传到了上图的rul中地址中。