Maven

最新推荐文章于 2023-05-11 22:46:36 发布

AloneDrifters

最新推荐文章于 2023-05-11 22:46:36 发布

阅读量384

点赞数 1

分类专栏：工具文章标签： maven

本文链接：https://blog.csdn.net/qq_53609683/article/details/119869861

版权

工具专栏收录该内容

7 篇文章 0 订阅

订阅专栏

文章目录

一、 Maven引入

[1] 传统方式中项目jar包资源的问题

传统方式中项目jar包资源的问题：
问题一：
项目中的jar包资源需要我们自己从网上下载后，手动
导入到项目中使用，一旦jar包资源过多，容易造成遗漏并且不好管理。
问题二:
假如我们有两个项目，项目A和项目B，如果项目A中需要使用项目B 中的某些资源，需要我们自己手动的将项目B中的资源导出为jar包，然后手动导入到A项目中，比较麻烦。
解决:
管理项目中的第三方的jar包资源，可以通过maven来导入我们自己项目开发需要的jar包资源，同时还可以通过maven将自己的项目中的资源导出为jar包对外提供服务。

[2] Maven的介绍和作用

Maven的本质
其实就是一款管理软件。
作用
(1) 通过maven来导入第三方的jar包资源到项目中
(2) 通过maven将自己项目导出为jar包资源对外提供服务

[3] Maven的基本原理图

在这里插入图片描述

[4] Maven的专业术语:

本地仓库:maven软件在本地电脑中存储第三方法资源的位置
云仓库:maven在本地仓库中没有对应的资源后会自动的去云仓库中下载，云仓库就是所有的程序员开发好的jar包资源的在线存储仓库(百度云)
资源坐标:maven查找需要的资源的定位地址，类似URL。
资源坐标必须是唯一的。

二、 Maven的项目类型

[1] 项目的概念

在刚开始学习java时，我们直接手动创建单个的java文件，并在该文件中声明对应的功能代码，自己使用java和javac命令完成文件的编译和运行，当时感觉特别的神奇，尤其是在控制台中显示出”hello world”时，简直是惊为天人，美滋滋。但是随着我们的深入学习，我们发现一个功能的实现不仅仅需要一个java文件，可能是很多java文件的联动操作。但是这个时候如果我们还是自己手动单个创建java文件，会造成java文件不好管理。于是，我们将处理同一个功能的java 文件放在一起，称之为一个java项目。而为了让我们不同的程序员之间沟通方便，
我们规定java项目中的目录结构体系是大家都能够认识的，于是就诞生了JAVASE 项目的结构体系。并且又为了提升开发效率，IDE工具可以直接帮助我们创建一个
JAVASE项目，我们只需要声明项目代码即可，不需要手动创建项目的目录结构。

[2] 传统项目类型

JAVASE项目：
用来开发java项目的目录结构体系，项目的结构体系是给
我们的JDK工具来看的。
JAVAEE项目:
是一个web项目，该项目的运行不仅仅需要JDK的支持还需要服务器容器的支持。该项目的结构体系给服务器来查看的。

[3] Maven项目类型

问题:

我们希望使用maven工具将我们自己的项目打包，打包后将资源存储到
maven的本地仓库中给其他人使用，这样就意为着，maven需要能够识别我们创建的项目结构体系，这样才能进行资源的打包。但是maven是
第三方的工具，maven本身是无法识别我们目前通过IDE工具创建的 JAVASE和JAVAEE的项目体系的，怎么办？

解决:

我们创建的项目需要是Maven能够识别的项目，我们需要通过maven 来创建项目不就可以了。

实现:

1、POM类型:pom类型的项目只做资源管理，不做功能开发。在继承关系中父项目创建为 pom 类型比较合理。
2、WAR类型:相当于JAVAEE项目
3、JAR类型：想当于JAVASE项目

三、Maven项目类型和JAVASE项目和JAVAEE项目的关系

问题:
既然我们现在创建项目是通过maven工具来进行创建的，但是项目开发完成后
运行项目的不是maven。比如web项目，以前我们直接使用IDE工具创建一个
tomcat服务器能够直接识别的web项目结构，完成功能开发，等开发完成后，我们可以直接将项目放到tomcat服务器中运行，但是使用maven创建的项目结构和原有的web项目结构完全不同，那么我们开发完成后项目怎么放到tomcat中运行呢?
解决:
maven是个项目资源管理工具，只做资源的管理，不参与项目的运行的。那么是不是在项目开发阶段使用maven管理的时候是maven能够识别的结构体系，在运行阶段是jdk或者tomcat能够识别的结构体系
实现:
因为项目运行的是编译后的内容，不是源码文件。这样虽然maven项目源码的结构体系和JAVASE，JAVAEE的都不同，但是它们编译后的项目结构体系就是相同的不就可以了。

四、 Maven的安装和配置

在本地安装并配置maven
① 将maven的压缩包解压到指定的文件夹中

② maven的目录介绍
在这里插入图片描述

③ 配置maven的本地仓库地址
在conf文件夹下编辑setting.xml文件在第54行声明本地仓库地址
在这里插入图片描述

④ 配置maven的云仓库地址
在conf文件夹下编辑setting.xml文件在第159行声明云仓库地址

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

在这里插入图片描述

⑤ 配置maven的jdk版本
因为maven project是由maven地址调用JDK来完成编译，需要配置jdk 的版本，maven会自动的从网上下载对用的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>

在idea中集成maven

五、 Maven project的创建和使用

[1] Maven的jar类型的项目

1. 创建jar类型的项目

① 点击file–>new–>moudle–>maven,然后点击下一步即可

② 填写当前创建的maven项目的资源坐标，便于其他项目来调用我们的项目资源。

③ 设置项目在本地中的存储路径，一般就是在当前的工作空间中

④ 点击finish完成创建，然后在右下角的提示中点击import Changes
在这里插入图片描述

2. jar类型项目的结构和特点

① jar类型项目的结构
在这里插入图片描述

② jar类型项目的特点
i. jar类型的项目，相当于我们以前的JAVASE项目。
ii. jar项目编译后的项目结构体系和原有的JAVASE项目编译后的结构体系相同
在这里插入图片描述

iii. 默认在test目录下的测试代码是不会编译到项目中的。

[2] Maven的war类型项目

1. maven的war类型项目的创建

① 点击file–>new–>moudle–>maven，然后选择项目的模版
在这里插入图片描述

② 声明当前项目自己的资源坐标，方便其他项目调用

③ 直接点击下一步

④ 声明项目在本地的存储路径，一般是工作空间

⑤ 点击finish，完成创建，在窗口中点击import changes

2. war类型项目的结构配置

① 在war项目下的src下的main目录下手动创建java和resources目录。
java目录作为java源码存方法目录
resources目录作为配置文件目录

② 将创建的java目录设置为源码目录
在这里插入图片描述

③ 将resources目录设置为配置文件存储目录
在这里插入图片描述

3. war类型项目结构的作用

在这里插入图片描述

4. war类项目项目的特点

	i. 相当于我们以前的JAVAEE项目，完成web项目的开发。
	ii. 项目编译后的结构体系和原有的JAVAEE项目编译后的结构体系是相同的，

也就说我们maven的war类型项目编译后的资源也可以直接在tomcat中使用

六、 Maven项目中pom配置文件的使用

1、pom文件的作用

在maven项目中，通过maven来获取和管理第三方的资源。每个maven 项目默认是有一个pom文件的。该文件是用来告诉maven当前项目中需要
使用的资源的，该文件会被maven自动加载识别。我们需要在pom配置文件中声明需要使用的资源的坐标即可。

注意：

当pom文件被修改的时候，maven会自动的重新加载pom文件，并
根据文件的最新内容加载最新的资源。

2、pom文件的配置内容

modelverson：声明模块的版本
当前项目的资源坐标:给maven查看，并便于maven查找到该项目给其他项目使用
配置第三方的资源坐标：让maven根据坐标从本地仓库中引入第三方的资源到项目中使用，如果本地仓库中没有，则会自动从云仓库中下载

注意:
我们可以在https://mvnrepository.com/下来搜索需要的资源坐标，然后当我们将资源坐标变更后，需要点击import changes让maven重新加载pom文件，根据最新的资源坐标获取资源到项目中
注意2:
maven将资源引入到项目中后，在idea的项目视图中是看不到第三方资源的，需要点击idea右侧栏上的maven，进入maven的资源管理视图中，查看当前项目中引入的第三方的资源。

properties自定义资源版本号管理
一个第三方资源会有很多的版本，比如mybatis，spring等
如果我们需要引入的第三方资源过多，当我们对某一个资源的版本号
进行修改时，不好修改。可以使用properties标签将资源的版本号单独的声明在外部，便于我们的修改。

引入第三方的插件资源

3、jar类型和war类型配置示例

① jar类型的配置示例

<?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.bjsxt</groupId>
    <artifactId>01_maven_jar</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--自定义资源版本号管理-->
    <properties>
        <junit.version>4.13</junit.version><!--版本号的标签名可以自定义声明，但是建议格式为 资源.version-->
        <mysql.jdbc.version>5.1.31</mysql.jdbc.version>
    </properties>
    <!--引入第三方资源-->
    <dependencies>
        <!--一个dependency子标签表示一个要引入的资源，内容为要引入的资源的坐标-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <!--jdbc的资源坐标-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.jdbc.version}</version>
        </dependency>
    </dependencies>

</project>

② war类型的配置示例
问题：

在以前的JAVAEE项目中，IDE工具会自动的将JDK以及tomcat的资源依赖到项目中，我们在web-inf下的lib文件夹下声明的是自定义的第三方资源，而maven中的war类型项目中默认是没有给我们引入任何第三方资源的，造成我们在war类型项目中无法直接创建jsp和声明Servlet完成最基本的web开发。

解决:

在war类型的项目的pom文件中配置最基础的web开发相关的第三方的资源坐标:
servlet的资源坐标
jsp的资源坐标
jstl的资源坐标

配置示例:

<?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.bjsxt</groupId>
  <artifactId>02_maven_war</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>
<!--配置版本号-->
  <properties>
    <servlet-version>3.1.0</servlet-version>
    <jsp-version>2.2</jsp-version>
    <jstl-version>1.2</jstl-version>
  </properties>
<!--配置资源坐标-->
  <dependencies>
    <!--servlet的资源坐标-->
      <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>${servlet-version}</version>
        <scope>provided</scope>
      </dependency>
    <!--jsp的资源坐标-->
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>${jsp-version}</version>
      <scope>provided</scope>
    </dependency>
    <!--jstl的资源坐标-->
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>${jstl-version}</version>
    </dependency>
  </dependencies>
</project>

七、Maven的war类型项目的本地启动运行

问题:

以前我们使用idea工具直接创建javaEE项目，而idea在帮我们创建javaEE项目的时候就已经指定了项目运行所需要的tomcat，我们直接启动tomcat访问项目即可。但是使用maven创建的war类型的项目，在创建的时候并没有指明项目运行所需要的tomcat，那么maven的war类型项目，在功能开发完成后如何启动运行呢?

解决:

maven的项目中涉及到的资源需要maven来进行管理。war类型的项目在开发完成后，需要告诉maven去调用一个tomcat来运行我们当前的war项目，而maven的资源都是从本地仓库中加载或者从云仓库中下载，那么能不能我们自己在war类型项目中告诉maven去下载一个tomcat，来运行我们的war项目呢？
答案是可以的。

实现:
① 在war类型项目的pom文件中配置tomcat插件的资源坐标，并配置 tomcat的端口号以及项目的访问路径

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.tomcat.maven</groupId>
      <artifactId>tomcat7-maven-plugin</artifactId>
      <version>2.2</version>
      <configuration>
        <port>6060</port><!--配置tomcat启动的端口号-->
        <path>/my</path><!--配置项目的访问名称-->
      </configuration>
    </plugin>
  </plugins>
</build>

② 通过maven启动当前war项目的tomcat容器，运行项目
在这里插入图片描述

八、使用maven完成SSM项目示例

创建war类型的项目
配置war类型项目的基础配置
① 配置java源码目录
② 配置Resources配置文件目录
③ 在pom.xml文件中配置基础的web资源
④ 在pom.xml文件中配置tomcat插件
搭建SSM开发环境
① 在pom.xml文件中声明SSM的资源坐标
② 在resources下创建并配置SSM的配置文件
applicationcontext.xml
springmvc.xml
db.properties
log4j.properties
③ 配置web.xml文件
④ 在java目录下声明MVC的包结构
完成SSM项目代码的编写
① 在java目录下声明java代码
② 在webapp下声明页面资源以及静态资源

九、 Maven项目java目录下的配置文件不会被编译到项目中

问题:

maven的项目，是由maven来进行编译的。maven会将项目编译为以前的javaSE和javaEE的结构来运行。但是maven在编译项目的时候，不会将java目录下的配置文件编译到项目中，也就是maven默认认为java目录下只有java代码，没有其他文件。这样造成在SSM项目中，mapper包中除了java代码以外，还有mapper.xml文件，maven是不会将mapper.xml
文件被编译到项目中的，造成项目运行失败，怎么办呢?

解决:

我们需要告诉maven在编译项目中java代码时，在java目录下除了java代码，还有配置文件，需要将配置文件也编译到
项目中使用。我们需要在项目的pom.xml文件中配置相关标签即可

实现:

在项目的pom.xml文件的build标签下使用resources子标签来告诉maven需要将源码中的xml文件也进行编译:

<build>
  <plugins>
    <plugin>
       <groupId>org.apache.tomcat.maven</groupId>
       <artifactId>tomcat7-maven-plugin</artifactId>
       <version>2.2</version>
       <configuration>
          <port>7070</port><!--配置tomcat启动的端口号-->
          <path>/ty</path><!--配置项目的访问名称-->
       </configuration>
    </plugin>
  </plugins>
  <!--告诉maven将项目源码中的xml文件也进行编译，并放到编译目录中-->
  <resources>
    <resource>
      <directory>src/main/java</directory>
      <includes>
        <include>**/*.xml</include>
      </includes>
      <filtering>true</filtering>
    </resource>
    <resource>
      <directory>src/main/resources</directory>
      <filtering>true</filtering>
    </resource>
  </resources>
</build>

十、使用maven打包自己的项目到本地仓库中

问题:

假如我们使用maven在本地同时开发两个项目，分别为项目A和项目B，项目A已经开发完成了。而我们想在项目B中使用项目A的功能，怎么办?

解决:

项目B是由Maven进行管理的，项目B中的资源需要通过Maven来获取，而Maven会从本地仓库中加载对应的资源给项目Ｂ使用。而本地仓库中是没有项目A的资源。那么能不能让maven讲项目A打包并上传到其自己的本地仓库中一份儿，这样其他的项目就可以通过项目A的资源坐标来获取项目A的资源来使用了。答案是可以的。

实现:

注意:
jar类型的项目打成jar包放到maven的本地仓库中
war类型的项目打成war包放到maven的本地仓库中

十一、 Maven项目之间的关系

问题:

目前我们可以使用Maven来创建项目，并且使用Maven来
管理项目中的第三方的资源，同时当我们将项目的功能开发完成后，将自己的项目通过maven打包到本地仓库中，提供给
其他项目使用，但是在该流程中存在以下的问题:

问题一：
项目A中根据开发需求，将代码根据功能进行了分层，例如使用MVC的分层思想，将项目A的代码分为了service层pojo层，mapper层等。那么在项目B中需要使用项目A已经开发好的功能，我们目前会使用Maven将整个项目A的资源全部打包放到本地仓库中，但是项目B需要使用的是项目A 中的部分功能不是所有的功能，按照目前这种方式会造成项目 B中引入的是项目A的整个资源，造成项目B在资源加载时效率过低，浪费资源。
总结:打包项目整个项目打成一个包，造成资源使用不方便。
问题二：
我们使用Maven创建了三个项目，并且这三个项目，都在使用SSM的功能，那么我们就需要在三个项目的pom.xml 文件都要引入SSM的资源坐标。后期如果我们需要升级SSM的资源的版本号或者需要在三个项目中都引入其他的资源时，我们需要同时修改三个pom文件，麻烦！
总结:不同的maven项目会使用到相同的资源，造成资源修改麻烦。

解决:

① 问题一的解决：打包项目的方式过于死板，打的是整个包。
因为我们目前开发一个项目，会将项目所有的功能放在一个项目全部声明。
而maven打包的基础单位是一个maven项目，也就说一个maven的project
会被打成一个包。根据maven的打包规则，以及我们自己的项目功能对外提供的需求。我们需要在开发项目时，由以前在一个maven project中声明项目的所有功能代码，变为在N个maven project中来完成项目功能的开发，每个maven project中声明一部分功能代码，但是当我们使用maven去运行
我们的项目时，maven会将N个project中的代码合并为一个项目。也就说
在物理视图项目，一个项目的功能代码被拆分到N个项目中完成，在逻辑上
这N个项目是一个项目。这样我们在使用Maven去打包项目的时候，maven 会将项目的N个project分别打包，最后打成N个包，其他人就可以根据自己的需求来获取指定的资源使用了。
② 问题二的解决:不同的项目之间使用相同的资源坐标，不好管理。
我们将不同的项目中需要使用的相同的资源进行抽取，抽取为一个公共的配置
然后让其他的项目呢都引用该功能配置即可。

实现:

① 依赖关系
② 继承关系
③ 聚合关系

十二、 Maven项目之间的依赖关系

依赖关系的介绍
项目A中会使用项目B中的资源，我们会将项目B的包导入到项目A中使用
那么项目A和项目B之间就是依赖关系。项目A依赖项目B。
Maven项目依赖关系的使用
① 创建项目A完成功能开发
② 在项目A的pom文件中配置项目B或者其他第三方资源的资源坐标
③ 在项目A中正常调用项目B的资源即可。
注意：
在开发阶段，并且在同一个工作空间，不同的maven项目之间可以通过资源
坐标直接调用其资源，无需将其打包放到本地仓库中。但是在项目运行期间，必须根据依赖关系的顺序依次打包，才能正常运行。比如A–>B—>C—>D
打包的顺序为先打包D再打包C再打包B再打包A。最简单的记忆方法，就是
不管是开发阶段还是运行阶段只要项目A依赖的其他项目都需要进行打包，其他项目每修改依次就重新打包一次。

十三、 Maven项目之间的继承关系

1. 继承关系的介绍

继承关系指的是两个事物之间的逻辑联系，比如在现实生活中的父子之间存在继承关系，具备继承关系的两个事物之间具备以下特点:
子拥有父的所有资源。子可以直接调用父的所有资源。
注意：
java基本语法中的继承是继承理论的一种应用。

2. maven项目中使用继承关系管理资源

项目A继承项目B，那么项目A就直接拥有项目B中的资源。资源指的是项目B
通过pom文件获取的资源，不是项目B中的功能代码资源。也就说maven项目
之间的继承是pom资源之间的继承，不是项目功能代码的继承。

3. maven项目中的继承关系的代码实现案例

① 创建两个maven项目，项目parent和项目child
在这里插入图片描述

② 建立两个项目之间的继承关系
在子项目中的pom.xml文件中使用parent标签，并声明父项目的资源坐标即可。
在这里插入图片描述

③ 观察在父项目中配置资源，在子项目中是否会自动加载相关资源
在这里插入图片描述

4.继承关系中的父项目的作用以及改造

① pom项目类型的介绍

pom类型的项目只做资源管理，不做功能开发。在继承关系中父项目创建为pom类型比较合理。

② pom类型项目的创建

先创建一个jar类型的项目，然后将目录结构删除，只保留pom文件
然后在pom文件中使用packaging标签修改项目的类型为pom类型

5.注意

(1) maven项目的继承关系中的父项目要创建为pom类型
(2) 继承关系中的maven项目是相互独立的，本质就是两个项目
比如项目A继承了项目B，项目A和项目B的功能还是各自的功能，是独立只不过在项目A中可以拥有项目B的第三方资源。项目B的所有子项目之间也是相互独立的。

十四、 Maven项目的聚合关系

1. 聚合关系介绍

依赖关系是A调用B中的功能资源，将B打包放入A中使用。
继承关系是A可以拥有B中的声明的资源。
我们希望maven在将我们的项目进行打包上传本地仓库时，将项目根据功能
拆分成不同的包上传，可以让其他人根据需求使用。但是maven打包是按照
项目为基本单位打包的，那么也就说我们需要将一个本来在一个maven项目中
声明的代码，拆分为N个项目声明，并且在运行的时候还会合并成一个项目。
这N个项目之间的关系我们就成为聚合关系。

2. maven项目中使用聚合关系的流程

① 创建一个pom项目:
记录子项目之间的逻辑关系。
统一管理项目的资源，每个子项目的pom文件的依赖的并集。
让子项目都继承该pom项目。
② 根据MVC的代码结构，将项目拆分，拆分为四个子项目
pojo项目
mapper项目
service项目
web项目
③ 配置子项目之间的依赖关系
web–>service–>mapper—>pojo
总结：
我们在使用了聚合关系将项目拆分为N个子项目后，为了便于N个子项目
的资源的统一，N个子项目继承同一个父项目。又因为N个子项目开发的是
同一个功能，子项目之间又存在相互的调用，使用依赖关系来实现子项目之间
的相互调用。

3. 使用聚合关系拆分SSM项目代码示例

① 创建一个pom类型的项目。

② 选中聚合的父项目右键，创建子moudle。分别创建四个子项目
pojo子项目jar类型
mapper子项目jar类型
service子项目jar类型
web子项目war类型

③ 在聚合关系中的父项目中的pom文件中配置功能的资源依赖。
问题:
在pom文件中配置SSM的依赖，这样四个子项目中自然也就
具有了所有的SSM资源。根据maven项目的继承关系，每个
子项目中都拥有完整的SSM的资源，但是其实每个子项目中
只需要拥有其自己使用的资源即可，也就说我们需要自定义子
项目从项目中继承自己需要的资源，而不是使用默认方式继承所有的资源
解决:
在父项目的pom文件中使用dependencyManagement标签，被此标签管理的资源，不会直接被子项目继承，需要在子项目单独的声明从父项目中继承的资源，在子项目只需要声明资源的groupId和artifactid,不需要声明版本号，由父项目统一管理资源的版本号。

<?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.bjsxt</groupId>
    <artifactId>08_maven_jh_parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>jh_pojo</module>
        <module>jh_mapper</module>
        <module>jh_service</module>
        <module>jh_web</module>
    </modules>
    <packaging>pom</packaging>
    <!--配置依赖资源-->
    <!--配置版本号-->
    <properties>
        <servlet-version>3.1.0</servlet-version>
        <jsp-version>2.2</jsp-version>
        <jstl-version>1.2</jstl-version>
        <spring-version>5.1.11.RELEASE</spring-version>
        <aspectjweaver-version>1.9.4</aspectjweaver-version>
        <mybatis-version>3.5.2</mybatis-version>
        <mybatis-spring-version>2.0.2</mybatis-spring-version>
        <log4j-version>1.2.17</log4j-version>
        <mysql-connector-java-version>5.1.48</mysql-connector-java-version>
        <jackson-version>2.9.9</jackson-version>
        <commons-fileupload-version>1.3.1</commons-fileupload-version>
    </properties>
    <!--配置资源坐标-->
    <dependencyManagement>
    <!--配置资源坐标-->
    <dependencies>
        <!--servlet的资源坐标-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>${servlet-version}</version>
            <scope>provided</scope>
        </dependency>
        <!--jsp的资源坐标-->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>${jsp-version}</version>
            <scope>provided</scope>
        </dependency>
        <!--jstl的资源坐标-->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>${jstl-version}</version>
        </dependency>
        <!-- spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring-version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring-version}</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>${aspectjweaver-version}</version>
        </dependency>
        <!-- mybatis -->
        <!-- mybatis和spring整合 -->
        <!-- log4j 日志 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j-version}</version>
        </dependency>
        <!-- mysql 驱动类 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql-connector-java-version}</version>
        </dependency>
        <!-- jackson -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${jackson-version}</version>
        </dependency>
        <!-- apache 图片上传 -->
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>${commons-fileupload-version}</version>
        </dependency>
        <!--配置mybatisplus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus</artifactId>
            <version>3.3.1</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.6</version>
        </dependency>
        <!--配置aliyun的sdk-->
        <dependency>
            <groupId>com.aliyun</groupId>
            <artifactId>aliyun-java-sdk-core</artifactId>
            <version>4.0.6</version> <!-- 注：如提示报错，先升级基础包版，无法解决可联系技术支持 -->
        </dependency>
        <dependency>
            <groupId>com.aliyun</groupId>
            <artifactId>aliyun-java-sdk-dysmsapi</artifactId>
            <version>1.1.0</version>
        </dependency>
    </dependencies>
    </dependencyManagement>
</project>

④ 在子项目的pom文件中自定义配置从父项目中继承的资源
注意：一定在子项目中删除资源的版本号。
pojo子项目需要继承的资源:

<?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>08_maven_jh_parent</artifactId>
        <groupId>com.bjsxt</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>jh_pojo</artifactId>
    <!--继承的资源-->
    <dependencies>
        <!--配置mybatisPlus的依赖-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus</artifactId>
        </dependency>
        <!--配置lombok的依赖-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--配置jdbc的依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

    </dependencies>

</project>

mapper子项目中的依赖配置:

<?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>08_maven_jh_parent</artifactId>
        <groupId>com.bjsxt</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>jh_mapper</artifactId>
    <dependencies>
     <!--配置pojo的依赖-->
        <dependency>
            <groupId>com.bjsxt</groupId>
            <artifactId>jh_pojo</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
</project>

配置service子项目的依赖:
配置web子项目的依赖:
⑤ 配置SSM的配置文件
注意：SSM的相关配置全部声明在Web子项目中
在这里插入图片描述

⑥ 在子项目中完成功能代码的编写
pojo子项目中:实体类代码
mapper子项目中:数据库操作代码
service子项目中:业务层代码
web子项目：控制器代码和页面资源
在这里插入图片描述

⑦ 运行拆分后的SSM项目
注意：
在同一个工作空间中的maven项目可以根据依赖关系直接调用资源，
但是当war项目需要放到服务器中运行的时候，需要根据依赖关系将
依赖的资源使用maven逐个打包上传到本地仓库中。因为war项目
依赖的其他项目需要以jar包的形式导入到war项目中。
i.选择maven管理界面，在界面中选择SSM聚合项目的父项目，然后点击clean和install命令
在这里插入图片描述

ii. 在maven的管理视图中，选择web子项目，点击tomcat：run命令完成项目的运行
在这里插入图片描述

十五、将maven使用聚合关系拆分后的SSM项目部署到linux中运行

1.手动部署

① 使用maven将拆分后的SSM项目整体打包到本地仓库中
② 在idea中找到SSM拆分后的war类型的web项目将其target文件夹
下的war包上传到Linux中的tomcat中，然后启动Linux中的tomcat

③ 在本地的浏览器中访问Linux中的web项目
注意:访问项目的虚拟项目的名字为linux下tomcat的war包解压后的文件夹的名字

2. 热部署

① 问题：
我们目前可以使用手动部署的方式将开发好的项目的war包上传到linux中
运行。但是在实际开发环境中，我们会对项目进行频繁的修改。每次修改后我们
都需要重新将项目打包，然后将新的war包重新手动上传到linux中，太麻烦了。
② 解决:
由我们自己将修改后的项目的war包上传到linux中，变为由maven帮我们实现
也就说当我们的项目发生资源变更时，我们会在本地使用maven对项目资源进行
重新打包，打包后，我们再次使用maven将项目新的war上传到linux中的 tomcat。
③ 实现:
我们已经学过了web开发中的上传功能，那么我们是不是可以开发一个web项目
该web项目提供一个资源上传的功能，比如该项目的名字为:A项目。然后我们将 A项目部署到linux中的tomcat中，启动tomcat,然后我们在本地的浏览器中访问A项目，然后选择我们的war包，将上传请求发送给A项目，而A项目再接受
到上传请求后，将war包存储到linux下的tomcat中的webapps目录下，美滋滋。那么，再细细的思考一下，那么能不能让Maven去访问我们的项目A的上传
功能，将项目的war包上传到linux下的tomcat中呢？答案是可以的，说白了就是让我们的maven具备发送HTTP请求的功能。那么其实项目A是tomcat自带的一个web项目，不需要我们自己开发了。
④ Tomcat中的Root项目的配置和使用

启动tomcat服务器
访问tomcat服务器的首页(广告页，项目A)
tomcat自带的ROOT项目，是tomcat自带的一个web项目。
我们可以通过浏览器访问，然后在浏览器中管理tomcat中的项目资源。

3. 点击tomcat首页的manager app

当我们点击manager APP时，会先提示我们进行登录，在登录页面中输入
账号和密码即可进入到项目资源管理页面。我们点击取消，进入登录用户
配置提示页面，在该页面中，tomcat提示我们需要在tomcat-user.xml
文件中去配置我们的账户信息。
在这里插入图片描述

4. 在tomcat-user.xml中配置账户信息

打开XFTP工具，找到usr/local/tomcat7/conf下的tomcat-user.xml文件
然后选中右键，用记事本编辑，完成账户信息的配置。修改完成后，重新启动tomcat服务器。
在这里插入图片描述

<role rolename="manager-gui"/>
<role rolename="manager-script "/>
<role rolename="manager-jmx"/>
<role rolename="manager-status"/>
 <user username="admin" password="admin" roles="manager-gui,manager-script,manager-jmx,manager-status"/>

5. 登录ROOT项目，使用manager APP功能管理tomcat中的项目资源

⑤ maven远程上传war项目的配置和使用

在war项目中的pom文件中配置项目远程部署的参数信息

<!--配置插件-->
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
        <configuration>
          <!-- 域名也可以 -->
          <url>http://192.168.40.128:8080/manager/text</url>
          <server>TomcatServer</server>
          <username>admin</username>
          <password>admin</password>
          <path>/ty</path>
          <update>true</update>
        </configuration>
      </plugin>
    </plugins>
  </build>

启动远程部署
在本地的浏览器中访问linux下的tomcat中的项目即可
注意:
在使用maven远程部署项目时，一定要确保linux下的tomcat是开启的。
tomcat:run命令是本地运行项目。

十六、总结

maven的使用
管理项目中的资源，使用maven创建项目完成功能开发。
2.maven的jar类型项目的使用流程
① 创建maven项目，类型为jar
② 在java目录下声明源码完成功能开发
③ 在pom.xml文件中配置需要使用的第三方资源
3.maven的war类型项目的使用流程
① 创建maven项目，类型为war
② 完善war项目的目录结构，创建java和resources目录
③ 在pom.xml文件中配置web开发的依赖资源
servlet的依赖，jsp的依赖，jstl的依赖,tomcat的插件
④ 在java目录下声明代码完成功能开发
⑤ 在web目录下声明页面资源
4.maven使用聚合关系拆分SSM使用流程
① 创建一个pom类型的项目，管理拆分后的项目所有的资源
② 选中pom项目右键连续创建四个子moudle
pojo:jar类型
mapper:jar类型
service:jar类型
web:war类型
③ 配置父项目中的pom文件，配置SSM开发相关的资源
④ 配置pojo子项目中的pom文件
⑤ 配置mapper子项目中的pom文件(依赖pojo)
⑥ 配置service子项目的pom文件(依赖mapoper)
⑦ 配置web子项目的pom文件以及目录结构(依赖service)。
⑧ 在web子项目中的resources目录下配置SSM的配置文件
⑨ 完成功能开发
⑩ 在父项目中对整个项目资源进行clean和install，然后再war项目中
使用指令完成项目的运行或者远程部署

AloneDrifters

关注

1
点赞
踩
0

收藏

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

主要内容1. Maven简介2. Maven工具关于导jar的实现原理3. Maven总体配置4. Maven项目结构5. POM模型6. Maven中项目类型7. 创建war类型Maven项目8. scope属性可取值9. Maven项目名规范10.SSM项目拆分演示11. 热部署一、 Maven引入[1] 传统方式中项目jar包资源的问题传统方式中项目jar包资源的问题：问题一：项目中的jar包资源需要我们自己从网上下载后，手动导入到项目中使用，一旦jar包资源过
复制链接

扫一扫