【Java项目管理工具】Maven

Maven

一、简介

Maven 是一款为 Java 项目管理构建、依赖管理的工具（软件），使用 Maven 可以自动化构建、测试、打包和发布项目，大大提高了开发效率和质量

• 依赖管理 ：包括自动下载所需依赖库、自动下载依赖需要的依赖并且保证版本没有冲突、依赖版本管理等
• 构建管理 ：管理项目的编译、测试、打包、部署等构建过程。通过实现标准的构建生命周期，确保每一个构建过程都遵循同样的规则和最佳实践

二、安装和配置

官网下载：https://maven.apache.org/docs/history.html

1. 下载后解压即可

2. 配置Maven环境变量

3. 功能配置，修改 apache-maven-3.9.6\conf\settings.xml

   1. 本地仓库位置：<localRepository>D:\softwareData\mavenRepository</localRepository>

   2. 配置国内阿里镜像

      <!--在mirrors节点(标签)下添加中央仓库镜像 160行附近-->
      <mirror>
          <id>alimaven</id>
          <name>aliyun maven</name>
          <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
          <mirrorOf>central</mirrorOf>
      </mirror>
      

   3. 配置jdk17版本项目构建

      <!--在profiles节点(标签)下添加jdk编译版本 268行附近-->
      <profile>
          <id>jdk-17</id>
          <activation>
            <activeByDefault>true</activeByDefault>
            <jdk>17</jdk>
          </activation>
          <properties>
            <maven.compiler.source>17</maven.compiler.source>
            <maven.compiler.target>17</maven.compiler.target>
            <maven.compiler.compilerVersion>17</maven.compiler.compilerVersion>
          </properties>
      </profile>
      

   4. IDEA中配置 maven ：settings -> Build, Execution, Deployment -> Build Tools -> Maven

      • Maven home path
      • User setting file
      • Local repository ：一般上面两个配置好，这个会自动变；如果没变才配置

三、GAVP

Maven 中的 GAVP 是指 GroupId、ArtifactId、Version、Packaging 等四个属性的缩写，其中前三个是必要的，而 Packaging 属性为可选项。这四个属性主要为每个项目在maven仓库中做一个标识，类似人的姓-名。有了具体标识，方便后期项目之间相互引用依赖等

1. GroupID 格式：com.{公司/BU }.业务线.[子业务线]，最多 4 级。正例：com.taobao.tddl 或 com.alibaba.sourcing.multilang
2. ArtifactID 格式：产品线名-模块名。语义不重复不遗漏，先到仓库中心去查证一下。正例：tc-client / uic-api / tair-tool / bookstore
3. Version版本号格式推荐：主版本号.次版本号.修订号。例如： 初始→1.0.0 修改bug → 1.0.1 功能调整 → 1.1.1等
   • 主版本号：当做了不兼容的 API 修改，或者增加了能改变产品方向的新功能
   • 次版本号：当做了向下兼容的功能性新增（新增类、接口等）
   • 修订号：修复 bug，没有修改方法签名的功能加强，保持 API 兼容性
4. Packaging 项目类型 ：
   • jar（默认值）：代表普通的Java工程，打包以后是.jar结尾的文件
   • war ：代表Java的web工程，打包以后.war结尾的文件
   • pom ：代表不会打包，用来做继承的父工程

pom.xml ：

<!-- 模型版本 -->
<modelVersion>4.0.0</modelVersion>
<!-- 公司或者组织的唯一标志，并且配置时生成的路径也是由此生成， 如com.companyname.project-group，maven会将该项目打成的jar包放本地路径：/com/companyname/project-group -->
<groupId>com.companyname.project-group</groupId>
<!-- 项目的唯一ID，一个groupId下面可能多个项目，就是靠artifactId来区分的 -->
<artifactId>project</artifactId>
<!-- 版本号 -->
<version>1.0.0</version>

<!--打包方式
    默认：jar
    jar指的是普通的java项目打包方式
    war指的是web项目打包方式
    pom不会打包,这个项目作为父工程，被其他工程聚合或者继承
-->
<packaging>jar/pom/war</packaging>

四、IDEA Maven Java Web工程

1. 新建 module 选择 maven 工程（不要选 Maven Archetype）
2. 给 module 中 pom.xml 添加 <packaging>war</packaging> ，刷新 maven 依赖
3. 在 Project Structure 中，选中 对应 module 的 Web，复制 Web Resource Directory 下面爆红的路径
4. 再到上面 Deployment Descriptors 中点击 + 号，添加 web.xml ，将路径中 \WBE-INF 之前的路径替换为复制的路径
5. web.xml的版本选择看下面表格

Servlet Version	EE Version
6.1	Jakarta EE ?
6.0	Jakarta EE 10
5.0	Jakarta EE 9/9.1
4.0	JAVA EE 8
3.1	JAVA EE 7
3.1	JAVA EE 7
3.0	JAVAEE 6

• Tomcat 版本和Servlet版本之间的对应关系

Servlet Version	**Tomcat ** Version	JDK Version
6.1	11.0.x	17 and later
6.0	10.1.x	11 and later
5.0	10.0.x (superseded)	8 and later
4.0	9.0.x	8 and later
3.1	8.5.x	7 and later
3.1	8.0.x (superseded)	7 and later
3.0	7.0.x (archived)	6 and later (7 and later for WebSocket)

Maven工程项目结构说明：

|-- pom.xml                               # Maven 项目管理文件 
|-- src
    |-- main                              # 项目主要代码
    |   |-- java                          # Java 源代码目录
    |   |   |-- com/example/myapp         # 开发者代码主目录
    |   |       |-- controller            # 存放 Controller 层代码的目录
    |   |       |-- service               # 存放 Service 层代码的目录
    |   |       |-- dao                   # 存放 DAO 层代码的目录
    |   |       |-- model                 # 存放数据模型的目录
    |   |-- resources                     # 资源目录，存放配置文件、静态资源等
    |   |   |-- log4j.properties          # 日志配置文件
    |   |   |-- spring-mybatis.xml        # Spring Mybatis 配置文件
    |   |   |-- static                    # 存放静态资源的目录
    |   |       |-- css                   # 存放 CSS 文件的目录
    |   |       |-- js                    # 存放 JavaScript 文件的目录
    |   |       |-- images                # 存放图片资源的目录
    |   |-- webapp                        # 存放 WEB 相关配置和资源
    |       |-- WEB-INF                   # 存放 WEB 应用配置文件
    |       |   |-- web.xml               # Web 应用的部署描述文件
    |       |   |-- classes               # 存放编译后的 class 文件
    |       |-- index.html                # Web 应用入口页面
    |-- test                              # 项目测试代码
        |-- java                          # 单元测试目录
        |-- resources                     # 测试资源目录

五、插件、命令、生命周期

命令方式项目构建，对应命令也对应着构建的生命周期，一个命令可能会执行多个默认操作，如 package 会先执行 clean, complile, test-compile,test 再打包

命令	描述
mvn clean	清理编译或打包后的项目结构
mvn compile	编译项目，生成target文件
mvn test	执行测试源码
mvn package	打包项目，生成jar或war文件
mvn install	打包后上传到maven本地仓库
mvn deploy	只打包，上传到maven私服仓库
mvn site	生成站点

war包打包插件和jdk版本不匹配：pom.xml 添加以下代码即可

<build>
    <!-- jdk17 和 war包版本插件不匹配 -->
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-war-plugin</artifactId>
            <version>3.2.2</version>
        </plugin>
    </plugins>
</build>

插件、命令和周期之间的关系

周期→包含若干命令→包含若干插件。使用周期命令构建，简化构建过程。最终进行构建的是插件。

六、依赖配置

pom.xml：在该文件中对依赖进行管理配置，maven仓库信息官网 https://mvnrepository.com/

<dependencies>
    <!-- 引入具体的依赖包 -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
        <!-- 依赖范围 -->
        <scope>runtime</scope>
    </dependency>
</dependencies>

依赖版本统一管理和维护，推荐使用

<!--声明版本-->
<properties>
  <!--命名随便,内部制定版本号即可-->
  <junit.version>4.12</junit.version>
  <!-- 也可以通过 maven规定的固定的key，配置maven的参数，如下配置编码格式-->
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
</properties>

<dependencies>
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <!--引用properties声明版本 -->
    <version>${junit.version}</version>
  </dependency>
</dependencies>

依赖范围 ，通过设置坐标的依赖范围(scope)，可以设置 对应jar包的作用范围：编译环境、测试环境、运行环境

依赖范围	描述
compile	编译依赖范围，scope 元素的缺省值。对于三种 classpath 均有效
test	测试依赖范围。使用此依赖范围的 Maven 依赖，只对测试 classpath 有效
provided	已提供依赖范围。使用此依赖范围的 Maven 依赖，只对编译 classpath 和测试 classpath 有效。例如，servlet-api 依赖对于编译、测试阶段而言是需要的，但是运行阶段，由于外部容器已经提供，故不需要 Maven 重复引入该依赖。
runtime	运行时依赖范围。使用此依赖范围的 Maven 依赖，只对测试 classpath、运行 classpath 有效。例如，JDBC 驱动实现依赖，其在编译时只需 JDK 提供的 JDBC 接口即可，只有测试、运行阶段才需要实现了 JDBC 接口的驱动
system	系统依赖范围，其效果与 provided 的依赖范围一致。其用于添加非 Maven 仓库的本地依赖，通过依赖元素 dependency 中的 systemPath 元素指定本地依赖的路径。鉴于使用其会导致项目的可移植性降低，一般不推荐使用。
import	导入依赖范围，该依赖范围只能与 dependencyManagement 元素配合使用，其功能是将目标 pom.xml 文件中 dependencyManagement 的配置导入合并到当前 pom.xml 的 dependencyManagement 中

七、构建配置

项目构建是指将源代码、依赖库和资源文件等转换成可执行或可部署的应用程序的过程，在这个过程中包括编译源代码、链接依赖库、打包和部署等多个步骤。

默认情况下，构建不需要额外配置，都有对应的缺省配置。当然了，我们也可以在pom.xml定制一些配置，来修改默认构建的行为和产物。

构建配置是在 pom.xml / build 标签中指定

指定打包命名

<!-- 默认的打包名称：artifactid+verson.打包方式 -->
<build>
  <finalName>定义打包名称</finalName>
</build>  

指定打包文件：应用场景：mybatis中有时会将用于编写SQL语句的映射文件和mapper接口都写在src/main/java下的某个包中，此时映射文件就不会被打包

<build>
    <!--设置要打包的资源位置-->
    <resources>
        <resource>
            <!--设置资源所在目录-->
            <directory>src/main/java</directory>
            <includes>
                <!--设置包含的资源类型-->
                <include>**/*.xml</include>
            </includes>
        </resource>
    </resources>
</build>

配置依赖插件

常用的插件：修改jdk版本、tomcat插件、mybatis分页插件、mybatis逆向工程插件等等

<build>
  <plugins>
      <!-- java编译插件，配jdk的编译版本 -->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
          <encoding>UTF-8</encoding>
        </configuration>
      </plugin>
      <!-- tomcat插件 -->
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
         <version>2.2</version>
          <configuration>
          <port>8090</port>
          <path>/</path>
          <uriEncoding>UTF-8</uriEncoding>
          <server>tomcat7</server>
        </configuration>
      </plugin>
    </plugins>
</build>

八、依赖传递与依赖冲突

假如有Maven项目A，项目B依赖A，项目C依赖B。那么我们可以说 C依赖A。也就是说，依赖的关系为：C—>B—>A， 那么我们执行项目C时，会自动把B、A都下载导入到C项目的jar包文件夹中，这就是依赖的传递性。

传递的原则

• compile范围进行依赖传递，非compile 不传递，使用 test 或 provided 范围，不能传递
• 使用optional配置终止传递
• 依赖冲突（传递的依赖已经存在）

依赖冲突解决方式：

1. 自动选择原则
   • 短路优先原则（第一原则）
   • 依赖路径长度相同情况下，则“先声明优先”（第二原则）
2. 手动排除

<dependency>
  <groupId>com.atguigu.maven</groupId>
  <artifactId>pro01-maven-java</artifactId>
  <version>1.0-SNAPSHOT</version>
  <scope>compile</scope>
  <!-- 使用excludes标签配置依赖的排除  -->
  <exclusions>
    <!-- 在exclude标签中配置一个具体的排除 -->
    <exclusion>
      <!-- 指定要排除的依赖的坐标（不需要写version） -->
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
    </exclusion>
  </exclusions>
</dependency>

九、Maven工程继承和聚合关系

9.1 工程继承关系

Maven 继承是指在 Maven 的项目中，让一个项目从另一个项目中继承配置信息的机制。继承可以让我们在多个项目中共享同一配置信息，简化项目的管理和维护工作

继承语法：

• 父工程：打包方式必须是 <packaging>pom</packaging>

• 子工程：

  <!-- 使用parent标签指定当前工程的父工程 -->
  <parent>
    <!-- 父工程的坐标 -->
    <groupId>com.pro.maven</groupId>
    <artifactId>pro-maven-parent</artifactId>
    <version>1.0-SNAPSHOT</version>
  </parent>
  
  <!-- 子工程的坐标 -->
  <!-- 如果子工程坐标中的groupId和version与父工程一致，那么可以省略 -->
  <!-- <groupId>com.pro.maven</groupId> -->
  <artifactId>pro01-maven-module</artifactId>
  <!-- <version>1.0-SNAPSHOT</version> -->
  

依赖统一管理：

• dependencyManagement 标签：声明依赖版本，子工程需依赖时无需再声明版本，一般只使用该方式
• dependencies 标签：声明依赖，父工程声明的依赖在子工程中会自动全部导入，子工程无需任何声明，一般不使用，防止多导入依赖给子工程

9.2 工程聚合关系

聚合的项目通过父工程执行 maven 构建命令时，会同时触发其子模块的对应构建

聚合语法：<modules> 标签，注意，module 标签中包含的并不是子项目的项目名，而是项目的位置，即聚合不是必须得是父子项目关系

<project>
  <groupId>com.example</groupId>
  <artifactId>parent-project</artifactId>
  <packaging>pom</packaging>
  <version>1.0.0</version>
  <modules>
    <module>child-project1</module>
    <module>child-project2</module>
  </modules>
</project>

十、Maven私服

Maven 私服是一种特殊的Maven远程仓库，它是架设在局域网内的仓库服务，用来代理位于外部的远程仓库（中央仓库、其他远程公共仓库）。

常见的Maven私服产品

1. Apache的 Archiva
2. JFrog的 Artifactory
3. Sonatype的 Nexus（[?neks?s]）（当前最流行、使用最广泛）

10.1 Nexus下载安装

1. 下载地址：https://help.sonatype.com/repomanager3/product-information/download
2. 解压，以管理员身份打开CMD，进入bin目录下，执行 ./nexus/run 命令启动；需等到启动成功，需要一定时间
3. 首页地址：http://localhost:8081/，8081为默认端口号
4. 登陆，用户名：admin 密码：按提示找到对应文件；登陆后会要求设置新密码
5. 匿名登陆选择，启用匿名登陆后使用者无需用户名及密码即可访问私服

10.2 Nexus上的各种仓库

仓库名称	说明
maven-central	Nexus 对 Maven 中央仓库的代理，可点击 设置->仓库 修改对应仓库地址为阿里云仓库
maven-public	Nexus 默认创建，供开发人员下载使用的组仓库
maven-releases	Nexus 默认创建，供开发人员部署自己 jar 包的宿主仓库 要求 releases 版本
maven-snapshots	Nexus 默认创建，供开发人员部署自己 jar 包的宿主仓库 要求 snapshots 版本

仓库类型	说明
proxy	某个远程仓库的代理
group	存放：通过 Nexus 获取的第三方 jar 包
hosted	存放：本团队其他开发人员部署到 Nexus 的 jar 包

10.3 通过 Nexus 下载 jar 包

1. 客户端配置私服镜像 settings.xml ，url 点击对应仓库的 url 列复制即可

   <mirror>
   	<id>nexus-mine</id>
   	<mirrorOf>central</mirrorOf>
   	<name>Nexus mine</name>
   	<url>http://localhost:8081/repository/maven-public/</url>
   </mirror>
   

2. 如果前面未启动匿名登陆，则需继续配置。格外注意：server 标签内的 id 标签值必须和 mirror 标签中的 id 值一样

   <server>
     <id>nexus-mine</id>
     <username>admin</username>
     <password>上述自己填写的新密码</password>
   </server>
   

10.4 将 jar 包部署到 Nexus

maven工程中配置：这里 snapshotRepository 的 id 标签必须和 settings.xml 中指定的 mirror 标签的 id 属性一致。

<distributionManagement>
    <snapshotRepository>
        <id>nexus-mine</id>
        <name>Nexus Snapshot</name>
        <url>http://localhost:8081/repository/maven-snapshots/</url>
    </snapshotRepository>
</distributionManagement>

执行部署命令：

mvn deploy

10.5 引用别人部署的 jar 包

maven工程中配置：

<repositories>
    <repository>
        <id>nexus-mine</id>
        <name>nexus-mine</name>
        <url>http://localhost:8081/repository/maven-snapshots/</url>
        <snapshots>
            <enabled>true</enabled>
        </snapshots>
        <releases>
            <enabled>true</enabled>
        </releases>
    </repository>
</repositories>

十一、综合案例

需求案例：搭建一个电商平台项目，该平台包括用户服务、订单服务、通用工具模块等。

项目架构：

1. 用户服务：负责处理用户相关的逻辑，例如用户信息的管理、用户注册、登录等。
   • spring-context 6.0.6
   • spring-core 6.0.6
   • spring-beans 6.0.6
   • common-service
2. 订单服务：负责处理订单相关的逻辑，例如订单的创建、订单支付、退货、订单查看等。
   • spring-context 6.0.6
   • spring-core 6.0.6
   • spring-beans 6.0.6
   • spring-security 6.0.6
   • common-service
3. 通用模块：负责存储其他服务需要通用工具类，其他服务依赖此模块。
   • commons-io 2.11.0
   • junit 5.9.2

11.1 父模块 (micro-shop)

<?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.pro</groupId>
    <artifactId>micro-shop</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--知识点：父工程的打包方式为pom-->
    <packaging>pom</packaging>
    <!-- 使用idea 选中项目创建子工程会自动添加该标签，无需自己添加 -->
    <modules>
    	<module>common-service</module>
    	<module>user-service</module>
    	<module>order-service</module>
	</modules>

    <properties>
        <spring.version>6.0.6</spring.version>
        <jackson.version>2.15.0</jackson.version>
        <commons.version>2.11.0</commons.version>
        <junit.version>5.9.2</junit.version>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <!-- 依赖管理 -->
    <dependencyManagement>
        <dependencies>
            <!-- spring-context会依赖传递core/beans -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>

            <!-- jackson-databind会依赖传递core/annotations -->
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-databind</artifactId>
                <version>${jackson.version}</version>
            </dependency>

            <!-- commons-io -->
            <dependency>
                <groupId>commons-io</groupId>
                <artifactId>commons-io</artifactId>
                <version>${commons.version}</version>
            </dependency>

            <!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
            <dependency>
                <groupId>org.junit.jupiter</groupId>
                <artifactId>junit-jupiter-api</artifactId>
                <version>${junit.version}</version>
                <scope>test</scope>
            </dependency>

        </dependencies>
    </dependencyManagement>

    <!-- 统一更新子工程打包插件-->
    <build>
        <!-- jdk17 和 war包版本插件不匹配 -->
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>3.2.2</version>
            </plugin>
        </plugins>
    </build>

</project>

11.2 通用模块(common-service)

<?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">
    <parent>
        <artifactId>micro-shop</artifactId>
        <groupId>com.pro</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>common-service</artifactId>
    <!--知识点：打包方式默认就是jar，因此可以省略-->
    <packaging>jar</packaging>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- 配置spring-context，继承父工程版本，自动传递 core / beans -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
        <!-- 配置jackson-databind，继承父工程版本，自动传递 core / annotations -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
        <!-- 配置commons-io，继承父工程版本 -->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
        </dependency>
        <!-- 配置junit，继承父工程版本 -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

11.3 用户模块(user-service)

<?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">
    <parent>
        <artifactId>micro-shop</artifactId>
        <groupId>com.pro</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>user-service</artifactId>
    <!-- web工程打包方式为war -->
    <packaging>war</packaging>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- 配置common-service，所需依赖会传递到当前工程（仅限compile范围） -->
        <dependency>
            <groupId>com.atguigu</groupId>
            <artifactId>common-service</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

</project>

11.4 订单模块 (order-service)

<?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">
    <parent>
        <artifactId>micro-shop</artifactId>
        <groupId>com.atguigu</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>order-service</artifactId>
    <!-- web工程打包方式为war -->
    <packaging>war</packaging>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- 配置common-service，所需依赖会传递到当前工程（仅限compile范围） -->
        <dependency>
            <groupId>com.atguigu</groupId>
            <artifactId>common-service</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

</project>