maven添加tool maven toolchain

JavaWeb

• 一、Maven简介

• 1.1 什么是Maven？
• 1.2 构建

• 1.1.1 什么是构建
• 1.1.2 构建过程的几个环节

• 1.3 Maven的约定目录结构
• 1.4 Maven坐标
• 1.5 Maven仓库
• 1.6 Maven私服

• 二、Maven下载、安装与配置

• 2.1 Maven下载和安装
• 2.2 配置Maven文件

• 三、Maven使用

• 3.1 IDEA使用maven创建web项目
• 3.2 Maven配置文件 pom.xml 的使用

• 3.2.1 通过坐标管理项目中jar包
• 3.2.2 配置项目使用插件
• 3.2.3 将项目拆分成多个工程并进行依赖(Maven多模块开发)

• 3.2.3.1 Maven多模块开发的概念
• 3.2.3.2 Maven多模块开发项目的搭建步骤
• 1.创建普通maven工程(maven创建java工程,不要使用模板创建)
• 2.输入相应信息(建议修改,如果使用默认也可以)
• 3.删除src文件夹
• 4.在父模块pom.xml中引入当前项需要使用的所有jar包
• 5.在当前父模块中创建子模块

• 5.1 创建controller模块
• 5.2 创建service模块

• 6.书写代码完成模块间依赖操作

• 6.1书写dao模块代码

• 6.2 书写service模块代码
• 6.3 书写controller模块

---

一、Maven简介

1.1 什么是Maven？

Maven 翻译为"专家"、“内行”，是 Apache 下的一个纯 Java开发的开源项目。基于项目对象模型（缩写：POM）概念，Maven利用一个中央信息片断能管理一个项目的构建、报告和文档等步骤。
Maven 是一个项目管理工具，它包含了一个项目对象模型 (POM：Project Object Model)，一组标准集合，一个项目生命周期(Project Lifecycle)，一个依赖管理系统(Dependency Management System)，和用来运行定义在生命周期阶段(phase)中插件(plugin)目标(goal)的逻辑。Maven是一个Apache的开源项目，主要服务于基于Java平台的项目构建、依赖管理和项目信息管理。
Maven 也可被用于构建和管理各种项目，例如 C#，Ruby，Scala 和其他语言编写的项目。
Maven 曾是 Jakarta项目的子项目，现为由 Apache 软件基金会主持的独立 Apache 项目。

在使用前需要先理解 Maven 的常见概念：构建、坐标、仓库、私服、镜像。

1.2 构建

1.1.1 什么是构建

构建并不是创建，创建一个工程并不等于构建一个项目。要了解构建的含义我们应该由浅入深的从
以下三个层面来看：

1. 纯 Java 代码

大家都知道，我们 Java 是一门编译型语言，.java 扩展名的源文件需要编译成.class 扩展名的字节码文件才能够执行。所以编写任何 Java 代码想要执行的话就必须经过编译得到对应的.class 文件。

2. Web 工程

当我们需要通过浏览器访问 Java 程序时就必须将包含 Java 程序的 Web 工程编译的结果“拿”到服务器上的指定目录下，并启动服务器才行。这个“拿”的过程我们叫部署。

3. 实际项目

在实际项目中整合第三方框架，Web 工程中除了 Java 程序和 JSP 页面、图片等静态资源之外，还包括第三方框架的 jar 包以及各种各样的配置文件。所有这些资源都必须按照正确的目录结构部署到服务器上，项目才可以运行。

所以综上所述：构建就是以我们编写的 Java 代码、框架配置文件、国际化等其他资源文件、JSP 页面和图片等静态资源作为“原材料”，去“生产”出一个可以运行的项目的过程。那么项目构建的全过程中都包含哪些环节呢？

1.1.2 构建过程的几个环节

1. 清理：删除以前的编译结果，为重新编译做好准备。
2. 编译：将 Java源程序编译为字节码文件。
3. 测试：针对项目中的关键点进行测试，确保项目在迭代开发过程中关键点的正确性。
4. 报告：在每一次测试后以标准的格式记录和展示测试结果。
5. 打包：将一个包含诸多文件的工程封装为一个压缩文件用于安装或部署。Java 工程对应 jar 包，Web工程对应 war 包。
6. 安装：在 Maven 环境下特指将打包的结果——jar 包或 war 包安装到本地仓库中。
7. 部署：将打包的结果部署到远程仓库或将 war 包部署到服务器上运行。

1.3 Maven的约定目录结构

约定的目录结构对于Maven实现自动化构建而言是必不可少的一环，就拿自动化编译来说，Maven必须能找到Java源文件，下一步才能编译，而编译之后也必须有一个准确的位置保持编译得到的字节码文件。
我们在开发中如果需要让第三方工具或框架知道我们自己创建的资源在哪，那么基本上就是两种方式：

1. 通过配置的形式明确告诉它
2. 基于第三方工具或框架约定

现在JavaEE开发领域普遍认同一个观点：约定>配置>编码。意思就是能用配置解决的问题就不编码。能基于约定的就不进行配置。而Maven正是因为制定了特定文件保存的目录才能够对我们的Java工程进行自动化构建

1.4 Maven坐标

在Maven世界中任何一个依赖、插件或者项目构建的输出都可以称为构件，任何一个构件都有一个坐标作为唯一的标识。

• 这个坐标就是：groupId、artifactId、version；

• groupId：公司或组织的域名倒序+当前项目名称
• artifactId：当前项目的模块名称
• version：当前模块的版本

<groupId>com.queen.web</groupId>
<artifactId>queen-web</artifactId>
<version>1.0.0-SNAPSHOT</version>

根据这个坐标就可以定义其在仓库的唯一存储路径，那么就可以在项目中引用。

将groupId、artifactId、version三个连起来
com.queen.web+queen-web+1.0.0-SNAPSHOT
以连接起来的字符串作为目录结构去仓库中查找
com/queen/web/queen-web/1.0.0-SNAPSHOT/queen-web-1.0.0-SNAPSHOT.jar

注意：我们自己的Maven工程必须执行安装操作才会进入仓库，安装命令：mvn install

1.5 Maven仓库

Maven仓库是基于简单文件系统存储的，只要在文件系统中没有发现相关的文件，说明这几依赖并不存在，因此，我们很容易在本地仓库查找具体的依赖是否存在。

Maven仓库分为两种：本地仓库和远程仓库。

• 本地仓库就是我们自己机器上的文件系统，所以他是唯一的，项目构建时首先在本地仓库查找依赖，如果本地没有依赖时才会去寻找远程仓库。
• 远程仓库指的是非本地的其他所有仓库，中央仓库、私服等都是远程仓库的一种。如果本地仓库没有项目构建需要的构件，你们就会从远程仓库下载，可是远程仓库如果也没有的话，你们就会项目报错。

1.6 Maven私服

私服是一种特殊的远程仓库，他是架设在局域网内的仓库服务，私服代理广域网上的远程仓库，供局域网内的Maven用户使用。当Maven需要下载构件的时候，它从私服请求，如果私服上不存在改构件，则从外部的远程仓库下载，同时缓存在私服之上，然后为Maven下载请求提供服务，另外，对于第三方的jar无法从仓库下载（JDBC驱动），可以从本地上传到私服供客户端下载。

优点主要有：

1. 节省外网宽带
2. 加速Maven构建
3. 部署第三方构件
4. 提高稳定性、增强控制：原因是外网不稳定
5. 降低中央仓库的负荷：原因是中央仓库访问量太大

二、Maven下载、安装与配置

2.1 Maven下载和安装

1. 点此进入maven官网

2. 选择左侧Download

3. 点击指定的链接进行下载

4. 下载完成后，选择一个路径进行解压 然后配置path环境变量。

新建系统变量:MAVEN_HOME = F:\dev\apache-maven-3.6.1

添加系统变量:%MAVEN_HOME%\bin

（注意使用maven之前确定jdk安装环境）

5. 运行cmd 输入 mvn -v，查看Maven的版本以及Java的版本，如图所示则配置成功

2.2 配置Maven文件

2. 在maven文件conf下可以找到settings文件，notepad打开



4. 大约在第52行，这里是maven默认的仓库



5. 修改默认仓库位置，在指定位置新建用于保存的文件夹例如E:/repository
6. 复制第53行并将标签内容修改该为你设置的地址书写在注释外

<localRepository>E:/repository</localRepository>

4. 因为国外的服务器下载jar包很慢所以我们改为阿里云服务器（大约在150行左右）

直接复制粘贴指定位置即可 注意粘贴在mirrors标签中如图

<mirrors>
  <mirror>
      <id>alimaven</id>
      <name>aliyun maven</name>
      <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
      <mirrorOf>central</mirrorOf>        
    </mirror>
  </mirrors>

5. 下载repository，并保存在E盘下。

网盘链接：repository
提取码：1248

6. 修改maven默认的JDK版本

全局配置

全局配置是指在${MAVEN_HOME}\conf\settings.xml中进行配置，${MAVEN_HOME}指的是maven的安装目录。例如，要配置jdk1.8,打开settings.xml这个文件，然后在 之间添加如下代码。

<profile>     
    <id>JDK-1.8</id>       
    <activation>       
        <activeByDefault>true</activeByDefault>       
        <jdk>1.8</jdk>       
    </activation>       
    <properties>       
        <maven.compiler.source>1.8</maven.compiler.source>       
        <maven.compiler.target>1.8</maven.compiler.target>       
        <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>       
    </properties>       
</profile>

局部配置

局部配置就是只针对具体某个项目进行配置的。具体就是，在项目的pom.xml文件中添加如下代码

<build>
	<plugins>
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-compiler-plugin</artifactId>
			<configuration>
				<source>1.8</source>
				<target>1.8</target>
			</configuration>
		</plugin>
	</plugins>
</build>

三、Maven使用

3.1 IDEA使用maven创建web项目

1. 打开IDEA new->File->Project

2. 选择maven->create from archetype->webapp
使用原型创建maven项目

3. 选下拉填入项目详细信息（非必要）

Name：项目名

GroupId：包路径

rtifactId：项目名(跟默认跟name相同)

4. 选择maven相关配置，选择maven路径、仓库地址

点击+号添加 DarchetypeCatalog = internal

这样在创建maven时就不会每次都去中央仓库下载导致创建过慢默认结构：

5. 在main下新建文件夹

java：java代码存放路径类似于src。

resources：配置文件存放路径也可以当做src。

• 普通项目的目录结构：

src/main/java —— 存放项目的.java 文件
src/main/resources —— 存放项目资源文件，如 spring, hibernate 配置文件
src/test/java —— 存放所有单元测试.java 文件，如 JUnit 测试类
src/test/resources —— 测试资源文件
target —— 项目输出位置，编译后的 class 文件会输出到此目录
pom.xml——maven 项目核心配置文件

6. 在java文件下创建包

7. 在pom.xml中添加web项目依赖

<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>

8. 重新导入依赖（默认maven会自动加载，但还是手动导入下）

9. 在包下书写servlet

10. 将项目添加到tomcat

这里演示使用war的方式，开发建议使用war exploded的方式。

war模式：将WEB工程以包的形式上传到服务器 ；
war exploded模式：将WEB工程以当前文件夹的位置关系上传到服务器；

（1）war模式这种可以称之为是发布模式，看名字也知道，这是先打成war包，再发布；
（2）war exploded模式是直接把文件夹、jsp页面 、classes等等移到Tomcat 部署文件夹里面，进行加载部署。因此这种方式支持热部署，一般在开发的时候也是用这种方式。
（3）在平时开发的时候，使用热部署的话，应该对Tomcat进行相应的设置，这样的话修改的jsp界面什么的东西才可以及时的显示出来。

11. 启动项目发送请求

3.2 Maven配置文件 pom.xml 的使用

setting.xml主要用于配置maven的运行环境等一系列通用的属性，是全局级别的配置文件；而pom.xml主要描述了项目的maven坐标，依赖关系，开发者需要遵循的规则，缺陷管理系统，组织和licenses，以及其他所有的项目相关因素，是项目级别的配置文件。
maven在项目中进行jar包管理就是依赖于pom文件。

pom中主要有三个功能：
1、通过坐标管理项目中jar包
2、配置项目使用插件
3、将项目拆分成多个工程并进行依赖(Maven多模块开发)

3.2.1 通过坐标管理项目中jar包

<dependencies>
    <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
</dependencies>

所有坐标书写在dependencies标签中
GroupId：jar包所在包名
artifactId：jar包名
version：版本

3.2.2 配置项目使用插件

书写在build的plugins标签中，创建maven项目时模板后自动添加与生命周期对应会在右侧边栏中展示插件（如下是idea默认集成,应该是plugins中的）

常用对应的Maven指令(一般都是通过插件直接使用不会书写指令)

• mvn clean 清理
  进入项目根目录，执行「mvn clean」命令清理项目，清理项目的过程就是把执行「mvn compile」命令编译项目时生成的target文件夹删掉
• mvn compile编译

• 进入项目根目录执行 「mvn compile」命令编译项目java类
• 编译成功之后，项目的根目录下多了一个「target」文件夹

• mvn test 测试

• 测试成功之后，项目的根目录下多了一个「target」文件夹
• 执行测试时， Maven会自动执行编译过程

• mvn package打包

• 打包成功后，项目的根目录下的「target」文件夹中多了一个项目名-版本号.ja或war

• mvn install项目部署

• Maven 会对项目自动执行「清理」→「编译」→「测试」→「打包」过程
• 同时将打包好的jar包发布到本地的Maven仓库中，平时这个命令使用最多

命令组合

maven的编译，清理，测试，打包，部署命令是可以几个命令同时组合起来使用的
1. 先清理再编译：mvn clean compile
2. 先清理再测试：mvn clean test
3. 先清理再打包：mvn clean package
4. 先清理再部署：mvn clean install

配置tomcat7插件

<!-- 配置Tomcat7插件 -->
		<plugin>
			<groupId>org.apache.tomcat.maven</groupId>
			<artifactId>tomcat7-maven-plugin</artifactId>
			<version>2.2</version>
			<configuration>
				<!-- 访问路径 -->
				<path>/test</path>
				<!-- 端口号 -->
				<port>8080</port>
			</configuration>
		</plugin>

配置junit插件

<!-- junit -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.11</version>
		</dependency>

3.2.3 将项目拆分成多个工程并进行依赖(Maven多模块开发)

3.2.3.1 Maven多模块开发的概念

将一个项目拆分成多个模块(项目),模块直接相互依赖使用的过程.(也可以理解为我们将不同包下的代码书写到不同的模块中,其他模块可以根据依赖进行使用)。

Maven继承：子模块继承与父模块,可以使用父模块中pom.xml配置文件引入的jar包。
Maven依赖：子模块之间依赖使用(需要引入依赖)。

3.2.3.2 Maven多模块开发项目的搭建步骤

1.创建普通maven工程(maven创建java工程,不要使用模板创建)

2.输入相应信息(建议修改,如果使用默认也可以)

如果使用默认在子项目继承时也会直接使用之前默认的信息

3.删除src文件夹

因为我们创建是多模块项目,所以父模块只需要pom.xml文件进行配置即可,无需书写代码(不删除也没有影响)

4.在父模块pom.xml中引入当前项需要使用的所有jar包

<dependencies>
        <!-- junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
        </dependency>
        <!-- Servlet核心包 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.0.1</version>
            <scope>provided</scope>
        </dependency>
        <!--JSP -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.1</version>
            <scope>provided</scope>
        </dependency>
        <!-- JSTL -->
        <!-- https://mvnrepository.com/artifact/javax.servlet.jsp.jstl/jstl-api -->
        <dependency>
            <groupId>javax.servlet.jsp.jstl</groupId>
            <artifactId>jstl-api</artifactId>
            <version>1.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/taglibs/standard -->
        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>standard</artifactId>
            <version>1.1.2</version>
        </dependency>

        <!-- mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.6</version>
        </dependency>
        <!-- mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.40</version>
        </dependency>
        <!-- log4j -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
    </dependencies>

5.在当前父模块中创建子模块

5.1 创建controller模块

因为是处理客户发送的http请求,所以需要创建web项目,点击模板选择maven:webapp创建

选择当前模块继承的父模块

创建完项目后可以将web模块中pom.xml中的引入的jar包删除,因为可以直接继承父模块引入的jar包

如果创建的子模块没有父模块引用(不同版本模板创建不同),手动加入

<parent>
        <artifactId>maven0908</artifactId>
        <groupId>com.yunhe</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>

之后创建java与resource文件夹书写web代码即可(如果没有servlet选项刷新所有模块pom.xml)

注意:如果还是没有可能是因为没有书写<scope>provided</scope> ,因为maven默认scope为compile是jar编译时使用

5.2 创建service模块

service主要书写java代码所有不需要使用模板创建web,所以不要勾选模板创建

使用此方法依次创建 dao

6.书写代码完成模块间依赖操作

6.1书写dao模块代码

创建对应的包书写代码

6.2 书写service模块代码

就是书写接口与实现类,实现类调用dao模块的方法进行使用,需要添加dao模块的依赖

点击后会自动将对应模块依赖添加到当前模块pom.xml中并且模块配置自动配置

<dependencies>
        <dependency>
            <groupId>com.yunhe</groupId>
            <artifactId>dao</artifactId>
            <version>1.0-SNAPSHOT</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

也可以手动配置,先点击将模块添加

之后再手动书写pom.xml配置文件

6.3 书写controller模块

创建servlet调用对应的serivce方法并进行依赖(依赖service模块以及dao模块)

添加service依赖,由于service依赖于dao所以无需再次依赖,也可以书写依赖

因为只有controller模块是web模块所以只需要将controller模块加入tomcat运行即可(其他模块会被maven以jar包的形式添加至controller中)

Maven依赖管理的本质就是：将普通的java工程在运行时打成jar包引入到其他工程中直接使用。

---

每日一点点进步
不进则退