Maven高级

又该洗头了

于 2024-07-05 21:49:06 发布

阅读量1.5k

点赞数 50

文章标签： maven java 数据库

本文链接：https://blog.csdn.net/weixin_74521994/article/details/140214148

版权

分模块设计

Maven的高级特性之一是其对分模块设计的支持，这在大型项目开发中非常有用。通过将一个大型项目拆分成多个子模块，每个模块可以独立开发、测试和部署，从而提升项目的可维护性和可扩展性。

分模块设计的概念及优势

概念：分模块设计是指在项目设计阶段，将一个大型项目按照功能或结构拆分成若干个子模块，每个模块都是独立的，可以进行单独的开发和部署。
优势：
- 简化项目管理和维护：当项目被拆分成多个子模块后，各个模块可以由不同的小组独立开发和维护，降低了项目管理的复杂性。
- 提高复用性：通用的组件和工具类可以被抽取到独立模块中，其他项目或模块可以通过依赖的方式直接使用，提高了代码的复用性。
- 优化性能和安全性：分模块设计可以避免整个项目代码被加载，减少不必要的资源消耗，并且只有需要的模块被引入，避免了无关业务的暴露，增强了安全性。

分模块设计的实现步骤

创建新模块：根据功能需求，创建多个Maven模块，每个模块都有自己的pom.xml文件。例如，可以将实体类抽取到一个单独的模块中（如tlias-pojo），工具类抽取到另一个模块（如tlias-utils）。
建立模块间的依赖关系：在新模块中定义所需的依赖项，并在原始项目的pom.xml文件中添加对这些新模块的依赖。例如，如果订单模块需要使用实体类，只需引入实体类模块的依赖即可。
删除原项目中的相关代码包：将拆分出的模块代码移动到新模块中后，删除原项目中的相关包，这样Maven会自动从本地仓库查找对应的依赖模块。

分模块设计中的依赖管理

依赖传递与冲突解决：在多模块项目中，Maven会自动处理模块间的依赖传递，但有时也会出现依赖冲突。可以使用<dependencyManagement>元素统一管理版本号，或者使用<exclusions>排除特定的传递依赖。
安装和部署模块：完成模块的开发后，需要使用Maven的install命令将模块安装到本地仓库，以便其他模块使用。对于共享的模块，还可以部署到远程仓库，方便团队其他成员使用。

注意：分模块开发需要先针对模块功能进行设计，再进行编码。不会先将工程开发完毕，然后进行拆分。

继承与聚合

继承

Maven继承是Maven多模块项目开发中的一个重要概念，它允许子项目继承父项目中的pom.xml文件里的配置。这种机制大大减少了在多个子模块中重复配置相同信息的工作量，并有助于统一管理依赖和插件版本。以下是Maven继承的详细解释和具体应用：

继承的意义

减少配置：在多模块项目中，多个模块通常有相同的groupId、version或者依赖，为了避免在每个子模块的pom文件中重复配置这些信息，可以将这些配置放在一个父项目中，其他子项目通过继承来使用。
统一版本管理：通过将依赖的版本号集中在父项目的pom文件中管理，可以方便地升级或更改整个项目使用的版本，从而避免因版本不一致导致的潜在问题。

如何实现继承

创建父项目：首先创建一个作为父项目的Maven项目，该项目的打包类型应为pom，即在pom.xml中标签的值应设置为pom。例如，创建一个名为“mavenParent”的父项目，其pom文件包含定义的依赖和属性。
创建子项目并指定父项目：在子项目的pom.xml文件中，使用元素指定父项目的信息，包括groupId、artifactId和version。例如，创建一个名为“mavenChild”的子项目，其pom文件通过元素指向“mavenParent”。

可继承的元素

项目坐标和基本信息：子项目可以继承父项目的groupId和version，这样无需在每个子模块中重复声明。
项目描述和组织信息：description和organization等信息也是可以在子模块中继承的。
自定义属性和依赖：通过properties定义的自定义属性和dependencies标签下的依赖配置也可以被子项目继承，使得所有子项目可以使用相同的依赖版本。

依赖和插件管理

dependencyManagement元素：用于统一管理依赖版本，通常在顶层父POM中使用。子模块只需引入依赖而无需指定版本号，该版本号由父模块统一管理。
pluginManagement元素：类似dependencyManagement，用于管理插件的配置。在子模块中使用时，只需声明插件而无需详细配置。

以下是一个简单的Maven继承示例，展示了如何在父项目中定义依赖和属性，并在子项目中继承这些配置：

创建父项目（mavenParent）：

创建一个名为“mavenParent”的Maven项目，其pom.xml文件如下：

<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>mavenParent</artifactId>
    <version>1.0.0</version>
    <packaging>pom</packaging>
    
    <properties>
        <java.version>1.8</java.version>
    </properties>
    
    <dependencies>
        <!-- 定义依赖 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <!-- 定义插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

创建子项目（mavenChild）：

创建一个名为“mavenChild”的Maven项目，其pom.xml文件如下：

<project>
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.example</groupId>
        <artifactId>mavenParent</artifactId>
        <version>1.0.0</version>
    </parent>
    
    <artifactId>mavenChild</artifactId>
    
    <dependencies>
        <!-- 继承父项目的依赖 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
    </dependencies>
    
    <build>
        <!-- 继承父项目的插件配置 -->
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

在这个例子中，mavenChild项目继承了mavenParent项目中定义的依赖和插件配置。这样，在mavenChild项目中就无需重复声明这些配置，从而简化了项目的构建和管理。

聚合

Maven聚合是一种强大的项目管理机制，它允许开发者将多个模块组合成一个单一的构建过程。这种机制在大型项目开发中尤为重要，因为它不仅简化了多模块项目的构建和维护工作，还提高了项目的可管理性和可维护性。下面将深入探讨Maven聚合的各个方面：

聚合工程的定义和意义

概念理解：聚合在Maven中指的是能够将多个模块项目作为一个完整的项目进行构建的能力。
项目模块化的重要性：对于一个大型的项目，直接作为一个工程进行开发会造成类和功能的重复开发与更改，导致混乱的局面。通过横向和纵向拆分项目，再利用聚合工程整合各个模块，可以有效管理大型项目的开发。

创建聚合工程的要点

创建父级项目：需要创建一个用于聚合的父级项目，该项目自身也是一个Maven项目，并且其打包方式应为pom。
引入模块元素：在父级项目的pom.xml文件中，需要引入新的元素modules来列出所有子模块。
保持一致性：聚合模块的版本需要和被聚合的子模块版本保持一致，以便于统一管理和构建。
目录结构推荐：为了易于维护和理解，推荐使用平行目录结构而不是父子目录结构，并在pom文件中相应修改模块路径配置。

聚合工程的优点

构建简化：通过聚合，可以将整个项目的所有模块一次性构建，而不需要分别进入每个模块的目录执行构建命令。
依赖统一管理：通常在父模块的pom中定义项目所需的依赖及版本，在子模块中直接引用所需依赖不需要声明版本，这样依赖会从父模块自动传递到子模块。

以下是一个简单的Maven聚合工程的示例代码：

父级项目的pom.xml文件（parent-project）：

<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.example</groupId>
    <artifactId>parent-project</artifactId>
    <version>1.0.0</version>
    <packaging>pom</packaging>

    <modules>
        <module>module-a</module>
        <module>module-b</module>
    </modules>

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

    <dependencies>
        <!-- 添加项目所需的依赖 -->
    </dependencies>

</project>

子模块A的pom.xml文件（module-a）：

<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>com.example</groupId>
        <artifactId>parent-project</artifactId>
        <version>1.0.0</version>
    </parent>
    <artifactId>module-a</artifactId>
    <version>1.0.0</version>

    <dependencies>
        <!-- 添加模块A所需的依赖 -->
    </dependencies>

</project>

子模块B的pom.xml文件（module-b）：

<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>com.example</groupId>
        <artifactId>parent-project</artifactId>
        <version>1.0.0</version>
    </parent>
    <artifactId>module-b</artifactId>
    <version>1.0.0</version>

    <dependencies>
        <!-- 添加模块B所需的依赖 -->
    </dependencies>

</project>

在这个示例中，我们创建了一个名为parent-project的父级项目，它包含了两个子模块module-a和module-b。父级项目的pom文件中通过<modules>元素列出了所有子模块，而子模块的pom文件中通过<parent>元素引用了父级项目的坐标信息。这样，在父级项目中执行构建命令时，Maven会自动构建所有子模块。

继承与聚合对比

继承和聚合是面向对象编程中的两个基本概念，它们在设计和实现软件系统时扮演着重要的角色。通过对比这两个概念，可以更好地理解它们各自的特点和适用场景：

定义

继承：继承是一种类与类或接口与接口之间的关系，它允许一个类（子类）获取另一个类（父类）的所有属性和行为。子类可以继承父类的公有和保护成员，并可以添加新成员或重写父类的成员。这种关系通常表现为IS-A关系。
聚合：聚合是一种整体与部分的关系，也称为HAS-A关系。它表示一个类中包含另一个类的实例。例如，汽车类可能包含引擎类的实例，因为汽车具有一个引擎。这种关系体现了严格的部分和整体关系。

应用场景

继承：当需要在类之间建立IS-A关系时，应优先考虑使用继承。例如，如果有一个表示动物的类，并且需要创建一个表示狗的类，那么继承是一个好的选择。
聚合：当需要在一个类中包含另一个类的实例，且这两个类之间不存在IS-A关系时，聚合是更好的选择。例如，如果需要在表示汽车的类中包含表示引擎的类的实例，则应使用聚合。

优点

继承：能够增加代码的重用性，降低代码复杂性，使代码更易于维护和扩展。通过继承，子类可以直接使用父类的属性和方法，同时还可以重写这些方法以满足特定需求。
聚合：提高代码的灵活性和可重用性，因为部分（如引擎）可以在多个整体（如汽车、飞机）之间共享。聚合还能帮助组织代码，使其更加清晰和易于理解。

缺点

继承：过度使用可能导致代码复杂性和难以维护的问题。紧密的耦合关系使得子类依赖于父类的实现，这可能会限制子类的独立性和灵活性。
聚合：整体类不能自动获得和局部类相同的接口，必须手动创建所有局部类的实例，这可能会增加一些额外的工作负担。

耦合性

继承：具有较高的耦合度，子类的变化常常影响到父类，特别是当父类的实现发生改变时，所有子类都需要相应调整。
聚合：耦合度较低，整体与部分之间的变化相对独立，修改部分类的实现不会影响到整体类。

生命周期

继承：子类对象的生命周期通常依赖于父类对象的生命周期，一旦父类被销毁，子类也将无法存在。
聚合：整体和部分可以具有各自的生命周期，整体销毁不会影响部分的继续存在。

动态性

继承：不支持动态继承，子类在运行时无法选择不同的父类。
聚合：支持动态组合，整体对象可以在运行时选择不同类型的部分对象。

封装性

继承：子类依赖于父类的实现细节，容易破坏封装性。
聚合：整体类可以封装局部类的接口，提供新的接口，从而保持较好的封装性。

私服

Maven私服是一个公司内部搭建的远程仓库服务器，用于管理和分发项目依赖。

Maven私服在软件开发中具有重要作用，尤其是对于大型团队和多模块项目而言，它提供了一种高效、安全、可控的方式来共享和管理构件。这里将详细解读Maven私服的各个方面：

基本概念

定义：Maven私服是一个内部的或者共享的仓库，用于存放Maven项目中使用到的构件（如jar文件）。它允许开发者在组织内部共享自己的库和依赖，避免每次都从外部仓库下载，节省网络带宽并提高构建效率。
用途：私服主要用于存放那些不被公共或中央仓库支持的组件，比如公司内部的库或者第三方的私有库。同时，私服还可以作为缓存代理，加速公共库的获取过程。

重要性

安全性和权限控制：私服提供了更严格的安全措施。管理员可以配置权限，决定哪些用户或团队可以部署或获取特定的构件。这一点对于保护知识产权和确保项目安全至关重要。
加速构建过程：通过私服，公司内部的开发者可以快速获取到内部或共享的依赖，而无需频繁访问外部仓库。这减少了依赖于网络条件的构建时间，提高了整体的开发效率。
版本控制和依赖管理：Maven私服允许更好地控制库的版本。开发者可以发布特定版本的库到私服，其他团队成员就可以精确地引用这个版本，保证了项目的一致性和可靠性。

搭建和使用

Nexus：常用的私服软件有Nexus和Artifactory，以Nexus为例，首先需要下载并安装Nexus软件。启动后，可以通过访问 http://localhost:8081 进入Nexus的管理界面，进行仓库的配置和管理。
配置：在Maven项目中使用私服需要在Maven的settings.xml文件中配置服务器信息和仓库地址。激活这些配置后，项目就可以从私服下载依赖或者将构建结果上传到私服。

优点

节省带宽和成本：对于大企业而言，频繁地从外部下载大量的依赖会消耗大量网络带宽资源。私服能够有效地减少这种需求，因为它作为内部网络中的缓存层，只需下载一次即可在内部多次使用。
促进团队协作：在多模块项目中，不同团队可能负责不同模块。私服提供了一个平台，使得各个模块的开发者可以共享和复用代码，增强团队间的协作和效率。

配置

配置Maven私服通常涉及以下几个步骤：

安装私服软件：首先需要选择一个适合的私服软件，例如Nexus或Artifactory。下载并安装相应的软件包。
启动私服软件：启动私服软件后，可以通过浏览器访问其管理界面。默认情况下，私服软件会监听本地的某个端口（如8081）。
登录私服软件：使用默认的管理员账户和密码登录私服软件的管理界面。出于安全考虑，建议修改默认的管理员账户和密码。
创建仓库组：在私服软件的管理界面中，可以创建仓库组来组织和管理不同的仓库。例如，可以创建一个名为"releases"的仓库组，用于存放正式发布的构件。
创建仓库：在仓库组下创建具体的仓库。每个仓库可以有不同的存储类型和访问权限设置。例如，可以创建一个名为"my-company-repo"的仓库，用于存放公司内部的私有库。
配置Maven客户端：在Maven项目的settings.xml文件中，添加私服的配置信息。例如，可以在<mirrors>标签下添加一个镜像配置，指向私服的URL。示例如下：

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

上述配置将Maven中央仓库的镜像设置为私服的URL。这样，当Maven项目构建时，它会优先从私服获取依赖而不是直接从中央仓库下载。

资源上传与下载

在Maven私服中，上传和下载构件是两个非常核心的操作。理解如何正确地执行这些操作对于确保项目的依赖管理顺畅至关重要。下面将详细介绍如何在Maven私服中进行构件的上传和下载操作：

上传构件到Maven私服

为了在Maven私服中共享和维护内部或第三方的私有库，需要将构件上传到私服。这通常涉及以下步骤：

准备构件：确保你要上传的构件已经构建完成，并且可以通过Maven的mvn install命令生成在本地仓库中。

配置Maven设置：在settings.xml文件中添加私服的服务器信息，包括ID、URL等。例如：

<servers>
  <server>
    <id>my-releases</id>
    <username>deployuser</username>
    <password>deploypwd</password>
  </server>
</servers>

执行上传：使用mvn deploy:deploy-file命令上传单个文件，或者直接使用mvn deploy命令自动处理。例如，上传一个JAR文件：

mvn deploy:deploy-file -DgroupId=com.example -DartifactId=my-lib -Dversion=1.0.0 -Dpackaging=jar -Dfile=path/to/your/artifact.jar -DrepositoryId=my-releases -Durl=http://localhost:8081/repository/my-releases/

验证上传：上传完成后，通过私服的管理界面或Maven命令检查构件是否已成功上传。

从Maven私服下载构件

Maven默认从中心仓库下载依赖。要改为从私服下载，需要在settings.xml中配置镜像或仓库。

配置镜像：将所有请求重定向到私服，私服再决定是否转发到外部仓库。例如，配置中心仓库的镜像：

<mirrors>
  <mirror>
    <id>central-mirror</id>
    <url>http://localhost:8081/repository/maven-public/</url>
    <mirrorOf>central</mirrorOf>
  </mirror>
</mirrors>

配置仓库：仅对特定仓库的依赖项使用私服。例如，添加一个新的仓库配置：

<profiles>
  <profile>
    <id>my-profile</id>
    <repositories>
      <repository>
        <id>my-releases</id>
        <url>http://localhost:8081/repository/my-releases/</url>
        <releases>
          <enabled>true</enabled>
        </releases>
        <snapshots>
          <enabled>false</enabled>
        </snapshots>
      </repository>
    </repositories>
  </profile>
</profiles>
<activeProfiles>
  <activeProfile>my-profile</activeProfile>
</activeProfiles>