Maven教案
🔰学习目标
1.掌握maven的概念
2.能够搭建maven环境
3.熟练掌握maven核心概念
4.能够使用maven创建java工程
5.能够使用maven创建web工程
6.熟练掌握项目对象模型pom.xml文件
7.数量掌握maven的模块化开发
一、maven 介绍
1.1 关于jar管理存在的一些问题
🔰 一个项目中往往会应用比较多的jar包,每个jar都从官网下载会比较麻烦;费时费力,降低了开发效率。
🔰jar包与jar包之间有依赖关系,我们很难记住这些依赖关系;手动导入jar包容易把依赖的jar包丢掉。
🔰不同工程中有相同的jar包,使得资源浪费,项目臃肿。
🔰平时我们开发项目时,一般都是一个项目就是一个工程。我们划分模块时,都是使用package来进行划分。但是,当项目很大时,有很多子模块时,即使是package来进行划分,也是让人眼花缭乱。
※ 针对以上问题,现在最流行的解决方案就是maven
1.2 什么是maven
🔰正式的定义为:Maven是一个项目管理工具,它包含了一个项目对象模型 (Project Object Model),一组标准集合,一个项目生命周期(Project Lifecycle),一个依赖管理系统(Dependency Management System),和用来运行定义在生命周期阶段(phase)中插件(plugin)目标(goal)的逻辑。
🔰项目对象模型:java 工程的 jar、插件、坐标、统一由pom.xml文件管理。所以pom.xml称之为项目的对象模型。
🔰项目生命周期:maven工程的编译、测试、运行、部署等所有过程都可以通过maven工具独立完成。
🔰依赖管理系统:maven工程不需要引入jar包。通过坐标调用仓库的jar包进行运行。如图所示:
🔰插件和目标:maven的 编译、测试、运行、部署都是通过插件运行的。这些插件只需要在pom.xml中配置即可。每个插件的运行会分成n个步骤,每个步骤叫目标。
🔰对于不同职责的人来说有不同的不理解
- 绝大多数Maven的开发者认为Maven是一个构建工具,用来把源代码构建成可发布、可执行构建的工具。
- 项目经理可能会认为Maven是一个项目管理工具,可以管理项目建设的生命周期,包含:预处理、编译、打包、测试、部署等。
🔰为什么使用maven ?
- 下载第三方JAR包
- 添加第三方jar包
- jar包之间的依赖
二、准备maven开发环境
注意: Maven的执行需要使用JDK,所以一定安装JDK并配置环境变量,统一使用JDK8及以上版本。
2.1 下载maven
下载地址: http://maven.apache.org
2.2 解压即安装
2.3 配置环境变量
【1】在环境变量中配置 MAVEN_HOME
,为maven的安装目录
【2】修改环境变量中path
,添加 %MAVEN_HOME%\bin
2.4 验证Maven
🔰在命令窗口执行命令
mvn -v
2.5 准备仓库环境
2.5.1 仓库配置
🔰仓库类型:简单来说仓库就是存储Jar包的目录,一般情况分为3类:
- 中央仓库
- 本地仓库
- 远程仓库。
【1】 中央仓库
🔰由Maven社区提供的仓库,其中包含了绝大多数流行的开源Java构件,一般情况下简单的Java依赖都可以从这里下载到本地。其设置在Maven的核心中,不需要进行配置
【2】本地仓库
🔰在本地电脑中存储Jar包的目录,默认的仓库目录是在自己的用户目录下 .m2/respository/ 的仓库目录。通过修改Maven安装目录下的配置文件 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>E:\\java\\maven_repository2</localRepository>
<!-- ....-->
</settings>
【3】远程仓库
🔰远程仓库是企业或者个人搭建的一个可以通过互联网进行访问的jar包仓库。
🔰一般情况下,Maven执行时如果本地找不到依赖文件,就会去中央仓库进行查找,如果还找不到就会停止构建,并输出错误信息到控制台,远程仓库的出现就是为了解决这种问题的出现。
配置全局的远程仓库(AliMaven) [settings.xml【Maven主配置文件】]
<mirrors>
<mirror>
<id>alimaven</id>
<name>aliyun maven</name>
<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
<mirrorOf>central</mirrorOf>
</mirror>
</mirrors>
2.5.2 仓库之间的关系
🔰项目的jar通过依赖坐标去本地库去加载,如果本地库没有去远程库加载,如果远程库没有去中央仓库加载;如果没有配置远程库,本地库会直接去中央仓库去加载。
2.6 统一配置jdk版本
🔰刚才我们配置了maven工程的jar依赖来源,即本地仓库、远程仓库。接下来我们在maven目录conf目录settings.xml文件继续配置jdk的开发版本。配置内容如下:
<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>
三、入门使用
3.1 创建Maven工程
# 执行命令,进入交互式的创建应用的方式
mvn archetype:generate -DarchetypeCatalog=internal(如果不好用加上这个参数)
1、选择原型,即创建应用的类型,普通的java应用或者web应用;
2、设置应用的基本信息;
- groupId:公司或者组织的唯一标识,一般为官网域名倒序,
- artifactId:该应用在当前公司或者组织中的唯一标识,
- version:应用的版本号,
3、确认设置的应用信息;
4、创建应用完成。
3.2 应用目录
目录或文件 | 说明 |
---|---|
/src/main/java | 存放应用的源代码文件 |
/src/test/java | 存放应用的测试程序文件 |
/pom.xml | 该应用的描述信息,每个maven的工程中都会存在这个文件,也称为项目对象模型(POM) |
3.3 编译项目
# 编译源代码,生成jar包文件,并且保存到本地仓库中
cd 项目目录
mvn compile
此时项目的目录结构:
其中新增了 /target
目录,该目录下存放的就是在构建过程中生成的相关文件。
3.4 简单的项目对象模型
<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.psjj</groupId>
<!-- 项目名字 -->
<artifactId>helloworld</artifactId>
<!-- 项目版本 -->
<version>1.0-SNAPSHOT</version>
<!-- 项目类型 jar代表javaSE工程 war代表java web工程 pom代表maven父工程 -->
<packaging>jar</packaging>
<!-- 项目的描述信息 -->
<name>helloworld</name>
<url>http://maven.apache.org</url>
<!--属性该属性的意思是项目是utf-8编码 -->
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<!-- 测试jar 的坐标 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
四、核心概念
4.1 插件与目标
4.1.1 插件与目标的定义
在前面执行创建应用的指令是
mvn archetype:generate
🔰其中,archetype就是一个插件标识,generate是插件中的一个目标标识。一个插件可以看作是一组目标的集合,每个目标代表着执行的某一个具体操作。它们的作用就是帮助开发者完成构建应用。
通常通过 mvn 插件:help 命令查看每个插件的目标组成。
4.1.2 常见插件
常用插件如下:
插件 | 描述 |
---|---|
clean | 构建之后清理目标文件。删除目标目录。 |
compiler | 编译 Java 源文件。 |
surefire | 运行 JUnit 单元测试。创建测试报告。 |
jar | 从当前工程中构建 JAR 文件。 |
war | 从当前工程中构建 WAR 文件。 |
javadoc | 为工程生成 Javadoc。 |
总结:
🔰mvn compile 编译
🔰mvn clean 清理编译文件
🔰mvn test 测试
🔰这些叫命令 输入这些命令就会调用插件并执行;但是插件的执行分n步,每步叫目标 ,查询目标 mvn 插件:help
注意: 命令名和插件名未必相同。
4.2 生命周期
🔰Maven 中有三种标准的生命周期:
- clean:应用中目标目录中文件的清理周期
- default:应用从源代码构建成可执行的构件的周期
- site:项目站点文档创建的周期
🔰三个生命周期是相互独立,并且每个周期中包含很多的阶段,每个阶段的现实都是由插件完成的。
4.2.1 clean
- 包含的阶段
- pre-clean:执行一些需要在clean之前完成的工作
- clean:移除所有上一次构建生成的文件
- post-clean:执行一些需要在clean之后立刻完成的工作
- 触发的指令
mvn clean
4.2.2 default
- 简介
🔰这是 Maven 的主要生命周期,被用于构建应用,包括下面的 23 个阶段:
生命周期阶段 | 描述 |
---|---|
validate(校验) | 校验项目是否正确并且所有必要的信息可以完成项目的构建过程。 |
initialize(初始化) | 初始化构建状态,比如设置属性值。 |
generate-sources(生成源代码) | 生成包含在编译阶段中的任何源代码。 |
process-sources(处理源代码) | 处理源代码,比如说,过滤任意值。 |
generate-resources(生成资源文件) | 生成将会包含在项目包中的资源文件。 |
process-resources (处理资源文件) | 复制和处理资源到目标目录,为打包阶段最好准备。 |
compile(编译) | 编译项目的源代码。 |
process-classes(处理类文件) | 处理编译生成的文件,比如说对Java class文件做字节码改善优化。 |
generate-test-sources(生成测试源代码) | 生成包含在编译阶段中的任何测试源代码。 |
process-test-sources(处理测试源代码) | 处理测试源代码,比如说,过滤任意值。 |
generate-test-resources(生成测试资源文件) | 为测试创建资源文件。 |
process-test-resources(处理测试资源文件) | 复制和处理测试资源到目标目录。 |
test-compile(编译测试源码) | 编译测试源代码到测试目标目录. |
process-test-classes(处理测试类文件) | 处理测试源码编译生成的文件。 |
test(测试) | 使用合适的单元测试框架运行测试(Juint是其中之一)。 |
prepare-package(准备打包) | 在实际打包之前,执行任何的必要的操作为打包做准备。 |
package(打包) | 将编译后的代码打包成可分发格式的文件,比如JAR、WAR或者EAR文件。 |
pre-integration-test(集成测试前) | 在执行集成测试前进行必要的动作。比如说,搭建需要的环境。 |
integration-test(集成测试) | 处理和部署项目到可以运行集成测试环境中。 |
post-integration-test(集成测试后) | 在执行集成测试完成后进行必要的动作。比如说,清理集成测试环境。 |
verify (验证) | 运行任意的检查来验证项目包有效且达到质量标准。 |
install(安装) | 安装项目包到本地仓库,这样项目包可以用作其他本地项目的依赖。 |
deploy(部署) | 将最终的项目包复制到远程仓库中与其他开发者和项目共享。 |
🔰当一个阶段通过 Maven 命令调用时,例如 mvn compile,只有该阶段之前以及包括该阶段在内的所有阶段会被执行。
- 触发的指令
# 编程程序
mvn compile
# 执行应用中的测试程序,会先执行编译的生命周期
mvn test
# 执行打包的生命周期,会先执行编译、测试生命周期
mvn package
# 执行安装的生命周期,会依次执行编译、测试、打包的生命周期
mvn install
🔰 多个生命周期可以组合使用
mvn clean package
, 此时会先进行目标目录文件的清理,然后再执行default中的相关周期阶段。
4.2.3 site
-
简介:Maven Site 插件一般用来创建新的报告文档、部署站点等。
- pre-site:执行一些需要在生成站点文档之前完成的工作
- site:生成项目的站点文档
- post-site: 执行一些需要在生成站点文档之后完成的工作,并且为部署做准备
- site-deploy:将生成的站点文档部署到特定的服务器上
-
触发的指令
mvn site
需要如下配置信息
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-site-plugin</artifactId>
<version>3.7</version>
<dependencies>
<dependency>
<groupId>org.apache.maven.doxia</groupId>
<artifactId>doxia-site-renderer</artifactId>
<version>1.8</version>
</dependency>
</dependencies>
</plugin>
</plugins>
</build>
<reporting>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-javadoc-plugin</artifactId>
<version>2.10.4</version>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-project-info-reports-plugin</artifactId>
<version>2.9</version>
</plugin>
</plugins>
</reporting>
五、 idea集成maven软件
【1】打开idea全局配置
【2】打开maven工具配置
【3】配置mavenhome、settings.xml、localrepository
🔰 注意:虽然在全局配置中配置了maven的目录和仓库位置,但是在新建项目的时候可能又变回默认配置,建议每次创建项目前检查maven环境。
六、 构建web工程
6.1 创建maven工程
【1】创建maven工程,不选择任何骨架
【2】配置maven坐标
【3】pom文件配置
🔰 idea软件创建maven工程需要手动指定工程的打包方式,
- javaSE工程打成jar
- javaWEB工程打成war
- 父工程打成pom
<?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.psjj</groupId>
<artifactId>javaweb_day03_mvn</artifactId>
<version>1.0-SNAPSHOT</version>
<!--packaging默认是jar 是javaSE工程不用配置,war代表web工程,pom代表父工程-->
<packaging>war</packaging>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
</project>
【4】补充web.xml目录。操作如下:
然后,web项目就建立好了,目录结构如图所示:
其中css、js、page是根据需求自己手动创建的
6.2 添加依赖
为了说明一些问题,provided 这行我们先不引用
<!--添加坐标-->
<dependencies>
<!--servlet-api-->
<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
</dependency>
<!--jsp-api-->
<!-- https://mvnrepository.com/artifact/javax.servlet/jsp-api -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jsp-api</artifactId>
<version>2.0</version>
</dependency>
</dependencies>
🔰 依赖坐标从mavn仓库官https://mvnrepository.com/网获取
6.3 编写Servlet的代码
6.4 运行工程
6.4.1 外部tomcat运行
🔰 设置idea集成tomcat的默认设置。
🔰 将项目添加到服务器中
- war模式:将WEB工程以包的形式上传到服务器 ;war模式这种可以称之为是发布模式,看名字也知道,这是先打成war包,再发布;
- war exploded模式:将WEB工程以当前文件夹的位置关系上传到服务器; war exploded模式是直接把文件夹、jsp页面 、classes等等移到Tomcat 部署文件夹里面,进行加载部署。因此这种方式支持热部署,一般在开发的时候也是用这种方式。
🔰 最后,点击按钮启动服务器
6.4.2 tomcat插件运行
【1】加入插件
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<version>2.2</version>
<configuration>
<!--设置工程名-->
<path>/mvn</path>
<!--设置端口号-->
<port>81</port>
<!--设置编码 解决get请求乱码问题-->
<uriEncoding>utf-8</uriEncoding>
</configuration>
</plugin>
【2】启动并访问
【3】测试
【4】解决办法如下
🔰 测试访问成功,这是因为默认情况下依赖在编译、测试、运行阶段都有效。而tomcat插件包含这些jar包,所以运行阶段不需要引入依赖,否则引起冲突。而设置依赖范围为provided,依赖只在编译、测试阶段有效
七、项目对象模型
🔰 项目对象模型(Project Object Model)是用来描述项目、依赖、构件信息的xml文件,即项目工程中pom.xml文件。其作用是告诉maven项目是如何从源代码文件构建成可执行文件。
7.1 项目的主体信息
7.1.1 项目主体示例:
<?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>
<!--组id 一般指的是公司域名反写-->
<groupId>top.psjj</groupId>
<!--工程名字-->
<artifactId>maven-web</artifactId>
<!--项目版本SNAPSHOT 快照版本 开发板 -->
<version>1.0-SNAPSHOT</version>
<!--打包方式javaSE工程打jar web工程打成war 父工程打成pom-->
<packaging>war</packaging>
<!--总的集合配置
1.内置配置例如jdk
2.自定义配置 例如 下面的servlet和jsp的api版本控制 ,可以在依赖里面通过${key}获得值
-->
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
<servlet.api.version>3.1.0</servlet.api.version>
<jsp.api.version>2.0</jsp.api.version>
</properties>
<!--添加坐标
1.跟标签是dependencies
-->
<dependencies>
<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<!--依赖-->
<dependency>
<!--依赖的公司-->
<groupId>javax.servlet</groupId>
<!--依赖的名字-->
<artifactId>javax.servlet-api</artifactId>
<!--依赖的版本-->
<version>${servlet.api.version}</version>
<!--依赖的控制范围-->
<scope>provided</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.servlet/jsp-api -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jsp-api</artifactId>
<version>${jsp.api.version}</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>
<!--设置工程名-->
<path>/mvn</path>
<!--设置端口号-->
<port>81</port>
<!--设置编码 解决get请求乱码问题-->
<uriEncoding>utf-8</uriEncoding>
</configuration>
</plugin>
</plugins>
</build>
</project>
7.1.2 项目主体解释
🔰 top.psjj 项目组id,一般设置为公司的域名到写
🔰 maven-web 工程的名字
🔰 1.0-SNAPSHOT** 项目的版本号;常见的版本号中会包含两种字符:
- SNAPSHOT:表示当前版本为快照版,也可理解为开发版,其中的代码存在不稳定性
- RELEASE:正式发布的版本,其中的代码是具备稳定性的。
🔰 例如Spring框架的依赖坐标:
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.15.RELEASE</version>
</dependency>
🔰 jar 打包方式;一共有三种打包方式:jar、war、pom。
- jar 默认打成jar 。javaSE工程需要设置jar
- war web工程设置war
- pom 聚合工程的父工程需要设置pom
🔰 maven example 项目的描述名字
🔰 这是Maven入门使用案例 项目的详细描述
🔰 <junit.version>4.12</junit.version>** pom变量:
🔰 在pom文件中可以通过
<properties></properties>
自定义变量,在pom文件中其他位置可以使用${变量名}
的方式引用
<properties>
<junit.version>4.12</junit.version>
</properties>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
7.2 项目的依赖
7.2.1 依赖jar包的演示:
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
7.2.2 依赖的信息介绍
- javax.servlet 依赖的组id
- javax.servlet-api 依赖的名字
- 3.1.0 依赖的版本
- provided 依赖的范围
7.2.3 依赖范围
- 依赖范围是指向项目添加的依赖Jar在什么时期(编译期、运行期、测试期)是有效,可选值有:
依赖范围 | 说明 |
---|---|
compile | 默认的依赖范围,在编译、测试、运行三种classpath都是有效的 |
runtime | 运行时的依赖范围,对测试和运行的classpath有效 |
test | 只对测试的classpath有效 |
system | 依赖范围与compile完全一致,区别在于需要使用systempath绑定本地的系统磁盘路径 |
provided | 对编译和测试的classpath是有效的,在运行时无效;例如servlet-api,在tomcat中是存在,只需要用来进行编译或测试,那么就需要设置为provided |
- 依赖范围对比
依赖范围 | compile | test | provided | runtime |
---|---|---|---|---|
编译期 | ✅ | ❌ | ✅ | ❌ |
测试期 | ✅ | ✅ | ✅ | ✅ |
运行期 | ✅ | ❌ | ❌ | ✅ |
- 总结
- 普通jar 用 compile
- 测试jar 用 test
- servlet-api jsp-api provided
- mysql驱动包 等驱动程序 runtime
7.2.4 依赖的传递
1.简介
- 如果项目A依赖于项目B,而项目B依赖于项目C,这是就可以称为项目C是项目A的传递性依赖。
例如:在之前的web工程中添加了junit的依赖,而间接的向工程添加了其他的依赖
2.传递性依赖原则
- 当项目中出现多个相同名,不同版本号的传递性依赖时,maven采用的原则有两个:
- 依赖路径短者优先
例如:一个项目依赖于A和B, A依赖于C,C依赖于D(1.0),而B依赖于D(1.1),此时的依赖路径为:
|–> A --> C --> D(1.0)
|–>B --> D (1.1)
显然D(1.1)的依赖路径较短,故系统中引入D(1.1)- 依赖路径长度相同,先声明者优先
例如:一个项目依赖于A和B,A依赖于C(1.0),B依赖于C(1.1),测试依赖路径为
| --> A --> C(1.0)
| --> B --> C(1.1)
此时的依赖路径长度相同,故在pom文件中先声明哪一个依赖,会优先引入其传递的依赖
7.2.5 依赖冲突
解决依赖冲突的思想就是:排除掉不需要的传递性依赖。
<dependency>
<groupId>com.psjj</groupId>
<artifactId>project_A</artifactId>
<version>1.0-SNAPSHOT</version>
<exclusions>
<exclusion>
<groupId>com.psjj</groupId>
<artifactId>project_C</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>com.hckj</groupId>
<artifactId>project_B</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
7.3 构建插件
jdk编译插件构建如下:
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.6.0</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
简化
<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>
tomcat7服务器插件构建如下:
<!--2.tomcat7插件-->
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<version>2.2</version>
<configuration>
<!--访问的跟路径 默认是工程名-->
<path>/</path>
<!--端口号-->
<port>80</port>
<!--get请求的编码问题-->
<uriEncoding>UTF-8</uriEncoding>
</configuration>
</plugin>
八、模块化开发
8.1 继承与聚合
8.1.1 继承
🔰 在实际的开发中可能会创建很多关联的项目工程,每个工程中都会设置自己的依赖信息,而这些依赖信息可能存在着大量重复,而且版本号可能不一样,这对后期的系统维护会造成很大的影响,为了解决这种问题,我们可以创建一个顶级的项目,在其中设置好依赖的信息,其他项目工程都采用这个顶级项目的工程中的依赖信息。这就是Maven中提供的继承机制。
8.1.2 聚合
🔰 一个项目可能会拆分成持久层工程、业务层工程、表现层工程,那么在最终开发完成进行部署时就需要把这三类工程全部打包,而挨个的进行打包显然非常麻烦,Maven提供了聚合的机制,可以在顶级项目中设置关联的持久层工程、业务层工程、表现层工程,在顶级项目中执行打包的命令就可以把关联的工程也进行打包。
8.2 创建模块化工程
8.2.1 创建父工程
- 创建夫工程,并指定父工程描述信息
- 工程创建完毕后,我们需要手动补充信息指定是pom工程
- 接下来配置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>top.psjj</groupId>
<artifactId>javaweb-day03-register</artifactId>
<version>1.0-SNAPSHOT</version>
<!--代表是父工程-->
<packaging>pom</packaging>
<properties>
<mysql.version>8.0.26</mysql.version>
<druid.version>1.2.8</druid.version>
<dbutils.version>1.7</dbutils.version>
<servlet.api.version>3.1.0</servlet.api.version>
<jsp.api.version>2.0</jsp.api.version>
</properties>
<!--管理依赖版本,而不引入依赖-->
<dependencyManagement>
<dependencies>
<!-- mysql驱动包 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
<scope>runtime</scope>
</dependency>
<!-- druid连接池 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>${druid.version}</version>
</dependency>
<!-- dbutils框架 jdbc开发包 -->
<dependency>
<groupId>commons-dbutils</groupId>
<artifactId>commons-dbutils</artifactId>
<version>${dbutils.version}</version>
</dependency>
<!--servlet-api-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>${servlet.api.version}</version>
</dependency>
<!--jsp-api-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jsp-api</artifactId>
<version>${jsp.api.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
</project>
8.2.2创建PO模块
- 创建PO工程模块,PO工程是父工程的子模块。创建过程如下:
- 跳过骨架
- 设置子模块和父工程信息,然后点击完成。
- 最后创建完工程后,查看一下pom.xml文件
8.2.3 创建utils工具模块
-
创建utils模块和po模块步骤一样,省略;参照上面。
-
查阅一下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">
<parent>
<artifactId>javaweb-day03-register</artifactId>
<groupId>top.psjj</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>register-utils</artifactId>
<dependencies>
<!-- mysql驱动包 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<!-- druid连接池 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
</dependency>
</dependencies>
</project>
8.2.3 创建dao模块
-
创建dao模块和utils模块步骤一样,省略;参照上面。
-
查看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">
<parent>
<artifactId>javaweb-day03-register</artifactId>
<groupId>top.psjj</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>register-dao</artifactId>
<dependencies>
<dependency>
<groupId>top.psjj</groupId>
<artifactId>register-po</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<!--引入register-util模块-->
<dependency>
<groupId>top.psjj</groupId>
<artifactId>register-utils</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<!-- dbutils框架 jdbc开发包 -->
<dependency>
<groupId>commons-dbutils</groupId>
<artifactId>commons-dbutils</artifactId>
</dependency>
</dependencies>
</project>
8.2.4 创建业务层工程
-
步骤一样,参照上面
-
设置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">
<parent>
<artifactId>javaweb-day03-register</artifactId>
<groupId>top.psjj</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>register-service</artifactId>
<dependencies>
<dependency>
<groupId>top.psjj</groupId>
<artifactId>register-dao</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
</dependencies>
</project>
8.2.5 创建表现层工程
- 步骤一样,参照上面
- 注意:需要手动指定war工程
-
补充web.xml 文件
-
设置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">
<parent>
<artifactId>javaweb-day03-register</artifactId>
<groupId>top.psjj</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>register-web</artifactId>
<packaging>war</packaging>
<dependencies>
<!-- 引入service -->
<dependency>
<groupId>top.psjj</groupId>
<artifactId>register-service</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<!--servlet-api-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<scope>provided</scope>
</dependency>
<!--jsp-api-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jsp-api</artifactId>
<scope>provided</scope>
</dependency>
</dependencies>
<build>
<plugins>
<!--2.tomcat7插件-->
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<version>2.2</version>
<configuration>
<!--访问的跟路径 默认是工程名-->
<path>/register</path>
<!--端口号-->
<port>80</port>
<!--get请求的编码问题-->
<uriEncoding>UTF-8</uriEncoding>
</configuration>
</plugin>
</plugins>
</build>
</project>
- 引入静态资源
8.2.6 聚合测试
8.3 完善工程业务代码
8.3.1 po工程代码
package top.psjj.po;
/**
* 编写javaBean
*/
public class User {
private Integer id;
private String username;
private String password;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
8.3.2 utils工程代码
package top.psjj.utils;
/**
* 数据源工具类
*/
public class DataSourceUtils {
private static DataSource dataSource;
private static Properties properties = new Properties();
static{
try {
//加载配置信息
properties.load(DataSourceUtils.class.getClassLoader().getResourceAsStream("db.properties"));
//获得注册驱动
String driverClass = properties.getProperty("mysql.driverClass");
//获得url
String url = properties.getProperty("mysql.url");
//获得用户名
String username = properties.getProperty("mysql.username");
//获得密码
String password= properties.getProperty("mysql.password");
//创建连接池,并设置信息
DruidDataSource druidDataSource = new DruidDataSource();
druidDataSource.setDriverClassName(driverClass);
druidDataSource.setUrl(url);
druidDataSource.setUsername(username);
druidDataSource.setPassword(password);
//赋值给属性
dataSource = druidDataSource;
} catch (Exception e) {
e.printStackTrace();
}
}
public static DataSource getDataSource() {
return dataSource;
}
public static void main(String[] args) throws Exception {
System.out.println(DataSourceUtils.getDataSource().getConnection());
}
}
8.3.3 dao工程代码
【1】导入sql
use maven_db;
create table t_user(
id int not null auto_increment primary key comment '主键',
username varchar(255) not null unique comment '用户名',
password varchar(255) not null comment '密码'
) comment '用户表';
【2】编写dao
package top.psjj.dao;
/**
* 用户dao接口
*/
public interface UserDao {
//根据用户名查询用户
public User queryUser(String username);
//添加用户
public void addUser(User user);
}
package top.psjj.dao.impl;
/**
* 用户dao
*/
public class UserDaoImpl implements UserDao {
private QueryRunner queryRunner = new QueryRunner(DataSourceUtils.getDataSource());
@Override
public User queryUser(String username) {
User user = null;
try {
String sql = "select * from t_user where username=?";
user = queryRunner.query(sql, new BeanHandler<User>(User.class), username);
} catch (SQLException e) {
e.printStackTrace();
}
return user;
}
@Override
public void addUser(User user) {
try {
queryRunner.update("insert into t_user(username,password) values(?,?)",
user.getUsername(),user.getPassword());
} catch (SQLException e) {
e.printStackTrace();
}
}
}
8.3.4 service工程代码
package top.psjj.service;
/**
* 用户业务
*/
public interface UserService {
public boolean register(User user);
}
package top.psjj.service.impl;
/**
* 用户业务
*/
public class UserServiceImpl implements UserService {
private UserDao userDao = new UserDaoImpl();
@Override
public boolean register(User user) {
//如果用户名不存在注册成功,否则注册失败
String username = user.getUsername();
User queryUser = userDao.queryUser(username);
if(queryUser!=null){
return false;
}
userDao.addUser(user);
return true;
}
}
8.3.5 web工程代码
【1】检查页面
【2】编写web层代码
/**
* 用户servlet
*/
@WebServlet("/register.do")
public class UserServlet extends HttpServlet {
private UserService userService = new UserServiceImpl();
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//1.设置编码
req.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
//2.获得请求数据
String username = req.getParameter("username");
String password = req.getParameter("password");
User user = new User();
user.setUsername(username);
user.setPassword(password);
//3.进行注册
boolean tag = userService.register(user);
//4.判断进行处理,目前简单判断打印一句话即可
if(tag){
resp.getWriter().println("<h1>注册成功</h1>");
} else {
resp.getWriter().println("<h1>注册失败</h1>");
}
}
}
8.4 运行测试
8.4.1 父工程聚合子模块并安装
在创建工程的过程中Maven会自动添加聚合模块
8.4.2 启动tomcat服务器
在web工程中启动服务器
访问网址:
结果如下:
九、总结
- maven的概念
- 准备环境
- 安装
- 配置环境变量
- 配置本地库
- 配置阿里云库
- 配置统一jdk8
- idea集合mavn
- 创建mavenweb工程
- 依赖范围、依赖传递、依赖冲突
- 模块化开发