• Maven-快速入门教程

    目录

    一、简介

    二、POM文件的基本结构

    三、依赖的范围

    四、依赖的传递

    五、依赖的排除

    六、继承与聚合

    6.1 父工程的一些参数

    6.2 子工程的一些参数

    七、idea构建maven工程

    7.1 创建一个maven工程/父工程

    7.2 创建一个maven子工程

    7.3 创建依赖关系

    一、简介

            随着我们使用越来越多的框架，或者框架封装程度越来越高，项目中使用的jar包也越来越多。我们利用maven可以方便地对依赖进行管理。

            另外，maven可以作为构建管理工具。当我们使用 IDEA 在本地进行开发时，构建是 IDEA 替我们做的。如果我们要把代码部署到服务器中，就可以用maven完成打包操作。

    二、POM文件的基本结构

            pom.xml 配置文件就是 Maven 工程的核心配置文件。其实学习 Maven 就是学这个文件怎么配置，各个配置有什么用。

    2.   <groupId>com.mavengroupId>
    3.   <artifactId>pro01-maven-javaartifactId>
    4.   <version>1.0-SNAPSHOTversion>
    5.   
    6.   
    7.   
    8.   
    9.   
    10.   <packaging>jarpackaging>
    11.  
    12.   <name>pro01-maven-javaname>
    13.   <url>http://maven.apache.orgurl>
    14.  
    15.   <properties>
    16. 	
    17.     <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    18.   properties>
    19.  
    20.   
    21.   <dependencies>
    22. 	
    23.     <dependency>
    24. 	
    25. 	  
    26.       <groupId>junitgroupId>
    27.       <artifactId>junitartifactId>
    28.       <version>4.12version>
    29. 	  
    30. 	  
    31.       <scope>testscope>
    32.     dependency>
    33.   dependencies>

    三、依赖的范围

    1. <groupId>junitgroupId>
    2. <artifactId>junitartifactId>
    3. <version>4.12version>
    5. <scope>testscope>

            标签有如下取值：

            compile/test/provided/system/runtime/import

            compile：通常使用的第三方框架的 jar 包这样在项目实际运行时真正要用到的 jar 包都是以 compile 范围进行依赖的。比如 SSM 框架所需jar包。这个也是默认值。

            test：测试过程中使用的 jar 包，以 test 范围依赖进来。比如 junit。

            provided：在开发过程中需要用到的“服务器上的 jar 包”通常以 provided 范围依赖进来。比如 servlet-api、jsp-api。而这个范围的 jar 包之所以不参与部署、不放进 war 包，就是避免和服务器上已有的同类 jar 包产生冲突，同时减轻服务器的负担。说白了就是：“服务器上已经有了，你就别带啦！”

     

    四、依赖的传递

    在 A 依赖 B，B 依赖 C 的前提下，C 是否能够传递到 A，取决于 B 依赖 C 时使用的依赖范围。

    • B 依赖 C 时使用 compile 范围：可以传递
    • B 依赖 C 时使用 test 或 provided 范围：不能传递，所以需要这样的 jar 包时，就必须在需要的地方明确配置依赖才可以。

             比如这样的结构，parent依赖son1，son1依赖son2.

    五、依赖的排除

            当 A 依赖 B，B 依赖 C 而且 C 可以传递到 A 的时候，A 不想要 C，需要在 A 里面把 C 排除掉。而往往这种情况都是为了避免 jar 包之间的冲突。 

    1. <dependency>
    2. 	<groupId>com.mavengroupId>
    3. 	<artifactId>pro01-maven-javaartifactId>
    4. 	<version>1.0-SNAPSHOTversion>
    5. 	<scope>compilescope>
    6. 	
    7. 	<exclusions>
    8. 		
    9. 		<exclusion>
    10. 			
    11. 			<groupId>commons-logginggroupId>
    12. 			<artifactId>commons-loggingartifactId>
    13. 		exclusion>
    14. 	exclusions>
    15. dependency>

    六、继承与聚合

            聚合就是使用一个“总工程”将各个“模块工程”汇集起来，作为一个整体对应完整的项目

            Maven工程之间，A 工程继承 B 工程

                     B 工程：父工程

                     A 工程：子工程

            本质上是 A 工程的 pom.xml 中的配置继承了 B 工程中 pom.xml 的配置。我们可以在父工程中统一管理项目中的依赖信息，具体来说是管理依赖信息的版本。

    从继承关系角度来看：

    • 父工程
    • 子工程

    从聚合关系角度来看：

    • 总工程
    • 模块工程

            它的背景是：

    • 对一个比较大型的项目进行了模块拆分。
    • 一个 project 下面，创建了很多个 module。
    • 每一个 module 都需要配置自己的依赖信息。

            它背后的需求是：

    • 在每一个 module 中各自维护各自的依赖信息很容易发生出入，不易统一管理。
    • 使用同一个框架内的不同 jar 包，它们应该是同一个版本，所以整个项目中使用的框架版本需要统一。
    • 使用框架时所需要的 jar 包组合（或者说依赖信息组合）需要经过长期摸索和反复调试，最终确定一个可用组合。这个耗费很大精力总结出来的方案不应该在新的项目中重新摸索。

            通过在父工程中为整个项目维护依赖信息的组合既保证了整个项目使用规范、准确的 jar 包；又能够将以往的经验沉淀下来，节约时间和精力。

            注意：父工程的打包方式必须为pom

    4. <packaging>pompackaging>

    6.1 父工程的一些参数

             modules 和 module 标签是聚合功能的配置，这个父工程包含3个子工程

    1. <modules>  
    2. 	<module>maven-module1module>
    3. 	<module>maven-module2module>
    4. 	<module>maven-module3module>
    5. modules>

            父工程统一管理依赖：

    3. <dependencyManagement>
    4. 	<dependencies>
    5. 		<dependency>
    6. 			<groupId>org.springframeworkgroupId>
    7. 			<artifactId>spring-coreartifactId>
    8. 			<version>4.0.0.RELEASEversion>
    9. 		dependency>
    10. 		<dependency>
    11. 			<groupId>org.springframeworkgroupId>
    12. 			<artifactId>spring-beansartifactId>
    13. 			<version>4.0.0.RELEASEversion>
    14. 		dependency>
    15. 		<dependency>
    16. 			<groupId>org.springframeworkgroupId>
    17. 			<artifactId>spring-contextartifactId>
    18. 			<version>4.0.0.RELEASEversion>
    19. 		dependency>
    20. 		<dependency>
    21. 			<groupId>org.springframeworkgroupId>
    22. 			<artifactId>spring-expressionartifactId>
    23. 			<version>4.0.0.RELEASEversion>
    24. 		dependency>
    25. 		<dependency>
    26. 			<groupId>org.springframeworkgroupId>
    27. 			<artifactId>spring-aopartifactId>
    28. 			<version>4.0.0.RELEASEversion>
    29. 		dependency>
    30. 	dependencies>
    31. dependencyManagement>

            父工程自定义属性：

    2. <properties>
    3. 	<project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    4. 	
    5. 	
    6. 	<spring.version>4.3.6.RELEASEspring.version>
    7. properties>

            设置这个属性就可以动态地管理依赖的版本了，那么依赖的版本号可以这样表示：

    1. <dependency>
    2. 		<groupId>org.springframeworkgroupId>
    3. 		<artifactId>spring-coreartifactId>
    4. 		<version>${spring.version}version>
    5. dependency>

    6.2 子工程的一些参数

    2. <parent>
    3. 	
    4. 	<groupId>com.mavengroupId>
    5. 	<artifactId>maven-parentartifactId>
    6. 	<version>1.0-SNAPSHOTversion>
    7. parent>
    8.  
    12. <artifactId>maven-module1artifactId>

            在子工程中引用被父工程管理的依赖： 

    4. <dependencies>
    5. 	<dependency>
    6. 		<groupId>org.springframeworkgroupId>
    7. 		<artifactId>spring-coreartifactId>
    8. 	dependency>
    9. 	<dependency>
    10. 		<groupId>org.springframeworkgroupId>
    11. 		<artifactId>spring-beansartifactId>
    12. 	dependency>
    13. 	<dependency>
    14. 		<groupId>org.springframeworkgroupId>
    15. 		<artifactId>spring-contextartifactId>
    16. 	dependency>
    17. 	<dependency>
    18. 		<groupId>org.springframeworkgroupId>
    19. 		<artifactId>spring-expressionartifactId>
    20. 	dependency>
    21. 	<dependency>
    22. 		<groupId>org.springframeworkgroupId>
    23. 		<artifactId>spring-aopartifactId>
    24. 	dependency>
    25. dependencies>

    七、idea构建maven工程

    7.1 创建一个maven工程/父工程

                    新建工程->选择maven->next->设置坐标(可选)->完成

    7.2 创建一个maven子工程

                    在父工程上点击右键->new->module->maven->next->选择Parent->完成

            这时parent 和 son 就是父子工程的关系，在父工程的pom.xml中：

    1. <modules>
    2.         <module>maven-sonmodule>
    3. modules>

             在子工程的pom.xml中：

    1. <parent>
    2.         <artifactId>maven-parentartifactId>
    3.         <groupId>com.mavengroupId>
    4.         <version>1.0-SNAPSHOTversion>
    5. parent>

    7.3 创建依赖关系

            假如一个工程要引用另一个工程的依赖，就要在其pom.xml文件中加<dependency>：

    1. <--! 假如是parent工程要引用son工程的依赖 -->
    2. <dependency>
    3.             <groupId>com.mavengroupId>
    4.             <artifactId>maven-sonartifactId>
    5.             <version>1.0-SNAPSHOTversion>
    6. dependency>

  • 相关阅读:
    Java单例模式的完整实现，从0到1带你一步步优化
    正则基础入门学习
    聊一聊损失函数
    FastAPI 学习之路（二十一）请求体 - 更新数据
    Effctive C++
    Exchange Office 365邮箱报表
    浏览器本地存储webStorage
    Java日期时间的前世今生
    毕业季，既是告别，也是新的开始
    机器学习算法三之Python机器学习库sklearn简介
  • 原文地址：https://blog.csdn.net/weixin_62427168/article/details/126093712