博客

目录

1. maven打包

1.1 pom、jar、war

1.2 普通jar包和可执行jar包

1.3 打包同时生成依赖jar包和可执行jar包

2、module相互依赖

问题描述:你在A module引入了B module但是还是类没有发现？但是类上也有注解

1. maven打包

1.1 pom、jar、war

pom

：用在父级工程或聚合工程中，用来做jar包的版本控制，

必须指明这个聚合工程的打包方式为pom

。

<packaging>pom</packaging>

子module：

// 1、jar方式
<packaging>jar</packaging>
// 2、war方式
<packaging>war</packaging>

聚合工程

只是用来帮助其他模块构建的工具，本身并没有实质的内容。具体每个工程代码的编写还是在生成的工程中去写。对于在父工程中导的依赖工程也可享有 ，子module可继承父工程依赖。

jar

：

工程的默认打包方式

，打包成jar用作jar包使用。存放一些其他工程都会使用的类，工具类。我们可以在其他工程的pom文件中去引用它。

war

：将会打包成war，

发布在服务器上

，如网站或服务。用户可以通过浏览器直接访问，或者是通过发布服务被别的工程调用。

1.2 普通jar包和可执行jar包

maven打包插件:

// 1、maven 默认打包插件，用来创建 project jar
maven-jar-plugin

// 2、用来打可执行包
maven-shade-plugin

// 3、支持定制化打包方式，例如 apache 项目的打包方式
maven-assembly-plugin

//4、springboot打包插件
spring-boot-maven-plugin

Spring Boot 中默认打包成的 jar 叫做 可执行 jar，这种 jar 不同于普通的 jar，普通的 jar 不可以通过

java -jar xxx.jar

命令执行，普通的 jar 主要是被其他应用依赖，Spring Boot 打成的 jar 可以执行，但是不可以被其他的应用所依赖，即使强制依赖，也无法获取里边的类。但是可执行 jar 并不是 Spring Boot 独有的，Java 工程本身就可以打包成可执行 jar 。

既然同样是执行 mvn package 命令进行项目打包，为什么 Spring Boot 项目就打成了可执行 jar ，而普通项目则打包成了不可执行 jar 呢？既然同样是执行 mvn package 命令进行项目打包，为什么 Spring Boot 项目就打成了可执行 jar ，而普通项目则打包成了不可执行 jar 呢？

在springboot项目中，我们使用的是spring-boot-maven-plugin插件可以看下这个插件:

5个命令：

• build-info：生成项目的构建信息文件 build-info.properties
• repackage：这个是默认 goal，在 mvn package 执行之后，这个命令再次打包生成可执行的 jar，同时将 mvn package 生成的 jar 重命名为
  
  *.origin
  
• run：这个可以用来运行 Spring Boot 应用
• start：这个在 mvn integration-test 阶段，进行 Spring Boot 应用生命周期的管理
• stop：这个在 mvn integration-test 阶段，进行 Spring Boot 应用生命周期的管理

默认使用的命令是repackage，其它命令需要显示指定。

repackage命令到底怎样工作的？

1. 首先 mvn package 命令 对项目进行打包，打成一个 jar，
   
   这个 jar 就是一个普通的 jar
   
   ，可以被其他项目依赖，但是不可以被执行
2. repackage 命令，对第一步 打包成的 jar 进行再次打包，将之打成一个 可执行 jar ，通过将
   
   第一步打成的 jar 重命名为 *.original 文件
   

可以使用命令mvn package也可以直接idea maven窗口的Liftcycle进行打包:

.jar和.jar.original包结构:

MANIFEST.MF 文件:

Manifest-Version: 1.0
Implementation-Title: request-same-url
Implementation-Version: 1.0
Built-By: Administrator
Implementation-Vendor-Id: com.gisquest
Spring-Boot-Version: 2.0.1.RELEASE
Main-Class: org.springframework.boot.loader.JarLauncher
Start-Class: com.gisquest.requestsameurl.RequestSameUrlApplication
Spring-Boot-Classes: BOOT-INF/classes/
Spring-Boot-Lib: BOOT-INF/lib/
Created-By: Apache Maven 3.6.3
Build-Jdk: 1.8.0_291
Implementation-URL: https://projects.spring.io/spring-boot/#/spring-bo
 ot-starter-parent/gisquest-hnbcgd-parent/request-same-url

MANIFEST.MF 文件:

Manifest-Version: 1.0
Implementation-Title: request-same-url
Implementation-Version: 1.0
Built-By: Administrator
Implementation-Vendor-Id: com.gisquest
Created-By: Apache Maven 3.6.3
Build-Jdk: 1.8.0_291
Implementation-URL: https://projects.spring.io/spring-boot/#/spring-bo
 ot-starter-parent/gisquest-hnbcgd-parent/request-same-url

可执行jar包

有这几个参数：

Start-Class:可执行jar的入口类；

Spring-Boot-Classes:自己写的代码编译后的位置；

Spring-Boot-Lib:项目依赖jar的位置。

不可执行jar包：


像classpath打开就是我们的自己写的代码，没有启动类，也没有把依赖jar打进去。

1.3 打包同时生成依赖jar包和可执行jar包

springboot项目一般打包生成可执行jar，启动作为一个服务，不建议将springboot项目打成一个普通jar包，被其它module依赖。如果有这种依赖需求，建议将依赖的部分，单独抽取出来做一个普通的Maven项目，在springboot项目中引用这个Maven项目。

如果不新建Maven项目，还是想依赖springboot项目，可以同时打包的时候生成普通jar包和可执行jar包，通过



<classifier>exec</classifier>



标签对可执行jar进行命名


。


这样会打包成两个jar包，不会对普通jar重新命名。

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <classifier>exec</classifier>
            </configuration>
        </plugin>
    </plugins>
</build>

2、module相互依赖

两个module: A module: a.benjamin.c   B module: a.benjamin.d

A module引入B module，启动类在c包下，而Bmodule在d包下，类报没有发现？

解决：

1、把启动类放在benjamin包下，因为会扫描当前包及其子包注解进行注入

2、使用@ComponentScan(value=”com.xx”)注解，指定扫描的包路径