Maven-初级_maven.multimoduleprojectdirectory

Maven基础

学习目标

能够了解Maven的作用（第一章，1.1）

能够理解Maven仓库的作用（第一章，1.2）

能够理解Maven的坐标概念（第一章，1.2）

能够掌握Maven的安装（第二章，2.1）

能够掌握IDEA配置本地Maven（第二章，2.2）

能够使用IDEA创建javase的Maven工程（第三章，3.1）

能够使用IDEA创建javaweb的Maven工程（第三章，3.2）

能够掌握依赖引入的配置方式（第五章，5.1.1.1）

能够了解依赖范围的概念（第五章，5.1.1.2）

第1章 Maven相关的概念

1.1 知识点-Maven介绍

【掌握学习目标和路径】

1.目标

能够了解Maven的作用

2.路径

什么是Maven？

Maven的作用？

Maven的好处？

1.1.1 讲解

1.1.1.1 什么是Maven？

Maven是项目进行模型抽象，充分运用的面向对象的思想，Maven可以通过一小段描述信息来管理项目的构建，报告和文档的==软件项目管理工具==。Maven 除了以程序构建能力为特色之外，还提供高级项目管理工具。由于 Maven 的缺省构建规则有较高的可重用性，所以常常用两三行 Maven 构建脚本就可以构建简单的项目。
1

​ 说白了: Maven是由Apache开发的一个工具。用来管理java项目, 依赖管理(jar包的管理)，项目构建.

1.1.1.2 Maven的作用

​ 依赖管理: maven对项目的第三方构件（jar包）进行统一管理。向工程中加入jar包不要手工从其它地方拷贝，通过maven定义jar包的坐标，自动从maven仓库中去下载到工程中。

​ 项目构建: maven提供一套对项目生命周期管理的标准，开发人员、和测试人员统一使用maven进行项目构建。项目生命周期管理：编译、测试、打包、安装、部署、运行。

​ maven对工程分模块构建，提高开发效率。 (后面Maven高级会涉及)

1.1.1.3 Maven的好处

1：节省磁盘空间

使用普通方式构建项目

使用Maven构建项目

2：可以一键构建

3：可以跨平台

4：应用在大型项目时可以提高开发效率（后续maven高级讲，maven工程分解）

【小结】

Maven是apache开发工具, 对项目进行管理

Maven的作用:

1：依赖管理(管理jar包)

2：项目构建(编译, 测试, 打包…)

3：maven对工程分模块构建（后面讲）

1.2 知识点-Maven仓库和坐标

【目标】

能够理解Maven仓库的作用

【路径】

Maven的仓库？

Maven的坐标？

1.2.1 讲解

1.2.1.1 Maven的仓库

1.2.1.2 Maven的坐标

Maven的一个核心的作用就是管理项目的依赖，引入我们所需的各种jar包等。为了能自动化的解析任何一个Java构件，Maven必须将这些Jar包或者其他资源进行唯一标识，这是管理项目的依赖的基础，也就是我们要说的坐标。包括我们自己开发的项目，也是要通过坐标进行唯一标识的，这样才能才其它项目中进行依赖引用。坐标的定义元素如下：
1

groupId:项目组织唯一的标识符，实际对应JAVA的包的结构 (一般写公司的组织名称 eg:cn.iyhome,com.alibaba)

== artifactId: 项目的名称==

version：定义项目的当前版本

例如：要引入druid，只需要在pom.xml配置文件中配置引入junit的坐标即可：

<!--druid连接池-->
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>druid</artifactId>  
  <version>1.0.9</version>  
</dependency>
1
2
3
4
5
6

【小结】

我们如果要使用jar, 只需要在项目里面添加对应的坐标

先从本地仓库找

有, 就直接依赖使用

没有, 从中央仓库找, 提示会下载到本地仓库, 下次用的时候就直接从本地依赖使用了

第2章 Maven的安装

2.1 知识点-Maven的安装

【目标】

能够掌握Maven的安装

【路径】

下载Maven

安装Maven

Maven目录介绍

配置环境变量

配置本地仓库

测试Maven是否安装成功

2.1.1 讲解

2.1.1.1 下载Maven

http://maven.apache.org/

2.1.1.2 安装Maven

将Maven压缩包解压，即安装完毕

【注意】：不要出现中文或者空格。

2.1.1.3 Maven目录介绍

bin：可执行命令

boot：第三方类加载框架

conf：配置

lib：maven自身jar包

2.1.1.4 配置环境变量

进入环境变量

配置MAVEN_HOME和Path

MAVEN_HOME：

Path：

2.1.1.5 配置本地仓库

第一步：将软件文件夹中的Repository解压

放置到任何目录都可以，我这里放置到maven的安装环境下，便于管理

第二步：配置本地仓库

在maven的安装目录中conf/ settings.xml文件，在这里配置本地仓库

示例代码：

<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
  <!-- localRepository
   | The path to the local repository maven will use to store artifacts.
   |
   | Default: ${user.home}/.m2/repository
  <localRepository>/path/to/local/repo</localRepository>
  -->
<localRepository>D:\apache-maven-3.3.9\repository</localRepository>
  <!-- interactiveMode
   | This will determine whether maven prompts you when it needs input. If set to false,
   | maven will use a sensible default value, perhaps based on some other setting, for
   | the parameter in question.
   |
   | Default: true
  <interactiveMode>true</interactiveMode>
  -->
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

添加：D:\apache-maven-3.3.9\repository

Maven中setting.xml配置（先了解）

2.1.1.6 测试Maven安装成功

打开cmd本地控制台，输入mvn -version（或者mvn -v）

【小结】

Maven工具安装包和本地仓库解压到一个没有中文没有空格目录下。

配置Maven的时候(必须MAVEN_HOME)

MAVEN_HOME: 配置到Maven工具解压目录

Path: 配置到Maven工具解压之后里面的bin目录

仓库的配置：配置settings.xml

2.2 知识点-IDEA集成Maven

【目标】

能够掌握IDEA配置本地Maven

【路径】

在IDEA配置Maven？

配置默认的Maven环境？

2.2.1 讲解

2.2.1.1 配置Maven

配置Maven

配置参数(创建工程不需要联网,解决创建慢的问题) -DarchetypeCatalog=internal

archetypeCatalog表示插件使用的archetype元数据，不加这个参数时默认为remote，即中央仓库archetype元数据，由于中央仓库的archetype太多了，所以导致很慢，指定internal来表示仅使用内部元数据。就不会再去下载了。

2.2.1.2 配置默认Maven环境

每次创建Maven工程的时候，总是需要重新选择Maven配置信息，那是因为默认的Maven环境不是我们当前的maven环境，所以需要配置。

打开idea , file->other Settings ->Maven 设置同上

【小结】

大家把默认Maven环境也配置一下, 解决: 下次创建时候 是不需要再配置的, 使用的就是这个默认的配置。

第3章 使用IDEA创建Maven工程

3.1 实操-创建javase工程（使用骨架）

【目标】

能够使用IDEA创建javase的Maven工程

【路径】

创建java工程

java工程目录结构

编写Hello World！

3.1.1 讲解

3.1.1.1 创建java工程

创建新工程

点击【Finish】

创建工程成功，需要点击右下角的“Enable Auto-Import”

表示以后更新pom就会自动下载依赖的jar包。必须勾选

3.1.1.2 pom.xml

<?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.itheima</groupId>
  <artifactId>maven_day01_j2se_demo</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>maven_day01_j2se_demo</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <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>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-jar-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
        <!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
        <plugin>
          <artifactId>maven-site-plugin</artifactId>
          <version>3.7.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-project-info-reports-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

Ø Project：任何你想build的事物，maven都可以认为他们是工程，这些工程被定义为工程对象模型(POM:Project Object Model)一个工程可以依赖其他的工程，一个工程也可以有多个子工程构成。

Ø POM：就是xml文件，是maven的核心文件，它是Maven如何工作的元数据文件。POM文件位于每个工程的根目录中。

Ø GroupId：groupId是一个工程在全局唯一的标识符，一般，他就是包名。GroupId有利于使用一个完整的包名，将一个工程从其他有类似名称的工程里区别出来。

Ø Artifact：artifact是工程将要产生或者需要使用的文件，他可以是jar文件、源文件、二进制文件、war文件、甚至是pom文件。每个artifact都有groupId和artifactId组合的标识符唯一识别。需要被使用（依赖）的artifact都要放在仓库（见Repository）中，否则Maven无法找到他们。

Ø Version：版本

Ø Package：导入的jar包还是war包，还是父工程（后面高级课程讲）

<packaging>jar</packaging>：当前工程是java工程（默认值）
<packaging>war</packaging>：当前工程是web工程
<packaging>pom</packaging>：当前工程是聚合工程（父工程）
1
2
3

Ø Dependency：为了能够bulid或者运行，一个典型的java工程会依赖其他的包。在Maven中，这些被依赖的包就被称为dependency。Dependency一般是其他工程的jar。

Ø Plugin：Maven是由插件组成的，它的每一个工程都是由插件提供的。插件提供goal，并根据在POM中找到的元数据去完成工作。主要的Maven插件都是由java写成的，但是也支持用Beanshell或者Ant脚本写的插件。

Ø Repository：仓库。

相关概念的关系：

​ 新建maven工程称之为project， 每个maven工程都包含 pom.xml 描述文件（maven工程的核心配置文件）

​ 一个工程区分其它工程的方式，是通过 groupId（组）和 ArtifactId（唯一标识）来区分的。

​ 一个工程可以通过 dependency（依赖的jar包） 依赖其它工程

3.1.1.3 java工程目录结构

需要main/java文件夹变成 源码的目录(存放java源码)

用于存放java文件（写包，写类）（idea中显示蓝色）

需要test/java文件夹变成 测试源码的目录(存放单元测试)

用于存放java测试文件（写包，写测试类）（idea中显示绿色）

创建resources目录, 变成资源的目录

存放配置文件（xml、properties等文件）

第一步：创建resources目录

第二步：resources目录此时是一个普通文件夹，需要进行标记。让它成为maven工程资源路径

其中：

Sources Root：表示java文件

Test Sources Root：表示测试的java文件

Resources Root：表示资源目录（测试环境有效）

Test Resources Root：表示测试的资源目录（测试环境有效）

整体结构

3.1.1.4 编写Hello World！

创建类

编写main方法

public class HelloWorld {

    public static void main(String[] args) {
        System.out.println("Hello World!!!");
    }

}
1
2
3
4
5
6
7

运行

【小结】

Maven项目结构是标准的：

pom.xml 位于工程根目录，对项目进行配置，任何一个maven项目都有。

src/main/java 存放项目源码 （源码和测试代码是分开的）

src/main/resources 存放项目的配置文件

src/test/java 存放项目测试代码

src/test/resources 存放项目测试使用的配置文件（一般不用）

3.2 实操-创建javaweb工程（使用骨架）

【目标】

能够使用IDEA创建javaweb的Maven工程

【路径】

创建javaweb工程

发布javaweb工程

浏览器访问效果

3.2.1 讲解

3.2.1.1 创建javaweb工程

创建javaweb工程与创建javase工程类似，但在选择Maven骨架时，选择maven-archetype-webapp即可：

选择maven-archetype-webapp

创建好的javaweb工程如下：

3.2.1.2 pom.xml

<?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.itheima</groupId>
  <artifactId>maven_day01_web_demo</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>maven_day01_web_demo Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <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>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <finalName>maven_day01_web_demo</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

3.2.1.3 Web工程目录结构

所以，要手动创建一个java目录，用于编写java代码，创建resources目录，用于存放资源文件：

还要将java目录添加为Source Root，将resources目录添加为：

java目录：
resources目录；

同理，如果需要，创建测试环境

最终的效果图为：

3.2.1.4 发布javaweb工程

第一步：

第二步：
第三步：

第四步：
第五步：填写Application context路径

第六步：配置

第七步：启动

3.2.1.5 浏览器访问效果

index.jsp

【小结】

1：选择骨架选择webapp

2：目录结构

Maven Web项目结构是标准的：

pom.xml 位于工程根目录，对项目进行配置，任何一个maven项目都有。

src/main/java 存放项目源码 （源码和测试代码是分开的）

src/main/resources 存放项目的配置文件

src/test/java 存放项目测试代码

src/test/resources 存放项目测试使用的配置文件（一般不用）

src/main/webapp 存放资源，包括静态资源（css,img,js等）和动态资源（jsp,html等）。

3：web工程, pom文件里面

 <packaging>war</packaging>
1

3.3 实操-不使用骨架创建工程（建议）

【目标】

在第三章中，是使用骨架来创建工程的，如果不使用骨架，怎样创建工程呢?

【路径】

不使用骨架创建javase项目

不使用骨架创建javaweb项目

3.3.1 讲解

3.3.1.1 不使用骨架创建javase项目

其他和上面相同

3.3.1.2 不使用骨架创建javaweb项目

同上,不勾选即可.缺少的文件和web.xml配置文件自己添加上即可.

第4章 Maven的常用命令

4.1 知识点-Maven的常用命令（maven一步构建）

【目标】

掌握Maven的常用命令

【路径】

clean命令

compile命令

test命令

package命令

install命令

4.1.1 讲解

4.1.1.1 clean命令

clean命令：独立的生命周期

清除编译产生的target文件夹内容，可以配合相应命令一起使用，如mvn clean package， mvn clean test

（1）在cmd窗口下
（2）使用idea

4.1.1.2 compile命令

mavne的生命周期：compile、test、package、install

该命令可以对src/main/java目录的下的代码进行编译

（1）在cmd窗口下
（2）使用idea

4.1.1.3 test命令

测试命令,会执行src/test/java/下的所有junit的测试用例。

第一步：导入测试junit的jar包坐标

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>
1
2
3
4
5
6
7

第二步：在src/test/java下创建测试类DemoTest

编写TestDemo.java

public class TestDemo {

    @Test
    public void testAa(){
        System.out.println("Hello World Test");
    }
}
1
2
3
4
5
6
7

第三步：执行test命令测试
控制台显示测试结果

4.1.1.4 package命令

mvn package，打包项目

如果是Javase的项目,打包成jar包

如果是JavaWeb的项目,打包成war包

（1）cmd窗口
（2）idea工具

打包后的项目会在target目录下找到

jar包

war包

4.1.1.5 install命令

mvn install，打包后将其安装在本地仓库

（1）cmd命令
（2）idea工具
安装完毕后，在本地仓库中可以找到itheima_javase_demo的信息
查看本地仓库

【小结】

命令作用

clean 清除编译内容

compile 编译

test 执行单元测试

package 打包(java工程打成jar, javaweb工程打war)

install 把打的包安装到本地仓库

生命周期
执行后面的命令, 会先执行前面的命令 eg: install 先执行 compile ,test,package
clean命令是独立的一个周期，如果想要执行先清理，再打包，可以执行clean package的组合命令完成

第5章 依赖管理和插件

5.1 知识点-依赖管理

【目标】

能够掌握依赖引入的配置方式

【路径】

导入依赖练习

依赖访问

5.1.1 讲解

5.1.1.1 导入依赖

导入依赖坐标，无需手动导入jar包就可以引入jar。在pom.xml中使用标签引入依赖。

去Maven官网找, 赋值,粘贴. http://mvnrepository.com/

导入junit的依赖

导入junit坐标依赖

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>
1
2
3
4
5
6
7

进行单元测试

创建包com.itheima.test，创建类TestDemo.java

package com.itheima.test;

import org.junit.Test;

public class TestDemo {

    @Test
    public void testAa(){
        System.out.println("Hello World Test");
    }
}
1
2
3
4
5
6
7
8
9
10
11

导入servlet的依赖

创建Servlet，但是发现报错，原因是没有导入Servlet的坐标依赖

第一步：创建Servlet
第二步：

第三步：报错，原因是没有servlet的jar包
第四步：导入Servlet的坐标依赖

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>2.5</version>
    <scope>provided</scope>
</dependency>

1
2
3
4
5
6
7

原有报错的Servlet恢复正常
第五步：配置web.xml

<servlet>
    <servlet-name>DemoServlet</servlet-name>
    <servlet-class>com.itheima.servlet.DemoServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>DemoServlet</servlet-name>
    <url-pattern>/aa</url-pattern>
</servlet-mapping>

1
2
3
4
5
6
7
8
9

第六步：配置tomcat（略）

第七步：启动tomcat，运行

5.1.1.2 依赖范围

1：compile 编译、测试、运行，A在编译时依赖B，并且在测试和运行时也依赖

例如：strus-core、spring-beans, C3P0,Druid。会打到war包或jar包

2：provided 编译、和测试有效，A在编译和测试时需要B，在运行时不需要。

例如：servlet-api就是编译和测试有用，在运行时不用（tomcat容器已提供）不会打到war包中

3：runtime：测试、运行有效，编译时不需要。

例如：jdbc驱动包 ，在开发代码中针对java的jdbc接口开发，编译不用

在运行和测试时需要通过jdbc驱动包（mysql驱动）连接数据库。会打到war包中

4：test：只是测试有效，只在单元测试类中用

例如：junit不会打到war包中

按照依赖强度，由强到弱来排序：(理解)

compile> provided> runtime> test

【小结】

坐标不需要背, 做项目时候/工作开发 都有整套的坐标. 如果是导入一些特定, 可以查阅网站,直接拷贝

作用范围

compile 编译, 测试 打包部署有效（大部分jar包都是，默认值）

provided 编译, 测试 有效, 不会打包进去的（servlet的api）

test 测试有效（junit测试）

runtime 编译无效, 测试 打包部署有效（jdbc驱动包）

1
2
3
4
5
6
7
8

【脚下留心】：

1：servlet, jsp 坐标, 加上provided 这个范围,因为tomcat里面有这些jar, 如果没有加上provided 这个范围 可以能导致jar冲突。

【举例】：

去掉

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>2.5</version>
    <scope>provided</scope>
</dependency>

1
2
3
4
5
6
7

抛出异常；
2：junit坐标，单元测试的建议加上test 这个范围, 其它不加

5.2 知识点-Maven插件

【目标】

​ Maven是一个核心引擎，提供了基本的项目处理能力和建设过程的管理，以及一系列的插件是用来执行实际建设任务。maven插件可以完成一些特定的功能。例如，集成jdk插件可以方便的修改项目的编译环境；集成tomcat插件后，无需安装tomcat服务器就可以运行tomcat进行项目的发布与测试。在pom.xml中通过plugin标签引入maven的功能插件。

【路径】

学习JDK编译版本的插件

学习Tomcat的插件

5.2.1 讲解

5.2.1.1 JDK编译版本的插件【了解】

<build>
    <plugins>
        <!--jdk编译插件-->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.2</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <encoding>utf-8</encoding>
            </configuration>
        </plugin>
    </plugins>
</build>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

5.2.1.2 Tomcat7服务端的插件

添加tomcat7插件 ，放置到下

<!--tomcat插件-->
<plugin>
    <groupId>org.apache.tomcat.maven</groupId>
    <artifactId>tomcat7-maven-plugin</artifactId>
    <configuration>
        <!-- 指定端口 -->
        <port>82</port>
        <!-- 请求路径 -->
        <path>/</path>
    </configuration>
</plugin>

1
2
3
4
5
6
7
8
9
10
11
12

注意: Maven的中央仓库中只有Tomcat7.X版本的插件，而之前我们使用的是8.X的版本，如果想使Tomcat8.X的插件可以去其他第三方仓库进行寻找，或者使用IDEA集成外部Tomcat8极其以上版本，进行项目的发布。

第一步：配置：

第二步：启动：

第三步：访问，测试

【小结】

掌握在哪里添加(位置)

	<build>
        <!--添加插件-->
        <plugins>
 	        <!--插件1-->
            <plugin>
            </plugin>
            <!--插件2-->
            <plugin>              
            </plugin>
        </plugins>
    </build>

1
2
3
4
5
6
7
8
9
10
11
12

第6章 案例

6.1 案例-使用Maven搭建WEB项目

6.1.1 需求

在web页面【完成添加客户信息的操作】

6.1.2 思路分析

在页面点击保存, 数据提交到服务器

创建CustomerServlet, 在CustomerServlet的doGet()方法里面

​ //1. 获得请求参数(封装成一个对象)

​ //2. 调用业务 进行保存

​ //3. 响应

创建CustomerService, 创建一个方法

创建CustomerDao, 使用JDBCTemplate操作数据库(保存)

6.1.3 代码实现

6.1.3.1 案例的准备工作

创建数据库itmcatmaven

第一步：创建表

CREATE TABLE `cst_customer` (
  `cust_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
  `cust_name` varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
  `cust_source` varchar(32) DEFAULT NULL COMMENT '客户信息来源',
  `cust_industry` varchar(32) DEFAULT NULL COMMENT '客户所属行业',
  `cust_level` varchar(32) DEFAULT NULL COMMENT '客户级别',
  `cust_phone` varchar(64) DEFAULT NULL COMMENT '固定电话',
  `cust_mobile` varchar(16) DEFAULT NULL COMMENT '移动电话',
  PRIMARY KEY (`cust_id`)
)

1
2
3
4
5
6
7
8
9
10
11

第二步：创建Maven项目

第三步：配置pom.xml

（1）设置war包

<packaging>war</packaging>

1
2

（2）导入坐标

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>3.8.1</version>
        <scope>test</scope>
    </dependency>
    <!--servlet，3.1.0可以使用配置文件配置，也可以使用注解-->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>
        <scope>provided</scope>
    </dependency>
    <!--mysql驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.26</version>
    </dependency>
    <!--c3p0连接池-->
    <dependency>
        <groupId>c3p0</groupId>
        <artifactId>c3p0</artifactId>
        <version>0.9.1.2</version>
    </dependency>
    <!--jdbcTemplate-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>4.1.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>4.1.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>4.1.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>4.1.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.1.1</version>
        <scope>compile</scope>
    </dependency>
    <!--beanUtils-->
    <dependency>
        <groupId>commons-beanutils</groupId>
        <artifactId>commons-beanutils</artifactId>
        <version>1.9.2</version>
    </dependency>
</dependencies>

<build>
    <plugins>
        <!--jdk编译插件-->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.2</version>
            <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>
            <configuration>
                <!-- 指定端口 -->
                <port>82</port>
                <!-- 请求路径 -->
                <path>/</path>
            </configuration>
        </plugin>
    </plugins>
</build>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

第四步：创建javabean

创建包com.itheima.domain，创建类Customer.java

public class Customer implements Serializable {

    private Long cust_id;
    private String cust_name;
    private String cust_source;
    private String cust_industry;
    private String cust_level;
    private String cust_phone;
    private String cust_mobile;
    // set和get方法
}

1
2
3
4
5
6
7
8
9
10
11
12

第五步：导入页面

在webapp下中创建index.html

<!DOCTYPE html>
<html lang="en">
<head>
       <meta charset="UTF-8">
       <title>Title</title>
</head>
<body>
<form action="addCustomerServlet" method="post">
          客户名称：<input type="text" name="cust_name"/><br/>
          客户来源：<input type="text" name="cust_source"/><br/>
          客户级别：<input type="text" name="cust_level"/><br/>
          客户行业：<input type="text" name="cust_industry"/><br/>
          客户手机：<input type="text" name="cust_mobile"/><br/>
          客户电话：<input type="text" name="cust_phone"/><br/>
         <input type="submit" value="保存"/><br/>
</form>
</body>
</html>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

第六步：web.xml

在webapp下创建/WEB-INF/web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         id="WebApp_ID" version="3.0">

</web-app>

1
2
3
4
5
6
7
8

第七步：在resources下创建配置文件

c3p0-config.xml，用于配置连接数据库

<c3p0-config>
   <default-config>
      <property name="driverClass">com.mysql.jdbc.Driver</property>
      <property name="jdbcUrl">jdbc:mysql://localhost:3306/itcastmaven</property>
      <property name="user">root</property>
      <property name="password">root</property>
      <property name="initialPoolSize">5</property>
   </default-config>
</c3p0-config>

1
2
3
4
5
6
7
8
9
10

第八步：创建CustomerServlet

创建包com.itheima.servlet，创建类CustomerServlet.java

CustomerServlet.java

package com.itheima.servlet;

import com.itheima.domain.Customer;
import com.itheima.service.CustomerService;
import com.itheima.service.impl.CustomerServiceImpl;
import org.apache.commons.beanutils.BeanUtils;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Map;

@WebServlet("/addCustomerServlet")
public class CustomerServlet extends HttpServlet {

    CustomerService customerService = new CustomerServiceImpl();

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request,response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        try {
            // 1:处理乱码
            request.setCharacterEncoding("UTF-8");
            response.setContentType("text/html;charset=utf-8");
            response.setCharacterEncoding("UTF-8");
            // 2:获取请求参数（封装成一个javabean）
            Map<String,String[]> map = request.getParameterMap();
            Customer customer = new Customer();
            BeanUtils.populate(customer,map);
            System.out.println(customer);
            // 3:调用业务，保存
            customerService.saveCustomer(customer);
            // 4:响应
            response.getWriter().println("保存成功！");
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

注意：@WebServlet("/addCustomerServlet")不要添加生成的name属性。

第九步：创建CustomerServiceImpl.java

package com.itheima.service.impl;

import com.itheima.dao.CustomerDao;
import com.itheima.dao.impl.CustomerDaoImpl;
import com.itheima.domain.Customer;
import com.itheima.service.CustomerService;

public class CustomerServiceImpl implements CustomerService {

    CustomerDao customerDao = new CustomerDaoImpl();

    public void saveCustomer(Customer customer) {
        customerDao.save(customer);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

第十步：创建CustomerDaoImpl.java

package com.itheima.dao.impl;

import com.itheima.dao.CustomerDao;
import com.itheima.domain.Customer;
import com.itheima.utils.C3P0Utils;
import org.springframework.jdbc.core.JdbcTemplate;

public class CustomerDaoImpl implements CustomerDao{

    JdbcTemplate jdbcTemplate = new JdbcTemplate(C3P0Utils.getDataSource());

    public void save(Customer customer) {
        String sql = "insert into cst_customer (cust_name,cust_source,cust_industry,cust_level,cust_phone,cust_mobile) values (?,?,?,?,?,?)";
        Object [] params = {customer.getCust_name(),customer.getCust_source(),customer.getCust_industry(),customer.getCust_level(),customer.getCust_phone(),customer.getCust_mobile()};
        jdbcTemplate.update(sql,params);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

第十一步：C3P0Utils.java

创建包com.itheima.utils，创建类C3P0Utils.java

package com.itheima.utils;

import com.mchange.v2.c3p0.ComboPooledDataSource;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * c3p0工具类（数据库连接池工具），用于管理多个数据库连接对象。
 * 与DBCP不同的是，c3p0不用手动加载配置文件，只需将配置文件(c3p0-config.xml)放到resources目录即可。
 */
public class C3P0Utils {

    // 得到一个数据源（连接池）
    private static DataSource ds = new ComboPooledDataSource();

    public static DataSource getDataSource() {
        return ds;
    }

    /**
     * 得到数据库连接对象
     *
     * @return
     */
    public static Connection getConnection() {
        Connection conn;
        try {
            conn = ds.getConnection();
            return conn;
        } catch (SQLException e) {
            throw new RuntimeException("服务器忙。。。");
        }
    }

    /**
     * 关闭所有资源连接
     *
     * @param conn
     * @param ps
     * @param rs
     */
    public static void releaseAll(Connection conn, Statement ps, ResultSet rs) {
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            conn = null;
        }

        if (ps != null) {
            try {
                ps.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            ps = null;
        }

        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            rs = null;
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

第十二步：测试

访问：http://localhost:82/index.html

输入测试数据

查看页面：

查看数据库表数据是否添加成功

第7章 总结

7.1 一,概念

Maven 是apache开发的工具, 对项目进行管理

Maven作用

依赖管理

构建项目

分模块构建(后面会讲)

仓库: jar包所在位置

坐标: 作为jar的唯一标识

7.2 二,安装

不要有中文和空格

配置Maven_HOME和path

配置本地仓库

IDEA里面要集成

7.3 三,使用IDEA创建工程

掌握使用骨架创建

建议也掌握不使用骨架创建

7.4 四,依赖和插件

依赖范围

compile 编译, 测试 打包部署 运行 有效

test 测试有效

provided 编译, 测试有效 包部署 运行无效(Servlet)

runtime 编译无效

插件位置

    <build>
        <!--添加插件-->
        <plugins>
            <plugin>
            </plugin>

            <plugin>              
            </plugin>
        </plugins>
    </build>

1
2
3
4
5
6
7
8
9
10
11