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

练习过程中使用的源码：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\repositorylocalRepository>

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>nexus-aliyunid> 
	 
	<mirrorOf>centralmirrorOf> 
	 
	<name>Nexus aliyunname> 
	 <url>http://maven.aliyun.com/nexus/content/groups/publicurl> 
mirror>

3.3 配置 JDK 版本

<profile>
<id>jdk-1.8id> 
	<activation>
		 <activeByDefault>trueactiveByDefault>
		 <jdk>1.8jdk> 
	activation> 
	 <properties>
		 <maven.compiler.source>1.8maven.compiler.source>
		 <maven.compiler.target>1.8maven.compiler.target> 
		 <maven.compiler.compilerVersion>1.8maven.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.springframeworkgroupId> 
		<artifactId>spring-contextartifactId> 
		<version>5.2.4.RELEASEversion> 
	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.springframeworkgroupId> 
	<artifactId>spring-contextartifactId> 
	<version>5.2.4.RELEASEversion> 
	<exclusions> 
		<exclusion> 
			<groupId>org.springframeworkgroupId> 
			<artifactId>spring-aopartifactId> 
		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 提 供 了 一 个 机 制 来 集 中 管 理 依 赖 信 息 ， 叫 做 依 赖 管 理 元 素 。假设你有许多项目继承自同一个公有的父项目，那可以 把所有依赖信息放在一个公共的 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 中对于继承采用的也是单一继承，也就是说一个子项目只能有一 个父项目，但是有的时候我们项目可能需要从更多的项目中继承，那么我们可以 在子项目中通过添加标记来实现多继承。在子项 目的中每个标记就一个父工程 定义，同时还需要添加标记，值为 pom。添加标记，值为 import。

 <dependencyManagement>
        <dependencies>
            
        <dependency>
            <groupId>com.bjsxtgroupId>
            <artifactId>parent_aartifactId>
            <version>1.0-SNAPSHOTversion>
            <type>pomtype>
            <scope>importscope>
        dependency>
             
            <dependency> 
                <groupId>com.bjsxtgroupId> 
                <artifactId>parent_bartifactId> 
                <version>1.0-SNAPSHOTversion> 
                <type>pomtype> 
                <scope>importscope> 
            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 文件中的>标签中使用来配置。

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

1.1 配置编译插件

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

<profile> 
	 
	<id>jdk-1.8id> 
	 
	<activation> 
		<activeByDefault>trueactiveByDefault>
		<jdk>1.8jdk> 
	activation> 
	 
	<properties> 
		<maven.compiler.source>1.8maven.compiler.source> 
		<maven.compiler.target>1.8maven.compiler.target> 
		<maven.compiler.compilerVersion>1.8maven.compiler.compilerVersion> 
	properties> 
profile>

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

<build> 
	<plugins> 
		<plugin> 
			<groupId>org.apache.maven.pluginsgroupId> 
			<artifactId>maven-compiler-pluginartifactId> 
			<version>3.8.1version> 
			<configuration> 
				<source>1.8source> 
				<target>1.8target> 
				<encoding>UTF-8encoding> 
			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/javadirectory>
                <includes>
                    <include>**/*.xmlinclude>
                    <include>**/*.propertiesinclude>
                includes>
            resource>
            <resource>
                <directory>src/main/resourcesdirectory>
                <includes>
                    <include>**/*.xmlinclude>
                    <include>**/*.propertiesinclude>
                includes>
            resource>
 resources>

2 扩展插件

2.1Tomcat 插件

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

            <plugin>
                <groupId>org.apache.tomcat.mavengroupId>
                <artifactId>tomcat7-maven-pluginartifactId>
                <version>2.2version>
                <configuration>
                    
                    <port>8080port>
                    
                    <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 文件，添加插件

            <plugin>
                <groupId>org.mybatis.generatorgroupId>
                <artifactId>mybatis-generator-maven-pluginartifactId>
                <version>1.3.5version>
                <dependencies>
                    <dependency>
                        <groupId>mysqlgroupId>
                        <artifactId>mysql-connector-javaartifactId>
                        <version>5.1.38version>
                    dependency>
                dependencies>
                
                <configuration>
                    <configurationFile>${project.basedir}/src/main/resources/generatorConfig.xmlconfigurationFile>
                    <verbose>trueverbose>
                    <overwrite>trueoverwrite>
                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.mavengroupId>
                    <artifactId>tomcat7-maven-pluginartifactId>
                    <version>2.2version>
                plugin>
                <plugin>
                    <groupId>org.mybatis.generatorgroupId>
                    <artifactId>mybatis-generator-maven-pluginartifactId>
                    <version>1.3.5version>
                plugin>
            plugins>
        pluginManagement>
    build>

3.2 子工程 POM

<plugin> 
	<groupId>org.apache.tomcat.mavengroupId> 
	<artifactId>tomcat7-maven-pluginartifactId> 
	<configuration> 
		 
		<port>8080port> 
		 
		<path>/path> 
	configuration> 
plugin> 
 
<plugin> 
	<groupId>org.mybatis.generatorgroupId> 
	<artifactId>mybatis-generator-maven-pluginartifactId> 
	<dependencies> 
		<dependency> 
			<groupId>mysqlgroupId> 
			<artifactId>mysql-connector-javaartifactId> 
			<version>5.1.38version> 
		dependency> 
	dependencies> 
	
	<configuration> 
		<configurationFile>${project.basedir}/src/main/resources/generato rConfig.xmlconfigurationFile> 
		<verbose>trueverbose> 
		<overwrite>trueoverwrite> 
	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 节点中添加仓库的用户认证

在节点中配置仓库认证，操作仓库的用户以及密码，可以使用 deployment 用户，该用户为 Nexus 的缺省用户，也可以自己创建用户。

<server> 
	<id>releasesid> 
	<username>deploymentusername> 
	<password>deployment123password> 
server> 
<server> 
	<id>snapshotsid> 
	<username>deploymentusername> 
	<password>deployment123password>
server>

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

<profile> 
	<id>sxtid> 
	<activation> 
		<activeByDeffault>false activeByDeffault> 
		<jdk>1.8jdk> 
	activation> 
	 
	<repositories> 
		<repository> 
		 
			<id>publicid> 
		 
			<url>http://192.168.233.129:8081/nexus/content/groups/public/url> 
		 
			<releases> 
				<enabled>trueenabled> 
			releases> 
		 
			<snapshost> 
				<enabled>trueenabled> 
			snapshost> 
		repository> 
	repositories> 
	 
	<pluginRepositories> 
			<pluginRepository> 
				<id>publicid> 
				<url>http://192.168.233.129:8081/nexus/content/groups/public/url> 
			 
				<releases> 
					<enabled>trueenabled> 
				releases> 
			 
				<snapshost> 
					<enabled>trueenabled> 
				snapshost> 
			pluginRepository> 
	pluginRepositories> 
profile>

4.1.3配置 activeProfiles 激活 profile

<activeProfiles> 
	 
<activeProfile>sxtactiveProfile> 
activeProfiles>

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

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

4.2在 POM 文件中配置私服

4.2.1创建项目

4.2.2 修改 POM 文件

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

<distributionManagement>
        <repository>
            
            <id>releasesid>
            <name>Nexus Release Repositoryname>
            <url>http://192.168.233.129:8081/nexus/content/repositories/releases/url>
        repository>
        <snapshotRepository>
            
            <id>snapshotsid>
            <name>Nexus Snapshot Repositoryname>
            <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.pluginsgroupId>
                <artifactId>maven-source-pluginartifactId>
                <version>2.1.2version>
                <executions>
                    <execution>
                        <id>attach-sourcesid>
                        <goals>
                            <goal>jargoal>
                        goals>
                    execution>
                executions>
            plugin>
        plugins>
    build>

4.3发布第三方构件到私服

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

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

<dependencies>
        <dependency>
            <groupId>com.oraclegroupId>
            <artifactId>oracle-jdbcartifactId>
            <version>6.0version>
        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

<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.0modelVersion>

    <groupId>com.bjsxtgroupId>
    <artifactId>webdemoartifactId>
    <version>1.0-SNAPSHOTversion>
    <packaging>warpackaging>

    <dependencies>
        <dependency>
            <groupId>javax.servletgroupId>
            <artifactId>javax.servlet-apiartifactId>
            <version>3.1.0version>
            <scope>providedscope>
        dependency>
        <dependency>
            <groupId>javax.servlet.jspgroupId>
            <artifactId>jsp-apiartifactId>
            <version>2.2version>
            <scope>providedscope>
        dependency>
        <dependency>
            <groupId>jstlgroupId>
            <artifactId>jstlartifactId>
            <version>1.2version>
        dependency>
    dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.tomcat.mavengroupId>
                <artifactId>tomcat7-maven-pluginartifactId>
                <version>2.2version>
                <configuration>
                    <path>/path>
                    <port>8080port>
                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 文件添加依赖

<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.0modelVersion>

    <groupId>com.bjsxtgroupId>
    <artifactId>parentartifactId>
    <version>1.0-SNAPSHOTversion>
    <packaging>pompackaging>

    
    <properties>
        <spring.version>5.2.4.RELEASEspring.version>
        <mysql.driver.version>5.1.38mysql.driver.version>
        <log4j.version>1.2.17log4j.version>
        <aspectj.version>1.9.5aspectj.version>
        <mybatis.version>3.5.4mybatis.version>
        <mybatis-spring.version>2.0.3mybatis-spring.version>
        <servlet-api.version>3.1.0servlet-api.version>
        <jsp-api.version>2.2jsp-api.version>
        <jstl.version>1.2jstl.version>
        <tomcat-plugin.version>2.2tomcat-plugin.version>
        <mybatis-generator.version>1.3.5mybatis-generator.version>
    properties>
    <dependencyManagement>
        <dependencies>
            
            <dependency>
                <groupId>org.springframeworkgroupId>
                <artifactId>spring-webmvcartifactId>
                <version>${spring.version}version>
            dependency>
            <dependency>
                <groupId>org.springframeworkgroupId>
                <artifactId>spring-jdbcartifactId>
                <version>${spring.version}version>
            dependency>

            
            <dependency>
                <groupId>mysqlgroupId>
                <artifactId>mysql-connector-javaartifactId>
                <version>${mysql.driver.version}version>
            dependency>

            
            <dependency>
                <groupId>log4jgroupId>
                <artifactId>log4jartifactId>
                <version>${log4j.version}version>
            dependency>

            
            <dependency>
                <groupId>org.aspectjgroupId>
                <artifactId>aspectjweaverartifactId>
                <version>${aspectj.version}version>
            dependency>

            
            <dependency>
                <groupId>org.mybatisgroupId>
                <artifactId>mybatisartifactId>
                <version>${mybatis.version}version>
            dependency>

            
            <dependency>
                <groupId>org.mybatisgroupId>
                <artifactId>mybatis-springartifactId>
                <version>${mybatis-spring.version}version>
            dependency>

            
            <dependency>
                <groupId>javax.servletgroupId>
                <artifactId>javax.servlet-apiartifactId>
                <version>${servlet-api.version}version>
            dependency>
            <dependency>
                <groupId>javax.servlet.jspgroupId>
                <artifactId>jsp-apiartifactId>
                <version>${jsp-api.version}version>
            dependency>
            <dependency>
                <groupId>jstlgroupId>
                <artifactId>jstlartifactId>
                <version>${jstl.version}version>
            dependency>
        dependencies>
    dependencyManagement>

    <build>
        <pluginManagement>
            <plugins>
                
                <plugin>
                    <groupId>org.apache.tomcat.mavengroupId>
                    <artifactId>tomcat7-maven-pluginartifactId>
                    <version>${tomcat-plugin.version}version>
                plugin>

                
                <plugin>
                    <groupId>org.mybatis.generatorgroupId>
                    <artifactId>mybatis-generator-maven-pluginartifactId>
                    <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 文件添加依赖

<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>parentartifactId>
        <groupId>com.bjsxtgroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>mapperartifactId>

    <dependencies>
        <dependency>
            <groupId>com.bjsxtgroupId>
            <artifactId>pojoartifactId>
            <version>1.0-SNAPSHOTversion>
        dependency>

        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
        dependency>

        
        <dependency>
            <groupId>org.mybatisgroupId>
            <artifactId>mybatisartifactId>
        dependency>

        
        <dependency>
            <groupId>org.mybatisgroupId>
            <artifactId>mybatis-springartifactId>
        dependency>
    dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.mybatis.generatorgroupId>
                <artifactId>mybatis-generator-maven-pluginartifactId>
                <dependencies>
                    <dependency>
                        <groupId>mysqlgroupId>
                        <artifactId>mysql-connector-javaartifactId>
                        <version>5.1.38version>
                    dependency>
                dependencies>
                
                <configuration>
                    <configurationFile>${project.basedir}/src/main/resources/generatorConfig.xmlconfigurationFile>
                    <verbose>trueverbose>
                    <overwrite>trueoverwrite>
                configuration>
            plugin>
        plugins>

        <resources>
            <resource>
                <directory>src/main/javadirectory>
                <includes>
                    <include>**/*.xmlinclude>
                includes>
            resource>
            <resource>
                <directory>src/main/resourcesdirectory>
                <includes>
                    <include>**/*.xmlinclude>
                    <include>**/*.propertiesinclude>
                includes>
            resource>
        resources>
    build>
project>

5.2.3创建 Service 项目

5.2.3.1 修改 POM 文件添加依赖

<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>parentartifactId>
        <groupId>com.bjsxtgroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>serviceartifactId>


    <dependencies>
        <dependency>
            <groupId>com.bjsxtgroupId>
            <artifactId>mapperartifactId>
            <version>1.0-SNAPSHOTversion>
        dependency>
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-webmvcartifactId>
        dependency>
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-jdbcartifactId>
        dependency>
        
        <dependency>
            <groupId>log4jgroupId>
            <artifactId>log4jartifactId>
        dependency>
        
        <dependency>
            <groupId>org.aspectjgroupId>
            <artifactId>aspectjweaverartifactId>
        dependency>
    dependencies>
project>

5.2.4创建 Controller 项目

5.2.4.1 修改 POM 文件添加依赖

<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>parentartifactId>
        <groupId>com.bjsxtgroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>
    <packaging>warpackaging>
    <artifactId>controllerartifactId>

    <dependencies>
        <dependency>
            <groupId>com.bjsxtgroupId>
            <artifactId>serviceartifactId>
            <version>1.0-SNAPSHOTversion>
        dependency>
        
        <dependency>
            <groupId>javax.servletgroupId>
            <artifactId>javax.servlet-apiartifactId>
            <scope>providedscope>
        dependency>
        <dependency>
            <groupId>javax.servlet.jspgroupId>
            <artifactId>jsp-apiartifactId>
            <scope>providedscope>
        dependency>
        <dependency>
            <groupId>jstlgroupId>
            <artifactId>jstlartifactId>
        dependency>
    dependencies>
    <build>
        <plugins>
            
            <plugin>
                <groupId>org.apache.tomcat.mavengroupId>
                <artifactId>tomcat7-maven-pluginartifactId>
                <configuration>
                    
                    <path>/ROOTpath>
                    
                    <url>http://192.168.233.128:8080/manager/texturl>
                    
                    <username>tomcatusername>
                    <password>tomcatpassword>
                configuration>
            plugin>
        plugins>
    build>
project>

5.3添加插件

5.3.1在 Mapper 中添加 Mybatis generator 插件

<plugin>
               <groupId>org.mybatis.generatorgroupId>
                <artifactId>mybatis-generator-maven-pluginartifactId>
                <dependencies>
                    <dependency>
                        <groupId>mysqlgroupId>
                        <artifactId>mysql-connector-javaartifactId>
                        <version>5.1.38version>
                    dependency>
                dependencies>
                
                <configuration>
                    <configurationFile>${project.basedir}/src/main/resources/generatorConfig.xmlconfigurationFile>
                    <verbose>trueverbose>
                    <overwrite>trueoverwrite>
                configuration>
plugin>

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

<resources>
            <resource>
                <directory>src/main/javadirectory>
                <includes>
                    <include>**/*.xmlinclude>
                includes>
            resource>
            <resource>
                <directory>src/main/resourcesdirectory>
                <includes>
                    <include>**/*.xmlinclude>
                    <include>**/*.propertiesinclude>
                includes>
            resource>
        resources>

5.3.3在 Controller 中添加 Tomcat 插件

<plugin> <groupId>org.apache.tomcat.mavengroupId> 
	 <artifactId>tomcat7-maven-pluginartifactId> 
	 <configuration> 
		  
		 <port>8080port> 
		  
		 <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

<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">
    
    <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>
    
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="typeAliasesPackage" value="com.bjsxt.pojo"/>
    bean>
    
    <bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.bjsxt.mapper"/>
    bean>
beans>

6.3创建 applicationContext-service.xml

<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">
    
    <context:component-scan base-package="com.bjsxt.service"/>
beans>

6.4创建 applicationContext-trans.xml

<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

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

<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">
    
    <context-param>
        <param-name>contextConfigLocationparam-name>
        <param-value>classpath:spring/applicationContext-*.xmlparam-value>
    context-param>
    
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
    listener>
    
    <servlet>
        <servlet-name>springmvcservlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
        <init-param>
            <param-name>contextConfigLocationparam-name>
            <param-value>classpath:spring/springmvc.xmlparam-value>
        init-param>
        <load-on-startup>1load-on-startup>
    servlet>
    <servlet-mapping>
        <servlet-name>springmvcservlet-name>
        <url-pattern>/url-pattern>
    servlet-mapping>

    
    <filter>
        <filter-name>encodeFilterfilter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
        <init-param>
            <param-name>encodingparam-name>
            <param-value>utf-8param-value>
        init-param>
    filter>
    <filter-mapping>
        <filter-name>encodeFilterfilter-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>Titletitle>
head>
<body>
<a href="/addUsers">添加用户a>  <a href="/users/findUsers">查询用户a>
body>
html>

7.1.3创建添加用户页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Titletitle>
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>Titletitle>
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>Titletitle>
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>Titletitle>
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 插件，添加配置信息。

 
<plugin> 
	<groupId>org.apache.tomcat.mavengroupId> 
	<artifactId>tomcat7-maven-pluginartifactId> 
	<configuration> 
		 
		<path>/ROOTpath> 
		 
		<url>http://127.0.0.1:9090/manager/texturl> 
		 
		<username>tomcatusername> 
		<password>tomcatpassword> 
	configuration> 
plugin>

MyBatisPlus