项目管理——Maven的应用与实战

最新推荐文章于 2024-05-11 19:13:11 发布

脑袋不灵光的小白羊

最新推荐文章于 2024-05-11 19:13:11 发布

阅读量1.8k

点赞数

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

本文链接：https://blog.csdn.net/qq_42588990/article/details/119333503

版权

Java 专栏收录该内容

113 篇文章 8 订阅

订阅专栏

练习过程中使用的源码：https://gitee.com/cutelili/maven

一、Maven简介

1什么是Maven

目前无论使用IDEA还是Eclipse等其他IDE，使用里面的ANT工具。ANT 工具帮助我们进行编译，打包运行等工作。

Apache 基于 ANT 进行了升级，研发出了全新的自动化构建工具 Maven。（知道： ANT 有的功能 MAVEN 都有，只是使用起来更加方便了）。

Maven 工具基于 POM（Project Object Model，项目对象模型）模式实现的。在 Maven 中每个项目都相当于是一个对象，对象（项目）和对象（项目）之间是有关系的。关系包含了：依赖、继承、聚合，实现 Maven 项目可以更加方便的实现导 jar 包、拆分项目等效果。

Maven 是跨平台的，这意味着无论是在 Windows 上，还是在 Linux 或者 Mac 上，都可以使用同样的命令。

Maven 还有一个优点，它能帮助我们标准化构建过程。在 Maven 之前，十个项目可能有十种构建方式。有了 Maven 之后，所有项目的构建命令都是标准化。

Maven 还为全世界的 Java 开发者提供了一个免费的中央仓库，在其中几乎可以找到任何的流行开源类库。

2 Maven 的作用

1）Maven 统一集中管理好所有的依赖包，不需要程序员再去寻找。对应第三方组件用到的共同 jar，Maven 自动解决重复和冲突问题。

2）Maven 作为一个开放的架构，提供了公共接口，方便同第三方插件集成。程序员可以将自己需要的插件，动态地集成到 Maven，从而扩展新的管理功能。

3）Maven 可以统一每个项目的构建过程，实现不同项目的兼容性管理。

二、 Maven 的下载与 IDE 的整合

3 Maven 下载

http://maven.apache.org/download.cgi

4 Idea 整合 Maven

在 Idea 中默认已经整合了 Maven。由于 Idea 的版本不同，所整合的 Maven 的版本也不同。

如果需要更换其他版本可在 Idea 中进行配置。
在这里插入图片描述

三、 Maven 仓库与配置

1 Maven 仓库是什么

1.1 Maven 仓库

Maven 仓库是基于简单文件系统存储的，集中化管理 Java API 资源（构件）的一个服务。仓库中的任何一个构件都有其唯一的坐标，根据这个坐标可以定义其在仓库中的唯一存储路径，这要得益于 Maven 的坐标机制，任何 Maven 项目使用任何一个构件的方式都是完全相同的，Maven 可以在某个位置统一存储所有的 Maven 项目共享的构件，这个统一的位置就是仓库，项目构建完毕后生成的构件也可以安装或者部署到仓库中，供其它项目使用。

坐标：坐标有三个部分构成，如果一个部分不同那么表示的就是不同的 jar。

Group Id: 公司名，多用公司网址倒写
Artifact Id: 项目名
Version: 版本

对于 Maven 来说，仓库分为两类：本地仓库和中央仓库。

1.1.1 中央仓库

中央仓库是互联网上的服务器,是 Maven 提供的最大的仓库，里面拥有最全的 jar 包资源。默认是 Maven 自己的网络服务器，但是由于访问速度较慢，我们一般都配置成国内的镜像中央仓库如阿里镜像或者是华为镜像。

Maven 中央仓库访问页面：https://mvnrepository.com/
在这里插入图片描述

1.1.2 本地仓库

本地仓库指用户电脑中的文件夹,该文件夹中包含了自己下载的构件(jar 包)。文件夹结构为 groupid 分级的文件夹/artifactid 文件夹/version 文件夹/包含 jar 包。
在这里插入图片描述

2 仓库的访问优先级

2.1 本地仓库

第一访问本地仓库。

2.2 远程仓库

2.2.1镜像仓库

镜像仓库是 Maven 开发过程中的首选远程仓库，在本地仓库无法获取资源的时候，直接访问镜像仓库。

2.2.2 中央仓库

中央仓库是 Maven 官方提供的远程仓库，在本地仓库无法获取资源的时候，直接访问中央仓库。
在这里插入图片描述

3 配置 Maven

3.1 在 settings.xml 文件中配置本地仓库

本地仓库是开发者本地电脑中的一个目录，用于存储从远程仓库下载的构件(jar 包)。默认的本地仓库是${user.home}/.m2/repository。用户可使用 settings.xml 文件修改本地仓库。

具体内容如下：

<localRepository>C:\Users\Administrator\.m2\repository</localRepository>

在这里插入图片描述

3.2 在 settings.xml 文件中配置镜像仓库

如果仓库 A 可以提供仓库 B 存储的所有内容，那么就可以认为 A 是 B 的一个镜像。例如：在国内直接连接中央仓库下载依赖，由于一些特殊原因下载速度非常慢。这时，我们可以使用阿里云提供的镜像 http://maven.aliyun.com/nexus/content/groups/public/来替换中央仓库http://repol.maven.org/maven2/。修改 maven 的 setting.xml 文件，具体内容如下：

<mirror>
	<!-- 指定镜像 ID --> 
	<id>nexus-aliyun</id> 
	<!-- 匹配中央仓库。--> 
	<mirrorOf>central</mirrorOf> 
	<!-- 指定镜像名称 --> 
	<name>Nexus aliyun</name> 
	<!-- 指定镜像路径 --> <url>http://maven.aliyun.com/nexus/content/groups/public</url> 
</mirror>

在这里插入图片描述

3.3 配置 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>

在这里插入图片描述

四、 Maven 工程类型

1 POM 工程

POM 工程是逻辑工程。用在聚合工程中，或者父级工程用来做 jar 包的版本控制。

2 JAR 工程

创建一个 Java Project，在打包时会将项目打成 jar 包。

3 WAR 工程

创建一个 Web Project，在打包时会将项目打成 war 包。

五、在 Idea 中创建 Maven 工程

在这里插入图片描述

六、 Maven 项目结构

src 包含了项目所有的源代码和资源文件以及测试代码。
src/main/java 这个目录下储存 java 源代码
src/main/resources 储存主要的资源文件。比如 spring 的 xml 配置文件和 log4j 的properties 文件。
src/test/java 存放测试代码，比如基于 JUNIT 的测试代码一般就放在这个目录下面 target 编译后内容放置的文件夹

pom.xml 是 Maven 的基础配置文件，也是 Maven 项目核心配置文件，用于配置项项目的基本信息，项目的继承关系，项目类型，依赖管理，依赖注入，插件管理，插件注入等等

--mavenDemo 项目名 
--.idea 项目的配置，自动生成的，不需要关注。 
--src 
-- main 实际开发内容 
   --java 写包和 java 代码，此文件默认只编译.java 文件 
   --resource 所有配置文件。最终编译把配置文件放入到 classpath 中。
-- test 
   --java 测试时使用，自己写测试类或 junit 工具等
pom.xml 整个 maven 项目所有配置内容。

七、 POM 模型

1 依赖关系

Maven 一个核心的特性就是依赖管理。当我们处理多模块的项目（包含成百上千个模块或者子项目），模块间的依赖关系就变得非常复杂，管理也变得很困难。针对此种情形， Maven 提供了一种高度控制的方法。

通俗理解：依赖谁就是将谁的 jar 包添加到本项目中。可以依赖中央仓库的 jar，也可以依赖当前开发中其他项目打包后的 jar 包。

在 pom.xml 文件根元素 project 下的 dependencies 标签中，配置依赖信息，可以包含多个 dependence 元素，以声明多个依赖。每个依赖 dependence 标签都应该包含以下元素：groupId, artifactId, version : 依赖的基本坐标，对于任何一个依赖来说，基本坐标是最重要的， Maven 根据坐标才能找到需要的依赖。

<dependencies> 
	<dependency> 
		<groupId>org.springframework</groupId> 
		<artifactId>spring-context</artifactId> 
		<version>5.2.4.RELEASE</version> 
	</dependency> 
</dependencies>

1.1 依赖的传递性

依赖传递性是 Maven2.0 的新特性。假设你的项目依赖于一个 jar 包，而这个 jar 包又依赖于其他 jar 包。你不必自己去找出所有这些依赖，你只需要加上你直接依赖的 jar 包的坐标，Maven 会隐式的把这些 jar 包间接依赖的库也加入到你的项目中。这个特性是靠解析从远程仓库中获取的依赖 jar 包的项目文件实现的。这些项目的所有依赖都会加入到项目中这就是依赖传递性。

如果 A 依赖了 B，那么 C 依赖 A 时会自动把 A 和 B 都导入进来。

创建 A 项目后，选择 IDEA 最右侧 Maven 面板 lifecycle，双击 install 后就会把项目安装到本地仓库中，其他项目就可以通过坐标引用此项目。
在这里插入图片描述

1.2 依赖相同资源的依赖原则

1.2.1 第一原则：最短路径优先原则

“最短路径优先”意味着项目依赖关系树中路径最短的版本会被使用。例如，假设 A、 B、C 之间的依赖关系是 A->B->C->D(2.0)和 A->E->(D1.0)，那么 D(1.0)会被使用，因为 A 通过 E 到 D 的路径更短。

1.2.2 第二原则：最先声明原则

依赖调解第一原则不能解决所有问题，比如这样的依赖关系：A–>B–>Y(1.0)，A–>C –>Y(2.0)，Y(1.0)和 Y(2.0)的依赖路径长度是一样的，都为 2。那么到底谁会被解析使用呢？在 maven2.0.8 及之前的版本中，这是不确定的，但是 maven2.0.9 开始，为了尽可能避免构建的不确定性，maven 定义了依赖调解的第二原则：第一声明者优先。在依赖路径长度相等的前提下，在 POM 中依赖声明的顺序决定了谁会被解析使用。顺序最靠前的那个依赖优胜。

1.3 排除依赖

exclusions：用来排除传递性依赖其中可配置多个 exclusion 标签，每个 exclusion 标签里面对应的有 groupId, artifactId 两项基本元素。

注意：这里的排除对已经包含的依赖是无效的。比如，你的一个项目里有spring这个jar包，是你通过maven的pom文件下载的，完后你把这个项目通过maven打包成了jar包，这个时候就是包含关系了，所以无法排除。

<dependency> 
	<groupId>org.springframework</groupId> 
	<artifactId>spring-context</artifactId> 
	<version>5.2.4.RELEASE</version> 
	<exclusions> 
		<exclusion> 
			<groupId>org.springframework</groupId> 
			<artifactId>spring-aop</artifactId> 
		</exclusion> 
	</exclusions>
</dependency>

1.4 依赖范围

1.4.1 scope 属性可取值

1.4.1.1 compile

这是默认范围。如果没有指定，就会使用该依赖范围。表示该依赖在编译和运行时生效。在项目打包时会将该依赖包含进去。

1.4.1.2 provided

可以参与编译，测试，运行等周期，但是不会被打包到最终的 artifact 中。典型的例子是 servlet-api，编译和测试项目的时候需要该依赖，但在项目打包的时候，由于容器已经提供，就不需要 Maven 重复地引入一遍(如：servlet-api)

1.4.1.3 runtime

runtime 范围表明编译时不需要生效，而只在运行时生效。典型的例子是 JDBC 驱动实现，项目主代码的编译只需要 JDK 提供的 JDBC 接口，只有在执行测试或者运行项目的时候才需要实现上述接口的具体 JDBC 驱动。

1.4.1.4 system

如果有些你依赖的 jar 包没有 Maven 坐标的，它完全不在 Maven 体系中，这时候你可以把它下载到本地硬盘，然后通过 system 来引用。
不推荐使用 system，因为一个项目的 pom.xml 如果使用了 scope 为 system 的 depend 后，会导致传递依赖中断，即所有其他依赖本项目的项目都无法传递依赖了。

1.4.1.5 test

test 范围表明使用此依赖范围的依赖，只在编译测试代码和运行测试的时候需要，应用的正常运行不需要此类依赖。典型的例子就是 JUnit，它只有在编译测试代码及运行测试的时候才需要。

1.5 依赖管理

Maven 提供了一个机制来集中管理依赖信息，叫做依赖管理元素 <dependencyManagement>。假设你有许多项目继承自同一个公有的父项目，那可以把所有依赖信息放在一个公共的 POM 文件中并且在子 POM 中简单的引用该构件即可。

2 继承关系

2.1 什么是继承关系

Maven 中的继承跟 Java 中的继承概念一样，需要有父项目以及子项目。我们可以将项目中的依赖和插件配置提取出来在父项目中集中定义，从而更方便的管理项目的依赖以及插件。注意父项目类型一定为 POM 类型。

2.2 继承的优点

1）依赖或插件的统一管理（在 parent 中定义，需要变更 dependency 版本时，只需要修改一处）。

2）代码简洁（子 model 只需要指定 groupId，artifactId即可）。

3） dependencyManagement 是 “ 按需引入 ” ，即子 model不会继承parent中 dependencyManagement所有预定义的 dependency。

3 Maven 中的多继承

在 Maven 中对于继承采用的也是单一继承，也就是说一个子项目只能有一个父项目，但是有的时候我们项目可能需要从更多的项目中继承，那么我们可以在子项目中通过添加<dependencyManagement>标记来实现多继承。在子项目的<dependencyManagement>中每个<dependency>标记就一个父工程定义，同时还需要添加<type>标记，值为 pom。添加<scope>标记，值为 import。

 <dependencyManagement>
        <dependencies>
            <!--父项目 a-->
        <dependency>
            <groupId>com.bjsxt</groupId>
            <artifactId>parent_a</artifactId>
            <version>1.0-SNAPSHOT</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
            <!--父项目 b--> 
            <dependency> 
                <groupId>com.bjsxt</groupId> 
                <artifactId>parent_b</artifactId> 
                <version>1.0-SNAPSHOT</version> 
                <type>pom</type> 
                <scope>import</scope> 
            </dependency>
        </dependencies>
    </dependencyManagement>

4 聚合关系

Maven 的聚合特性可以帮助我们把多个项目基于多个模块聚合在一起，这样能够更加方便项目的管理。

前提：继承。

聚合包含了继承的特性。

聚合时多个项目的本质还是一个项目。这些项目被一个大的父项目包含。且这时父项目类型为 pom 类型。同时在父项目的 pom.xml 中出现表示包含的所有子模块。
即使在 idea 中，也可以使用聚合在一个窗口创建多个项目。

4.1 删除聚合模块步骤

右键模块–> remove module
在这里插入图片描述
右键项目 --> delete

在父项目中 pom.xml 中中删除模块名

八、 Maven 中的常见插件

1 Maven 内置插件

Maven 自身拥有很多内置插件，每一个内置插件都代表了 Maven 的一种行为。Maven 在管理项目整个生命周期时，在不同的阶段处理的过程都是使用插件来具体完成。如：构建项目时使用构建插件、编译项目时使用编译插件、清除构建使用清除构建的插件、测试项目时使用测试插件、打包时使用资源拷贝插件以及打包插件。

我们可以在不同阶段使用 Maven 中的不同命令来触发不同的插件来执行不同的工作。换言之，Maven 的插件是需要依赖命令来执行的。

Maven 在管理插件时也是通过坐标的概念和管理依赖的方式相同，通过坐标来定位唯一的一个插件。

在一般情况下，我们不需要额外配置 Maven 的内置插件，除非我们需要对插件做额外配置时才需要配置内置插件。如果我们重新配置了内置插件，那么则以我们配置的为主。

Maven 的插件配置需要在 pom.xml 文件中的<build>标签中使用<plugins>来配置。

现在在很多的 IDE 中都已经把 Maven 的常用命令通过界面中的按钮来体现，我们只要点击相应的按钮就等同于执行了相应的命令。

1.1 配置编译插件

1.1.1 在 setings.xml 中配置全局编译插件

<profile> 
	<!-- 定义的编译器插件 ID，全局唯一 --> 
	<id>jdk-1.8</id> 
	<!-- 插件标记，activeByDefault 默认编译器，jdk 提供编译器版本 --> 
	<activation> 
		<activeByDefault>true</activeByDefault>
		<jdk>1.8</jdk> 
	</activation> 
	<!-- 配置信息 source-源信息，target-字节码信息，compilerVersion-编译过程版 本 --> 
	<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>

1.1.2 在 pom.xml 文件中配置局部的编译插件

<build> 
	<plugins> 
		<plugin> 
			<groupId>org.apache.maven.plugins</groupId> 
			<artifactId>maven-compiler-plugin</artifactId> 
			<version>3.8.1</version> 
			<configuration> 
				<source>1.8</source> 
				<target>1.8</target> 
				<encoding>UTF-8</encoding> 
			</configuration> 
		</plugin> 
	</plugins> 
</build>

1.2 资源拷贝插件

Maven 在打包时默认只将 src/main/resources 里的配置文件拷贝到项目中并做打包处理，而非 resource 目录下的配置文件在打包时不会添加到项目中。我们在使用 MyBatis 时，如果接口与 Mapper 文件在同一个目录中，在默认的情况下 Maven 打包的时候，对于 src/main/java 目录只打包源代码，而不会打包其他文件。所以 Mapper 文件不会打包到最终的 jar 文件夹中，也不会输出到 target 文件夹中，此时运行代码操作数据库时会报异常。

解决方案：

1）将 Mapper 文件放入到 resources 目录中。

2）配置资源拷贝插件，指定其拷贝文件的位置。

<resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
            </resource>
 </resources>

2 扩展插件

2.1Tomcat 插件

Tomcat 插件是 Maven 的扩展插件，其作用是为基于 Maven 开发的 Web 项目提供一个内置的 Tomcat 支持，这样我们在开发阶段可以不在依赖外部的 Tomcat 来运行 Web 项目，该插件目前使用的 Tomcat 版本为 Tomcat7。该插件的作用很强大，除了提供了 Tomcat 以外，还可以通过该插件实现项目的远程热部署。

<!-- 配置 Tomcat 插件 -->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <!-- 配置Tomcat监听端口 -->
                    <port>8080</port>
                    <!-- 配置项目的访问路径(Application Context) -->
                    <path>/</path>
                </configuration>
            </plugin>

2.2 Mybatis Generator 插件

Mybatis Generator 插件可以根据数据库自动生成实体类、单表查询接口映射 xml 文件以及 POJO。

2.2.1 创建 Users 表

CREATE TABLE `users` ( 
`userid` int(11) NOT NULL, 
`username` varchar(20) DEFAULT NULL, 
`userage` int(11) DEFAULT NULL, 
PRIMARY KEY (`userid`) 
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

2.2.2 修改 POM 文件，添加插件

<!--配置Generator插件-->
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.5</version>
                <dependencies>
                    <dependency>
                        <groupId>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <version>5.1.38</version>
                    </dependency>
                </dependencies>
                <!--指定配置文件的路径-->
                <configuration>
                    <configurationFile>${project.basedir}/src/main/resources/generatorConfig.xml</configurationFile>
                    <verbose>true</verbose>
                    <overwrite>true</overwrite>
                </configuration>
            </plugin>

2.2.3 添加 generator 配置文件

在这里插入图片描述
导入generatorConfig配置文件后，会出现一个报错，这是因为我们第一次在IDEA中添加这个配置文件，默认情况下是没有generatorConfig的约束文件的，需要手动添加本地约束。

2.2.4 添加 generator 配置文件的 DTD 文件

在这里插入图片描述

2.2.5 运行 generator 插件生成代码

在这里插入图片描述

3 插件管理

在Maven中提供了和依赖管理相同的方式用于来管理插件，我们可以在父工程中声明插件，然后在具体的子项目中按需引入不同的插件。

3.1父工程 POM

<build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.tomcat.maven</groupId>
                    <artifactId>tomcat7-maven-plugin</artifactId>
                    <version>2.2</version>
                </plugin>
                <plugin>
                    <groupId>org.mybatis.generator</groupId>
                    <artifactId>mybatis-generator-maven-plugin</artifactId>
                    <version>1.3.5</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>

3.2 子工程 POM

<plugin> 
	<groupId>org.apache.tomcat.maven</groupId> 
	<artifactId>tomcat7-maven-plugin</artifactId> 
	<configuration> 
		<!-- 配置 Tomcat 监听端口 --> 
		<port>8080</port> 
		<!-- 配置项目的访问路径(Application Context) --> 
		<path>/</path> 
	</configuration> 
</plugin> 
<!--配置 Generator 插件--> 
<plugin> 
	<groupId>org.mybatis.generator</groupId> 
	<artifactId>mybatis-generator-maven-plugin</artifactId> 
	<dependencies> 
		<dependency> 
			<groupId>mysql</groupId> 
			<artifactId>mysql-connector-java</artifactId> 
			<version>5.1.38</version> 
		</dependency> 
	</dependencies> 
	<!--指定配置文件的路径-->
	<configuration> 
		<configurationFile>${project.basedir}/src/main/resources/generato rConfig.xml</configurationFile> 
		<verbose>true</verbose> 
		<overwrite>true</overwrite> 
	</configuration> 
</plugin>

九、 Maven 常用命令

1 clean

清除已编译信息。删除工程中的 target 目录。

2 validate

验证项目是否正确

3 compile

只编译。 javac 命令。

4 test

用于执行项目的测试。如果在 test 目录下含有测试代码，那么 Maven 在执行 install 命令会先去执行 test 命令将所有的 test 目录下的测试代码执行一遍，如果有测试代码执行失败，那么 install 命令将会终止。

5 package

打包。包含编译，打包两个功能。

6 verify

运行任何检查，验证包是否有效且达到质量标准。

7 install

本地安装，包含编译，打包，安装到本地仓库
编译 - javac
打包 - jar，将 java 代码打包为 jar 文件
安装到本地仓库 - 将打包的 jar 文件，保存到本地仓库目录中。

8 site

项目站点文档创建的处理，该命令需要配置插件。

9 deploy

远程部署命令。

十、 Maven 项目名规范

官网的命名规范说明 http://maven.apache.org/guides/mini/guide-naming-conventions.html

1 groupId

groupId 定义当前 Maven 项目隶属的实际项目。groupId 应该遵循 Java 的包名称规则使用反向域名。例如 com.bjsxt 。或者以反向域名开头加项目的名称。例如 com.bjsxt.example，此 id 前半部分 com.bjsxt 代表此项目隶属的组织或公司，example 部分代表项目的名称。

2 artifactId

artifactId 是构件 ID，该元素定义实际项目中的一个 Maven 项目或者是子模块的名称，如官方约定中所说，构建名称必须小写字母，没有其他的特殊字符，推荐使用“实际项目名称－模块名称”的方式定义，例如：spirng-mvn、spring-core 等。

3 version

可以选择带有数字和点（1.0、1.1、1.0.1，…）的任何典型版本。不要使用日期指定当前构件的版本。默认版本为 1.0-SNAPSHOT

十一、搭建 Maven 私服

1 什么是私服

私服是一种特殊的远程仓库，它是架设在局域网的仓库服务，私服代理广域网上的远程仓库，供局域网使用。在企业开发中，私服的建设是有必要的，其好处如下：

1.1节省资金、外网带宽

利用私服代理外部仓库之后，对外的重复构件下载便得以简化，降低外网带宽压力。

1.2 加速 Maven 构建

不停地连接请求外部仓库是相当耗时的，但是 maven 的一些内部机制（如快照更新检查）要求 Maven 在执行构建的时候不停地检查远程仓库数据。因此，当项目配置了很多外部远程仓库的时候，构建速度会降低。使用私服解决这问题，因为 Maven 只需要检查局域网内私服的数据时，构建速度便有明显提高。

1.3部署第三方构件

当某个构件无法从任何一个远程仓库获取怎么办？比如 Oracle 的 JDBC 驱动由于版权原因不能发布到公共仓库中。建立私服后，便可以将这些构件部署到这个内部仓库中，供内部 Maven 项目使用。

1.4提高稳定性，增强控制

对于远程仓库来说，当外网不可用时，Maven 构建有可能因为依赖没有下载而不可行，搭建并应用私服后，即使没有外网，如果该构件之前被其它人下载过就会存在私服上，此时再次依赖该构件就可以不用连接外网直接就可以从私服上下载到。同时私服软件（nexus) 还提供了额外的管理功能。

1.5降低中央仓库的负荷

中央仓库是有限的。如果所有的 Maven 工程开发过程中，都通过中央仓库实现构件的依赖和管理，那么中央仓库的负荷过高，也会严重影响工程构建的效率。如果使用私服，可以分散中央仓库的负荷，只有在私服中没有需要依赖的构件时才会去连接中央仓库。

2 使用 Nexus 搭建私服

2.1搭建环境

CentOS8、JDK1.8、Sonatype Nexus2.11.2

2.2搭建步骤

2.2.1 安装 JDK

http://www.oracle.com/technetwork/java/javase/downloads/index.html
我这里使用的版本为 JDK1.8。（jdk-8u221-linux-x64.tar.gz）

2.2.1.1 JDK 资源包解压

在Linux中安装应用的常用目录为：/opt或/usr/local目录。这里将JDK安装到/usr/local/jdk目录中。

2.2.1.2 环境变量配置

修改/etc/profile 配置文件，增加环境变量配置。

export JAVA_HOME=/usr/local/jdk 
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar 
export PATH=$JAVA_HOME/bin:$PATH

环境变量修改后，可以重启Linux实现永久生效；或执行source/etc/profile命令，让新修改的环境在当前终端中生效。

2.2.2安装 Nexus

2.2.2.1Nexus 资源包下载

Nexus 官方下载地址为： https://www.sonatype.com/nexus-repository-oss
本应用版本为：nexus-2.11.2-03

2.2.2.2 Nexus 资源包解压

在/usr/local 目录中创建子目录 nexus：
mkdir /usr/local/nexus
解压 Nexus 到指定目录：
tar -zxvf nexus-2.11.2-03-bundle.tar.gz -C /usr/local/nexus
Nexus 压缩包中包含两个子目录: nexus-2.11.2-03 和 sonatype-work
nexus-2.11.2-03 是具体的私服应用内容，
sonatype-work是 Nexus 私服下载的构件存放工作目录

2.2.2.3 检查私服端口和工作目录

在 nexus-2.11.2-03 目录中有子目录 conf，其中保存私服应用的配置信息。查看 nexus.properties 文件，确定私服访问端口和工作目录。此操作可不做任何内容修改。配置文件内容如下：

# Jetty section，Nexus 私服应用是使用 Jetty 提供 web 服务的，下述内容为 Jetty 配置。 
application-port=8081 
# 私服访问端口 
application-host=0.0.0.0 
nexus-webapp=${bundleBasedir}/nexus 
# Nexus 私服 WEB 应用所在位置 nexus-webapp-context-path=/nexus 
# Nexus 私服 WEB 应用 contextPath 
# Nexus section Nexus 私服配置信息 
nexus-work=${bundleBasedir}/../sonatype-work/nexus # 私服工作目录，即构件保存目 录
runtime=${bundleBasedir}/nexus/WEB-INF # 私服 WEB 应用运行目录

2.2.2.4 修改 Nexus 运行用户

Nexus 私服在启动后，私服应用需要访问 Linux 的文件系统，所以需要有足够的权限。
Nexus 的启动脚本文件中，可以指定私服应用的访问用户，此信息在 nexus-2.11.2-03/bin/nexus 脚本文件中定义。需要修改的信息如下：
在这里插入图片描述

在这里插入图片描述

# NOTE - This will set the user which is used to run the Wrapper as well as 
# the JVM and is not useful in situations where a privileged resource or 
# port needs to be allocated prior to the user being changed. 
#RUN_AS_USER= #原内容 
RUN_AS_USER=root #修改后的内容，代表 Nexus 私服使用 root 用户权限。

2.2.2.5 关闭防火墙

service firewalld stop

2.2.2.6 启动并测试访问

启动 Nexus 私服：
/usr/local/nexus/nexus-2.11.2-03/bin/nexus start
成功启动后，控制台输出内容如下：
在这里插入图片描述

可通过命令检查私服运行状态：
/usr/local/nexus/nexus-2.11.2-03/bin/nexus status
内容如下为私服运行中：
在这里插入图片描述

内容如下为私服未运行：
在这里插入图片描述
也可使用浏览器访问 Nexus 私服 WEB 应用，访问地址为：
http://ip:8081/nexus （ip 为 Nexus 所在系统的访问 IP）

2.2.3登录私服

Nexus 默认提供管理用户，用户名为 admin，密码为 admin123。
在这里插入图片描述

2.2.4仓库管理

在这里插入图片描述

2.2.4.2 仓库类型简述

在这里插入图片描述

3.2.2.1 group

仓库组：Nexus 通过仓库组来统一管理多个仓库，这样访问仓库组就相当于访问仓库组管理的多个仓库。

3.2.2.2 hosted

宿主仓库：主要用于发布内部项目构件或第三方的项目构件（如购买商业的构件）以及无法从公共仓库获取的构件（如 oracle 的 JDBC 驱动）。

3.2.2.2.1 releases

发布内部的 releases 模块的仓库，所有非快照版本工程都发布到此仓库中。

3.2.2.2.2 snapshots

发布内部的快照模块的仓库，所有工程版本以 SNAPSHOT 结尾的都发布到此仓库中。

3.2.2.2.3 3rd party

第三方依赖的仓库，这个数据通常是由内部人员自行下载之后发布上去

3.2.2.3 proxy

代理仓库：代理公共的远程仓库。

3.2.2.4 virtual

虚拟仓库：用于适配 Maven 1。

2.2.4.3 代理仓库配置

为 Nexus 配置阿里云代理仓库。
Nexus 默认远程仓库为 https://repo1.maven.org/maven2/
在这里插入图片描述
设置阿里云代理仓库 http://maven.aliyun.com/nexus/content/groups/public/

在这里插入图片描述
Repository ID: aliyun
Repository Name: Aliyun Repository
Remote Storage Location: http://maven.aliyun.com/nexus/content/groups/public/

把 aliyun 添加到仓库组中，并把 aliyun 排在 central 之上。

3 Nexus 用户管理

3.1Nexus 中的缺省用户及角色说明

在 Nexus 中内置了三个缺省用户，每个用户都拥有不同的角色，不同的角色对应不同的权限。在 Nexus 中用户必须要拥有角色。
在这里插入图片描述

3.1.1 admin 用户(管理员)

admin 管理员用户拥有最大权限，可以对 Nexus 进行全向控制。
在这里插入图片描述

3.1.2 deployment(部署用户)

deployment 用户为部署用户，该用户拥有对 nexus 的部分的操作，但是该用户具有对所有仓库的操作权限。
在这里插入图片描述

3.1.3 anonymous(匿名用户)

anonymous 用户为匿名用户，只具备了对 nexus 操作的部分权限，对于仓库也只是拥有读和查看权限。
在这里插入图片描述

3.2用户操作

3.2.1修改用户密码

在这里插入图片描述
点击 Change Password 修改用户密码。

输入当前密码以及新密码。

3.2.2新建用户

点击创建 Nexus Users 创建一个 Nexus 用户。
在这里插入图片描述
输入用户信息并给用户分配角色。

点击 Savea 按钮完成用户的创建。

在用户列表中可以查看到新创建用户。

3.2.3删除用户

选中需要删除的用户，点击删除按钮即可删除该用户。
在这里插入图片描述

4 私服应用

要在 Maven 工程中使用私服，需要提供私服配置信息。

4.1修改 settings.xml 配置文件

4.1.1在 servers 节点中添加仓库的用户认证

在<server>节点中配置仓库认证，操作仓库的用户以及密码，可以使用 deployment 用户，该用户为 Nexus 的缺省用户，也可以自己创建用户。
在这里插入图片描述

<server> 
	<id>releases</id> 
	<username>deployment</username> 
	<password>deployment123</password> 
</server> 
<server> 
	<id>snapshots</id> 
	<username>deployment</username> 
	<password>deployment123</password>
</server>

4.1.2在 profile 节点中添加配置信息

<profile> 
	<id>sxt</id> 
	<activation> 
		<activeByDeffault>false </activeByDeffault> 
		<jdk>1.8</jdk> 
	</activation> 
	<!-- 公共仓库配置 --> 
	<repositories> 
		<repository> 
		<!-- 仓库 id --> 
			<id>public</id> 
		<!-- 私服地址 --> 
			<url>http://192.168.233.129:8081/nexus/content/groups/public/</url> 
		<!-- 仓库是否支持 releases 版本 --> 
			<releases> 
				<enabled>true</enabled> 
			</releases> 
		<!-- 仓库是否支持 snapshost 版本 --> 
			<snapshost> 
				<enabled>true</enabled> 
			</snapshost> 
		</repository> 
	</repositories> 
	<!-- 插件仓库配置 --> 
	<pluginRepositories> 
			<pluginRepository> 
				<id>public</id> 
				<url>http://192.168.233.129:8081/nexus/content/groups/public/</url> 
			<!-- 插件仓库是否支持 releases 版本 --> 
				<releases> 
					<enabled>true</enabled> 
				</releases> 
			<!-- 插件仓库是否支持 snapshost 版本 --> 
				<snapshost> 
					<enabled>true</enabled> 
				</snapshost> 
			</pluginRepository> 
	</pluginRepositories> 
</profile>

4.1.3配置 activeProfiles 激活 profile

<activeProfiles> 
	<!--根据 profile 的 id 标签值激活指定的内容--> 
<activeProfile>sxt</activeProfile> 
</activeProfiles>

4.1.4删除阿里镜像仓库的配置

我们在私服中已经配置了对于连接阿里镜像的代理，所以在 setings.xml 中需要将该配置去掉，否则会自动去阿里镜像下载插件。

4.2在 POM 文件中配置私服

4.2.1创建项目

在这里插入图片描述

4.2.2 修改 POM 文件

4.2.2.1 添加上传构件的仓库地址

<distributionManagement>
        <repository>
            <!--需要与settings.xml中server的id相同-->
            <id>releases</id>
            <name>Nexus Release Repository</name>
            <url>http://192.168.233.129:8081/nexus/content/repositories/releases/</url>
        </repository>
        <snapshotRepository>
            <!--需要与settings.xml中server的id相同-->
            <id>snapshots</id>
            <name>Nexus Snapshot Repository</name>
            <url>http://192.168.233.129:8081/nexus/content/repositories/snapshots/</url>
        </snapshotRepository>
    </distributionManagement>

4.2.2.2 配置插件上传项目的源码包

<build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-source-plugin</artifactId>
                <version>2.1.2</version>
                <executions>
                    <execution>
                        <id>attach-sources</id>
                        <goals>
                            <goal>jar</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

在这里插入图片描述

4.3发布第三方构件到私服

4.3.1将第三方构建上传到 3rd party 仓库中

在这里插入图片描述

4.3.2在项目中引入第三方构件依赖

<dependencies>
        <dependency>
            <groupId>com.oracle</groupId>
            <artifactId>oracle-jdbc</artifactId>
            <version>6.0</version>
        </dependency>
    </dependencies>

十二、基于 Maven 创建 war 工程

1 创建 maven 项目

在这里插入图片描述

2 创建 webapp 文件夹

在 src/main 下新建 webapp 文件夹

在 webapp 下新建 WEB-INF 文件夹

在 WEB-INF 下新建 web.xml
在这里插入图片描述

3 配置 web 模块

如果不配置会导致无法新建 jsp 文件
菜单 --> Project Structure -->
在这里插入图片描述

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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.bjsxt</groupId>
    <artifactId>webdemo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <dependencies>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <path>/</path>
                    <port>8080</port>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

十三、 Maven 实战

1 需求分析

基于 SSM 框架的 CRUD 案例
增加(Create)、读取(Retrieve)、更新(Update)、删除(Delete)

2 技术选型

框架：SpringMVC+Spring+Mybatis
数据库：MySQL
项目管理工具：Maven
POM 模型：使用聚合模型

3 项目架构设计

3.1传统项目设计方式

在这里插入图片描述

3.2Maven 项目设计方式

在这里插入图片描述

4 创建 Users 表

CREATE TABLE `users` ( 
`userid` int(11) NOT NULL AUTO_INCREMENT, 
`username` varchar(30) DEFAULT NULL, 
`userage` int(11) DEFAULT NULL, 
PRIMARY KEY (`userid`) 
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

5 创建项目

5.1创建父工程

5.1.1项目名称

父工程名称：parent

5.1.1.1 修改 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.bjsxt</groupId>
    <artifactId>parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <!--Dependency Version Management-->
    <properties>
        <spring.version>5.2.4.RELEASE</spring.version>
        <mysql.driver.version>5.1.38</mysql.driver.version>
        <log4j.version>1.2.17</log4j.version>
        <aspectj.version>1.9.5</aspectj.version>
        <mybatis.version>3.5.4</mybatis.version>
        <mybatis-spring.version>2.0.3</mybatis-spring.version>
        <servlet-api.version>3.1.0</servlet-api.version>
        <jsp-api.version>2.2</jsp-api.version>
        <jstl.version>1.2</jstl.version>
        <tomcat-plugin.version>2.2</tomcat-plugin.version>
        <mybatis-generator.version>1.3.5</mybatis-generator.version>
    </properties>
    <dependencyManagement>
        <dependencies>
            <!--Spring Dependency-->
            <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>

            <!--MySQL Driver Dependency-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.driver.version}</version>
            </dependency>

            <!--Log4j Dependency-->
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>${log4j.version}</version>
            </dependency>

            <!--AspectJ Dependency-->
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>${aspectj.version}</version>
            </dependency>

            <!--MyBatis Dependency-->
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>${mybatis.version}</version>
            </dependency>

            <!--MyBatis Integration Spring Dependency-->
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>${mybatis-spring.version}</version>
            </dependency>

            <!--Web Dependency-->
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>${servlet-api.version}</version>
            </dependency>
            <dependency>
                <groupId>javax.servlet.jsp</groupId>
                <artifactId>jsp-api</artifactId>
                <version>${jsp-api.version}</version>
            </dependency>
            <dependency>
                <groupId>jstl</groupId>
                <artifactId>jstl</artifactId>
                <version>${jstl.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <pluginManagement>
            <plugins>
                <!--Tomcat Plugin-->
                <plugin>
                    <groupId>org.apache.tomcat.maven</groupId>
                    <artifactId>tomcat7-maven-plugin</artifactId>
                    <version>${tomcat-plugin.version}</version>
                </plugin>

                <!--MyBatis Generator Plugin-->
                <plugin>
                    <groupId>org.mybatis.generator</groupId>
                    <artifactId>mybatis-generator-maven-plugin</artifactId>
                    <version>${mybatis-generator.version}</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>

5.2创建聚合模块

5.2.1创建 POJO 项目

POJO 项目不需要添加任何依赖。

5.2.2创建 Mapper 项目

5.2.2.1 修改 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">
    <parent>
        <artifactId>parent</artifactId>
        <groupId>com.bjsxt</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>mapper</artifactId>

    <dependencies>
        <dependency>
            <groupId>com.bjsxt</groupId>
            <artifactId>pojo</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <!--MySQL Driver Dependency-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <!--MyBatis Dependency-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
        </dependency>

        <!--MyBatis Integration Spring Dependency-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <dependencies>
                    <dependency>
                        <groupId>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <version>5.1.38</version>
                    </dependency>
                </dependencies>
                <!--指定配置文件的路径-->
                <configuration>
                    <configurationFile>${project.basedir}/src/main/resources/generatorConfig.xml</configurationFile>
                    <verbose>true</verbose>
                    <overwrite>true</overwrite>
                </configuration>
            </plugin>
        </plugins>

        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
            </resource>
        </resources>
    </build>
</project>

5.2.3创建 Service 项目

5.2.3.1 修改 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">
    <parent>
        <artifactId>parent</artifactId>
        <groupId>com.bjsxt</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>service</artifactId>


    <dependencies>
        <dependency>
            <groupId>com.bjsxt</groupId>
            <artifactId>mapper</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!--Spring Dependency-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
        </dependency>
        <!--Log4j Dependency-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
        </dependency>
        <!--AspectJ Dependency-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
        </dependency>
    </dependencies>
</project>

5.2.4创建 Controller 项目

5.2.4.1 修改 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">
    <parent>
        <artifactId>parent</artifactId>
        <groupId>com.bjsxt</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <packaging>war</packaging>
    <artifactId>controller</artifactId>

    <dependencies>
        <dependency>
            <groupId>com.bjsxt</groupId>
            <artifactId>service</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!--Web Dependency-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <!-- 配置Tomcat插件 -->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <configuration>
                    <!-- path: 上传的war包解压后的路径命名 -->
                    <path>/ROOT</path>
                    <!-- url : 上传war包到什么位置,除IP和端口可以修改外其他不变 -->
                    <url>http://192.168.233.128:8080/manager/text</url>
                    <!-- 为tomcat配置的管理用户名和密码. -->
                    <username>tomcat</username>
                    <password>tomcat</password>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

5.3添加插件

5.3.1在 Mapper 中添加 Mybatis generator 插件

<plugin>
               <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <dependencies>
                    <dependency>
                        <groupId>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <version>5.1.38</version>
                    </dependency>
                </dependencies>
                <!--指定配置文件的路径-->
                <configuration>
                    <configurationFile>${project.basedir}/src/main/resources/generatorConfig.xml</configurationFile>
                    <verbose>true</verbose>
                    <overwrite>true</overwrite>
                </configuration>
</plugin>

5.3.2在 Mapper 中指定资源拷贝目录

<resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
            </resource>
        </resources>

5.3.3在 Controller 中添加 Tomcat 插件

<!-- 配置Tomcat插件 -->
<plugin> <groupId>org.apache.tomcat.maven</groupId> 
	 <artifactId>tomcat7-maven-plugin</artifactId> 
	 <configuration> 
		 <!-- 配置 Tomcat 监听端口 --> 
		 <port>8080</port> 
		 <!-- 配置项目的访问路径(Application Context) --> 
		 <path>/</path> 
	 </configuration> 
 </plugin>

6 框架整合

在 Controller 项目中配置框架整合。

6.1创建 db.properties 配置文件

jdbc.driver=com.mysql.jdbc.Driver 
jdbc.url=jdbc:mysql://localhost:3306/bjsxt?characterEncoding=utf-8 
jdbc.username=root 
jdbc.password=root

6.2创建 applicationContext-dao.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context.xsd
   http://www.springframework.org/schema/aop
   http://www.springframework.org/schema/aop/spring-aop.xsd
   http://www.springframework.org/schema/tx
   http://www.springframework.org/schema/tx/spring-tx.xsd
   http://www.springframework.org/schema/util
   http://www.springframework.org/schema/util/spring-util.xsd">
    <!--解析properties配置文件-->
    <context:property-placeholder location="classpath:resource/db.properties"/>
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!--配置SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="typeAliasesPackage" value="com.bjsxt.pojo"/>
    </bean>
    <!--配置MapperScanner-->
    <bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.bjsxt.mapper"/>
    </bean>
</beans>

6.3创建 applicationContext-service.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context.xsd
   http://www.springframework.org/schema/aop
   http://www.springframework.org/schema/aop/spring-aop.xsd
   http://www.springframework.org/schema/tx
   http://www.springframework.org/schema/tx/spring-tx.xsd
   http://www.springframework.org/schema/util
   http://www.springframework.org/schema/util/spring-util.xsd">
    <!--配置Spring包扫描-->
    <context:component-scan base-package="com.bjsxt.service"/>
</beans>

6.4创建 applicationContext-trans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context.xsd
   http://www.springframework.org/schema/aop
   http://www.springframework.org/schema/aop/spring-aop.xsd
   http://www.springframework.org/schema/tx
   http://www.springframework.org/schema/tx/spring-tx.xsd
   http://www.springframework.org/schema/util
   http://www.springframework.org/schema/util/spring-util.xsd">
    <!--配置事务管理器切面-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--配置事务传播行为-->
    <tx:advice id="txAdvice">
        <tx:attributes>
            <tx:method name="add*" propagation="REQUIRED"/>
            <tx:method name="modify*" propagation="REQUIRED"/>
            <tx:method name="drop*" propagation="REQUIRED"/>
            <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="get*" propagation="SUPPORTS" read-only="true"/>
        </tx:attributes>
    </tx:advice>
    <!--配置事务切点-->
    <aop:config>
        <aop:pointcut id="myPointcut" expression="execution(* com.bjsxt.service.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="myPointcut"/>
    </aop:config>
</beans>

6.5创建 springmvc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context.xsd
   http://www.springframework.org/schema/aop
   http://www.springframework.org/schema/aop/spring-aop.xsd
   http://www.springframework.org/schema/tx
   http://www.springframework.org/schema/tx/spring-tx.xsd
   http://www.springframework.org/schema/util
   http://www.springframework.org/schema/util/spring-util.xsd
    http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!--配置SpringMVC包扫描-->
    <context:component-scan base-package="com.bjsxt.web.controller"/>
    <!--配置注解驱动-->
    <mvc:annotation-driven/>
    <!--配置视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

6.6修改 web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <!--指定Spring配置文件位置-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring/applicationContext-*.xml</param-value>
    </context-param>
    <!--配置启动Spring框架的监听器-->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!--配置SpringMVC主控制器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring/springmvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!--配置SpringMVC中的编码过滤器-->
    <filter>
        <filter-name>encodeFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodeFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

7 业务实现

7.1实现添加用户业务

7.1.1创建添加用户 Service

package com.bjsxt.service;

import com.bjsxt.pojo.Users;

import java.util.List;

public interface UsersService {
    void addUsers(Users users);
    List<Users> findUsers();
    Users findUserById(Integer userid);
    void modifyUsers(Users users);
    void dropUsersById(Integer userid);
}

package com.bjsxt.service.impl;

import com.bjsxt.mapper.UsersMapper;
import com.bjsxt.pojo.Users;
import com.bjsxt.service.UsersService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * 用户管理业务层
 */
@Service
public class UsersServiceImpl implements UsersService {

    @Autowired
    private UsersMapper usersMapper;

    /**
     * 用户添加业务
     * @param users
     */
    @Override
    public void addUsers(Users users) {
        this.usersMapper.insert(users);
    }

    @Override
    public List<Users> findUsers() {
        return null;
    }

    @Override
    public Users findUserById(Integer userid) {
        return null;
    }

    @Override
    public void modifyUsers(Users users) {

    }

    @Override
    public void dropUsersById(Integer userid) {

    }
}

7.1.2创建首页

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<a href="/addUsers">添加用户</a>&nbsp;&nbsp;<a href="/users/findUsers">查询用户</a>
</body>
</html>

7.1.3创建添加用户页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <form action="/users/addUsers" method="post">
        用户名:<input type="text" name="username"/><br/>
        用户年龄：<input type="text" name="userage"/><br/>
        <input type="submit" value="OK"/>
    </form>
</body>
</html>

7.1.4创建成功页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
操作成功，请<a href="/index">返回</a>
</body>
</html>

7.1.5创建页面跳转的 Controller

package com.bjsxt.web.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * 页面跳转Controller
 */
@Controller
public class PageController {

    /**
     * 页面跳转
     */
    @RequestMapping("/{page}")
    public String showPage(@PathVariable String page){
        return page;
    }
}

7.1.6创建添加用户 Controller

package com.bjsxt.web.controller;

import com.bjsxt.pojo.Users;
import com.bjsxt.service.UsersService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;


/**
 * 处理用户管理请求
 */
@Controller
@RequestMapping("/users")
public class UsersController {
    @Autowired
    private UsersService usersService;
    /**
     * 处理添加用户请求
     */
    @RequestMapping("/addUsers")
    public String addUsers(Users users){
        this.usersService.addUsers(users);
        return "redirect:/ok";
    }

    /**
     * 处理查询所以用户请求
     */
    @RequestMapping("/findUsers")
    public String findUsers(Model model){
        List<Users> list = this.usersService.findUsers();
        model.addAttribute("list",list);
        return "/showUsers";
    }

    /**
     * 处理预更新用户的查询
     */
    @RequestMapping("/preUpdateUser")
    public String preUpdateUser(Integer userid,Model model){
        Users users = this.usersService.findUserById(userid);
        model.addAttribute("users",users);
        return "/updateUsers";
    }

    /**
     * 更新用户
     */
    @RequestMapping("/updateUsers")
    public String updateUsers(Users users){
        this.usersService.modifyUsers(users);
        return "redirect:/ok";
    }

    /**
     * 删除用户
     */
    @RequestMapping("/deleteUser")
    public String deleteUser(Integer userid){
        this.usersService.dropUsersById(userid);
        return "redirect:/ok";
    }
}

在这里插入图片描述

7.2实现查询用户业务

7.2.1创建查询用户 Service

添加接口：

List<Users> findUsers();

/**
     * 查询全部用户
     * @return
     */
    @Override
    public List<Users> findUsers() {
        UsersExample example = new UsersExample();
        return this.usersMapper.selectByExample(example);
    }

7.2.2创建查询用户 Controller

/**
     * 处理查询所以用户请求
     */
    @RequestMapping("/findUsers")
    public String findUsers(Model model){
        List<Users> list = this.usersService.findUsers();
        model.addAttribute("list",list);
        return "/showUsers";
    }

7.2.3创建显示用户页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<table border="1" align="center">
    <tr>
        <th>用户名</th>
        <th>年龄</th>
        <th>操作</th>
    </tr>
    <c:forEach items="${list}" var="user">
        <tr>
            <td>${user.username}</td>
            <td>${user.userage}</td>
            <td>
                <a href="/users/preUpdateUser?userid=${user.userid}">更新</a>
                <a href="/users/deleteUser?userid=${user.userid}">删除</a>
            </td>
        </tr>
    </c:forEach>
</table>
</body>
</html>

7.3更新用户业务

7.3.1预更新查询

7.3.1.1 创建查询用户 Service

添加接口

Users findUserById(Integer userid);

/**
     * 根据用户ID查询用户
     * @param userid
     * @return
     */
    @Override
    public Users findUserById(Integer userid) {
        return this.usersMapper.selectByPrimaryKey(userid);
    }

7.3.1.2 创建查询用户 Controller

/**
     * 处理预更新用户的查询
     */
    @RequestMapping("/preUpdateUser")
    public String preUpdateUser(Integer userid,Model model){
        Users users = this.usersService.findUserById(userid);
        model.addAttribute("users",users);
        return "/updateUsers";
    }

7.3.1.3 创建显示预更新用户页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form action="/users/updateUsers" method="post">
            <input type="hidden" name="userid" value="${users.userid}"/>
    用户名:<input type="text" name="username" value="${users.username}"/><br/>
    用户年龄：<input type="text" name="userage" value="${users.userage}"/><br/>
    <input type="submit" value="OK"/>
</form>
</body>
</html>

7.3.2更新用户

7.3.2.1 创建更新用户 Service

添加方法

void modifyUsers(Users users);

/**
     * 更新用户
     * @param users
     */
    @Override
    @Transactional
    public void modifyUsers(Users users) {
        this.usersMapper.updateByPrimaryKey(users);
    }

7.3.2.2 创建更新用户 Controller

 /**
     * 更新用户
     */
    @RequestMapping("/updateUsers")
    public String updateUsers(Users users){
        this.usersService.modifyUsers(users);
        return "redirect:/ok";
    }

7.4删除用户业务

7.4.1创建删除用户 Service

添加方法

void dropUsersById(Integer userid);

/**
     * 根据用户ID删除用户
     * @param userid
     */
    @Override
    @Transactional
    public void dropUsersById(Integer userid) {
        this.usersMapper.deleteByPrimaryKey(userid);
    }

7.4.2创建删除用户 Controller

/**
     * 删除用户
     */
    @RequestMapping("/deleteUser")
    public String deleteUser(Integer userid){
        this.usersService.dropUsersById(userid);
        return "redirect:/ok";
    }

十四、 Tomcat 热部署

热部署是指，在外部的Tomcat容器运行过程中，动态实现war工程的部署，或者重新部署的功能。我们可以使用Maven的Tomcat插件实现远程热部署，具体命令为：tomcat7:deploy或tomcat7:redeploy。其中deploy代表第一次部署war工程；redeploy代表Tomcat容器中已有同名应用。本次操作为重新部署同名war工程。
实现热部署需要远程访问Tomcat容器，所以需要开启Tomcat的用户认证机制。在Tomcat中，对于支持远程热部署的用户需要拥有相应的权限。

1 Tomcat 权限介绍

在这里插入图片描述

2 在 Tomcat 中添加用户并分配权限

修改 Tomcat 中的 conf/tomcat-users.xml 文件的配置

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

3 配置 Tomcat 插件实现热部署

修改项目 POM 文件中的 Tomcat 插件，添加配置信息。

<!-- 配置 Tomcat 插件 --> 
<plugin> 
	<groupId>org.apache.tomcat.maven</groupId> 
	<artifactId>tomcat7-maven-plugin</artifactId> 
	<configuration> 
		<!-- path: 上传的 war 包解压后的路径命名 --> 
		<path>/ROOT</path> 
		<!-- url : 上传 war 包到什么位置,除 IP 和端口可以修改外其他不变 --> 
		<url>http://127.0.0.1:9090/manager/text</url> 
		<!-- 为 tomcat 配置的管理用户名和密码. --> 
		<username>tomcat</username> 
		<password>tomcat</password> 
	</configuration> 
</plugin>

MyBatisPlus

脑袋不灵光的小白羊

关注

0
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
项目管理——Maven的应用与实战

Maven 简介 Maven 的下载与 IDE 的整合 Maven 仓库与配置 Maven 工程类型在 Idea 中创建 Maven 工程 Maven 项目结构 POM 模型 Maven 中的常见插件 Maven 常用命令 Maven 项目命名规范搭建 Maven 私服基于 Maven 创建 war 工程 Maven 实战 Tomcat 热部署
复制链接

扫一扫