框架 - Maven入门
【第一部分：Maven简介】
1、Maven 概述
Maven 项目对象模型(POM)，可以通过一小段 描述信息 来管理项目的构建、报告和文档的 【项目管理构建工具】软件。
Maven 是 Apache 软件基金会组织维护的一款【自动化构建工具】，专注服务于 Java 平台的项目构建和依赖管理。
Maven 是目前最流行的自动化构建工具，对于生产环境下多框架、多模块整合开发有重要作用，
是一款在大型项目开发过程中不可或缺的重要工具。
Maven 可以整合多个项目之间的引用关系，我们可以根据业务和分层需要任意拆分一个项目；
Maven 提供规范的管理各个常用 jar 包及其各个版本，并且可以自动下载和引入项目中；
Maven 可以根据指定版本自动解决 jar 包版本兼容问题；
Maven 可以把 jar 包所依赖的其它 jar 包自动下载并引入项目。
类似自动化构建工具还有： Maven, Gradle, Ant。
2、完成一个java项目 需要做的工作
1.分析项目要做什么，知道项目有哪些组成部分。
2.设计项目，通过哪些步骤，使用哪些技术。需要多少人， 多长的时间。
3.组建团队，招人， 购置设备，服务器， 软件， 笔记本。
4.开发人员写代码。 开发人员需要测试自己写代码。 重复多次的工作。
5.测试人员，测试项目功能是否符合要求。
过程：
软件开发需要编译代码 —> 开发人员自己测试代码 —> 把代码打包 —> 部署项目到测试服务器 —> 测试人员测试功能 —> 测试测试出 bug
开发人员需要修改bug —> 开发人员自己测试代码 —> 把代码打包 —> 部署项目到测试服务器 —> 测试人员测试功能 —> 直到符合功能要求。
上述过程需要重复多次，大型项目中构建项目比较复杂，有很多的配置文件，jar 文件，多个子项目等等。都用人力完成费时费力，效率比较低。
maven 可以让我们从上面的工作中解脱出来。maven 是自动化构建工具。
3、传统项目开发存在的问题
1）很多模块，模块之间有关系， 手工管理关系，比较繁琐。
2）需要很多第三方功能， 需要很多jar文件，需要手工从网络中获取各个jar，并且多个项目需要的 jar 包存在重复的问题；
3）管理jar的版本兼容问题： 你需要的是mysql.5.1.5.jar ，那你就不能给给一个mysql.4.0.jar
4）管理jar文件之间的依赖： 你的项目要使用a.jar，而a.jar需要使用到b.jar里面的class类。
必须首先获取到b.jar才可以， 然后才能使用a.jar.
4、改进项目的开发和管理，需要使用到Maven
1）maven可以管理jar文件
2）自动下载jar和他的文档，源代码
3）管理jar直接的依赖， a.jar需要b.jar ， maven会自动下载b.jar
4）管理你需要的jar版本
5）帮你编译程序，把java编译为class
6）帮你测试你的代码是否正确。
7）帮你打包文件，形成jar文件，或者war文件
8）帮你部署项目
5、Maven项目的构建过程
构建（build），是面向过程的(从开始到结尾的多个步骤)，涉及到多个环节的协同工作。
maven支持的构建过程主要包括：
① 清理：删除以前的编译结果，为重新编译做好准备。
② 编译：将Java源程序编译为字节码文件。 .java ——> .class文件
③ 测试：针对项目中的关键点进行测试，确保项目在迭代开发过程中关键点的正确性。
④ 报告：在每一次测试后以标准的格式记录和展示测试结果。
⑤ 打包：将一个包含诸多文件的工程封装为一个压缩文件用于安装或部署。
Java 工程对应 jar 包，Web工程对应 war包。
⑥ 安装：在Maven环境下特指 将打包的结果 ——> jar包或war包 安装到本地仓库中。
⑦ 部署：将打包的结果部署到远程仓库或将war包部署到服务器上运行。
把程序安装好可以执行。
6、Maven 工具的安装和配置
① 确保安装了 java 环境:
maven 本身就是 java 写的，所以要求必须安装 JDK。
查看 java 环境变量：echo %JAVA_HOME%
② 下载并解压 maven 安装程序：
官网 http://maven.apache.org/download.cgi
我这里选择了最常用的版本：【apache-maven-3.3.9-bin.zip】，它是可以配合jdk1.8版本的
解压到一个目录，非中文目录：【D:\zzzz\apache-maven-3.3.9】
子目录 bin: 一些执行程序，最常用是mvn.cmd
子目录 conf: maven工具本身的配置文件 settings.xml
③ 配置 Maven 的环境变量：
在系统的环境变量中，指定maven工具的安装目录：
MAVEN_HOME=D:\zzzz\apache-maven-3.3.9
再把它的bin加入到path之中 ：
path =%MAVEN_HOME%\bin
④ 验证是否安装成功:
打开dos窗口：mvn –v回车
出现版本信息，即可
【第二部分：Maven的核心概念】
1、Maven 的核心概念-简介
Maven能够实现自动化构建是和它的内部原理分不开的，这里我们从 Maven的九个核心概念入手，
看看Maven是如何实现自动化构建的：
① POM： 一个文件，名称是pom.xml , pom翻译过来叫做项目对象模型。
maven把一个项目当做一个模型使用。控制maven构建项目的过程、管理jar依赖等。
② 约定的目录结构 ： maven项目的目录和文件的位置都是规定的。
③ 坐标 ： 是一个唯一的字符串，用来表示资源的。
④ 依赖管理 ： 管理你的项目中可以使用的jar文件
⑤ 仓库管理 ： 你的资源所存放的位置
⑥ 生命周期 ： maven工具构建项目的过程，即生命周期。
⑦ 插件和目标：执行maven构建的时候用的工具就是插件
⑧ 继承
⑨ 聚合
2、Maven 工程约定的目录结构（重点）
约定：大家都认可的一种规则，虽然不这样做也可以，但最好不要违反约定。
maven 中约定的目录结构：
【Hello】：根目录，也就是工程名
--------【src】：源代码
----------------【main】：主程序
------------------------【java】： 主程序的 java 源码
------------------------【resources】：主程序的配置文件
----------------【test】：测试程序
------------------------【java】： 测试程序的 java 源码
------------------------【resources】：测试程序的配置文件
--------【pom.xml】：Maven 工程的核心配置文件
一般情况下，我们习惯上采取的措施是：约定 > 配置 > 编码
maven 的 pom.xml 记录的关于构建项目的各个方面的设置，maven 从 pom.xml 文件开始，
按照助约定的工程目录编译，测试，打包，部署，发布项目。
【第一个 maven 工程】
按照如下步骤，实现第一个 maven 项目，以 maven 推荐的约定方式创建目录、类文件。
1.某个目录中创建文件夹 Hello。（我这里是 D:\zzzz\Hello）
2.在 Hello 中创建子目录 src
3.拷贝 pom.xml 到 Hello 目录下，和 src 是同级放置的。
4.进入 Hello/src 目录，创建 main， test 目录
5.在 main 和test 目录，都创建 java、resources 目录。
6.进入Hello/src/main/java 目录，创建目录 com/yuming/maven/ 即包名
6.在 com/yuming/maven/目录下创建 HelloMaven.java 文件，编写代码，其中有个add方法，用来计算两个数字的和
7.进入到 Hello 目录下，在地址栏输出cmd，回车，执行【mvn compile】
mvn compile ,是编译 src/main/java目录下的所有java文件的。
结果是在项目的根目录Hello下生成了target目录（目标目录），
maven编译的java程序，生成的class文件都放在target目录中
8.进入到 Hello/target/classes 目录下，在地址栏输出cmd，回车，执行 【java com.yuming.maven.HelloMaven】
疑问：执行mvn compile时，dos窗口显示：
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven-resources-plugin/2.6/maven-resources-plugin-2.6.pom
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven-resources-plugin/2.6/maven-resources-plugin-2.6.pom (8 KB at 4.4 KB/sec)
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven-plugins/23/maven-plugins-23.pom
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven-plugins/23/maven-plugins-23.pom (9 KB at 14.6 KB/sec)
......
......
Downloading...Downloaded...下载了许多东西？
1）为什么要下载？
maven工具执行的操作，是需要很多插件来完成的，会在编译的时候，自动下载对应的插件
jar文件--叫做插件--插件是完成某些功能
2）下载的东西存放到哪里了。
默认仓库（本机仓库）：C:\Users\Administrator\.m2\repository
3）配置本地仓库地址
不想把本地仓库放在C盘下面，可以设置本机存放资源的目录位置(设置本机仓库)：
（1）找到 maven的配置文件。 在maven安装目录/conf/settings.xml
先备份 settings.xml-----复制粘贴命名为【settings - 原备份.xml】
（2）修改 settings.xml里面的 <localRepository> ， 指定你的目录（不要使用中文目录）
<localRepository>D:/zzzz/myLocalRepository</localRepository>
然后把C:\Users\Administrator\.m2\repository下面的插件复制过来就好了。
以后一些常用的插件下载之后，可以复制一份保存下来，直接粘贴使用，以免当时网络状况不好的情况
3、仓库
1、仓库是存放东西的，Maven 仓库存放的是：
（1） Maven 的插件，插件也是一些 jar，这些 jar 可以完成一定的功能。
（2）第三方框架或工具的 jar 包
（3）我们自己开发项目的模块
2、仓库的分类
（1）本地仓库：
存在于当前电脑上,默认存放在C:\Users\Administrator\.m2\repository中,为本机上所有的Maven工程服务。
你也可以通过Maven的配置文件：在maven安装目录/conf/settings.xml中修改本地仓库所在的目录。
（2）远程仓库：不在本机上， 通过网络才能使用。多电脑共享使用的。
①：中央仓库：通过Internet访问，为全世界所有 Maven工程服务。最权威的。
中央仓库的地址：https://repo.maven.apache.org
②：中央仓库的镜像：架设在不同位置，欧洲，美洲，亚洲等每个洲都有若干的服务器，为中央仓库分担流量。
减轻中央仓库的访问，下载的压力。所在洲的用户首先访问的是本洲的镜像服务器。
③：私服：在公司内部，在局域网中使用的，不是对外使用的。
3、Maven 对仓库的使用，不需要人为参与
在 Maven 构建项目的过程中如果需要某些插件，首先会到 Maven 的本地仓库中查找，如果找到则可以直接使用；
如果找不到，它会自动连接外网，到远程中央仓库中查找；如果远程仓库中能找到，则先把所需要的插件下载
到本地仓库，然后再使用，并且下次再用到相同的插件也可以直接使用本地仓库的；如果没有外网或者远程仓库
中也找不到，则构建失败。
开发人员需要使用某些插件--->首先查maven的本地仓库--->私服--->镜像--->中央仓库
4、POM 文件、坐标、依赖（重点）
-
POM： Project Object Model 项目对象模型。
Maven 把一个项目的结构和内容抽象成一个模型，在 xml 文件中进行声明；以方便进行构建和描述；
pom.xml 是 Maven 的灵魂。
所以，maven 环境搭建好之后，所有的学习和操作都是关于 pom.xml 的。
其中主要用到这几个：
1）坐标(GAV)：唯一值， 在互联网中唯一标识一个项目的
<groupId> 公司域名的倒写 </groupId> <artifactId> 自定义项目名称 </artifactId> <version> 自定版本号 </version> https://mvnrepository.com/ ：搜索使用的中央仓库， 使用groupId 或者 artifactId作为搜索条件，下载相关jar包，比如mysql驱动jar包2）packaging：项目打包的类型，可以不写，默认是jar ，web应用是war
3）依赖(dependency)
dependencies 和 dependency ，相当于是 java代码中的 import 就是你的项目中要使用的各种资源说明， 比我的项目要使用mysql驱动 ------------------------------------------------------------------ <dependencies> <!--依赖mysql\mysql-connector-java\5.1.9下面的jar包 --> <dependency> <groupId> mysql </groupId> <artifactId> mysql-connector-java </artifactId> <version> 5.1.9 </version> </dependency> 还可以加很多个<dependency></dependency>依赖 </dependencies> ------------------------------------------------------------------4）properties：设置属性
5）build ：构建项目的相关参数配置，最常用的是设置 编译java代码使用的jdk的版本等
5、Maven 的生命周期
-
maven的生命周期：就是maven构建项目的过程：清理，编译，测试，报告，打包，安装，部署
对于我们程序员而言，无论我们要进行哪个阶段的构建，直接执行相应的命令即可，
无需担心它前边阶段是否构建，Maven 都会自动构建。
这也就是 Maven 这种自动化构建工具给我们带来的好处。
6、Maven 的常用命令
-
Maven 对所有的功能都提供相对应的命令，要想知道 maven 都有哪些命令，那要看 maven 有哪些功能。
maven 三大功能：管理依赖、构建项目、管理项目信息。
管理依赖，只需要声明就可以自动到仓库下载；
管理项目信息，其实就是生成一个站点文档，一个命令就可以解决，最后再说；
maven 功能的主体其实就是项目构建。Maven 提供一个项目构建的模型，把编译、测试、打包、部署等都对应成一个个的生命周期阶段，并对
每一个阶段提供相应的命令，程序员只需要掌握一小堆命令，就可以完成项目的构建过程。【mvn clean】 清理：会删除原来编译和测试的目录，即 target 目录，但是已经 install 到仓库里的包不会删除 【mvn compile】 编译 主程序：会在当前目录下生成一个 target,里边存放编译主程序之后生成的字节码文件 【mvn test-compile】 编译 测试程序：会在当前目录下生成一个 target,里边存放编译测试程序之后生成的字节码文件 【mvn test】 测试：会生成一个目录surefire-reports，保存测试结果（测试报告） 【mvn package】 打包主程序：会编译、编译测试、测试、并且按照 pom.xml 配置把主程序打包生成 jar 包或者 war 包 【mvn install】 安装主程序：会把本工程打包，并且按照本工程的坐标保存到 本地仓库 中 【mvn deploy】 部署主程序：会把本工程打包，按照本工程的坐标保存到本地库中，并且还会保存到私服仓库中。 还会自动把项目部署到 web 容器中。 注意：执行以上命令必须在命令行进入 pom.xml 所在目录！ 并且：执行 Maven 的生命周期 后面的命令的时候，会自动把前面的命令依次执行一遍 -
【练习maven 各种命令】：
以上面【第一个 maven 工程】继续，测试 maven 各种命令1、单元测试（测试方法）： 用的是junit， junit是一个专门测试的框架（工具）。 junit测试的内容：测试的是类中的方法， 每一个方法都是独立测试的。方法是测试的基本单位（单元）。 maven借助单元测试，批量的测试类中的大量方法，是否符合预期的。 2、测试步骤 1）加入依赖，在pom.xml加入单元测试依赖，相当于java代码中，如果要连接mysql数据库，需要导入mysql的jar包一样 <!-- 单元测试 --> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.11</version> <scope>test</scope> </dependency> 2）在maven项目中的src/test/java目录下，创建测试程序。 在 Hello/src/test/java 目录下，创建 com/yuming/maven/目录，在该目录中创建 测试程序 推荐的创建测试类和测试方法的方式： 1.测试类的名称 是Test + 你要测试的类名 2.测试的方法名称 是：Test + 方法名称 因为我们测试的是HelloMaven, 所以就创建测试类 TestHelloMaven 测试的方法是add方法，创建测试方法testAdd 【测试方法】的定义规则: 1.方法是public的 2.方法没有返回值 void 3.方法名称是自定义的，推荐是Test + 方法名称 4.在方法的上面加入 @Test ------------------------------------------------------------------------ package com.yuming.maven; //导入的这两个类就是在上面加入的依赖所表示的目录下jar包:junit\junit\4.11\junit-4.11.jar的里面的 import org.junit.Assert; import org.junit.Test; public class TestHelloMaven { @Test public void testAdd(){ System.out.println("测试 HelloMaven 类 add()方法："); HelloMaven hello = new HelloMaven(); int res = hello.add(10,20); //验证hello.add(10,20)结果是不是30： /* junit提供的方法，对比结果的————assertEquals(期望值，实际值) 如果期望值和实际值是相等的，证明我们的HelloMaven是没有问题的， 如果不等，则会抛异常，说明HelloMaven有问题 */ Assert.assertEquals(30,res); } } ------------------------------------------------------------------------ 3） 执行【mvn clean】， 观察 taget 目录被清除 4） 执行【mvn compile】，编译主程序，又生成了taget 目录 ① 编译src/main/java 目录下的所有java 为class文件， 同时把class拷贝到 target/classes目录下面 ② 把src/main/resources目录下的所有文件 都拷贝到target/classes目录下 5) 进入 target/classes 目录，执行 java com.yuming.maven.HelloMaven，运行该程序 6）进入 Hello 目录，执行 【mvn test-compile】 编译测试程序，会在target下面生成test-classes目录。存放测试程序的class文件 7）进入 Hello 目录，执行 【mvn test】 执行 TestHelloMaven 类中方法，生成测试报告 会在target下面生成一个目录surefire-reports，里面有生成的测试报告： 8）进入目录 surefire-reports，查看测试报告com.yuming.maven.TestHelloMaven.txt ------------------------------------------------------------------------------- Test set: com.yuming.maven.TestHelloMaven ------------------------------------------------------------------------------- Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.053 sec 9）打开 TestHelloMaven.java, 增加测试方法testAdd2 @Test public void testAdd2(){ System.out.println("测试 HelloMaven 类 add()方法："); HelloMaven hello = new HelloMaven(); int res = hello.add(10,20); // 期望值，实际值 Assert.assertEquals(50,res); } 10）进入 Hello 目录，执行 【mvn test】 不用执行 mvn test-compile进行重新编译， 因为执行 Maven 的生命周期 后面的命令的时候，会自动把前面的命令依次执行一遍 11）进入目录 surefire-reports，查看测试报告com.yuming.maven.TestHelloMaven.txt ------------------------------------------------------------------------------- Test set: com.yuming.maven.TestHelloMaven ------------------------------------------------------------------------------- Tests run: 2, Failures: 1, Errors: 0, Skipped: 0, Time elapsed: 0.073 sec <<< FAILURE! testAdd2(com.yuming.maven.TestHelloMaven) Time elapsed: 0.007 sec <<< FAILURE! java.lang.AssertionError: expected:<50> but was:<30> at org.junit.Assert.fail(Assert.java:88) at org.junit.Assert.failNotEquals(Assert.java:743) at org.junit.Assert.assertEquals(Assert.java:118) at org.junit.Assert.assertEquals(Assert.java:555) at org.junit.Assert.assertEquals(Assert.java:542) ...... 12）去TestHelloMaven.java中，将增加的测试方法testAdd2删掉，或者将该方法中的50改为30 如果测试结果出错，没有解决的话，是进行不了后面的命令的。 就是前面所述的：执行 Maven 的生命周期 后面的命令的时候，会自动把前面的命令依次执行一遍 12）进入 Hello 目录，执行【mvn package】 ，会在target目录下生成 xxx.jar 文件，这就是所说的打包 生成的jar包：ch01-maven-1.0-SNAPSHOT.jar， 该jar包名字即为，我们在pom.xml中配置的artifactId和version的组合起来的： <groupId> com.yuming.maven </groupId> <artifactId> ch01-maven </artifactId> <version> 1.0-SNAPSHOT </version> 13）进入 Hello 目录，执行【mvn install】， 把 xxx.jar 文件安装到本地 maven 仓库，安装成功后查看仓库中的 jar 文件
7、Maven 的插件
-
maven命令执行时，真正完成功能的是插件，插件就是一些jar文件、一些类。
-
maven 过程构建周期，由 maven 的插件 plugin 来执行完成。
1）clean 清理插件： maven-clean-plugin:2.5 clean 阶段是独立的一个阶段，功能就是清除工程目前下的 target 目录 2）resources 插件： maven-resources-plugin:2.6 resource 插件的功能就是将项目的资源文件resources文件夹 拷贝 到目标目录 3）compile 编译插件： maven-compiler-plugin 功能就是把 src\main\java 源码编译成字节码生成 class 文件，并把编译好的 class 文件输出到 target\classes 目录下 4) test 测试插件 单元测试所用的 compile 和 resources 插件和主代码是相同的，但执行的目标不同， testCompile 和 testResources是把 src\test\java 下的代码编译成字节码输出到 target\test-classes， 同时把 src\test\resources 下的配置文件拷贝到target\test-classes 5) package 打包插件： maven-jar-plugin 这个插件是把 class 文件、配置文件打成一个 jar(war 或其它格式)包 6) deploy 发布插件： maven-install-plugin 发布插件的功能就是把构建好的 artifact 部署到本地仓库， 还有一个 deploy 插件是将构建好的 artifact 部署到远程仓库 这些插件，在上面练习maven 各种命令时，在dos窗口基本上出现过的 -
插件可以在自己的项目中设置，最常使用的是 maven 编译的插件。设置项目使用的 jdk 版本时通过编译插件指定。
在pom.xml 文件中设置：
<!-- 构建项目的相关参数配置，最常用的是设置编译Java代码的jdk的版本 -->
<build>
<!-- 配置插件，在下面可以配置多个 -->
<plugins>
<!-- 配置某个具体的插件 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId> <!-- 插件的名称 -->
<version>3.8.1</version> <!-- 插件的版本 -->
<configuration> <!-- 配置插件的信息 -->
<source>1.8</source> <!--告诉maven，我们写的代码是在jdk1.8上面 编译的 -->
<target>1.8</target> <!--告诉maven，我们写的代码是在jdk1.8上面 运行的 -->
</configuration>
</plugin>
</plugins>
</build>
【第三部分：Maven 在 IDEA 中的应用】
1、在IDEA中设置maven
DEA中内置了maven ，一般不使用内置的， 因为用内置修改maven的设置不方便。
使用自己安装的maven， 需要覆盖IDEA中的默认的设置，让IDEA指定自己maven安装位置等信息：
- ①：配置 当前工程的设置：
File———— settings ———— Build,Execution,Deployment ———— Build Tools ———— Maven
在右面的窗口配置这几项：
Maven Home directory: maven的安装目录 :
D:\zzzz\apache-maven-3.3.9
User Settings File : 就是maven安装目录下/conf/setting.xml配置文件：
D:\zzzz\apache-maven-3.3.9\conf\settings.xml
Local Repository : 本机仓库的目录位置 :
D:\zzzz\myLocalRepository
配置完之后，点击右下角的Apply。
继续在左边窗口的Maven下面————Runner里面设置:
VM Options: -DarchetypeCatalog=internal
JRE: 项目的jdk（我使用的1.8版本）
说明：在maven项目创建时，会联网从远程仓库加载 archetype 元数据，下载速度很慢，导致创建过程卡住。
使用-DarchetypeCatalog=internal，表示仅使用内部元数据，不用下载， 创建maven项目速度快。
配置完之后，点击右下角的Apply。
- ②：配置 以后新建工程的设置：
File ———— other settings ———— Settings for New Project
配置和上面一样，两个位置的配置
2、IDEA 创建 Maven版 Java项目
首先新建一个空的工程：
File——New——Project——在打开的窗口左侧最下面：Empty project——Next——工程名字：【maven-project】
在工程下面创建一个普通java项目：
-
1、File————New————Module————选择左边的Maven：
1）在右边上方选择jdk，建议选择与之配套的jdk1.8的，
2）在下面的【create from archetype】
archetype也就是原型，准确说是一个项目模板，我们可以根据该模板来生成项目。
在【create from archetype】下面有许多定义好的模板：常用的Archetype：
(1) maven-archetype-quickstart ———— 普通的java项目模板
默认的Archetype,基本内容包括：
（1）一个包含junit依赖声明的pom.xml
（2）src/main/java主代码目录及一个名为App的类（内容就是一个HelloWord）
（3）src/test/java测试代码目录及一个名为AppTest的测试用例(2) maven-archetype-webapp ———— web项目模板
一个最简单的Maven web项目模板，当需要快速创建一个Web应用的时候可以使用它。生成的项目内容包括：
（1）一个packaging为war且带有junit依赖声明的pom.xml
（2）src/main/webapp/目录
（3）src/main/webapp/index.jsp文件
（4）src/main/webapp/WEB-INF/web.xml文件因为现在是创建普通的java项目，就选择maven-archetype-quickstart就好了，Next
-
2、设置该项目的坐标
groupId ： com.yuming （公司域名的倒写）
artifactId： ch01-maven-java （自定义项目名称）
version ： 1.0 （自定版本号）
-
3、点击Next之后，会出现当前maven项目的一些信息
-
4、点击Next之后，填写Module名和存储路径————Finish
Module名建议和上面的artifactId名一致
-
5、然后就生成了该项目（Module）：【ch01-maven-java】
因为我们使用的maven-archetype-quickstart模板，
现在可以看到，果然生成了这些内容:
（1）一个包含junit依赖声明的pom.xml
（2）src/main/java主代码目录及一个名为App的类（内容就是一个HelloWord）
（3）src/test/java测试代码目录及一个名为AppTest的测试用例
注：这两个生成的类可以都删掉，写我们自己的类文件但是在之前讲到的【maven中约定的目录结构】，src/main和src/test下面都还应该有一个【resources】配置文件，
这里如果我们需要的话，可以手工在IDEA中创建：
在main和test上分别 右键 —— new —— Directory —— 命名为 resources要想使这两个resources成为IDEA中放置配置文件的文件夹，还需要一步，进行标识：
右键 main下面的resources ———— Mark Directory as —————— Resources Root
右键 test下面的resources ———— Mark Directory as —————— Test Resources Root最终，IDEA中maven版java项目的视图结构：
-
6、查看pom.xml
1、里面有自己项目的坐标（gav)，可以再修改都行
2、在 < properties>里面修改jdk为1.8
3、< dependencies>，依赖，里面有一个单元测试的依赖
4、< build>下面< pluginManagement>，插件管理，里面有maven生命周期的所有插件，
是IDEA方便我们配置插件用都给列出来了，如果我们不需要配置他们，整个build可以都删掉
<?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>
<!-- 自己项目的坐标（gav)-->
<groupId>com.yuming</groupId>
<artifactId>ch01-maven-java</artifactId>
<version>1.0</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <!--maven构建项目使用的是utf-8 ，避免中文的乱码-->
<maven.compiler.source>1.8</maven.compiler.source> <!--设置 编译java代码使用的jdk版本为1.8-->
<maven.compiler.target>1.8</maven.compiler.target> <!--设置 运行java代码使用的jdk版本为1.8-->
</properties>
<!--依赖-->
<dependencies>
<dependency> <!--单元测试依赖-->
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
- 7、在src/main/java的下面新建类：HelloMaven.java
package com.yuming;
public class HelloMaven {
public int add(int n1, int n2){
return n1+n2;
}
public static void main(String[] args) {
HelloMaven hello = new HelloMaven();
int res = hello.add(10,20);
System.out.println("10+20="+res); //10+20=30
}
}
- 8、在src/test/java的下面新建测试类：TestHelloMaven.java
然后直接运行该方法，就可以了
在该类里面，可以写多个测试方法，每个测试方法都可以单独运行进行测试
也可以直接在类上，运行整个类，这样所有方法都执行了
package com.yuming;
import org.junit.Assert;
import org.junit.Test;
public class TestHelloMaven {
@Test
public void testAdd(){
System.out.println("====testAdd 测试add方法=====");
HelloMaven helloMaven = new HelloMaven();
int res = helloMaven.add(10, 20);
//测试结果是否正确：
//Assert.assertEquals(期望值，方法实际返回值);
Assert.assertEquals(30,res);
}
@Test
public void testAdd2(){
System.out.println("====testAdd 测试add方法=====222");
HelloMaven helloMaven = new HelloMaven();
int res = helloMaven.add(10, 20);
//测试结果是否正确：
//Assert.assertEquals(期望值，方法实际返回值);
//Assert.assertEquals(50,res);
Assert.assertEquals(30,res);
}
}
- 9、使用IDEA中的maven工具窗口
在IDEA最右侧边缘处，可以点击“Maven”，打开maven工具窗口。
里面有我们创建的各个项目，项目下面第一个是【Lifecycle】，就是项目的生命周期，
clean、validate、compile、test等等，直接双击它就可以了
（不像之前没有使用IDEA工具时，要打开dos窗口，进去到pom.xml所在目录输出各种命令来执行了）
双击clean清理，可以看到target目录没有了；
双击compile编译，可以看到又生成了target目录。
双击test测试，可以看到生成了测试报告。。
双击package打包、双击install安装到本地仓库。。。。deploy部署。。
3、IDEA 创建 Maven版 Web项目
- 1、File————New————Module————选择左边的Maven：
1）在右边上方选择jdk，建议选择与之配套的jdk1.8的，
2）在下面的【create from archetype】中选择【maven-archetype-webapp】
maven-archetype-webapp ———— web项目模板:
一个最简单的Maven war项目模板，当需要快速创建一个Web应用的时候可以使用它。生成的项目内容包括：
（1）一个packaging为war且带有junit依赖声明的pom.xml
（2）src/main/webapp/目录
（3）src/main/webapp/index.jsp文件
（4）src/main/webapp/WEB-INF/web.xml文件
-
2、设置该项目的坐标
groupId ： com.yuming （公司域名的倒写）
artifactId： ch02-maven-web （自定义项目名称）
version ： 1.0 （自定版本号） -
3、其他步骤和上面一样，直到了生成该项目（Module）：【ch02-maven-web】
可以看到该项目下，已经根据模板生成了：
（1）一个packaging为war且带有junit依赖声明的pom.xml
（2）src/main/webapp/目录
（3）src/main/webapp/index.jsp文件
（4）src/main/webapp/WEB-INF/web.xml文件显然，按照 maven archetype 原型创建的 maven web 工程缺少 maven 项目的完整结构：
src-main-java /resources，src-test-java/resources，所以需要我们手动添加文件目录，并进行进行标识：src/main下面的创建 java目录， 并右键—————— Mark Directory as —————— Sources Root
src/main下面的创建 resources目录，并右键—————— Mark Directory as —————— Resources Rootsrc下面创建 test目录
src/test下面创建 java目录， 并右键—————— Mark Directory as ——————Test Sources Root
src/test下面创建 resources目录，并右键—————— Mark Directory as ——————Test Resources Root
最终，IDEA中maven版web项目的视图结构：
- 4、查看pom.xml
1、里面有自己项目的坐标（gav)，可以再修改都行
2、比java项目多了一个：< packaging>war</ packaging> ， web项目，默认打包类型为war
3、将< properties>里面修改jdk为1.8
4、< dependencies>，依赖，里面有一个单元测试的依赖
因为是web项目，会用到Servlet和jsp，所以在这里添加这两个依赖，就相当于添加这2个jar包
5、< build>下面< pluginManagement>，插件管理，里面有maven生命周期的所有插件，
是IDEA方便我们配置插件用都给列出来了，如果我们不需要配置他们，整个build可以都删掉
<?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.yuming</groupId>
<artifactId>ch02-maven-web</artifactId>
<version>1.0</version>
<packaging>war</packaging> <!--web项目，默认打包类型为war-->
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source> <!--记住指定这里的jdk版本为1.8-->
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<dependencies>
<dependency> <!--单元测试依赖-->
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency> <!--添加Servlet的依赖，也就是Servlet的jar包-->
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
<dependency> <!--添加JSP的依赖（jar包）-->
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.1</version>
<scope>provided</scope>
</dependency>
</dependencies>
</project>
-
5、创建servlet和jsp
-
【File】——> 【Settings】————【Build, Execution, Deployment】————>【Application Servers】， 点击【+】，选择【Tomcat Server】，在弹出的对话框中填入Tomcat的安装路径：D:/apache-tomcat-9.0.30 点击【OK】——>【OK】 设置Tomcat的启动与关闭按钮： 选择【Run】————>【Edit Configuration】，点击左侧【+】号，找到【Tomcat Server】---【Local】 （若是没有找到Tomcat Server 可以点击最后一行 34 items more）， 在name后面填写名字：myTomcat 下面的【Server】 -> 【Application server】有上面刚刚配置的本地 Tomcat 服务器， 下面【JRE】选择自己的jdk版本。。热部署。。。最后点击Apply，再点OK按钮。 这个时候就可以看到IDEA下面打开了一个窗口【Application Servers】,里面有自己刚刚设置的按钮【myTomcat】 -
7、发布网站（部署项目）
【Run】————>【Edit Configuration】，选择中间第二个：【Deployment】部署
点右边的【+】————>【Artifact】，就会在中间页面出现自己的项目：ch02-maven-web ：war exploded
在下面的【Application content：】后面可以写网站的别名，但是要注意一定要以/开头
我的是：/myWeb点【Apply】。 点【OK】 -
8、启动Tomcat，进行测试
IDEA下面【Application Servers】窗口,找到【myTomcat】，点击左侧的run -
9、web项目打包
在IDEA最右侧边缘处，可以点击“Maven”，打开maven工具窗口，找到该项目，双击package进行打包，
最后在target目录下生成了：【ch02-maven-web-1.0.war】
这就是我们项目的成果，可以把它交给用户：—————————————————————————————————————————————————————————————————————————————— 把这个文件复制到 Tomcat安装目录/webapps文件夹下面（D:\apache-tomcat-9.0.30\webapps） 可以将ch02-maven-web-1.0.war重命名为 myWeb.war，方便下面访问，不改也行 启动tomcat：双击Tomcat安装目录/bin目录下面的startup.bat, 这个时候去webapps文件夹下面，可以看到myWeb.war解压出来了一个文件夹：myWeb， 里面就是编译好的servlet和jsp文件等等 打开浏览器，访问 http://localhost:8080/myWeb/index.jsp 可以正常访问 关闭tomcat：双击bin目录下面的shutdown.bat ——————————————————————————————————————————————————————————————————————————————
4、常用技巧
-
1、在pom.xml,pom文件中添加一些依赖时，可能IDEA没有立即就识别出来，会报错，有一些红色波浪线。
解决办法：
右键 pom.xml ———— Maven ———— Reimport，相当于刷新，就好了 -
2、按照 maven archetype 原型创建的 maven web 工程缺少 maven 项目的完整结构是，我们需要自己创建缺少的文件夹，
然后要一个个右键，【Mark Directory as】进行标识，还有个方法是：
打开【Project Structure】工程结构, 点击左侧【Module】,在右侧选择【Sources】，
可以直接选中对应目录，然后点击“Mark as”后面对应的类型进行标识
-
3、IDEA 中导入 Maven 项目(module)
假设该项目名为【imModule】 1）找到该项目的所在文件夹，点进去，将imModule.iml删除掉 （后面IDEA会自动生成该模块对应的iml文件） 2）到IDEA中。File - new - Module from Existing Sources... 在弹出的窗口中，找到该项目，选中它点击OK - 下一步， 点击【import module from external module】,选择它下面的【Maven】 - 然后一直Next - Finish 3）File - Project Structure窗口，点击左边的Modules，选中【imModule】， 在右边的【Dependencies】看是否有指定的jdk，如果没有就选择一个。 -
4、对于web项目打包之后，是war类型的文件，不能直接用压缩文件打开这个war文件
我们可以先把它复制一份，再重命名为rar或者zip等类型的文件，就可以用压缩文件打开查看有什么内容了
5、总结：以后一般使用maven的模板创建项目
- maven-archetype-quickstart ———— 普通的java项目模板
- maven-archetype-webapp ———— web项目模板
【第四部分：依赖管理 和 Maven的常用设置】
1、依赖范围 ———— 使用scope表示的
scope的值有 compile、 test、 provided等。默认是compile
scope：表示依赖使用的范围，也就是在maven构建项目的哪些阶段中起作用。
maven构建项目: 编译、 测试、 打包、安装、部署
maven中的依赖范围有很多种，但是我们常用的只有以下三种：
compile：编译依赖范围, 指A在编译时依赖B，该范围为 默认依赖范围。
编译范围的依赖会用在【编译、测试、运行】，由于运行时需要，所以会参与【打包和部署】。
test： 测试依赖范围，在编译和运行时都不需要，只在【测试】时需要。
例如：Junit。由于运行时不需要，所以test范围依赖 不会被打包。
provide：已提供依赖范围，只有当jdk或者一个容器已提供该依赖之后才使用。
provide依赖在【编译、测试】时需要，在运行时不需要。
例如：servlet-api.jar被Tomcat容器提供了，所以 不需要打包。
junit的依赖范围: test
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope> <!--test依赖范围————只在测试阶段起作用-->
</dependency>
servlet-api的依赖范围:provided
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version> <!--servlet-api.jar-->
<scope>provided</scope> <!-- provided已提供依赖范围————在编译和测试时用 -->
</dependency>
项目的中的用到的所有依赖（jar ），必须在本地仓库中有。如果没有，会在pom.xml中报红色，
然后maven会自动下载到本地仓库里面，下载好之后，就没有红色了。
2、maven的属性设置
pom.xml中 设置maven的常用属性
<properties>
<maven.compiler.source>1.8</maven.compiler.source> 源码编译 jdk 版本
<maven.compiler.target>1.8</maven.compiler.target> 运行代码的 jdk 版本
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> 项目构建使用的编码，避免中文乱码
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> 生成报告的编码
</properties>
3、maven的全局变量
-
自定义的属性，
1.在< properties> 通过自定义标签声明变量（标签名就是变量名）
2.在pom.xml文件中的其它位置，使用 ${标签名} 使用变量的值 -
自定义全局变量一般是定义 依赖的版本号， 当你的项目中要使用多个相同的版本号，
先使用全局变量定义， 再使用${变量名}
<properties>
<spring.version>4.3.10.RELEASE</spring.version> <!--定义全局变量-->
</properties>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version> ${spring.version} </version> <!--引用全局变量-->
</dependency>
4、指定资源位置
- src/main/java 和 src/test/java 这两个目录中的所有*.java 文件会分别在 comile 和 test-comiple 阶段被编译，
编译结果分别放到了 target/classes 和 targe/test-classes 目录中，但是这两个目录中的其他文件都会被忽略掉，
如果需要把 src目录下的文件包放到 target/classes 目录，作为输出的 jar 一部分。
需要指定资源文件位置。以下内容放到标签中。
<build>
<resources>
<resource>
<directory>src/main/java</directory> <!--目录-->
<includes> <!--包括目录下面的所有 .properties, .xml 文件都会扫描到-->
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering> <!--filtering 为 false 表示不启用过滤器 -->
</resource>
</resources>
</build>
-
作用：
1、默认情况下，即没有使用标签的时候， maven执行compile 编译代码时，除了使用编译插件进行编译，
在这之前会先使用resources插件， 会把src/main/resource目录中的所有文件拷贝到target/classes目录中。
但是src/main/java下面的 非java文件，并不会拷贝到target/classes目录中，会被忽略掉。2、我们的程序有需要把一些文件放在src/main/java目录中，
当执行java程序时， 需要用到src/main/java目录中的文件。
这时需要告诉 maven 在compile 编译 src/main/java 目录下程序时，
需把非java文件一同拷贝到target/classes目录中。
此时就需要在< build>中 加入< resources>标签.
【思维导图】
传送门
上一章：框架 - jdk动态代理
下一章：框架 - MyBatis框架
扫一扫
1480
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
