Maven基础

Maven的安装和配置

Maven概述和作用

Maven简介

maven是什么

maven的作用

小结

Maven的安装

maven下载

安装Maven

直接解压到任意目录，在预习资料中已经提供了安装包

1. 不要有汉字的目录
2. 不要有空格
3. 目录层次不要太深

Maven目录介绍

目录名	功能说明
bin	可执行文件的目录，其中mvn.cmd这是它的启动命令
boot	第三方的类加载器
conf	配置文件所在的目录，其中settings.xml是它的核心配置文件 如果这个文件配置有错误，会导致maven项目有问题。
lib	maven所依赖的jar包和一些插件

配置环境变量

1. 我的电脑右键，选择属性
   
2. 左上角选择"高级系统设置"
   

3. 选择高级下面的"环境变量"的按钮
   

4) 添加Maven的主目录为你的安装目录，设置Maven的可执行文件访问路径为Maven主目录的bin目录下

MAVEN_HOME=e:\apache-maven-3.5.2
Path=%MAVEN_HOME%\bin

测试安装好的Maven

出现如下提示信息表示配置成功：

Maven仓库的概念

仓库分类

目录

1. 什么是POM
   

2. 三种仓库的特点
   

3. 配置本地仓库
   

什么是POM

使用maven创建的项目，每个项目都有一个pom.xml配置文件，这是maven项目的配置文件。

POM的全称：Project Object Model 项目对象模型，按面向对象的思想来管理整个项目

在pom.xml文件中包含以下内容：

1. 当前模块或项目的坐标
2. 项目依赖了哪些jar包(常用)
3. 项目使用了哪些插件等

Maven的仓库概念

项目所有的jar包都从仓库中去下载，仓库就是存放jar包的地方

仓库分类

本地仓库

相当于缓存，工程第一次会从远程仓库（互联网）去下载jar 包，将jar包存在本地仓库（在本地电脑上）。以后不需要从远程仓库去下载，先从本地仓库找，如果找不到才去远程仓库找。

远程仓库

中央仓库

仓库中的jar包由专业团队（maven团队）统一维护，有全球最完整，最通用的jar包。https://repo1.maven.org/maven2/

私服

在公司内部架设jar包的私有服务器，中央仓库中存放的是通用的jar包。公司自己开发的jar包可以放在公司内部的私服中供企业内部使用，私服仓库中也包含了大量中央仓库的jar包。访问私服仓库比访问中央仓库速度更快，更稳定。

第三方公共库

由大型公司搭建的服务器供大家使用的jar包服务器，例如：阿里云仓库 https://maven.aliyun.com/mvn/view

配置本地仓库(重点)

1. 将本地仓库文件夹中的repository.zip解压，可以放在任意的位置，这是我提供的本地仓库。

e:\maven\repository

2. 配置本地仓库，修改maven的安装目录中conf/settings.xml文件，在53行配置本地仓库为上面的目录。

<localRepository>e:\maven\repository</localRepository>

3. 修改settings.xml文件，146行的下一级元素，指定中央仓库的镜像。这里使用的是阿里云的中央仓库，速度比官方的快很多。注：在mirrors下面

<mirror>  
	<id>nexus-aliyun</id>  
	<mirrorOf>*</mirrorOf>    
	<url>http://maven.aliyun.com/nexus/content/groups/public</url>  
</mirror>

4. 修改maven使用JDK的版本，187行。如果不配置就需要在idea中配置。maven默认使用的是JDK1.5的版本，这里使用1.8的版本。注：在profiles下面

<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>

5. 保存文件
   
   

小结

Maven的坐标

坐标的基本概念

目标

1. 坐标的作用
   

2. 定义坐标有哪些元素
   

Maven坐标的概念

每个jar包在仓库中都有一个唯一标识，这就是坐标，由以下三个元素组成

坐标的元素定义

命名规范：

元素名称	说明
groupId	表示一级或多级目录
artifactId	表示下一级目录
version	表示下一级目录

坐标示例

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

​ 可以通过官方的中央仓库地址：http://repo1.maven.org/maven2/

​ 通过以上三层结构就可以在仓库里面定位到一个jar包，坐标的每个组成部分都对应仓库里面的一级目录结构。如果之前已经访问过，则在本地仓库中也可以找到。`

​ 有一些groupId项目名字对应两级目录，而artifactId和version元素都对应一级目录

小结

groupId：对应一级或多级(组织或公司名字)
artifactId：对应一级 (项目或模块名字)
version：对应一级 (版本号)

在idea中配置maven

IDEA中配置Maven环境(重点)方式一:骨架创建

目标

在idea中配置maven的环境

IDEA绑定本地Maven服务器

1. 选择File–> Settings (配置当前的项目) ，这个配置只影响当前项目。但以后新创建的工程还需要重新配置。
   
   而选择File–>Other Settings (配置以后新创建的项目) ，则是影响以后新创建的项目。

2020版

2) 选择Build,Execution,Deployment–>Build Tools–>Maven

3) 配置以下三项信息：Maven的主目录，配置文件settings.xml和本地仓库repository目录

4) 选择Build,Execution,Deployment–>Build Tools -->Maven–>Runner，设置Maven启动虚拟机的选项：VMOption，设置所有资源先从本地仓库查找，如果本地仓库中没有才去互联网找。

-DarchetypeCatalog=internal

5) 可选，如果汉字没有乱码则不用设置，Maven控制台输出中文如果出现乱码，则进行如下设置。

VMoptions: -Dfile.encoding=GBK  或者 -Dfile.encoding=UTF-8

VMOptions配置多个参数需要使用空格隔开

使用Maven骨架创建JavaWeb工程

创建JavaWeb工程

1. 选择Maven骨架时，要选择maven-archetype-webapp，注：不要选成cocoon-22-archetype-webapp。
   
2. 将模块添加到哪个项目，指定其父模块，设置为none。指定项目的坐标。 (2020版)
   
3. 确认Web的骨架信息，检查是否正确
   
4. 点finish按钮，运行Maven构建web项目，这时要连接网络，一段时间后显示Maven exeution finished。
   
5. 默认骨架创建好的JavaWeb工程如下，选右边的Maven Projects中的刷新。
   
6. 左边的webapp图标上出现蓝色小点。表示这是Web页面的根目录，类似于以前的web目录。
   
   Maven对JavaWeb工程目录结构的要求
   

手动完善JavaWeb的目录结构

1. 手动在main目录下创建java目录和resources，如图
   
2. 在src目录下，与main目录同级，创建test目录，并在test目录下创建java文件夹和resources，如图
   
3. 在右边的Maven Projects刷新，左边的工程各个文件夹的图标都发生变化
   
4. 最终目录结构，如图红色方框中的文件夹都是手动创建的。
   

小结

相对JavaSE结构，Web的结构只是在main目录下多了一个webapp目录。这个目录是放网页的地方。

方式二:使用插件来创建javaWeb工程

目标

1. 插件的安装

2. 使用插件创建Web工程

默认创建结构

需要将一个Java工程转成Web工程

idea插件安装

1. 打开idea开发工具，如图安装插件

2. 选中插件的zip包文件，注：不要解压缩
   

3. 安装好以后，会提示重启idea开发工具

4. 重启以后就安装好了
   

创建Web项目

1. 创建maven模块
   

2. 创建工程坐标，注：Location的位置，不要创建到了上一个模块的下面。注：以下截图是2020版的。

3. 创建出来的是一个普通的工程，不是一个web项目

4. 使用插件把普通的Java工程转换为web项目

5. 出现如下中文提示

6. 转换后的项目如下图，webapp下放网页和JS等静态内容。如果webapp上没有蓝色小点，就点右边的刷新按钮

发布Web工程

1. 点上面的执行工具栏，编辑运行配置
   

2. 点Deployment，删除原有的项目，添加一个新的Artifact

3. 选择两个都可以，区别是：exploded是未打包成war的文件夹，访问速度更快一点，适合于开发阶段。

4. Application context的访问地址可以不变，设置成/

5. Server标签页的设置，这里默认的端口号是8080

6. 注意Tomcat默认访问的是index.jsp，要输入地址访问demo1

拓展：在线查询jar包依赖的写法

在maven中只需要导入依赖坐标，无需手动导入jar包就可以引入jar。在pom.xml中使用<dependency>标签引入依赖。如果pom模板中没有配置过的依赖，可以通过https://mvnrepository.com/在线搜索坐标写法。

1. 输入网址，在文本框中输入要查找的包名，如：servlet

2. 找到相应的结果，选择使用最多的

3. 点进去以后，选择相应的Servlet版本，如：3.1.0

4. 将相应的Maven依赖文本复制过来即可，只要点击文本就会自动复制，以后你按ctrl+v粘贴就可以了

注：以后开发项目，通常pom.xml中所有的依赖包的坐标都会提供。

Maven的生命周期：概述

目标

了解maven的生命周期

生命周期的概念和组成

maven对项目构建过程分为三套相互独立的生命周期

分别是：

1. Clean Lifecycle 在进行真正的构建之前进行一些清理工作。
2. Default Lifecycle 构建的核心部分，编译，测试，打包，部署等等。
3. Site Lifecycle 生成项目报告，站点，发布站点。

一个项目生命周期(Project Lifecycle)

使用maven完成项目的构建，项目构建包括：清理、编译、测试、部署等过程，maven将这些过程规范为一个生命
周期，如下所示是生命周期的各阶段：

maven命令

maven通过执行一些简单命令即可实现上边生命周期的各个过程，比如执行mvn compile执行编译、执行mvn clean
执行清理。

生命周期命令：clean、compile、test

以下所有的操作针对第1个通过向导创建的Web项目

clean命令

命令作用

清除target目录，target是字节码文件和项目发布的目录。用clean可以清除缓存。

也可以在命令行下执行：mvn clean

操作演示

1. 选择day39_02_Web项目，可以看到target文件夹
   

2. 双击右边的Maven Projects–>Lifecycle–>clean执行清除操作
   

3. 操作结果如下
   

4. 可以看到删除了target目录。
   

5. 也可以选择Execute Maven Goal选择clean命令执行，注意选择正确的路径。这种方式主要用于命令带参数的情况。

compile命令

命令作用

编译main目录，不会编译test目录

操作演示

1. 选择day39_02_Web项目，删除target中classes目录下和test-classes目录下所有的文件，不删除目录。

2. 双击compile命令执行
   

3. 在Run下查看结果

4. 只编译了java中的代码，test-classes中的代码没有编译。
   

test命令

命令作用

执行test目录下的测试类和方法
1. 需要导入Junit包
2. 汉字可能会有乱码，因为maven默认是使用GBK编码，如果有乱码不用理会。
3. 通常在junit中直接执行不会出现乱码

操作演示

1. 确认JUnit已经导入

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

2. 在src/test/java下创建测试类AppTest

3. 执行test命令测试，双击或输入运行的test命令
   

4. 在Run查看测试结果

• 如果有多个测试类，每个测试类中有多个方法，每个测试方法都会执行。

小结

1. clean：删除target目录
2. compile：编译main目录
3. test：执行test目录下所有的测试类和方法

生命周期命令：package，install

目标

1. 学习使用package和install命令
   

2. 在命令行方式下使用生命周期的命令
   

package命令

命令作用

如果是java项目，打包成jar
如果是web项目，打包成war
将项目打包到target目录下

操作演示

1. 确认在Web项目中已经设置了打包的方式

<packaging>war</packaging>

2. 双击package或者输入命令执行
   

3. 在Run查看日志输出结果。注：每次打包前还会再次执行所有test命令

4. 在target或windows目录下都可以看到生成的war文件
   

install命令

命令作用

将工程安装到本地仓库

操作演示

1. 双击install或者输入命令，执行安装命令
   

2. 执行以后在Run窗口看到如下信息

3. 安装完毕后，在本地仓库中可以找到当前项目创建的war包信息

4. 可以将war复制到tomcat/webapps目录下
   

5. 通过浏览器访问
   

命令行下执行Maven命令

操作演示：

1. 打开命令提示符窗口
   

2. 运行命令之前，必须进入项目所在的根目录，可以看到pom.xml所在的目录

3. 执行Maven的清除命令：mvn clean

4. 查看执行结果，发现target文件夹已经没有

小结:生命周期的命令

命令	说明
mvn clean	删除target目录
mvn compile	编译main目录
mvn test	执行test目录
mvn package	打包到target目录下
mvn install	安装到本地仓库中

扩展：创建自己的jar包

目标

1. 创建自己的jar包

2. 在其它maven工程中使用

案例需求：

1. 在JavaSE的项目中创建一个工具类MyUtils，类中包含静态方法sum(int m,int n)实现两个数相加

2. 将工具类打包成jar，安装到本地仓库中。

3. 在Web项目使用pom.xml文件引入本地仓库中的jar包

4. 创建类使用上面的工具类中的方法

实现步骤

1. 在main/java中创建MyUtils类和sum()方法

package com.itheima;

/**
 * 我的工具类
 */
public class MyUtils {

    /**
     * 实现两个数相加
     * @param m 第1个数
     * @param n 第2个数
     * @return 两个数的和
     */
    public static int sum(int m, int n) {
        return m + n;
    }

}

2. 修改pom.xml文件，确认设置了packaging元素为jar，并且修改artifactId和version元素

<?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>myutils</artifactId>
    <!--版本-->
    <version>1.0</version>
    <!--打包类型-->
    <packaging>jar</packaging>

</project>

3. 双击install，打包并且将jar包发布到本地仓库。
   

4. 检查本地仓库有了相应的jar包
   

5. 在另一个web项目中引用刚刚创建的jar包，并且点右边的Maven Projects刷新。

 <!--引用myutils-->
 <dependency>
     <groupId>com.itheima</groupId>
     <artifactId>myutils</artifactId>
     <version>1.0</version>
 </dependency>

6. 在web项目的main/java下创建一个类调用sum方法

package com.itheima.maven;

import com.itheima.MyUtils;

/**
 * 引用自己创建的工具类
 */
public class Demo3MyUtils {

    public static void main(String[] args) {
        int sum = MyUtils.sum(5, 3);
        System.out.println("两个数的和：" + sum);
    }

}

7. 运行结果如下：
   

创建自己的开发文档

1. 选择Tools菜单下：生成JavaDoc文档

2. 

3. 选择以下选项

Maven插件的使用

目标

学习maven中tomcat7插件的使用

插件的使用

​ Maven只提供了基本的项目处理能力和管理，它的功能主要是通过其它插件来实现的。就好比jQuery和jQuery插件的关系。每个Maven插件可以完成一些特定的功能。

配置Tomcat7插件步骤

如：集成Tomcat插件后，无需安装Tomcat服务器就可以运行Tomcat进行项目的发布与测试。只需在pom.xml中通过plugin标签引入maven的功能插件。

Maven官方目前只有tomcat7插件，没有提供tomcat8的版本。

1. 选择day39_02_Web项目，将下面的代码复制成plugins的子元素。这时刷新Maven Projects不会出现任何变化。可以修改端口号和访问地址。

<build>
	<plugins>
		<!--Tomcat7插件-->
		<plugin>
			<groupId>org.apache.tomcat.maven</groupId>
			<artifactId>tomcat7-maven-plugin</artifactId>
			<version>2.2</version>
			<configuration>
				<port>8080</port>
				<path>/</path>
				<uriEncoding>UTF-8</uriEncoding>
				<server>tomcat7</server>
			</configuration>
		</plugin>
	</plugins>
</build>

2. 刷新maven工程，即可使用maven来运行tomcat
   

3. 完整的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>day39_02_Web</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--打包成war-->
    <packaging>war</packaging>

    <properties>
        <!--源代码的字符集-->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!--JDK编译的版本-->
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
        <!--Servlet的配置-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <!--指定作用范围-->
            <scope>provided</scope>
        </dependency>
    </dependencies>

<build>
	<plugins>
		<!--Tomcat7插件-->
		<plugin>
			<groupId>org.apache.tomcat.maven</groupId>
			<artifactId>tomcat7-maven-plugin</artifactId>
			<version>2.2</version>
			<configuration>
				<port>8080</port>
				<path>/</path>
				<uriEncoding>UTF-8</uriEncoding>
				<server>tomcat7</server>
			</configuration>
		</plugin>
	</plugins>
</build>
</project>

使用Maven运行Tomcat

1. 运行Tomcat7插件(注意要使用jdk1.8)，这时通过Maven来启动Tomcat7。

2. 可以点Run中出现的http://localhost:8080地址栏，打开浏览器看到结果。

小结

1. 配置tomcat7
2. 启动tomcat

包的依赖范围(重点)

目标

1. 有哪三种不同的类路径

2. 常用的依赖范围有哪些

依赖范围

三种不同的类路径

​ Maven在执行过程中有三种不同的classpath，它们运行Java代码的时候，使用不同的classpath类路径下的jar包来执行。三种classpath范围如下：

classpath范围	理解为
编译类路径	只在main目录下源代码起作用
测试类路径	只在test目录下起作用
运行时类路径	在运行的时候起作用，可以理解为会打包到target目录下

常用依赖范围

• 什么是依赖范围：选择上面一种或多种类路径，起一个名字

• 通过标签：scope

• 默认是：compile

依赖范围

依赖范围	main编译类路径	test测试类路径	target运行时类路径
compile	Y	Y	Y
provided	Y	Y
runtime		Y	Y
test		Y

示例：test依赖范围

1. 在02_Web项目中，main目录下创建一个类的，写一个测试类，加上@Test注解，发现报错。

2. 因为在pom.xml的dependency中配置了scope为test，表示只在test目录下可以使用，如果改成compile或provided并且刷新Maven Projects，则可以使用。

示例：provided依赖范围

​ 例如：servlet-api就是编译和测试的时候才有用，在运行时不用，因为Tomcat容器已经提供了。如果打包到war文件中，可能会导致与Tomcat容器中的Servlet有冲突。

1. 在现在我们删除Servlet中的scope，这时它的依赖范围变成默认compile，即在编译，测试，运行时(打包到war中)都可以使用。

<!--Servlet的配置-->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
</dependency>

2. 通过Maven启动Tomcat7的方式运行，发现出现如下错误，这是因为我们的Servlet被打包到了war包中，与Tomcat容器中的Servlet API发生了冲突导致。
   

3. 这时如果使用生成周期package打包，会发现在lib下有多余的jar包

4. 将servlet的scope改成provided。停止Tomcat7，执行生命周期的clean命令，再次运行package，可以看到新产生的lib下没有servlet的jar包
   

5. 再次启动tomcat7，执行正常
   

示例：runtime依赖范围

​ JDBC访问MySQL数据库，在写代码的过程中是针对接口开发，不会牵涉到任何JDBC的实现类。如：得到连接对象Connection不是通过我们在代码中写new JDBC4Connection子类来得到的，而是程序在执行过程中才读取MySQL的驱动类生成它的子类对象，只在测试和运行期间才会用到MySQL的子类，所以设置为runtime范围。

1. 在pom.xml中配置mysql驱动的依赖，指定依赖范围为runtime，只在测试和运行时期间起作用。

<!-- mysql的驱动 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.22</version>
    <!--指定依赖范围-->
    <scope>runtime</scope>
</dependency>

2. 在test中，创建一个JDBC的测试方法，得到连接对象，可以发现JDBC的实现类在编译阶段是用不到的。因为编译阶段没有用到任何与JDBC4Connection相关的类，只在测试阶段和运行时才会用到。

@Test
public void testConnection() throws SQLException {
    Connection connection = DriverManager.getConnection("jdbc:mysql:///test", "root", "root");
    System.out.println(connection);
}

3. 得到MySQL的连接对象
   

扩展：如何在idea中打开或关闭maven项目

Maven案例

lombok的使用

lombok是什么

​ 以前的Java类中，充斥着太多不友好的代码

1. 实体类中大量的getter/setter/toString方法；

2. 异常处理；

3. I/O流的关闭操作等等

   这些样板代码既没有技术含量，又影响着代码的美观，于是Lombok应运而生。

导入依赖

​ 引入相应的maven包， Lombok的scope=provided，说明它只在编译阶段生效，不需要打入包中。Lombok在编译期将带Lombok注解的Java文件正确编译为完整的Class文件，它的任务就完成了。

 <dependency>
	<groupId>org.projectlombok</groupId>
	<artifactId>lombok</artifactId>
	<version>1.16.18</version>
	<scope>provided</scope>
</dependency>

注解的使用

@Getter/@Setter

作用类上：给所有的成员变量生成get和set方法
成员变量上：给这个成员变量生成get和set方法

@ToString

作用于类：生成toString方法
of属性：指定只包含哪些属性
exclude属性：除非哪些属性

@EqualsAndHashCode

作用于类：生成equals和hashCode方法

@NoArgsConstructor

生成无参的构造方法

@AllArgsConstructor

生成全参的构造方法

@Data

注解在类上，会为类的所有属性自动生成setter/getter、equals、canEqual、hashCode、toString方法，
如为final属性，则不会为该属性生成setter方法

代码

package com.itheima.entity;

import lombok.*;

/**
 * 所有的成员变量都生成set和get方法
 */
@Data
public class Employee {

    /**
     * 用在属性上生成这个属性的set和get方法
     */
    private int id;
    private String name;
    private boolean sex;
    private double salary;
}

package com.itheima.test;

import com.itheima.entity.Employee;
import org.junit.Test;

public class TestLombok {

    @Test
    public void testEmployee() {
        //员工类
        Employee employee = new Employee();
        employee.setId(100);
        employee.setName("张三");
        employee.setSex(false);
        employee.setSalary(4900);
        System.out.println(employee);
    }

}

IDEA中引入Lombok支持

注：插件的安装不是必须要的，没有安装插件也可以正常使用lombok

1. 点击File-- Settings设置界面，安装Lombok插件

2. 点击File-- Settings设置界面，开启 AnnocationProcessors，开启该项是为了让Lombok注解在编译阶段起到作用

3. 可以通过以下菜单查看lombok生成的类结构

4. 类结构：
   

案例：省市级联分析

目标

1. 流程分析
2. DAO层代码
3. 业务层代码

需求

页面上有两个下拉列表框，页面加载的时候访问数据库，得到所有的省份显示在第1个列表框中。当选择不同的省份的时候，加载这个省份下所有的城市显示在第二个下拉列表中。

效果

分析

表中的数据

pid是它的上级id，pid如果是0表示是最高级

sql语句

-- 同一张表中包含省和市
create table `area` (
`id` int primary key,
`name` varchar (50),
`pid` int   -- 父级的id，如果为0，表示没有父元素
); 

-- pid为0表示省，否则为某一个省下面的市
insert into `area` (`id`, `name`, `pid`) values(1,'广东省',0);
insert into `area` (`id`, `name`, `pid`) values(2,'湖南省',0);
insert into `area` (`id`, `name`, `pid`) values(3,'广西省',0);
insert into `area` (`id`, `name`, `pid`) values(4,'深圳',1);
insert into `area` (`id`, `name`, `pid`) values(5,'广州',1);
insert into `area` (`id`, `name`, `pid`) values(6,'东莞',1);
insert into `area` (`id`, `name`, `pid`) values(7,'长沙',2);
insert into `area` (`id`, `name`, `pid`) values(8,'株洲',2);
insert into `area` (`id`, `name`, `pid`) values(9,'湘潭',2);
insert into `area` (`id`, `name`, `pid`) values(10,'南宁',3);
insert into `area` (`id`, `name`, `pid`) values(11,'柳州',3);
insert into `area` (`id`, `name`, `pid`) values(12,'桂林',3);

select * from `area`;

2. 使用maven搭建环境

1. 创建新的工程，选择maven，输入以下参数

2. 使用插件将Java工程转成Web工程

3. 完整的工程结构如下：
   

4. 在pom.xml中配置所需要的jar包和插件

       <dependencies>
           <!-- junit包 -->
           <dependency>
               <groupId>junit</groupId>
               <artifactId>junit</artifactId>
               <version>4.12</version>
               <scope>test</scope>
           </dependency>
   
           <!-- lombok -->
           <dependency>
               <groupId>org.projectlombok</groupId>
               <artifactId>lombok</artifactId>
               <version>1.18.8</version>
               <scope>provided</scope>
           </dependency>
   
           <!-- servlet -->
           <dependency>
               <groupId>javax.servlet</groupId>
               <artifactId>javax.servlet-api</artifactId>
               <version>3.1.0</version>
               <scope>provided</scope>
           </dependency>
   
           <!-- mybatis -->
           <dependency>
               <groupId>org.mybatis</groupId>
               <artifactId>mybatis</artifactId>
               <version>3.5.0</version>
           </dependency>
   
           <!-- mysql驱动 -->
           <dependency>
               <groupId>mysql</groupId>
               <artifactId>mysql-connector-java</artifactId>
               <version>5.1.30</version>
               <scope>runtime</scope>
           </dependency>
   
           <!--jackson-->
           <dependency>
               <groupId>com.fasterxml.jackson.core</groupId>
               <artifactId>jackson-databind</artifactId>
               <version>2.9.8</version>
           </dependency>
       </dependencies>
   
       <build>
           <plugins>
               <!--Tomcat7插件-->
               <plugin>
                   <groupId>org.apache.tomcat.maven</groupId>
                   <artifactId>tomcat7-maven-plugin</artifactId>
                   <version>2.2</version>
                   <configuration>
                       <port>8080</port>
                       <path>/</path>
                       <uriEncoding>UTF-8</uriEncoding>
                       <server>tomcat7</server>
                   </configuration>
               </plugin>
           </plugins>
       </build>
   

Area实体类

在java目录下创建以下代码

package com.itheima.entity;

import lombok.Data;

@Data
public class Area {
    private int id;  //主键
    private String name;  //名字
    private int pid;  //上一级的id
}

核心配置文件mybatis-config.xml

在resources目录下创建

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <settings>
        <!--在控制台显示SQL语句-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

    <!--定义实体类别名-->
    <typeAliases>
        <package name="com.itheima.entity"/>
    </typeAliases>

    <environments default="default">
        <!--环境变量-->
        <environment id="default">
            <!--事务管理器-->
            <transactionManager type="JDBC"/>
            <!--数据源-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/day35"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

    <!--加载其它映射文件-->
    <mappers>
        <package name="com.itheima.dao"/>
    </mappers>
</configuration>

会话工具类：MyBatisUtils

在java目录下创建

package com.itheima.utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

/**
 * 会话工具类
 */
public class MyBatisUtils {

    //会话工厂的创建类->会话工厂->会话
    private static SqlSessionFactory factory;

    static {
        //1.会话工厂的创建类
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        //2.得到配置文件的输入流
        try (InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml")) {
            //3.创建会话工厂
            factory = builder.build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 得到会话对象
     * @return
     */
    public static SqlSession getSession() {
        return factory.openSession();
    }


}

DAO接口的代理实现类

package com.itheima.utils;

import org.apache.ibatis.session.SqlSession;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

/**
 * 所有DAO接口的代理实现类
 */
public class DaoInstanceFactory {

    /**
     * 获取DAO接口的代理对象
     */
    public static <T> T getBean(Class<T> interfaceClass) {
        /**
         * 参数1：类加载器，我们自己写的类是同一个类加载器
         * 参数2：实现的接口
         * 参数3：回调函数，接口中每个方法都会调用一次
         */
        return (T) Proxy.newProxyInstance(
                DaoInstanceFactory.class.getClassLoader(),
                new Class[]{interfaceClass},
                new InvocationHandler() {
                    /**
                     * 每个被代理的方法都会调用一次
                     * @param proxy 代理对象
                     * @param method 被代理的方法
                     * @param args 方法参数
                     * @return 方法的返回值
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //1.获取会话对象
                        SqlSession session = MyBatisUtils.getSession();
                        //2.得到dao的代理对象
                        T dao = session.getMapper(interfaceClass);
                        //3.调用接口中方法,查询得到结果
                        //参数1：调用方法的对象，参数2：方法参数数组
                        System.out.println("调用了DAO的方法：" + method.getName() + "，参数是：" + Arrays.toString(args));
                        Object result = method.invoke(dao, args);
                        //4.关闭会话
                        session.commit();
                        session.close();
                        //5.返回
                        return result;
                    }
                });
    }
}

AreaDao

package com.itheima.dao;

import com.itheima.entity.Area;
import org.apache.ibatis.annotations.Select;

import java.util.List;

/**
 * 持久层
 */
public interface AreaDao {

    /**
     * 查询相应的省份或城市
     */
    @Select("SELECT * FROM `area` WHERE pid=#{pid}")
    List<Area> findAllByPid(int pid);
}

AreaService接口

package com.itheima.service;

import com.itheima.entity.Area;

import java.util.List;

/*
业务层
 */
public interface AreaService {

    /**
     * 查询相应的省份或城市
     * @param pid
     */
    List<Area> findCitiesByPid(int pid);

}

AreaServiceImpl实现类

package com.itheima.service.impl;

import com.itheima.dao.AreaDao;
import com.itheima.entity.Area;
import com.itheima.service.AreaService;
import com.itheima.utils.DaoInstanceFactory;

import java.util.List;

public class AreaServiceImpl implements AreaService {

    //依赖于dao层
    private AreaDao areaDao = DaoInstanceFactory.getBean(AreaDao.class);

    /**
     * 查询相应的省份或城市
     * @param pid
     */
    @Override
    public List<Area> findCitiesByPid(int pid) {
        return areaDao.findAllByPid(pid);
    }
}

3. 案例：省市级联Servlet

目标

Servlet的代码

Servlet

步骤

1. 得到省份pid的值
2. 查询某个省下所有的城市
3. 转成JSON字符串输出到浏览器

代码

package com.itheima.servlet;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.itheima.entity.Area;
import com.itheima.service.AreaService;
import com.itheima.service.impl.AreaServiceImpl;

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.io.PrintWriter;
import java.util.List;

@WebServlet("/area")
public class AreaServlet extends HttpServlet {

    private AreaService areaService = new AreaServiceImpl();

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
       //1. 得到pid
        int pid = Integer.parseInt(request.getParameter("pid"));
        //2. 调用业务层查询，通过pid来查询城市或省份
        List<Area> areaList = areaService.findCitiesByPid(pid);
        //3. 将查询的结果转成JSON字符串
        String json = new ObjectMapper().writeValueAsString(areaList);
        //4. 以JSON格式发送给浏览器
        response.setContentType("application/json;charset=utf-8");
        PrintWriter out = response.getWriter();
        out.print(json);
    }

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

测试

4. 案例：省市级联HTML

目标

前端ajax的代码

html

步骤

1. 加载所有的省份
   1. 页面加载访问服务器，传递的数据是pid=0
   2. 保留第1项
   3. 遍历集合，每个元素添加成一个option。值是id属性，文本内容是name属性
2. 使用省份的改变事件
   1. 访问服务器，传递的数据是pid当前选中的值
   2. 保留第1项
   3. 遍历集合，每个元素添加成一个option。值是id属性，文本内容是name属性

代码

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>省市级联</title>
    <script src="js/jquery-3.3.1.js"></script>
</head>
<body>

<select id="province">
    <option>---请选择省---</option>
</select>
<select id="city">
    <option>---请选择城市---</option>
</select>

<script type="text/javascript">
    //页面加载完毕就加载所有的省份
    window.onload = function () {
        $.get("area","pid=0",function (provinces) {
            let html = `<option>---请选择省---</option>`;
            //遍历集合
            for (let province of provinces) {
                html+=`<option value="${province.id}">${province.name}</option>`;
            }
            //显示在省份中
            document.getElementById("province").innerHTML = html;
        })
    }

    //省份变化的事件
    document.getElementById("province").onchange=function () {
        $.get("area",`pid=${this.value}`,function (cities) {
            let html = `<option>---请选择城市---</option>`;
            //遍历集合
            for (let city of cities) {
                html+=`<option value="${city.id}">${city.name}</option>`;
            }
            //显示在省份中
            document.getElementById("city").innerHTML = html;
        })
    }
</script>
</body>
</html>

学习总结

1. 解释maven工程的标准目录结构
   

2. 能够独立安装和配置maven

   1. 安装：直接解压到任意目录，不要有中文

   2. 配置settings.xml

      1. 配置本地仓库位置
      2. 配置远程仓库，选择阿里云
      3. 配置JDK版本1.8

   3. 在idea中配置
      

3. 能够解释maven仓库
   坐标有三个元素：

   1. groupId：对应一级或多级目录
   2. artifactId：对应下一级目录
   3. version：对应下一级目录
      

4. 能够描述maven的生命周期

   1. clean：删除target目录
   2. compile：编译main目录
   3. test：测试test目录
   4. package：打包到target目录
   5. install：安装到本地仓库
      

5. 能够独立使用maven构建JavaWeb工程

   1. 创建一个普通的java工程
   2. 使用插件将java工程转成web工程

6. 能够在maven工程中添加依赖
   

依赖范围	main编译classpath	test测试classpath	target运行时classpath
compile	Y	Y	Y
provided	Y	Y
runtime		Y	Y
test		Y