Maven

码字小萌新♡

已于 2023-03-23 21:30:47 修改

阅读量276

点赞数

分类专栏： java 文章标签： maven

于 2022-12-21 23:26:43 首次发布

本文链接：https://blog.csdn.net/qq_51712954/article/details/128402015

版权

java 专栏收录该内容

4 篇文章 1 订阅

订阅专栏

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

包含的阶段
1. pre-clean：执行一些需要在clean之前完成的工作
2. clean：移除所有上一次构建生成的文件
3. 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 插件一般用来创建新的报告文档、部署站点等。
1. pre-site：执行一些需要在生成站点文档之前完成的工作
2. site：生成项目的站点文档
3. post-site：执行一些需要在生成站点文档之后完成的工作，并且为部署做准备
4. 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的概念
准备环境
1. 安装
2. 配置环境变量
3. 配置本地库
4. 配置阿里云库
5. 配置统一jdk8
idea集合mavn
创建mavenweb工程
依赖范围、依赖传递、依赖冲突
模块化开发

码字小萌新♡

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Maven

🔰学习目标一、maven 介绍1.1 关于jar管理存在的一些问题下载地址： http://maven.apache.org【1】在环境变量中配置，为maven的安装目录【2】修改环境变量中，添加【1】中央仓库【2】本地仓库【3】远程仓库配置全局的远程仓库（AliMaven）2.5.2 仓库之间的关系三、入门使用3.1 创建Maven工程此时项目的目录结构：其中新增了目录，该目录下存放的就是在构建过程中生成的相关文件。四、核心概念4.1 插件与目标4.1.1 插件与
复制链接

扫一扫