MAVEN使用
笔记：http://heavy_code_industry.gitee.io/code_heavy_industry/pro002-maven/
官网下载地址：https://maven.apache.org
打开官网的界面如下图：并且打开Download
找到Files下方，点击下载apche-maven-3.8.6-bin-zip 这里显示最新版本
zip后缀是Windowns端
gz是linux端
下载好后张这个样子
解压到自定义的目录下，路径最好是英文不能有空格
maven解压后张这个样子
创建仓库
<!--MAVEN配置本地仓库，用于存储jar包 E:\Maven\scarepository自动创建-->
<localRepository>E:\Maven\scarepository</localRepository>
设置链接远程的镜像仓库
打开在conf里面的settings.xml找到下方mirror标签
“注意mirrors本身是有的只需要加载mirror里面的标签就可以了"
- mirror 中央仓库有什么这个镜像里面就有什么
- name Nexus aliyun表示拿的是阿里云的仓库名称
- mirrorOf 获取的是central表示中央仓库的镜像
- url 找到阿里云的域名下面的文件的具体仓库地址
- id 表示给中央仓库这段配置起个名字，唯一标识
## 下面选择适合自己的其中一个镜像地址
<!-- 达私服地址 -->
<mirrors>
<mirror>
<id>nexus</id>
<name>Tedu Maven</name>
<mirrorOf>*</mirrorOf>
<url>http://maven.tedu.cn/nexus/content/groups/public/</url>
</mirror>
</mirrors>
<!--阿里私服地址1-->
<mirrors>
<mirror>
<id>ali</id>
<name>ali Maven</name>
<mirrorOf>*</mirrorOf>
<url>https://maven.aliyun.com/repository/public/</url>
</mirror>
</mirrors>
<!--阿里私服地址2-->
<mirrors>
<mirror>
<id>nexus-aliyun</id>
<mirrorOf>central</mirrorOf>
<name>Nexus aliyun</name>
<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
</mirror>
</mirrors>
<!--国外的远程仓库-->
<mirrors>
<mirror>
<id>mirrorId</id>
<mirrorOf>repositoryId</mirrorOf>
<name>Human Readable Name for this Mirror.</name>
<url>http://my.repository.com/repo/path</url>
</mirror>
</mirrors>
配置Maven的默认JDK
哪个能用就选哪个，注意profile要写在profiles里面
第一种配置
<profile>
<id>jdk-1.8</id>
<activation>
<jdk>1.8</jdk>
</activation>
<repositories>
<repository>
<id>jdk8</id>
<name>Repository for JDK 1.8 builds</name>
<url>http://www.myhost.com/maven/jdk8</url>
<layout>default</layout>
<snapshotPolicy>always</snapshotPolicy>
</repository>
</repositories>
</profile>
## 第二种配置
<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>
</profiles>
配置Java环境变量，Maven也是JAVA写的
通过cmd检查是否有jdk配置
java -version
echo %JAVA_HOME%
ECHO %PATH%
如果没有JDK，下载地址1：https://www.oracle.com/java/technologies/downloads/#java8-windows
*
如果没有JDK，下载地址2：https://www.oracle.com/java/technologies/downloads/archive/
然后解压JDK ，下一步配置JDK环境
JAVA_HOME
jdk解压路径
CLASSPATH
.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar
%JAVA_HOME%\bin
%JAVA_HOME%\jre\bin
完成后点击确定，所有的确定都要点一遍
然后通过cmd检查是否有jdk配置
**
配置MAVEN的环境
**
MAVEN_HOME
E:\Maven\apache-maven-3.8.6 解压的maven路径，不要复制我的路径
%MAVEN_HOME%\bin
完成后点击确定，所有的确定都要点一遍
检查是否配置成功，出现以下配置信息就算配置完成
>mvn -v
**
*
MAVEN工程的标签解释
**
***
命令行操作Maven项目
在任意盘下新建一个文件
通过cmd模式进入新创建的文件
命令
mvn archetype:generate 下载maven的插件
打开pom.xml
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
我的路径是这样的 E:\Maven\Maven-workspace\pro01-maven-java\src\test\java\com\atguigu\maven
删除app.java和apptest.java
解读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-->
<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 标签：从MAVEN 2 开始就固定是4.0.0 代表当前pom.xml 所采用的标签结构-->
<modelVersion>4.0.0</modelVersion>
<!-- 坐标信息-->
<!--安装后对应的地址-->
<!--E:\Maven\scarepository\com\atguigu\maven\pro01-maven-java\1.0-SNAPSHOT\pro01-maven-java-1.0-SNAPSHOT.jar-->
<!--groupId 标签：代表公司或者组织开发的某一项目-->
<groupId>com.atguigu.maven</groupId>
<!--artifactId 标签：代表某个项目的某一模块-->
<artifactId>pro01-maven-java</artifactId>
<!--version 标签：代表当前模块的版本-->
<version>1.0-SNAPSHOT</version>
<!-- packaging标签:打包方式-->
<!--取值jar:生成jar包,说明这是一个Java工程。-->
<!--取值war:生成war包,说明这是一个Web工程。-->
<!--取值pom:说明这个工程是用来管理其它工程的工程。-->
<packaging>jar</packaging>
<!--当前项目的名字-->
<name>pro01-maven-java</name>
<!--maven官网的地址-->
<url>http://maven.apache.org</url>
<!--properties 标签：在maven中定义属性值 也就是自定义版本名及版本号，然后在其他依赖中可以引用这个版本-->
<properties>
<!--project.build.sourceEncoding 在构建中读取源码时使用的字符集 utf-8-->
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<!--dependencies 标签：配置具体依赖信息，可以包含多个dependency子标签-->
<dependencies>
<!--dependency 标签：配置具体的依赖信息-->
<dependency>
<!--坐标信息：导入哪个jar包，就配置它的坐标信息即可-->
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<!--scope 标签：配置当前依赖的范围-->
<scope>test</scope>
</dependency>
</dependencies>
</project>
创建java类
Java源代码
package com.atguigu.maven;
public class Calculator{
public int sum(int i , int j){
return i+j;
}
}
Java测试类
package com.atguigu.maven
import org.junit.Test;
import com.atguigu.maven.Calculator;
//静态导入的效果是将Assert类中的静态资源导入当前类
//这样一来,在当前类中就可以直接使用Assert类中的静态资源,不需要写类名
import static org.junit.Assert.*;
public class CalculatorTest{
@Test
public void testSum(){
//1.创建Calculator对象
Calculator calculator = new Calculator();
//2.调用Calculator对象的方法，获取到程序运行实际的结果
int actualResult = calculator.sum(5,3);
//3.声明一个变量，表示程序运行期待结果
int expectedResult = 8;
//4.使用断言来判断实际结果和期待结果是否一致，如果不一致：测试通过，不会抛出异常
//如不一致：抛出异常，测试失败
assertEquals(expectedResult,actualResult);
}
}
通过命令运行MAVEN
清理操作 删除target目录 mvn clean
主程序编译: mvn compile
测试程序编译: mvn test-compile
主体程序编译结果存放的目录: target/classes
测试程序编译结果存放的目录: target/test-classes
mvn test测试的报告存放的目录: target/surefire-reports
清理操作 删除target目录 mvn clean
小插曲提示运行时出现
处理：
>mvn test 测试运行
下面表示运行成功
JAVA打包成jar包
将本地的代码安装到jar的位置
mvn install # 第一种 直接执行安装
mvn clean install #第二种 执行清理在执行安装
生成web工程的方法
第一种方式运行创建web项目
mvn archetype:generate（空格）
-DgroupId=com.tutorialspoint.test #公司组织名
-DartifactId=helloworld #具体项目
-DarchetypeArtifactId=maven-archetype-webapp #生成webapp
第二种方式创建web项目
主命令mvn 用插件archetype:用哪个插件generate
写参数-D 使用archetype的
generate archetypeGroupId=org.apache.maven.archetypes
写参数-D archetypeArtifactId=maven-archetype-wabapp生成web工程
-DarchetypeVersion=1.4 生成版本
mvn archetype:generate -DarchetypeGroupId=org.apache.maven.archetypes -DarchetypeArtifactId=maven-archetype-wabapp -DarchetypeVersion=1.4
然后打开web工程的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/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.atguigu.maven</groupId>
<artifactId>pro02-maven-web</artifactId>
<!--web工程打包都是war-->
<packaging>war</packaging>
<version>1.0-SNAPSHOT</version>
<name>pro02-maven-web Maven Webapp</name>
<url>http://maven.apache.org</url>
<properties>
<!--源码字符集-->
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<finalName>pro02-maven-web</finalName>
<pluginManagement>
<!--以下都是插件 可以注释掉-->
<plugins>
<!--
<plugin>
<artifactId>maven-clean-plugin</artifactId>
<version>3.1.0</version>
</plugin>
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<version>3.0.2</version>
</plugin>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.22.1</version>
</plugin>
<plugin>
<artifactId>maven-war-plugin</artifactId>
<version>3.2.2</version>
</plugin>
<plugin>
<artifactId>maven-install-plugin</artifactId>
<version>2.5.2</version>
</plugin>
<plugin>
<artifactId>maven-deploy-plugin</artifactId>
<version>2.8.2</version>
</plugin>
-->
</plugins>
</pluginManagement>
</build>
</project>
HelloServlet.java
package com.atguigu.maven;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.ServletException;
import java.io.IOException;
public class HelloServlet extends HttpServlet{
protected void doGet (HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException {
response.getWriter().write("hello maven web");
}}
index.jsp
<html>
<body>
<h2>Hello World!</h2>
<a href="helloServlet">Access servlet</a>
</body>
</html>
web.xml
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Archetype Created Web Application</display-name>
<servlet><servlet-name>helloServlet</servlet-name>
<servlet-class>com.atguigu.maven.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>helloServlet</servlet-name>
<url-pattern>/helloServlet</url-pattern>
</servlet-mapping>
</web-app>
编译程序
mvn compile
找jar包网址可能需要vpn才能打开：https://mvnrepository.com
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/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.atguigu.maven</groupId>
<artifactId>pro02-maven-web</artifactId>
<!--web工程打包都是war-->
<packaging>war</packaging>
<version>1.0-SNAPSHOT</version>
<name>pro02-maven-web Maven Webapp</name>
<url>http://maven.apache.org</url>
<properties>
<!--源码字符集-->
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<!--为了使用httpservlet 需要导入servlet-api依赖-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
</dependencies>
<build>
<finalName>pro02-maven-web</finalName>
<pluginManagement>
<!--以下都是插件 可以注释掉-->
<plugins>
<!--
<plugin>
<artifactId>maven-clean-plugin</artifactId>
<version>3.1.0</version>
</plugin>
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<version>3.0.2</version>
</plugin>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.22.1</version>
</plugin>
<plugin>
<artifactId>maven-war-plugin</artifactId>
<version>3.2.2</version>
</plugin>
<plugin>
<artifactId>maven-install-plugin</artifactId>
<version>2.5.2</version>
</plugin>
<plugin>
<artifactId>maven-deploy-plugin</artifactId>
<version>2.8.2</version>
</plugin>
-->
</plugins>
</pluginManagement>
</build>
</project>
运行，先清理再编译
mvn clean compile
现在程序正常运行可以使用打包命令
先清理在打包war包
mvn clean package
Tomcat运行war包
可以在tomcat的bin目录下面运行cmd
startup.bat
访问链接：http://localhost:8080/web/index.jsp
让web工程依赖java工程
创建web里面的test和java和main的文件
E:\Maven\Maven-workspace\pro02-maven-web\src\main\java\com\atguigu\maven
E:\Maven\Maven-workspace\pro02-maven-web\src\test\java\com\atguigu\maven
然后将E:\Maven\Maven-workspace\pro01-maven-java项目的java源码和测试类放进pro02-maven-web新创建对应的文件夹里，Java源码就放源码，测试就放测试的文件。
然后在pro02-maven-web的pom文件里面写入
<dependency>
<groupId>com.atguigu.maven</groupId>
<artifactId>pro01-maven-java</artifactId>
<version>1.0-SNAPSHOT</version>
<scope>compile</scope>
</dependency>
然后在pro02-maven-web 有pom文件的上方打开cmd然后运行mvn test运行测试在打包mvn package
以下就是war包
查看j哪些依赖jar包
mvn dependency:list
查看层级的jar包依赖
mvn dependency:tree
pom标签的引入范围
web引入java类测试引入的效果
web测试类
>mvn clean compile #java源码编译测试
>mvn clean test-compile #测试类编译
web运行cmd
mvn clean package #清除并且重新打包war 在target里面会有打包的war
test只能在测试的时候去使用
compile 默认的，使用自己下载的jar包
provided 一般在tomcat中有jar包就要添加provided不会被打包，直接用tomcat服务器提供的jar包，如果硬要添加自己的jar包就会有冲突，
tomcat的jar包路径E:\apache-tomcat-9.0.53-windows-x64\apache-tomcat-9.0.53\lib
依赖传递
在java中的pro01-maven-java的\pom添加spring依赖
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.0.0.RELEASE</version>
</dependency>
查看依赖的关系 mvn dependency:tree
查看依赖的关系出现的依赖都可以直接用的 mvn dependency:list
从新清理pro01-maven-java并且安装一下jar包到本地仓库 mvn clean install
然后在pro02-maven-web中执行 mvn dependency:tree
依赖排除
<dependency>
<groupId>com.atguigu.maven</groupId>
<artifactId>pro01-maven-java</artifactId>
<version>1.0-SNAPSHOT</version>
<scope>compile</scope>
<!--配置依赖的排除-->
<exclusions>
<!--配置具体排除信息，让commns-logging不要传递到当前工程（pro02-maven-web）-->
<exclusion>
<!--被pro01-maven-java依赖的,并且排除掉-->
<!--这里指定坐标时不需要指定version -->
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
pom继承
重新创建父工程
cd ..
mvn archetype:generate
返回上一级重新创建父工程
进入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.0</modelVersion>
<groupId>com.atguigu.maven</groupId>
<artifactId>pro03-maven-parent</artifactId>
<version>1.0-SNAPSHOT</version>
<!--当前工程作为父工程，要起管理其他工程，打包方式必须是pom-->
<packaging>pom</packaging>
<name>pro03-maven-parent</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<!--
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
-->
</dependencies>
</project>
在pro03-maven-parent目录里面执行cmd输入以下命令
mvn archetype:generate #创建工程
com.atguigu.maven
pro03-maven-parent
pro04-maven-module
pro05-maven-module
pro06-maven-module
添加完子工程后，父工程有子工程的信息
以下是父工程pom文件
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<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.atguigu.maven</groupId>
<artifactId>pro03-maven-parent</artifactId>
<version>1.0-SNAPSHOT</version>
<!--当前工程作为父工程，要起管理其他工程，打包方式必须是pom-->
<packaging>pom</packaging>
<name>pro03-maven-parent</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<!--
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
-->
</dependencies>
<modules>
<!--聚合工程，就是子工程的名称依赖父工程-->
<module>pro04-maven-module</module>
<module>pro05-maven-module</module>
<module>pro06-maven-module</module>
</modules>
<!--在父工程中统一管理依赖信息-->
<!--被管理的依赖并没有真正被引入到工程-->
<!--注意：即使在父工程配置了对依赖的管理，子工程需要使用具体哪一个依赖还是要明确配置-->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.0.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>4.0.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.0.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-expression</artifactId>
<version>4.0.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>4.0.0.RELEASE</version>
</dependency>
</dependencies>
</dependencyManagement>
</project>
以下是子工程pom文件
<?xml version="1.0"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<!--自动添加父工程 parent 标签给当前工程配置父工程-->
<parent>
<!--通过指定父工程找到父工程-->
<groupId>com.atguigu.maven</groupId>
<artifactId>pro03-maven-parent</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>
<!--子工程坐标groupI 如果和父工程一样可以省略不写-->
<!- <groupId>com.atguigu.maven</groupId>-->
<!--省略groupID和version后，子工程自己的坐标只保留artifactId-->
<artifactId>pro04-maven-module</artifactId>
<!--子工程坐标version 如果和父工程一样可以省略不写-->
<!--<version>1.0-SNAPSHOT</version>-->
<name>pro04-maven-module</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<!--注意：即使在父工程配置了对依赖的管理，子工程需要使用具体哪一个依赖还是要明确配置-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<!-- 可以不用写版本号啊，已经依赖父类-->
<!--<version>4.0.0.RELEASE</version>-->
</dependency>
</dependencies>
</project>
需要哪个依赖就拿哪个
<?xml version="1.0"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.atguigu.maven</groupId>
<artifactId>pro03-maven-parent</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>
<groupId>com.atguigu.maven</groupId>
<artifactId>pro05-maven-module</artifactId>
<version>1.0-SNAPSHOT</version>
<name>pro05-maven-module</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
</dependency>
</dependencies>
</project>
maven链接 ： https://mvnrepository.com/artifact/org.springframework/spring-core/4.0.0.RELEASE
mvn dependency:tree
mvn dependency:list
提示修改父工程的版本，子工程的版本也会跟着父工程的变动而变动
父工程pom文件一处修改处处修改
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<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.atguigu.maven</groupId>
<artifactId>pro03-maven-parent</artifactId>
<version>1.0-SNAPSHOT</version>
<!--当前工程作为父工程，要起管理其他工程，打包方式必须是pom-->
<packaging>pom</packaging>
<name>pro03-maven-parent</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<!--创建我们自定义的属性标签-->
<!--标签名：属性名 表情值：属性值 引用方式：${atguigu.spring.zidingyibiaoqian.version}-->
<atguigu.spring.zidingyibiaoqian.version>4.1.0.RELEASE</atguigu.spring.zidingyibiaoqian.version>
</properties>
<dependencies>
<!--
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
-->
</dependencies>
<modules> <module>pro04-maven-module</module>
<module>pro05-maven-module</module>
<module>pro06-maven-module</module>
</modules>
<!--在父工程中统一管理依赖信息-->
<!--被管理的依赖并没有真正被引入到工程-->
<!--注意：即使在父工程配置了对依赖的管理，子工程需要使用具体哪一个依赖还是要明确配置-->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<!--通过引用属性表达式设定版本号，这样版本号就变成了一个动态值 通过属性名解析后才知道具体什么值-->
<version>${atguigu.spring.zidingyibiaoqian.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${atguigu.spring.zidingyibiaoqian.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${atguigu.spring.zidingyibiaoqian.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-expression</artifactId>
<version>${atguigu.spring.zidingyibiaoqian.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${atguigu.spring.zidingyibiaoqian.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
</project>
聚合安装依赖
介绍：安装父工程就自动安装子工程，有聚合性
父工程
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<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.atguigu.maven</groupId>
<artifactId>pro03-maven-parent</artifactId>
<version>1.0-SNAPSHOT</version>
<!--当前工程作为父工程，要起管理其他工程，打包方式必须是pom-->
<packaging>pom</packaging>
<name>pro03-maven-parent</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<!--创建我们自定义的属性标签-->
<!--标签名：属性名 表情值：属性值 引用方式：${atguigu.spring.zidingyibiaoqian.version}-->
<atguigu.spring.zidingyibiaoqian.version>4.2.0.RELEASE</atguigu.spring.zidingyibiaoqian.version>
</properties>
<dependencies>
<!--
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
-->
</dependencies>
<modules> <module>pro04-maven-module</module>
<module>pro05-maven-module</module>
<module>pro06-maven-module</module>
</modules>
<!--在父工程中统一管理依赖信息-->
<!--被管理的依赖并没有真正被引入到工程-->
<!--注意：即使在父工程配置了对依赖的管理，子工程需要使用具体哪一个依赖还是要明确配置-->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<!--通过引用属性表达式设定版本号，这样版本号就变成了一个动态值 通过属性名解析后才知道具体什么值-->
<version>${atguigu.spring.zidingyibiaoqian.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${atguigu.spring.zidingyibiaoqian.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${atguigu.spring.zidingyibiaoqian.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-expression</artifactId>
<version>${atguigu.spring.zidingyibiaoqian.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${atguigu.spring.zidingyibiaoqian.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
</project>
子工程4依赖5
<?xml version="1.0"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.atguigu.maven</groupId>
<artifactId>pro03-maven-parent</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>
<groupId>com.atguigu.maven</groupId>
<artifactId>pro04-maven-module</artifactId>
<version>1.0-SNAPSHOT</version>
<name>pro04-maven-module</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<!--测试聚合之后可以一件安装：让pro04 依赖pro05-->
<dependency>
<groupId>com.atguigu.maven</groupId>
<artifactId>pro05-maven-module</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
</dependency>
</dependencies>
</project>
子工程5依赖6
<?xml version="1.0"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.atguigu.maven</groupId>
<artifactId>pro03-maven-parent</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>
<groupId>com.atguigu.maven</groupId>
<artifactId>pro05-maven-module</artifactId>
<version>1.0-SNAPSHOT</version>
<name>pro05-maven-module</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<!--测试聚合之后可以一件安装：让pro05 依赖pro06-->
<dependency>
<groupId>com.atguigu.maven</groupId>
<artifactId>pro06-maven-module</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
</dependency>
</dependencies>
</project>
子工程6不动
但最保险还是用 mvn clean install 生成最新的jar包
mvn clean install
使用idea运行maven
打开idea
创建maven项目
选择自动导入包
添加子工程
现在运行一个java
package com.atguigu.maven;
public class Hello {
public void mssingHello(){
System.out.println("hello maven ");
}
}
测试类
package com.atguigu.maven;
import org.junit.Test;
public class TestHello {
@Test
public void testHello(){
Hello hello = new Hello();
hello.mssingHello();
}
}
maven运行的几种方式
mvn clean install -Dmaven.test.skip=true
通过父工程创建web工程
在web的pom文件里指定打包为war
<!--war工程按要求打包为war -->
<packaging>war</packaging>
下面生产wab
需要自己添加路径 src\main\webapp\WEB-INF
看路径是否正确
现在已经完成web基本操作
现在写javaweb
package com.atguigu.maven;
public class Message {
public String Messages(){
return "hello messages";
}
}
<%@ page import="com.atguigu.maven.Message" %><%--
Created by IntelliJ IDEA.
User: admin
Date: 2022/6/28
Time: 18:01
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%--jsp模式new类调方法--%>
<%=new Message().Messages()%>
</body>
</html>
创建一个工程 打开命令
导入
运行报错的是没有指定maven的配置文件
现在就不报错了
模块导入
重新创建一个p’roject
从新加载文档
现在点亮pom文件
现在java工程导入成功
导入web工程和上面导入java工程类似
下面让idea识别wabapp
pro04-maven-import-module的pom文件要修改modules
和packaging
<?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.atguigu.maven</groupId>
<artifactId>pro04-maven-import-module</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging>
<modules>
<module>pro03-module-java</module>
<module>pro04-module-web</module>
</modules>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
</project>
pro04-module-web 要修改parent
<?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>pro04-maven-import-module</artifactId>
<groupId>com.atguigu.maven</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>pro04-module-web</artifactId>
<!--war工程按要求打包为war -->
<packaging>war</packaging>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
</project>
pro03-module-java 要修改parent
<?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>pro04-maven-import-module</artifactId>
<groupId>com.atguigu.maven</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>pro03-module-java</artifactId>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
然后运行tomcat和java的main方法
maven生命周期
生命周期，当你运行3的时候会自动执行123三个环节
当你运行5的时候前面的1234都会被执行一遍
Clean 清理操作相关
pre-clean
clean
post-clean
Site 生成站点相关
pre-site 生成站点之前
site 生产站点
post-site 生成站点之后
deploy-site 部署这个站点
Default主要构建过程
validate 检查语法结构对不对
generate-sources 生成源码 对应的是Java目录也就是main下面
process-sources 对应的是java目录
generate-resources 对应的是java目录下面的resources目录
process-resources 复制并处理资源文件，至目标目录，准备打包。
compile 编译项目 main 目录下的源代码。
process-classes 处理编译好的类
generate-test-sources 测试的java目录
process-test-sources
generate-test-resources
process-test-resources 复制并处理资源文件，至目标测试目录。
test-compile 编译测试源代码。
process-test-classes
test 使用合适的单元测试框架运行测试。这些测试代码不会被打包或部署。
prepare-package 准备打包
package 接受编译好的代码，打包成可发布的格式，如JAR。
pre-integration-test
integration-test
post-integration-test
verify
install将包安装至本地仓库，以让其它项目依赖。
deploy将最终的包复制到远程的仓库，以让其它开发人员共享；或者部署到服务器上运行（需借助插件，例如：cargo）
列如执行install就会执行install之前的所有
一个插件就是本地库的jar包
执行了某个插件下的命令就等于执行了一个生命周期
③特点
前面三个生命周期彼此是独立的。
在任何一个生命周期内部，执行任何一个具体环节的操作，都是从本周期最初的位置开始执行，直到指定的地方。（本节记住这句话就行了，其他的都不需要记）
Maven 之所以这么设计其实就是为了提高构建过程的自动化程度：让使用者只关心最终要干的即可，过程中的各个环节是自动执行的。
2、插件和目标
#①插件
Maven 的核心程序仅仅负责宏观调度，不做具体工作。具体工作都是由 Maven 插件完成的。例如：编译就是由 maven-compiler-plugin-3.1.jar 插件来执行的。
#②目标
一个插件可以对应多个目标，而每一个目标都和生命周期中的某一个环节对应。
Default 生命周期中有 compile 和 test-compile 两个和编译相关的环节，这两个环节对应 compile 和 test-compile 两个目标，而这两个目标都是由 maven-compiler-plugin-3.1.jar 插件来执行的。
3、仓库
本地仓库：在当前电脑上，为电脑上所有 Maven 工程服务
远程仓库：需要联网
局域网：我们自己搭建的 Maven 私服，例如使用 Nexus 技术。
Internet
中央仓库
镜像仓库：内容和中央仓库保持一致，但是能够分担中央仓库的负载，同时让用户能够就近访问提高下载速度，例如：Nexus aliyun
建议：不要中央仓库和阿里云镜像混用，否则 jar 包来源不纯，彼此冲突。
专门搜索 Maven 依赖信息的网站：https://mvnrepository.com/
***`
*** ## 单体架构 ***
`***
1、架构
#①架构的概念
『架构』其实就是『项目的结构』，只是因为架构是一个更大的词，通常用来形容比较大规模事物的结构。
#②单一架构
单一架构也叫『all-in-one』结构，就是所有代码、配置文件、各种资源都在同一个工程。
一个项目包含一个工程
导出一个 war 包
放在一个 Tomcat 上运行
创建pro05-demo-all-in-one项目
<?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.atguigu.com</groupId>
<artifactId>pro05-demo-all-in-one</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.37</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.2.8</version>
</dependency>
<!-- https://mvnrepository.com/artifact/commons-dbutils/commons-dbutils -->
<dependency>
<groupId>commons-dbutils</groupId>
<artifactId>commons-dbutils</artifactId>
<version>1.6</version>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/org.thymeleaf/thymeleaf -->
<dependency>
<groupId>org.thymeleaf</groupId>
<artifactId>thymeleaf</artifactId>
<version>3.0.11.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/junit/junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/ch.qos.logback/logback-classic -->
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.2.3</version>
</dependency>
</dependencies>
</project>
maven地址：https://mvnrepository.com/
物理建模 ：在MySQL里面写
create database db_imperial_court;
use db_imperial_court;
create table t_emp
(
emp_id int primary key auto_increment,
emp_name char(100) not null,
emp_position char(100) not null,
login_account char(100) not null unique,
login_password char(100) not null
);
insert into t_emp(emp_name, emp_position, login_account, login_password)
values ('爱新觉罗·玄烨', 'emperor', 'xiaoxuanzi1654', '25325C896624D444B2E241807DCAC98B'), # 16540504
('纳兰明珠', 'minister', 'brightball1635', 'A580D0EF93C22036C859E194C14CB777'), # 16351119
('赫舍里·索额图', 'minister', 'tutu1636', 'E40FD7D49B8B7EF46F47407D583C3538'); # 17030921
create table t_memorials
(
memorials_id int primary key auto_increment,
memorials_title char(100) not null,
memorials_content varchar(5000) not null,
memorials_emp int not null,
memorials_create_time char(100),
feedback_time char(100),
feedback_content varchar(1000),
memorials_status int not null
);
insert into t_memorials(memorials_title,
memorials_content,
memorials_emp,
memorials_create_time,
feedback_time,
feedback_content,
memorials_status)
values ('浙江巡抚奏钱塘堤决口疏', '皇上啊，不好啦！钱塘江发大水啦！堤坝冲毁啦！您看这咋弄啊！', 2, '1690-05-07', null, null, 0),
('左都御史参鳌拜圈地疏', '皇上啊，鳌拜这厮不是东西呀！占老百姓的地哇！还打人呀！您看咋弄啊！', 3, '1690-04-14', null, null, 0),
('都察院劾吴三桂不臣疏', '皇上啊，不得了啦！吴三桂那孙子想造反呀！', 2, '1693-11-18', null, null, 0),
('兵部奏准噶尔犯境疏', '皇上啊，不得了啦！葛尔丹要打过来了呀！', 3, '1693-11-18', null, null, 0),
('朝鲜使臣朝拜事宜呈皇上御览', '皇上啊！朝鲜国的人要来啦！咱们请他们吃猪肉炖粉条子吧！', 2, '1680-06-11', null, null, 0),
('英吉利炮舰购买事宜疏', '皇上啊！英国的小船船咱们买多少啊？', 3, '1680-06-12', null, null, 0),
('劾杭州织造贪墨疏', '皇上啊！杭州织造有问题啊！', 2, '1680-06-13', null, null, 0),
('禀畅春园落成疏', '皇上啊！畅春园修好了哇！您啥时候过来看看呀！', 3, '1680-06-14', null, null, 0),
('请旨木兰秋狝疏', '皇上啊！秋天到啦，又该打猎啦！', 2, '1680-06-15', null, null, 0),
('核准西北军饷银两疏', '皇上啊！您看看这钱数算的对不对呀！', 3, '1680-06-16', null, null, 0),
('请旨裁撤三藩疏', '皇上啊！咱们不裁撤三藩就芭比Q了哇！', 2, '1680-06-17', null, null, 0),
('蒙古王公进京朝拜疏', '皇上啊！蒙古王公要来啦！咱们请他们吃猪肉炖粉条子吧！', 3, '1680-06-18', null, null, 0),
('礼部请旨九阿哥赐名疏', '皇上啊！您看九阿哥该叫什么名字呀？', 2, '1680-06-19', null, null, 0),
('户部尚书请旨告老还乡疏', '皇上啊！臣想回家养老啦！您看看啥时候给臣把俸禄结一下啊！', 3, '1680-06-20', null, null, 0),
('查江宁织造贪墨疏', '皇上啊！江宁织造有问题啊！', 2, '1680-06-21', null, null, 0)
;
遇见数据库插入中文出现问号处理
创建数据库名称
create database '数据库名' default character set utf8 collate utf8_general_ci;
登录mysql黑框框输入show variables like 'char%';
找到mysql安装的路径，修改my.ini文件，插入以下
[client]
default-character-set=utf8
[mysql]
default-character-set=utf8
[mysqld]
character_set_server=utf8
collation-server=utf8_general_ci
在任务管理器
开服务，找到mysql服务，重启服务，则配置会生效
再输入show variables like 'char%'; 就变成了utf-8
查看sql的结构语句
desc "表的名字"
将java工程变成web工程，添加一个war就可以
web.xml
<filter>
<filter-name>txFilter</filter-name>
<filter-class>com.atguigu.imperial.court.filter.TransactionFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>txFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
对构建过程进行自己的定制
<build>
<!-- 最终打包的名称-->
<finalName>name-demo1</finalName>
</build>
#[1]确保异常回滚
在程序执行的过程中，必须让所有 catch 块都把编译时异常转换为运行时异常抛出；如果不这么做，在 TransactionFilter 中 catch 就无法捕获到底层抛出的异常，那么该回滚的时候就无法回滚
查看他们的关系
<!-- 依赖MyBatis核心包 -->
<dependencies>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.7</version>
</dependency>
</dependencies>
<!-- 控制Maven在构建过程中相关配置 -->
<build>
<!-- 构建过程中用到的插件 -->
<plugins>
<!-- 具体插件，逆向工程的操作是以构建过程中插件形式出现的 -->
<plugin>
<groupId>org.mybatis.generator</groupId>
<artifactId>mybatis-generator-maven-plugin</artifactId>
<version>1.3.0</version>
<!-- 插件的依赖 -->
<dependencies>
<!-- 逆向工程的核心依赖 -->
<dependency>
<groupId>org.mybatis.generator</groupId>
<artifactId>mybatis-generator-core</artifactId>
<version>1.3.2</version>
</dependency>
<!-- 数据库连接池 -->
<dependency>
<groupId>com.mchange</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.2</version>
</dependency>
<!-- MySQL驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.8</version>
</dependency>
</dependencies>
</plugin>
</plugins>
</build>
import依赖范围
如果不能依赖到父类可以强行执行
在父工程打包，依赖的子工程也会被打包
<sourceDirectory>D:\idea2019workspace\atguigu-maven-test-prepare\src\main\java</sourceDirectory>
<scriptSourceDirectory>D:\idea2019workspace\atguigu-maven-test-prepare\src\main\scripts</scriptSourceDirectory>
<testSourceDirectory>D:\idea2019workspace\atguigu-maven-test-prepare\src\test\java</testSourceDirectory>
<outputDirectory>D:\idea2019workspace\atguigu-maven-test-prepare\target\classes</outputDirectory>
<testOutputDirectory>D:\idea2019workspace\atguigu-maven-test-prepare\target\test-classes</testOutputDirectory>
<resources>
<resource>
<directory>D:\idea2019workspace\atguigu-maven-test-prepare\src\main\resources</directory>
</resource>
</resources>
<testResources>
<testResource>
<directory>D:\idea2019workspace\atguigu-maven-test-prepare\src\test\resources</directory>
</testResource>
</testResources>
<directory>D:\idea2019workspace\atguigu-maven-test-prepare\target</directory>
可以拿出来运行脱离本地maven’配置文件
<!-- build 标签：意思是告诉 Maven，你的构建行为，我要开始定制了！ -->
<build>
<!-- plugins 标签：Maven 你给我听好了，你给我构建的时候要用到这些插件！ -->
<plugins>
<!-- plugin 标签：这是我要指定的一个具体的插件 -->
<plugin>
<!-- 插件的坐标。此处引用的 maven-compiler-plugin 插件不是第三方的，是一个 Maven 自带的插件。 -->
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<!-- configuration 标签：配置 maven-compiler-plugin 插件 -->
<configuration>
<!-- 具体配置信息会因为插件不同、需求不同而有所差异 -->
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
</plugins>
</build>
②示例代码
所有的一切已经都被 SpringBoot 封装好了，所以配置非常简单，提供插件坐标即可。
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>2.5.5</version>
</plugin>
</plugins>
</build>
#③小结
其实 Maven 的版本仲裁机制只是在没有人为干预的情况下，自主决定 jar 包版本的一个办法。而实际上我们要使用具体的哪一个版本，还要取决于项目中的实际情况。所以在项目正常运行的情况下，jar 包版本可以由 Maven 仲裁，不必我们操心；而发生冲突时 Maven 仲裁决定的版本无法满足要求，此时就应该由程序员明确指定 jar 包版本。
maven插件
maven-plugin
③引入依赖
下面两种方式二选一：
#[1]将来在文档注释中使用注解需要实现接口
<dependency>
<groupId>org.apache.maven</groupId>
<artifactId>maven-plugin-api</artifactId>
<version>3.5.2</version>
</dependency>
[2]将来直接使用注解
<dependency>
<groupId>org.apache.maven.plugin-tools</groupId>
<artifactId>maven-plugin-annotations</artifactId>
<version>3.5.2</version>
</dependency>
③配置到 build 标签里
这里找一个和插件无关的 Maven 工程配置才有说服力
<build>
<plugins>
<plugin>
需要被打成jar包
<groupId>com.atguigu.maven</groupId>
<artifactId>hello-maven-plugin</artifactId>
<version>1.0-SNAPSHOT</version>
<executions>
<execution>
<id>hello</id>
<!-- 指定和目标关联的生命周期阶段 -->
<phase>clean</phase>
<goals>
<goal>sayHello</goal>
</goals>
</execution>
<execution>
<id>blood</id>
<phase>validate</phase>
<goals>
<goal>firstBlood</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
profile
3、激活 profile
#①默认配置默认被激活
前面提到了，POM 中没有在 profile 标签里的就是默认的 profile，当然默认被激活。
#②基于环境信息激活
环境信息包含：JDK 版本、操作系统参数、文件、属性等各个方面。一个 profile 一旦被激活，那么它定义的所有配置都会覆盖原来 POM 中对应层次的元素。大家可以参考下面的标签结构：
<profile>
<id>dev</id>
<activation>
<!-- 配置是否默认激活 -->
<activeByDefault>false</activeByDefault>
<jdk>1.5</jdk>
<os>
<name>Windows XP</name>
<family>Windows</family>
<arch>x86</arch>
<version>5.1.2600</version>
</os>
<property>
<name>mavenVersion</name>
<value>2.0.5</value>
</property>
<file>
<exists>file2.properties</exists>
<missing>file1.properties</missing>
</file>
</activation>
</profile>
这里有个问题是：多个激活条件之间是什么关系呢？
Maven 3.2.2 之前：遇到第一个满足的条件即可激活——或的关系。
Maven 3.2.2 开始：各条件均需满足——且的关系。
下面我们来看一个具体例子。假设有如下 profile 配置，在 JDK 版本为 1.6 时被激活
<profiles>
<profile>
<id>JDK1.6</id>
<activation>
<!-- 指定激活条件为：JDK 1.6 -->
<jdk>1.6</jdk>
</activation>
……
</profile>
</profiles>
这里需要指出的是：Maven 会自动检测当前环境安装的 JDK 版本，只要 JDK 版本是以 1.6 开头都算符合条件。下面几个例子都符合：
1.6.0_03
1.6.0_02
……
③命令行激活
#[1]列出活动的 profile# 列出所有激活的 profile，以及它们在哪里定义 mvn help:active-profiles
2]指定某个具体 profilemvn compile -P<profile id>
①编写 Lambda 表达式代码
Lambda 表达式代码要求 JDK 版本必须是 1.8，我们可以以此来判断某个指定更低 JDK 版本的 profile 是否被激活生效。
@Test
public void test() {
new Thread(()->{
System.out.println(Thread.currentThread().getName() + " is working");
}).start();
}
②配置 profile
<profiles>
<profile>
<id>myJDKProfile</id>
<!-- build 标签：意思是告诉 Maven，你的构建行为，我要开始定制了！ -->
<build>
<!-- plugins 标签：Maven 你给我听好了，你给我构建的时候要用到这些插件！ -->
<plugins>
<!-- plugin 标签：这是我要指定的一个具体的插件 -->
<plugin>
<!-- 插件的坐标。此处引用的 maven-compiler-plugin 插件不是第三方的，是一个 Maven 自带的插件。 -->
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<!-- configuration 标签：配置 maven-compiler-plugin 插件 -->
<configuration>
<!-- 具体配置信息会因为插件不同、需求不同而有所差异 -->
<source>1.6</source>
<target>1.6</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
</plugins>
</build>
</profile>
</profiles>
5、资源属性过滤
#①简介
Maven 为了能够通过 profile 实现各不同运行环境切换，提供了一种『资源属性过滤』的机制。通过属性替换实现不同环境使用不同的参数。
②操作演示
#[1]配置 profile
<profiles>
<profile>
<id>devJDBCProfile</id>
<properties>
<dev.jdbc.user>root</dev.jdbc.user>
<dev.jdbc.password>atguigu</dev.jdbc.password>
<dev.jdbc.url>http://localhost:3306/db_good</dev.jdbc.url>
<dev.jdbc.driver>com.mysql.jdbc.Driver</dev.jdbc.driver>
</properties>
<build>
<resources>
<resource>
<!-- 表示为这里指定的目录开启资源过滤功能 -->
<directory>src/main/resources</directory>
<!-- 将资源过滤功能打开 -->
<filtering>true</filtering>
</resource>
</resources>
</build>
</profile>
</profiles>
#[2]创建待处理的资源文件
[2]创建待处理的资源文件
dev.user=${dev.jdbc.user}
dev.password=${dev.jdbc.password}
dev.url=${dev.jdbc.url}
dev.driver=${dev.jdbc.driver}
[3]执行处理资源命令
mvn clean resources:resources -PdevJDBCProfile
<build>
<resources>
<resource>
<!-- 表示为这里指定的目录开启资源过滤功能 -->
<directory>src/main/resources</directory>
<!-- 将资源过滤功能打开 -->
<filtering>true</filtering>
<includes>
<include>*.properties</include>
</includes>
<excludes>
<exclude>happy.properties</exclude>
</excludes>
</resource>
</resources>
</build>
执行处理资源命令：mvn clean resources:resources -PdevJDBCProfile
搭建 Maven 私服：Nexus
①下载地址
小诀窍：使用迅雷下载比直接用浏览器下载快很多
https://download.sonatype.com/nexus/3/latest-unix.tar.gz
②上传、解压
上传到 Linux 系统，解压后即可使用，不需要安装。但是需要注意：必须提前安装 JDK。
[root@x nexus-3.37.0-01]# ll
总用量 96
drwxr-xr-x. 3 root root 4096 2月 13 17:33 bin
drwxr-xr-x. 2 root root 4096 2月 13 17:33 deploy
drwxr-xr-x. 7 root root 4096 2月 13 17:33 etc
drwxr-xr-x. 5 root root 4096 2月 13 17:33 lib
-rw-r–r–. 1 root root 651 11月 20 01:40 NOTICE.txt
-rw-r–r–. 1 root root 17321 11月 20 01:40 OSS-LICENSE.txt
-rw-r–r–. 1 root root 41954 11月 20 01:40 PRO-LICENSE.txt
drwxr-xr-x. 3 root root 4096 2月 13 17:33 public
drwxr-xr-x. 3 root root 4096 2月 13 17:33 replicator
drwxr-xr-x. 23 root root 4096 2月 13 17:33 system
#③启动 Nexus
[root@x ~]# /opt/nexus-3.37.0-01/bin/nexus start
WARNING: ************************************************************
WARNING: Detected execution as “root” user. This is NOT recommended!
WARNING: ************************************************************
Starting nexus
[root@x ~]# /opt/nexus-3.37.0-01/bin/nexus status
WARNING: ************************************************************
WARNING: Detected execution as “root” user. This is NOT recommended!
WARNING: ************************************************************
nexus is running.
#④查看端口占用情况
[root@x ~]# netstat -anp | grep java
tcp 0 0 127.0.0.1:45614 0.0.0.0:* LISTEN 9872/java
tcp 0 0 0.0.0.0:8081 0.0.0.0:* LISTEN 9872/java
上面 45614 这个每次都不一样，不用管它。我们要访问的是 8081 这个端口。但是需要注意：8081 端口的这个进程要在启动 /opt/nexus-3.37.0-01/bin/nexus 这个主体程序一、两分钟后才会启动，请耐心等待。
⑤访问 Nexus 首页
首页地址：http://[Linux 服务器地址]:8081/
关闭关闭防火墙
解决jar冲突
第二种方法 ③Maven 的 enforcer 插件
使用 Maven 的 enforcer 插件既可以检测同一个 jar 包的不同版本，又可以检测不同 jar 包中同名的类。
#[1]引入 netty 依赖
这里我们引入两个对 netty 的依赖，展示不同 jar 包中有同名类的情况。
举例在这里插入代码片
<dependencies>
<dependency>
<groupId>org.jboss.netty</groupId>
<artifactId>netty</artifactId>
<version>3.2.10.Final</version>
</dependency>
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty</artifactId>
<version>3.9.2.Final</version>
</dependency>
</dependencies>
[2]配置 enforcer 插件
<build>
<pluginManagement>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-enforcer-plugin</artifactId>
<version>1.4.1</version>
<executions>
<execution>
<id>enforce-dependencies</id>
<phase>validate</phase>
<goals>
<goal>display-info</goal>
<goal>enforce</goal>
</goals>
</execution>
</executions>
<dependencies>
<dependency>
<groupId>org.codehaus.mojo</groupId>
<artifactId>extra-enforcer-rules</artifactId>
<version>1.0-beta-4</version>
</dependency>
</dependencies>
<configuration>
<rules>
<banDuplicateClasses>
<findAllDuplicates>true</findAllDuplicates>
</banDuplicateClasses>
</rules>
</configuration>
</plugin>
</plugins>
</pluginManagement>
</build>
执行如下 Maven 命令：mvn clean package enforcer:enforce
部分运行结果：
[INFO] — maven-enforcer-plugin:1.4.1:enforce (default-cli) @ pro32-duplicate-class —
[WARNING] Rule 0: org.apache.maven.plugins.enforcer.BanDuplicateClasses failed with message:
Duplicate classes found:
Found in:
io.netty:netty:jar:3.9.2.Final:compile
org.jboss.netty:netty:jar:3.2.10.Final:compile
Duplicate classes:
org/jboss/netty/channel/socket/ServerSocketChannelConfig.class
org/jboss/netty/channel/socket/nio/NioSocketChannelConfig.class
org/jboss/netty/util/internal/jzlib/Deflate.class
org/jboss/netty/handler/codec/serialization/ObjectDecoder.class
org/jboss/netty/util/internal/ConcurrentHashMap$HashIterator.class
……
引入外部jar，非maven
第三节 体系外 jar 包引入
#1、提出问题
『体系外 jar 包』这个名字是我起的，来源是这样——目前来说我们在 Maven 工程中用到的 jar 包都是通过 Maven 本身的机制导入进来的。
而实际开发中确实有可能用到一些 jar 包并非是用 Maven 的方式发布，那自然也没法通过 Maven 导入。
此时如果我们能够拿到该 jar 包的源码那还可以自己建一个 Maven 工程，自己打包。可是如果连源码都没有呢？
这方面的例子包括一些人脸识别用的 jar 包、海康视频监控 jar 包等等。
#2、解决办法
#①准备一个体系外 jar 包
我们通过学 Maven 以前的方式创建一个 Java 工程，然后导出 jar 包即可用来测试。
这里我们使用 install 插件的 install-file 目标：
mvn install:install-file -Dfile=[体系外 jar 包路径] \
-DgroupId=[给体系外 jar 包强行设定坐标] \
-DartifactId=[给体系外 jar 包强行设定坐标] \
-Dversion=1 \
-Dpackage=jar
例如（Windows 系统下使用 ^ 符号换行；Linux 系统用 \）：
mvn install:install-file -Dfile=D:\idea2019workspace\atguigu-maven-outer\out\artifacts\atguigu_maven_outer\atguigu-maven-outer.jar ^
-DgroupId=com.atguigu.maven ^
-DartifactId=atguigu-maven-outer ^
-Dversion=1 ^
-Dpackaging=jar
我们打开 POM 文件看看：
<?xml version="1.0" encoding="UTF-8"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<groupId>com.atguigu.maven</groupId>
<artifactId>atguigu-maven-outer</artifactId>
<version>1</version>
<description>POM was created from install:install-file</description>
</project>
③测试
在其它地方依赖这个 jar 包：
<dependency>
<groupId>com.atguigu.maven</groupId>
<artifactId>atguigu-maven-outer</artifactId>
<version>1</version>
</dependency>
能运行就完成了
665
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
