maven基础+maven阿里云镜像和maven官方仓库

如何跳过测试

方法一 skipTests图标

点击skipTests，此时test变灰,此时执行package,install 将不会执行测试test

方法二 直接命令mvn package -DskipTests

方法三 插件

配置插件跳过测试skipTests

<plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.22.2</version>
                <configuration>
                    <skipTests>true</skipTests>
                </configuration>
            </plugin>

选择/排除测试

配置排除或者包含测试，此时不需要配置skipTests

 <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.22.2</version>
                <configuration>
                    <!--包含-->
                    <includes>
                        <include>**/login</include>
                    </includes>
                    <!--排除-->
                    <excludes>
                        <exclude>**/Sms</exclude>
                    </excludes>
                </configuration>
            </plugin>

        </plugins>

 

maven项目(1):文件上传与下载

概述

平常经常使用文件的上传下载功能，这里特定集合上传下载编写一个简单的文件管理项目。

本项目源码已发布至Gitee,欢迎下载使用。
https://gitee.com/lengcz/filemanager.git

创建项目

1. 创建maven-web项目
   此步骤略。
   项目文件结构
   

2. 编写核心代码
   (1) 上传

package com.upload;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUploadBase;
import org.apache.commons.fileupload.ProgressListener;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;

import com.alibaba.fastjson.JSONObject;
import com.upload.constant.SplitConstant;
import com.upload.util.DateUtils;

public class UploadHandleServlet extends HttpServlet {

	private static final String projectName = "filemanager";

	/**
	 * 
	 */
	private static final long serialVersionUID = 50516503021L;

	public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		InetAddress addr = InetAddress.getLocalHost();
		String ip = addr.getHostAddress().toString(); // 获取本机ip

		String returnType = request.getParameter("returnType");

		// 得到上传文件的保存目录，将上传的文件存放于WEB-INF目录下，不允许外界直接访问，保证上传文件的安全
		String savePath = this.getServletContext().getRealPath("/WEB-INF/upload");
		// 上传时生成的临时文件保存目录
		String tempPath = this.getServletContext().getRealPath("/WEB-INF/temp");
		File tmpFile = new File(tempPath);
		if (!tmpFile.exists()) {
			// 创建临时目录
			tmpFile.mkdir();
		}
		// System.out.println("文件位置:" + tmpFile.getAbsolutePath());

		// 消息提示
		String message = "";

		List<String> downLoadList = new ArrayList<String>();

		try {
			// 使用Apache文件上传组件处理文件上传步骤：
			// 1、创建一个DiskFileItemFactory工厂
			DiskFileItemFactory factory = new DiskFileItemFactory();
			// 设置工厂的缓冲区的大小，当上传的文件大小超过缓冲区的大小时，就会生成一个临时文件存放到指定的临时目录当中。
			factory.setSizeThreshold(1024 * 100);// 设置缓冲区的大小为100KB，如果不指定，那么缓冲区的大小默认是10KB
			// 设置上传时生成的临时文件的保存目录
			factory.setRepository(tmpFile);
			// 2、创建一个文件上传解析器
			ServletFileUpload upload = new ServletFileUpload(factory);
			// 监听文件上传进度
			upload.setProgressListener(new ProgressListener() {
				public void update(long pBytesRead, long pContentLength, int arg2) {
					System.out.println("文件大小为：" + pContentLength + ",当前已处理：" + pBytesRead);
					/**
					 * 文件大小为：14608,当前已处理：4096 文件大小为：14608,当前已处理：7367
					 * 文件大小为：14608,当前已处理：11419 文件大小为：14608,当前已处理：14608
					 */
				}
			});
			// 解决上传文件名的中文乱码
			upload.setHeaderEncoding("UTF-8");
			// 3、判断提交上来的数据是否是上传表单的数据
			if (!ServletFileUpload.isMultipartContent(request)) {
				// 按照传统方式获取数据
				return;
			}

			// 设置上传单个文件的大小的最大值，目前是设置为1024*1024字节，也就是1MB*512
			upload.setFileSizeMax(1024 * 1024 * 512);
			// 设置上传文件总量的最大值，最大值=同时上传的多个文件的大小的最大值的和，目前设置为10MB*512
			upload.setSizeMax(1024 * 1024 * 10 * 256);
			// 4、使用ServletFileUpload解析器解析上传数据，解析结果返回的是一个List<FileItem>集合，每一个FileItem对应一个Form表单的输入项
			List<FileItem> list = upload.parseRequest(request);

			int uploadFileCount = 0;

			for (FileItem item : list) {
				// 如果fileitem中封装的是普通输入项的数据
				if (item.isFormField()) {
					String name = item.getFieldName();
					// 解决普通输入项的数据的中文乱码问题
					String value = item.getString("UTF-8");
					// value = new String(value.getBytes("iso8859-1"),"UTF-8");
					System.out.println(name + "=" + value);
				} else {// 如果fileitem中封装的是上传文件
						// 得到上传的文件名称，
					String filename = item.getName();
					System.out.println(filename);
					if (filename != null && !filename.trim().equals("")) {
						uploadFileCount++;
					} else {
						continue;
					}
					// 注意：不同的浏览器提交的文件名是不一样的，有些浏览器提交上来的文件名是带有路径的，如：
					// c:\a\b\1.txt，而有些只是单纯的文件名，如：1.txt
					// 处理获取到的上传文件的文件名的路径部分，只保留文件名部分
					filename = filename.substring(filename.lastIndexOf("\\") + 1);
					// 得到上传文件的扩展名
					String fileExtName = filename.substring(filename.lastIndexOf(".") + 1);
					// 如果需要限制上传的文件类型，那么可以通过文件的扩展名来判断上传的文件类型是否合法
					System.out.println("上传的文件的扩展名是：" + fileExtName);
					// 获取item中的上传文件的输入流
					InputStream in = item.getInputStream();
					// 得到文件保存的名称
					String saveFilename = makeFileName(filename);
					downLoadList.add(saveFilename);
					// 得到文件的保存目录
					String realSavePath = makePath(saveFilename, savePath);
					// 创建一个文件输出流
					FileOutputStream out = new FileOutputStream(realSavePath + "\\" + saveFilename);
					// 创建一个缓冲区
					byte buffer[] = new byte[1024];
					// 判断输入流中的数据是否已经读完的标识
					int len = 0;
					// 循环将输入流读入到缓冲区当中，(len=in.read(buffer))>0就表示in里面还有数据
					while ((len = in.read(buffer)) > 0) {
						// 使用FileOutputStream输出流将缓冲区的数据写入到指定的目录(savePath + "\\"
						// + filename)当中
						out.write(buffer, 0, len);
					}
					// 关闭输入流
					in.close();
					// 关闭输出流
					out.close();
					// 删除处理文件上传时生成的临时文件
					// item.delete();
					message = "文件上传成功";
				}
			}

			if (uploadFileCount == 0) {
				request.setAttribute("message", "未上传任何文件");
				request.getRequestDispatcher("/message.jsp").forward(request, response);
				return;
			}
		} catch (FileUploadBase.FileSizeLimitExceededException e) {
			e.printStackTrace();
			message = "单个文件超出最大值！！！";
			// request.setAttribute("message", "单个文件超出最大值！！！");
			// request.getRequestDispatcher("/message.jsp").forward(request,
			// response);
			// return;
		} catch (FileUploadBase.SizeLimitExceededException e) {
			e.printStackTrace();
			message = "上传文件的总的大小超出限制的最大值！！！";
			// request.setAttribute("message", "上传文件的总的大小超出限制的最大值！！！");
			// request.getRequestDispatcher("/message.jsp").forward(request,
			// response);
			// return;
		} catch (Exception e) {
			message = "文件上传失败！";
			e.printStackTrace();
		}

		JSONObject json = new JSONObject();
		json.put("code", message == "文件上传成功" ? 0 : 1);
		json.put("message", message);

		String downloadUrl = "";
		if (downLoadList.size() == 1) {
			downloadUrl = "http://" + ip + ":8080/" + projectName + "/servlet/DownLoadServlet?filename="
					+ downLoadList.get(0);
			json.put("downloadUrl", downloadUrl);
		} else if (downLoadList.size() > 1) {
			for (int i = 0; i < downLoadList.size(); i++) {
				json.put("downloadUrl_" + i, "http://" + ip + ":8080/" + projectName
						+ "/servlet/DownLoadServlet?filename=" + downLoadList.get(i));
			}
		}

		if ((returnType + "").equals("json")) {
			request.setAttribute("message", json.toString());
		} else {
			request.setAttribute("message", message);
			request.setAttribute("downloadUrl", downloadUrl);
		}

		// String
		// downloadUrl="http://localhost:8080/upload/servlet/DownLoadServlet?filename="+fileName;
		// http://localhost:8080/upload/servlet/DownLoadServlet?filename=e331e853-1c0e-4a74-a978-b1c12c559fee_aaa.png
		request.getRequestDispatcher("/message.jsp").forward(request, response);
	}

	private String makeFileName(String filename) { // 2.jpg
		// 为防止文件覆盖的现象发生，要为上传文件产生一个唯一的文件名
		String nowStr = DateUtils.getNowStr();
		return UUID.randomUUID().toString() + SplitConstant.SPLIT_SYMBOL + nowStr + SplitConstant.SPLIT_SYMBOL + filename;
	}

	private String makePath(String filename, String savePath) {
		// 得到文件名的hashCode的值，得到的就是filename这个字符串对象在内存中的地址
		// int hashcode = filename.hashCode();
		// int dir1 = hashcode & 0xf; // 0--15
		// int dir2 = (hashcode & 0xf0) >> 4; // 0-15
		// 构造新的保存目录
		String[] filenames = filename.split(SplitConstant.SPLIT_SYMBOL);
		String dir = savePath + "\\" + filenames[1]; // upload\2\3
														// upload\3\5
		// File既可以代表文件也可以代表目录
		File file = new File(dir);
		// 如果目录不存在
		if (!file.exists()) {
			// 创建目录
			file.mkdirs();
		}
		return dir;
	}

	public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

		doGet(request, response);
	}
}

（2）下载

package com.upload;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.URLEncoder;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.upload.constant.SplitConstant;

public class DownLoadServlet extends HttpServlet {

	/**
	 * 
	 */
	private static final long serialVersionUID = 201805081622162L;

	public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// 得到要下载的文件名
		String fileName = request.getParameter("filename"); // 23239283-92489-阿凡达.avi
		// fileName = new String(fileName.getBytes("iso8859-1"), "UTF-8");
		// 上传的文件都是保存在/WEB-INF/upload目录下的子目录当中
		String fileSaveRootPath = this.getServletContext().getRealPath("/WEB-INF/upload");
		// 通过文件名找出文件的所在目录
		String path = findFileSavePathByFileName(fileName, fileSaveRootPath);
		// 得到要下载的文件
		File file = new File(path + "\\" + fileName);
		// 如果文件不存在
		if (!file.exists()) {
			request.setAttribute("message", "您要下载的资源已被删除！！");
			request.getRequestDispatcher("/message.jsp").forward(request, response);
			return;
		}
		// 处理文件名
		String realname = fileName.substring(fileName.lastIndexOf(SplitConstant.SPLIT_SYMBOL) + SplitConstant.SPLIT_SYMBOL.length());
		// 设置响应头，控制浏览器下载该文件
		response.setHeader("content-disposition", "attachment;filename=" + URLEncoder.encode(realname, "UTF-8"));
		// 读取要下载的文件，保存到文件输入流
		FileInputStream in = new FileInputStream(path + "\\" + fileName);
		// 创建输出流
		OutputStream out = response.getOutputStream();
		// 创建缓冲区
		byte buffer[] = new byte[1024];
		int len = 0;
		// 循环将输入流中的内容读取到缓冲区当中
		while ((len = in.read(buffer)) > 0) {
			// 输出缓冲区的内容到浏览器，实现文件下载
			out.write(buffer, 0, len);
		}
		// 关闭文件输入流
		in.close();
		// 关闭输出流
		out.close();
	}

	public String findFileSavePathByFileName(String filename, String saveRootPath) {
		// int hashcode = filename.hashCode();
		// int dir1 = hashcode & 0xf; // 0--15
		// int dir2 = (hashcode & 0xf0) >> 4; // 0-15
		// String dir = saveRootPath + "\\" + dir1 + "\\" + dir2; // upload\2\3

		String[] filenames = filename.split(SplitConstant.SPLIT_SYMBOL);
		String dir = saveRootPath + "\\" + filenames[1]; // upload\2\3
															// upload\3\5//
															// upload\3\5
		File file = new File(dir);
		if (!file.exists()) {
			// 创建目录
			file.mkdirs();
		}
		return dir;
	}

	public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		doGet(request, response);
	}
}

(3)显示列表

package com.upload;

import java.io.File;
import java.io.IOException;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.upload.constant.SplitConstant;
import com.upload.entity.FileInfo;
import com.upload.util.DateUtils;

public class ListFileServlet extends HttpServlet {

	/**
	 * 
	 */
	private static final long serialVersionUID = 201805089626295L;

	public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// 获取上传文件的目录
		String uploadFilePath = this.getServletContext().getRealPath("/WEB-INF/upload");
		// 存储要下载的文件名

		List<FileInfo> listFile = new ArrayList<FileInfo>();
		listfile(new File(uploadFilePath), listFile);// File既可以代表一个文件也可以代表一个目录


		Collections.sort(listFile, new Comparator<FileInfo>() {

			public int compare(FileInfo o1, FileInfo o2) {
				// 返回值为int类型，大于0表示正序，小于0表示逆序
				return (int) (o2.getUploadTime() - o1.getUploadTime());
			}
		});

		request.setAttribute("listFile", listFile);

		double totalLength = 0D;// 文件总大小
		for (FileInfo f : listFile) {
			totalLength = totalLength + f.getFileLength();
		}

		DecimalFormat df = new DecimalFormat("0.00");

		request.setAttribute("fileCount", listFile.size());
		request.setAttribute("totalLength", df.format(totalLength/(1024*1024)));
		request.getRequestDispatcher("/listfile.jsp").forward(request, response);
	}

	public void listfile(File file, List<FileInfo> listFile) {
		// 如果file代表的不是一个文件，而是一个目录
		if (!file.isFile()) {
			// 列出该目录下的所有文件和目录
			File files[] = file.listFiles();
			// 遍历files[]数组
			for (File f : files) {
				// 递归
				listfile(f, listFile);
			}
		} else {
			/**
			 * 处理文件名，上传后的文件是以uuid_文件名的形式去重新命名的，去除文件名的uuid_部分
			 * file.getName().indexOf("_")检索字符串中第一次出现"_"字符的位置，如果文件名类似于：
			 * 9349249849-88343-8344_阿_凡_达.avi
			 * 那么file.getName().substring(file.getName().indexOf("_")+1)
			 * 处理之后就可以得到阿_凡_达.avi部分
			 */
			String realName = file.getName().substring(
					file.getName().lastIndexOf(SplitConstant.SPLIT_SYMBOL) + SplitConstant.SPLIT_SYMBOL.length());
			// file.getName()得到的是文件的原始名称，这个名称是唯一的，因此可以作为key，realName是处理过后的名称，有可能会重复

			// String[] fileInfos =
			// file.getName().split(SplitConstant.SPLIT_SYMBOL);

			FileInfo f = new FileInfo();
			f.setName(realName);
			f.setFullName(file.getName());
			try {

				double filelength = file.length();
				f.setFileLength(filelength);
				DecimalFormat df = new DecimalFormat("0.00");
				if (filelength / (1024 * 1024) > 1) {
					f.setFileLengthStr(df.format(filelength / (1024 * 1024)) + " MB");
				} else if (filelength / (1024) > 1) {
					f.setFileLengthStr(df.format(filelength / (1024)) + " KB");
				} else {
					f.setFileLengthStr(file.length() + " Byte");
				}

				// long uploadTime = Long.parseLong(fileInfos[fileInfos.length -
				// 2]);
				long uploadTime = file.lastModified();
				f.setUploadTime(uploadTime);
				f.setUploadTimeStr(DateUtils.getDateString(uploadTime));
			} catch (Exception e) {
				e.printStackTrace();
			}

			listFile.add(f);
		}
	}

	public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		doGet(request, response);
	}
}

（4）删除

package com.upload;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.URLEncoder;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.upload.constant.SplitConstant;

public class DeleteServlet extends HttpServlet {

	/**
	 * 
	 */
	private static final long serialVersionUID = 201805081622162L;

	public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// 得到要下载的文件名
		String fileName = request.getParameter("filename"); // 23239283-92489-阿凡达.avi
		// fileName = new String(fileName.getBytes("iso8859-1"), "UTF-8");
		// 上传的文件都是保存在/WEB-INF/upload目录下的子目录当中
		String fileSaveRootPath = this.getServletContext().getRealPath("/WEB-INF/upload");
		// 通过文件名找出文件的所在目录
		String path = findFileSavePathByFileName(fileName, fileSaveRootPath);
		// 得到要下载的文件
		File file = new File(path + "\\" + fileName);
		// 如果文件不存在
		if (!file.exists()) {
			request.setAttribute("message", "您要刪除的资源不存在！！");
			request.getRequestDispatcher("//message.jsp").forward(request, response);
			return;
		}
		
		file.delete();
		
		request.setAttribute("message", "文件刪除成功！！");
		request.getRequestDispatcher("/message.jsp").forward(request, response);
	}

	public String findFileSavePathByFileName(String filename, String saveRootPath) {
		// int hashcode = filename.hashCode();
		// int dir1 = hashcode & 0xf; // 0--15
		// int dir2 = (hashcode & 0xf0) >> 4; // 0-15
		// String dir = saveRootPath + "\\" + dir1 + "\\" + dir2; // upload\2\3

		String[] filenames = filename.split(SplitConstant.SPLIT_SYMBOL);
		String dir = saveRootPath + "\\" + filenames[1]; // upload\2\3
															// upload\3\5//
															// upload\3\5
		File file = new File(dir);
		if (!file.exists()) {
			// 创建目录
			file.mkdirs();
		}
		return dir;
	}

	public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		doGet(request, response);
	}
}

3. 配置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>UploadHandleServlet</servlet-name>
		<servlet-class>com.upload.UploadHandleServlet</servlet-class>
	</servlet>
	<servlet>
		<servlet-name>ListFileServlet</servlet-name>
		<servlet-class>com.upload.ListFileServlet</servlet-class>
	</servlet>

	<servlet>
		<servlet-name>DownLoadServlet</servlet-name>
		<servlet-class>com.upload.DownLoadServlet</servlet-class>
	</servlet>

<servlet>
		<servlet-name>DeleteServlet</servlet-name>
		<servlet-class>com.upload.DeleteServlet</servlet-class>
	</servlet>


	<servlet-mapping>
		<servlet-name>UploadHandleServlet</servlet-name>
		<url-pattern>/servlet/UploadHandleServlet</url-pattern>
	</servlet-mapping>

	<servlet-mapping>
		<servlet-name>ListFileServlet</servlet-name>
		<url-pattern>/servlet/ListFileServlet</url-pattern>
	</servlet-mapping>

	<servlet-mapping>
		<servlet-name>DownLoadServlet</servlet-name>
		<url-pattern>/servlet/DownLoadServlet</url-pattern>
	</servlet-mapping>
	
	<servlet-mapping>
		<servlet-name>DeleteServlet</servlet-name>
		<url-pattern>/servlet/DeleteServlet</url-pattern>
	</servlet-mapping>
	<welcome-file-list>
		<welcome-file>index.html</welcome-file>
		<welcome-file>index.htm</welcome-file>
		<welcome-file>index.jsp</welcome-file>
		<welcome-file>default.html</welcome-file>
		<welcome-file>default.htm</welcome-file>
		<welcome-file>default.jsp</welcome-file>
	</welcome-file-list>
</web-app>

4. 其他代码略

5. 启动项目
   

6. 访问测试 http://localhost:8000/filemanager/
   

项目构建启动成功

maven基础(2):坐标

Maven坐标

坐标的定义

坐标用于描述资源在仓库的地址

坐标的构成

groupId:组织的id,例如org.apache
artifactId:项目名称,例如ERP
version:版本，例如1.0.0-RELEASE正式发布版本,1.0.0-SNAPSHOT快照版本(测试)
packaging:打包方式,默认jar,可以打包为war(web项目),pom(父子项目的父项目的打包方式)
其他坐标参数：

 <!--项目的名称, Maven产生的文档用-->
    <name>ERP</name>
    <!--项目主页的URL, Maven产生的文档用-->
    <url>http://www.baidu.com/banseon</url>
    <!--项目的详细描述, Maven 产生的文档用。 当这个元素能够用HTML格式描述时（例如，CDATA中的文本会被解析器忽略，就可以包含HTML标签）， 不鼓励使用纯文本描述。如果你需要修改产生的web站点的索引页面，你应该修改你自己的索引页文件，而不是调整这里的文档。-->
    <description>this is ERP.</description>

maven基础(1):下载安装和配置环境变量

下载安装和配置环境变量

1. maven下载:https://maven.apache.org/download.cgi

2. 解压文件到指定目录:

3. 配置环境变量
   新建MAVEN_HOME:D:\developsoft\apache-maven-3.5.0
   编辑path,新增%MAVEN_HOME%\bin
   
   

4. 检查maven是否安装成功
   

配置镜像仓库:

由于maven中央仓库在国外，速度会比较慢，这里可以配置maven镜像仓库
，如下是配置的阿里云镜像仓库
找到maven路径下conf文件夹下的settings.xml文件

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

配置本地仓库下载路径

maven默认将下载的jar文件存到: ${user.home}/.m2/repository文件夹，在C盘目录下,会导致C盘占用越来越大。
这里同样找到maven安装目录conf文件夹下面的setting.xml文件

<localRepository>D:\developsoft\maven\repository</localRepository>

基本命令

mvn compile 编译
mvn clean 清理
mvn test 跑测试
mvn package 测试
mvn install 安装到本地仓库
mvn deploy 发布到远程仓库

mvn package -DskipTests 跳过测试打包

maven pom文件简单模板和配置详解:

https://blog.csdn.net/earbao/article/details/49924943

1. <?xml version="1.0" encoding="UTF-8"?>
2. <project xmlns="http://maven.apache.org/POM/4.0.0"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5. <parent>
6. <artifactId>docbuilder</artifactId>
7. <groupId>com.jiepu</groupId>
8. <version>1.0</version>
9. </parent>
10. <modelVersion>4.0.0</modelVersion>
11.  
12. <artifactId>Core</artifactId>
13.  
14. <properties>
15. <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
16. <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
17. <java.version>1.8</java.version>
18. </properties>
19.  
20.  
21. <dependencies>
22. <dependency>
23. <groupId>com.alibaba</groupId>
24. <artifactId>fastjson</artifactId>
25. <version>1.2.6</version>
26. </dependency>
27. <dependency>
28. <groupId>org.apache.poi</groupId>
29. <artifactId>poi</artifactId>
30. <version>3.12</version>
31. </dependency>
32. <dependency>
33. <groupId>org.freemarker</groupId>
34. <artifactId>freemarker</artifactId>
35. <version>2.3.23</version>
36. </dependency>
37. <dependency>
38. <groupId>sax</groupId>
39. <artifactId>sax</artifactId>
40. <version>2.0.1</version>
41. </dependency>
42.  
43. <!-- 本地lib引用，不用的就删除掉,demo而已-->
44. <dependency>
45. <groupId>org.sqlite</groupId>
46. <artifactId>sqlite-jdbc</artifactId>
47. <version>3.7.2</version>
48. <scope>system</scope>
49. <systemPath>${project.basedir}/lib/sqlite-jdbc-3.7.2.jar</systemPath>
50. </dependency>
51. </dependencies>
52.  
53. <build>
54. <!-- 强制设置JDK编译版本为1.8 -->
55. <plugins>
56. <plugin>
57. <groupId>org.apache.maven.plugins</groupId>
58. <artifactId>maven-compiler-plugin</artifactId>
59. <configuration>
60. <source>${java.version}</source>
61. <target>${java.version}</target>
62. </configuration>
63. </plugin>
64.  
65. </plugins>
66. </build>
67.  
68.  
69. </project>

 

 

1. <project xmlns="http://maven.apache.org/POM/4.0.0 "
2. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance "
3. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd ">
4. <!--父项目的坐标。如果项目中没有规定某个元素的值，那么父项目中的对应值即为项目的默认值。 坐标包括group ID，artifact ID和 version。-->
5. <parent>
6. <!--被继承的父项目的构件标识符-->
7. <artifactId/>
8. <!--被继承的父项目的全球唯一标识符-->
9. <groupId/>
10. <!--被继承的父项目的版本-->
11. <version/>
12. <!--父项目的pom.xml文件的相对路径。相对路径允许你选择一个不同的路径。默认值是../pom.xml。Maven首先在构建当前项目的地方寻找父项目的pom，其次在文件系统的这个位置（relativePath位置），然后在本地仓库，最后在远程仓库寻找父项目的pom。-->
13. <relativePath/>
14. </parent>
15. <!--声明项目描述符遵循哪一个POM模型版本。模型本身的版本很少改变，虽然如此，但它仍然是必不可少的，这是为了当Maven引入了新的特性或者其他模型变更的时候，确保稳定性。-->
16. <modelVersion>4.0.0</modelVersion>
17. <!--项目的全球唯一标识符，通常使用全限定的包名区分该项目和其他项目。并且构建时生成的路径也是由此生成， 如com.mycompany.app生成的相对路径为：/com/mycompany/app-->
18. <groupId>asia.banseon</groupId>
19. <!--构件的标识符，它和group ID一起唯一标识一个构件。换句话说，你不能有两个不同的项目拥有同样的artifact ID和groupID；在某个特定的group ID下，artifact ID也必须是唯一的。构件是项目产生的或使用的一个东西，Maven为项目产生的构件包括：JARs，源码，二进制发布和WARs等。-->
20. <artifactId>banseon-maven2</artifactId>
21. <!--项目产生的构件类型，例如jar、war、ear、pom。插件可以创建他们自己的构件类型，所以前面列的不是全部构件类型-->
22. <packaging>jar</packaging>
23. <!--项目当前版本，格式为:主版本.次版本.增量版本-限定版本号-->
24. <version>1.0-SNAPSHOT</version>
25. <!--项目的名称, Maven产生的文档用-->
26. <name>banseon-maven</name>
27. <!--项目主页的URL, Maven产生的文档用-->
28. <url>http://www.baidu.com/banseon</url>
29. <!--项目的详细描述, Maven 产生的文档用。 当这个元素能够用HTML格式描述时（例如，CDATA中的文本会被解析器忽略，就可以包含HTML标签）， 不鼓励使用纯文本描述。如果你需要修改产生的web站点的索引页面，你应该修改你自己的索引页文件，而不是调整这里的文档。-->
30. <description>A maven project to study maven.</description>
31. <!--描述了这个项目构建环境中的前提条件。-->
32. <prerequisites>
33. <!--构建该项目或使用该插件所需要的Maven的最低版本-->
34. <maven/>
35. </prerequisites>
36. <!--项目的问题管理系统(Bugzilla, Jira, Scarab,或任何你喜欢的问题管理系统)的名称和URL，本例为 jira-->
37. <issueManagement>
38. <!--问题管理系统（例如jira）的名字，-->
39. <system>jira</system>
40. <!--该项目使用的问题管理系统的URL-->
41. <url>http://jira.baidu.com/banseon</url>
42. </issueManagement>
43. <!--项目持续集成信息-->
44. <ciManagement>
45. <!--持续集成系统的名字，例如continuum-->
46. <system/>
47. <!--该项目使用的持续集成系统的URL（如果持续集成系统有web接口的话）。-->
48. <url/>
49. <!--构建完成时，需要通知的开发者/用户的配置项。包括被通知者信息和通知条件（错误，失败，成功，警告）-->
50. <notifiers>
51. <!--配置一种方式，当构建中断时，以该方式通知用户/开发者-->
52. <notifier>
53. <!--传送通知的途径-->
54. <type/>
55. <!--发生错误时是否通知-->
56. <sendOnError/>
57. <!--构建失败时是否通知-->
58. <sendOnFailure/>
59. <!--构建成功时是否通知-->
60. <sendOnSuccess/>
61. <!--发生警告时是否通知-->
62. <sendOnWarning/>
63. <!--不赞成使用。通知发送到哪里-->
64. <address/>
65. <!--扩展配置项-->
66. <configuration/>
67. </notifier>
68. </notifiers>
69. </ciManagement>
70. <!--项目创建年份，4位数字。当产生版权信息时需要使用这个值。-->
71. <inceptionYear/>
72. <!--项目相关邮件列表信息-->
73. <mailingLists>
74. <!--该元素描述了项目相关的所有邮件列表。自动产生的网站引用这些信息。-->
75. <mailingList>
76. <!--邮件的名称-->
77. <name>Demo</name>
78. <!--发送邮件的地址或链接，如果是邮件地址，创建文档时，mailto: 链接会被自动创建-->
79. <post>banseon@126.com</post>
80. <!--订阅邮件的地址或链接，如果是邮件地址，创建文档时，mailto: 链接会被自动创建-->
81. <subscribe>banseon@126.com</subscribe>
82. <!--取消订阅邮件的地址或链接，如果是邮件地址，创建文档时，mailto: 链接会被自动创建-->
83. <unsubscribe>banseon@126.com</unsubscribe>
84. <!--你可以浏览邮件信息的URL-->
85. <archive>http:/hi.baidu.com/banseon/demo/dev/</archive>
86. </mailingList>
87. </mailingLists>
88. <!--项目开发者列表-->
89. <developers>
90. <!--某个项目开发者的信息-->
91. <developer>
92. <!--SCM里项目开发者的唯一标识符-->
93. <id>HELLO WORLD</id>
94. <!--项目开发者的全名-->
95. <name>banseon</name>
96. <!--项目开发者的email-->
97. <email>banseon@126.com</email>
98. <!--项目开发者的主页的URL-->
99. <url/>
100. <!--项目开发者在项目中扮演的角色，角色元素描述了各种角色-->
101. <roles>
102. <role>Project Manager</role>
103. <role>Architect</role>
104. </roles>
105. <!--项目开发者所属组织-->
106. <organization>demo</organization>
107. <!--项目开发者所属组织的URL-->
108. <organizationUrl>http://hi.baidu.com/banseon</organizationUrl>
109. <!--项目开发者属性，如即时消息如何处理等-->
110. <properties>
111. <dept>No</dept>
112. </properties>
113. <!--项目开发者所在时区， -11到12范围内的整数。-->
114. <timezone>-5</timezone>
115. </developer>
116. </developers>
117. <!--项目的其他贡献者列表-->
118. <contributors>
119. <!--项目的其他贡献者。参见developers/developer元素-->
120. <contributor>
121. <name/><email/><url/><organization/><organizationUrl/><roles/><timezone/><properties/>
122. </contributor>
123. </contributors>
124. <!--该元素描述了项目所有License列表。 应该只列出该项目的license列表，不要列出依赖项目的 license列表。如果列出多个license，用户可以选择它们中的一个而不是接受所有license。-->
125. <licenses>
126. <!--描述了项目的license，用于生成项目的web站点的license页面，其他一些报表和validation也会用到该元素。-->
127. <license>
128. <!--license用于法律上的名称-->
129. <name>Apache 2</name>
130. <!--官方的license正文页面的URL-->
131. <url>http://www.baidu.com/banseon/LICENSE-2.0.txt</url>
132. <!--项目分发的主要方式：
133. repo，可以从Maven库下载
134. manual， 用户必须手动下载和安装依赖-->
135. <distribution>repo</distribution>
136. <!--关于license的补充信息-->
137. <comments>A business-friendly OSS license</comments>
138. </license>
139. </licenses>
140. <!--SCM(Source Control Management)标签允许你配置你的代码库，供Maven web站点和其它插件使用。-->
141. <scm>
142. <!--SCM的URL,该URL描述了版本库和如何连接到版本库。欲知详情，请看SCMs提供的URL格式和列表。该连接只读。-->
143. <connection>
144. scm:svn:http://svn.baidu.com/banseon/maven/banseon/banseon-maven2-trunk(dao-trunk)
145. </connection>
146. <!--给开发者使用的，类似connection元素。即该连接不仅仅只读-->
147. <developerConnection>
148. scm:svn:http://svn.baidu.com/banseon/maven/banseon/dao-trunk
149. </developerConnection>
150. <!--当前代码的标签，在开发阶段默认为HEAD-->
151. <tag/>
152. <!--指向项目的可浏览SCM库（例如ViewVC或者Fisheye）的URL。-->
153. <url>http://svn.baidu.com/banseon</url>
154. </scm>
155. <!--描述项目所属组织的各种属性。Maven产生的文档用-->
156. <organization>
157. <!--组织的全名-->
158. <name>demo</name>
159. <!--组织主页的URL-->
160. <url>http://www.baidu.com/banseon</url>
161. </organization>
162. <!--构建项目需要的信息-->
163. <build>
164. <!--该元素设置了项目源码目录，当构建项目的时候，构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。-->
165. <sourceDirectory/>
166. <!--该元素设置了项目脚本源码目录，该目录和源码目录不同：绝大多数情况下，该目录下的内容 会被拷贝到输出目录(因为脚本是被解释的，而不是被编译的)。-->
167. <scriptSourceDirectory/>
168. <!--该元素设置了项目单元测试使用的源码目录，当测试项目的时候，构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。-->
169. <testSourceDirectory/>
170. <!--被编译过的应用程序class文件存放的目录。-->
171. <outputDirectory/>
172. <!--被编译过的测试class文件存放的目录。-->
173. <testOutputDirectory/>
174. <!--使用来自该项目的一系列构建扩展-->
175. <extensions>
176. <!--描述使用到的构建扩展。-->
177. <extension>
178. <!--构建扩展的groupId-->
179. <groupId/>
180. <!--构建扩展的artifactId-->
181. <artifactId/>
182. <!--构建扩展的版本-->
183. <version/>
184. </extension>
185. </extensions>
186. <!--当项目没有规定目标（Maven2 叫做阶段）时的默认值-->
187. <defaultGoal/>
188. <!--这个元素描述了项目相关的所有资源路径列表，例如和项目相关的属性文件，这些资源被包含在最终的打包文件里。-->
189. <resources>
190. <!--这个元素描述了项目相关或测试相关的所有资源路径-->
191. <resource>
192. <!--描述了资源的目标路径。该路径相对target/classes目录（例如${project.build.outputDirectory}）。举个例子，如果你想资源在特定的包里(org.apache.maven.messages)，你就必须该元素设置为org/apache/maven/messages。然而，如果你只是想把资源放到源码目录结构里，就不需要该配置。-->
193. <targetPath/>
194. <!--是否使用参数值代替参数名。参数值取自properties元素或者文件里配置的属性，文件在filters元素里列出。-->
195. <filtering/>
196. <!--描述存放资源的目录，该路径相对POM路径-->
197. <directory/>
198. <!--包含的模式列表，例如**/*.xml.-->
199. <includes/>
200. <!--排除的模式列表，例如**/*.xml-->
201. <excludes/>
202. </resource>
203. </resources>
204. <!--这个元素描述了单元测试相关的所有资源路径，例如和单元测试相关的属性文件。-->
205. <testResources>
206. <!--这个元素描述了测试相关的所有资源路径，参见build/resources/resource元素的说明-->
207. <testResource>
208. <targetPath/><filtering/><directory/><includes/><excludes/>
209. </testResource>
210. </testResources>
211. <!--构建产生的所有文件存放的目录-->
212. <directory/>
213. <!--产生的构件的文件名，默认值是${artifactId}-${version}。-->
214. <finalName/>
215. <!--当filtering开关打开时，使用到的过滤器属性文件列表-->
216. <filters/>
217. <!--子项目可以引用的默认插件信息。该插件配置项直到被引用时才会被解析或绑定到生命周期。给定插件的任何本地配置都会覆盖这里的配置-->
218. <pluginManagement>
219. <!--使用的插件列表 。-->
220. <plugins>
221. <!--plugin元素包含描述插件所需要的信息。-->
222. <plugin>
223. <!--插件在仓库里的group ID-->
224. <groupId/>
225. <!--插件在仓库里的artifact ID-->
226. <artifactId/>
227. <!--被使用的插件的版本（或版本范围）-->
228. <version/>
229. <!--是否从该插件下载Maven扩展（例如打包和类型处理器），由于性能原因，只有在真需要下载时，该元素才被设置成enabled。-->
230. <extensions/>
231. <!--在构建生命周期中执行一组目标的配置。每个目标可能有不同的配置。-->
232. <executions>
233. <!--execution元素包含了插件执行需要的信息-->
234. <execution>
235. <!--执行目标的标识符，用于标识构建过程中的目标，或者匹配继承过程中需要合并的执行目标-->
236. <id/>
237. <!--绑定了目标的构建生命周期阶段，如果省略，目标会被绑定到源数据里配置的默认阶段-->
238. <phase/>
239. <!--配置的执行目标-->
240. <goals/>
241. <!--配置是否被传播到子POM-->
242. <inherited/>
243. <!--作为DOM对象的配置-->
244. <configuration/>
245. </execution>
246. </executions>
247. <!--项目引入插件所需要的额外依赖-->
248. <dependencies>
249. <!--参见dependencies/dependency元素-->
250. <dependency>
251. </dependency>
252. </dependencies>
253. <!--任何配置是否被传播到子项目-->
254. <inherited/>
255. <!--作为DOM对象的配置-->
256. <configuration/>
257. </plugin>
258. </plugins>
259. </pluginManagement>
260. <!--使用的插件列表-->
261. <plugins>
262. <!--参见build/pluginManagement/plugins/plugin元素-->
263. <plugin>
264. <groupId/><artifactId/><version/><extensions/>
265. <executions>
266. <execution>
267. <id/><phase/><goals/><inherited/><configuration/>
268. </execution>
269. </executions>
270. <dependencies>
271. <!--参见dependencies/dependency元素-->
272. <dependency>
273. </dependency>
274. </dependencies>
275. <goals/><inherited/><configuration/>
276. </plugin>
277. </plugins>
278. </build>
279. <!--在列的项目构建profile，如果被激活，会修改构建处理-->
280. <profiles>
281. <!--根据环境参数或命令行参数激活某个构建处理-->
282. <profile>
283. <!--构建配置的唯一标识符。即用于命令行激活，也用于在继承时合并具有相同标识符的profile。-->
284. <id/>
285. <!--自动触发profile的条件逻辑。Activation是profile的开启钥匙。profile的力量来自于它
286. 能够在某些特定的环境中自动使用某些特定的值；这些环境通过activation元素指定。activation元素并不是激活profile的唯一方式。-->
287. <activation>
288. <!--profile默认是否激活的标志-->
289. <activeByDefault/>
290. <!--当匹配的jdk被检测到，profile被激活。例如，1.4激活JDK1.4，1.4.0_2，而!1.4激活所有版本不是以1.4开头的JDK。-->
291. <jdk/>
292. <!--当匹配的操作系统属性被检测到，profile被激活。os元素可以定义一些操作系统相关的属性。-->
293. <os>
294. <!--激活profile的操作系统的名字-->
295. <name>Windows XP</name>
296. <!--激活profile的操作系统所属家族(如 'windows')-->
297. <family>Windows</family>
298. <!--激活profile的操作系统体系结构 -->
299. <arch>x86</arch>
300. <!--激活profile的操作系统版本-->
301. <version>5.1.2600</version>
302. </os>
303. <!--如果Maven检测到某一个属性（其值可以在POM中通过${名称}引用），其拥有对应的名称和值，Profile就会被激活。如果值
304. 字段是空的，那么存在属性名称字段就会激活profile，否则按区分大小写方式匹配属性值字段-->
305. <property>
306. <!--激活profile的属性的名称-->
307. <name>mavenVersion</name>
308. <!--激活profile的属性的值-->
309. <value>2.0.3</value>
310. </property>
311. <!--提供一个文件名，通过检测该文件的存在或不存在来激活profile。missing检查文件是否存在，如果不存在则激活
312. profile。另一方面，exists则会检查文件是否存在，如果存在则激活profile。-->
313. <file>
314. <!--如果指定的文件存在，则激活profile。-->
315. <exists>/usr/local/hudson/hudson-home/jobs/maven-guide-zh-to-production/workspace/</exists>
316. <!--如果指定的文件不存在，则激活profile。-->
317. <missing>/usr/local/hudson/hudson-home/jobs/maven-guide-zh-to-production/workspace/</missing>
318. </file>
319. </activation>
320. <!--构建项目所需要的信息。参见build元素-->
321. <build>
322. <defaultGoal/>
323. <resources>
324. <resource>
325. <targetPath/><filtering/><directory/><includes/><excludes/>
326. </resource>
327. </resources>
328. <testResources>
329. <testResource>
330. <targetPath/><filtering/><directory/><includes/><excludes/>
331. </testResource>
332. </testResources>
333. <directory/><finalName/><filters/>
334. <pluginManagement>
335. <plugins>
336. <!--参见build/pluginManagement/plugins/plugin元素-->
337. <plugin>
338. <groupId/><artifactId/><version/><extensions/>
339. <executions>
340. <execution>
341. <id/><phase/><goals/><inherited/><configuration/>
342. </execution>
343. </executions>
344. <dependencies>
345. <!--参见dependencies/dependency元素-->
346. <dependency>
347. </dependency>
348. </dependencies>
349. <goals/><inherited/><configuration/>
350. </plugin>
351. </plugins>
352. </pluginManagement>
353. <plugins>
354. <!--参见build/pluginManagement/plugins/plugin元素-->
355. <plugin>
356. <groupId/><artifactId/><version/><extensions/>
357. <executions>
358. <execution>
359. <id/><phase/><goals/><inherited/><configuration/>
360. </execution>
361. </executions>
362. <dependencies>
363. <!--参见dependencies/dependency元素-->
364. <dependency>
365. </dependency>
366. </dependencies>
367. <goals/><inherited/><configuration/>
368. </plugin>
369. </plugins>
370. </build>
371. <!--模块（有时称作子项目） 被构建成项目的一部分。列出的每个模块元素是指向该模块的目录的相对路径-->
372. <modules/>
373. <!--发现依赖和扩展的远程仓库列表。-->
374. <repositories>
375. <!--参见repositories/repository元素-->
376. <repository>
377. <releases>
378. <enabled/><updatePolicy/><checksumPolicy/>
379. </releases>
380. <snapshots>
381. <enabled/><updatePolicy/><checksumPolicy/>
382. </snapshots>
383. <id/><name/><url/><layout/>
384. </repository>
385. </repositories>
386. <!--发现插件的远程仓库列表，这些插件用于构建和报表-->
387. <pluginRepositories>
388. <!--包含需要连接到远程插件仓库的信息.参见repositories/repository元素-->
389. <pluginRepository>
390. <releases>
391. <enabled/><updatePolicy/><checksumPolicy/>
392. </releases>
393. <snapshots>
394. <enabled/><updatePolicy/><checksumPolicy/>
395. </snapshots>
396. <id/><name/><url/><layout/>
397. </pluginRepository>
398. </pluginRepositories>
399. <!--该元素描述了项目相关的所有依赖。 这些依赖组成了项目构建过程中的一个个环节。它们自动从项目定义的仓库中下载。要获取更多信息，请看项目依赖机制。-->
400. <dependencies>
401. <!--参见dependencies/dependency元素-->
402. <dependency>
403. </dependency>
404. </dependencies>
405. <!--不赞成使用. 现在Maven忽略该元素.-->
406. <reports/>
407. <!--该元素包括使用报表插件产生报表的规范。当用户执行“mvn site”，这些报表就会运行。 在页面导航栏能看到所有报表的链接。参见reporting元素-->
408. <reporting>
409. </reporting>
410. <!--参见dependencyManagement元素-->
411. <dependencyManagement>
412. <dependencies>
413. <!--参见dependencies/dependency元素-->
414. <dependency>
415. </dependency>
416. </dependencies>
417. </dependencyManagement>
418. <!--参见distributionManagement元素-->
419. <distributionManagement>
420. </distributionManagement>
421. <!--参见properties元素-->
422. <properties/>
423. </profile>
424. </profiles>
425. <!--模块（有时称作子项目） 被构建成项目的一部分。列出的每个模块元素是指向该模块的目录的相对路径-->
426. <modules/>
427. <!--发现依赖和扩展的远程仓库列表。-->
428. <repositories>
429. <!--包含需要连接到远程仓库的信息-->
430. <repository>
431. <!--如何处理远程仓库里发布版本的下载-->
432. <releases>
433. <!--true或者false表示该仓库是否为下载某种类型构件（发布版，快照版）开启。 -->
434. <enabled/>
435. <!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。这里的选项是：always（一直），daily（默认，每日），interval：X（这里X是以分钟为单位的时间间隔），或者never（从不）。-->
436. <updatePolicy/>
437. <!--当Maven验证构件校验文件失败时该怎么做：ignore（忽略），fail（失败），或者warn（警告）。-->
438. <checksumPolicy/>
439. </releases>
440. <!--如何处理远程仓库里快照版本的下载。有了releases和snapshots这两组配置，POM就可以在每个单独的仓库中，为每种类型的构件采取不同的策略。例如，可能有人会决定只为开发目的开启对快照版本下载的支持。参见repositories/repository/releases元素-->
441. <snapshots>
442. <enabled/><updatePolicy/><checksumPolicy/>
443. </snapshots>
444. <!--远程仓库唯一标识符。可以用来匹配在settings.xml文件里配置的远程仓库-->
445. <id>banseon-repository-proxy</id>
446. <!--远程仓库名称-->
447. <name>banseon-repository-proxy</name>
448. <!--远程仓库URL，按protocol://hostname/path形式-->
449. <url>http://192.168.1.169:9999/repository/</url>
450. <!--用于定位和排序构件的仓库布局类型-可以是default（默认）或者legacy（遗留）。Maven 2为其仓库提供了一个默认的布局；然而，Maven 1.x有一种不同的布局。我们可以使用该元素指定布局是default（默认）还是legacy（遗留）。-->
451. <layout>default</layout>
452. </repository>
453. </repositories>
454. <!--发现插件的远程仓库列表，这些插件用于构建和报表-->
455. <pluginRepositories>
456. <!--包含需要连接到远程插件仓库的信息.参见repositories/repository元素-->
457. <pluginRepository>
458. </pluginRepository>
459. </pluginRepositories>
460. <!--该元素描述了项目相关的所有依赖。 这些依赖组成了项目构建过程中的一个个环节。它们自动从项目定义的仓库中下载。要获取更多信息，请看项目依赖机制。-->
461. <dependencies>
462. <dependency>
463. <!--依赖的group ID-->
464. <groupId>org.apache.maven</groupId>
465. <!--依赖的artifact ID-->
466. <artifactId>maven-artifact</artifactId>
467. <!--依赖的版本号。 在Maven 2里, 也可以配置成版本号的范围。-->
468. <version>3.8.1</version>
469. <!--依赖类型，默认类型是jar。它通常表示依赖的文件的扩展名，但也有例外。一个类型可以被映射成另外一个扩展名或分类器。类型经常和使用的打包方式对应，尽管这也有例外。一些类型的例子：jar，war，ejb-client和test-jar。如果设置extensions为 true，就可以在plugin里定义新的类型。所以前面的类型的例子不完整。-->
470. <type>jar</type>
471. <!--依赖的分类器。分类器可以区分属于同一个POM，但不同构建方式的构件。分类器名被附加到文件名的版本号后面。例如，如果你想要构建两个单独的构件成JAR，一个使用Java 1.4编译器，另一个使用Java 6编译器，你就可以使用分类器来生成两个单独的JAR构件。-->
472. <classifier></classifier>
473. <!--依赖范围。在项目发布过程中，帮助决定哪些构件被包括进来。欲知详情请参考依赖机制。
474. - compile ：默认范围，用于编译
475. - provided：类似于编译，但支持你期待jdk或者容器提供，类似于classpath
476. - runtime: 在执行时需要使用
477. - test: 用于test任务时使用
478. - system: 需要外在提供相应的元素。通过systemPath来取得
479. - systemPath: 仅用于范围为system。提供相应的路径
480. - optional: 当项目自身被依赖时，标注依赖是否传递。用于连续依赖时使用-->
481. <scope>test</scope>
482. <!--仅供system范围使用。注意，不鼓励使用这个元素，并且在新的版本中该元素可能被覆盖掉。该元素为依赖规定了文件系统上的路径。需要绝对路径而不是相对路径。推荐使用属性匹配绝对路径，例如${java.home}。-->
483. <systemPath></systemPath>
484. <!--当计算传递依赖时， 从依赖构件列表里，列出被排除的依赖构件集。即告诉maven你只依赖指定的项目，不依赖项目的依赖。此元素主要用于解决版本冲突问题-->
485. <exclusions>
486. <exclusion>
487. <artifactId>spring-core</artifactId>
488. <groupId>org.springframework</groupId>
489. </exclusion>
490. </exclusions>
491. <!--可选依赖，如果你在项目B中把C依赖声明为可选，你就需要在依赖于B的项目（例如项目A）中显式的引用对C的依赖。可选依赖阻断依赖的传递性。-->
492. <optional>true</optional>
493. </dependency>
494. </dependencies>
495. <!--不赞成使用. 现在Maven忽略该元素.-->
496. <reports></reports>
497. <!--该元素描述使用报表插件产生报表的规范。当用户执行“mvn site”，这些报表就会运行。 在页面导航栏能看到所有报表的链接。-->
498. <reporting>
499. <!--true，则，网站不包括默认的报表。这包括“项目信息”菜单中的报表。-->
500. <excludeDefaults/>
501. <!--所有产生的报表存放到哪里。默认值是${project.build.directory}/site。-->
502. <outputDirectory/>
503. <!--使用的报表插件和他们的配置。-->
504. <plugins>
505. <!--plugin元素包含描述报表插件需要的信息-->
506. <plugin>
507. <!--报表插件在仓库里的group ID-->
508. <groupId/>
509. <!--报表插件在仓库里的artifact ID-->
510. <artifactId/>
511. <!--被使用的报表插件的版本（或版本范围）-->
512. <version/>
513. <!--任何配置是否被传播到子项目-->
514. <inherited/>
515. <!--报表插件的配置-->
516. <configuration/>
517. <!--一组报表的多重规范，每个规范可能有不同的配置。一个规范（报表集）对应一个执行目标 。例如，有1，2，3，4，5，6，7，8，9个报表。1，2，5构成A报表集，对应一个执行目标。2，5，8构成B报表集，对应另一个执行目标-->
518. <reportSets>
519. <!--表示报表的一个集合，以及产生该集合的配置-->
520. <reportSet>
521. <!--报表集合的唯一标识符，POM继承时用到-->
522. <id/>
523. <!--产生报表集合时，被使用的报表的配置-->
524. <configuration/>
525. <!--配置是否被继承到子POMs-->
526. <inherited/>
527. <!--这个集合里使用到哪些报表-->
528. <reports/>
529. </reportSet>
530. </reportSets>
531. </plugin>
532. </plugins>
533. </reporting>
534. <!--继承自该项目的所有子项目的默认依赖信息。这部分的依赖信息不会被立即解析,而是当子项目声明一个依赖（必须描述group ID和artifact ID信息），如果group ID和artifact ID以外的一些信息没有描述，则通过group ID和artifact ID匹配到这里的依赖，并使用这里的依赖信息。-->
535. <dependencyManagement>
536. <dependencies>
537. <!--参见dependencies/dependency元素-->
538. <dependency>
539. </dependency>
540. </dependencies>
541. </dependencyManagement>
542. <!--项目分发信息，在执行mvn deploy后表示要发布的位置。有了这些信息就可以把网站部署到远程服务器或者把构件部署到远程仓库。-->
543. <distributionManagement>
544. <!--部署项目产生的构件到远程仓库需要的信息-->
545. <repository>
546. <!--是分配给快照一个唯一的版本号（由时间戳和构建流水号）？还是每次都使用相同的版本号？参见repositories/repository元素-->
547. <uniqueVersion/>
548. <id>banseon-maven2</id>
549. <name>banseon maven2</name>
550. <url>file://${basedir}/target/deploy</url>
551. <layout/>
552. </repository>
553. <!--构件的快照部署到哪里？如果没有配置该元素，默认部署到repository元素配置的仓库，参见distributionManagement/repository元素-->
554. <snapshotRepository>
555. <uniqueVersion/>
556. <id>banseon-maven2</id>
557. <name>Banseon-maven2 Snapshot Repository</name>
558. <url>scp://svn.baidu.com/banseon:/usr/local/maven-snapshot</url>
559. <layout/>
560. </snapshotRepository>
561. <!--部署项目的网站需要的信息-->
562. <site>
563. <!--部署位置的唯一标识符，用来匹配站点和settings.xml文件里的配置-->
564. <id>banseon-site</id>
565. <!--部署位置的名称-->
566. <name>business api website</name>
567. <!--部署位置的URL，按protocol://hostname/path形式-->
568. <url>
569. scp://svn.baidu.com/banseon:/var/www/localhost/banseon-web
570. </url>
571. </site>
572. <!--项目下载页面的URL。如果没有该元素，用户应该参考主页。使用该元素的原因是：帮助定位那些不在仓库里的构件（由于license限制）。-->
573. <downloadUrl/>
574. <!--如果构件有了新的group ID和artifact ID（构件移到了新的位置），这里列出构件的重定位信息。-->
575. <relocation>
576. <!--构件新的group ID-->
577. <groupId/>
578. <!--构件新的artifact ID-->
579. <artifactId/>
580. <!--构件新的版本号-->
581. <version/>
582. <!--显示给用户的，关于移动的额外信息，例如原因。-->
583. <message/>
584. </relocation>
585. <!--给出该构件在远程仓库的状态。不得在本地项目中设置该元素，因为这是工具自动更新的。有效的值有：none（默认），converted（仓库管理员从Maven 1 POM转换过来），partner（直接从伙伴Maven 2仓库同步过来），deployed（从Maven 2实例部署），verified（被核实时正确的和最终的）。-->
586. <status/>
587. </distributionManagement>
588. <!--以值替代名称，Properties可以在整个POM中使用，也可以作为触发条件（见settings.xml配置文件里activation元素的说明）。格式是<name>value</name>。-->
589. <properties/>
590. </project>

命令创建java工程

mvn archetype:generate -DgroupId=com.demo -DartifactId=javaproject -DarchetypeArtifactId=maven-archetype-quickstart -Dversion=0.0.1-snapshot -DinteractiveMode=false

命令创建web工程

mvn archetype:generate -DgroupId=com.demo -DartifactId=webproject -DarchetypeArtifactId=maven-archetype-webapp -Dversion=0.0.1-snapshot -DinteractiveMode=false

 

idea配置maven

找到settings>>Build,Execution,Deployment>>Build Tools>>Maven

IDEA创建MAVEN项目

1. 创建一个空项目
   
   

2. 新建module,然后finish
   
   

3. 双击java,新建resouces
   

4. 引入junit,

5. 点击maven,然后点击刷新，显示Dependencies依赖的包 

6. 创建测试的demo，编译测试，执行成功

补充(配置快速运行):

你也可以配置快速运行，不用每次点击test
https://blog.csdn.net/u011628753/article/details/123094566?spm=1001.2014.3001.5502

 

第一节、使用模板创建maven项目(java工程)

1. 新建模块，选择模板maven-archetype-quickstart

2. 输入坐标信息

3. 直接下一步(点击Finish后稍等项目自动构建)

4. 分别在main和test新建resources文件夹，并且标记main下面的resources文件夹为Resouces Root，而test下的resources文件夹为Test Resources Root

5. 删除App.java和AppTest.java(这是模板自动创建出来的东西，没有实际作用，可删可不删)，

6. 此时项目创建成功

第二节、使用模板创建maven项目(web工程)

1.新建模块，选择模板cocoon-22-archetype-web

2. 输入坐标信息

3. 直接下一步(点击Finish后稍等项目自动构建)

4. 这时候看到这个web项目里没有没有java文件夹，需要手动创建，并将java文件夹标记为Sources Root

5. 接下来在src下创建test文件夹,并在test下创建java和resouces文件夹

将java标记为Test Resources Root (此步骤请按照上面的示范操作来)
将resources标记为Test Sources Root (此步骤请按照上面的示范操作来)

6.创建成功

到这里项目ok了

如何启动 maven web项目

如下介绍如何配置tomcat插件运行项目

1. pom文件配置tomcat插件

 <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
        <configuration>
          <port>8888</port>
          <path>/</path>
        </configuration>
      </plugin>

2. 窗口右侧点击maven,并点击刷新，展开即可查看到tomcat插件

3. 移除掉web.xml多余的内容

4. 新建index.jsp主页

5. 点击tomcat7:run运行（如图表示运行成功），点击这个红色标记的地址进行访问

第三节、标记文件夹颜色的其它方式

1.选择项目/模块，并右键 >>Open Module Setting,

2. 选中进行标记

依赖

依赖配置

项目运行所需要的jar包,可以配置0个或者多个依赖
配置依赖的格式

<!--依赖群-->
  <dependencies>
    <!--具体的依赖-->
    <dependency>
       <!--依赖群组的id-->
      <groupId>junit</groupId>
      <!--项目id-->
      <artifactId>junit</artifactId>
      <!--版本号-->
      <version>4.13.2</version>
    </dependency>
  </dependencies>

示例

  <!--添加的依赖-->
  <dependencies>
    <!--junit-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13.2</version>
    </dependency>
    <!--fastjson-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.2.79</version>
    </dependency>
  </dependencies>

---

依赖传递

依赖具有传递性。
如果项目C依赖B，而B项目依赖A,那么C就间接依赖A，这称为依赖的传递，此时C不需要显示的配置A，即可使用A。
比如

依赖传递时版本冲突

当依赖发生版本冲突时

• 路径优先:层级越浅越优先。例如当前项目A，依赖B，B依赖C，C依赖D，如果B和D都依赖log4j,那么离项目A越近则越优先。
• 声明优先: 当引入的依赖层级相同时，谁先被声明谁优先。例如当前项目A中同时引入了B和C两个依赖，B和C里面都配置了log4j，那么B和C到A的路径距离相等，谁在A中先引入，log4j的版本跟谁。
• 覆盖优先：如果项目A中同时直接引入了两个log4j（不同的版本），那么后面声明的覆盖前面。例如pom文件里配置了先后配置了ａ和ｂ版本的log4j，那么因为ｂ版本生效（覆盖ａ）。

---

可选依赖

对外隐藏当前所依赖的资源，让引用者看不到。

 <dependency>
      <groupId>com.demo</groupId>
      <artifactId>maven01</artifactId>
      <version>1.0-SNAPSHOT</version>
      <!--配置可选后,该依赖将不会被继承-->
      <optional>true</optional>
    </dependency>

---

排除依赖

依赖传递时，不想要某个依赖。
junit依赖hamcrest

此时我不想要hamcrest

 <!--junit-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13.2</version>
      <exclusions>
        <exclusion>
          <!--排除依赖时不需要写版本-->
          <groupId>org.hamcrest</groupId>
          <artifactId>hamcrest-core</artifactId>
        </exclusion>
      </exclusions>
    </dependency>

---

依赖范围

依赖范围

引入的依赖的jar包在什么地方可以使用，通过scope进行设定。
作用范围

• 主代码(main包下面的)
• 测试代码(test包下面的)
• 是否参与打包(执行package命令时最终打出的jar/war文件)
  
  例如:(现在junit只在测试代码有效)

    <!--junit-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13.2</version>
      <!--依赖范围,只在测试代码中使用-->
      <scope>test</scope>
    </dependency>

依赖范围的传递性

当直接引用和间接引用的jar发生范围冲突时，具有如下的关系。

项目A 中直接依赖，同时项目A也依赖项目B，那么当A和B引用相同的依赖，范围发生冲突时，遵循上面的关系。

生命周期

Default (Build) 生命周期

这是 Maven 的主要生命周期，被用于构建应用，包括下面的 23 个阶段：

生命周期阶段	描述
validate（校验）	校验项目是否正确并且所有必要的信息可以完成项目的构建过程。
initialize（初始化）	初始化构建状态，比如设置属性值。
generate-sources（生成源代码）	生成包含在编译阶段中的任何源代码。
process-sources（处理源代码）	处理源代码，比如说，过滤任意值。
generate-resources（生成资源文件）	生成将会包含在项目包中的资源文件。
process-resources （处理资源文件）	复制和处理资源到目标目录，为打包阶段最好准备。
compile（编译）	编译项目的源代码。
process-classes（处理类文件）	处理编译生成的文件，比如说对Java class文件做字节码改善优化。
generate-test-sources（生成测试源代码）	生成包含在编译阶段中的任何测试源代码。
process-test-sources（处理测试源代码）	处理测试源代码，比如说，过滤任意值。
generate-test-resources（生成测试资源文件）	为测试创建资源文件。
process-test-resources（处理测试资源文件）	复制和处理测试资源到目标目录。
test-compile（编译测试源码）	编译测试源代码到测试目标目录.
process-test-classes（处理测试类文件）	处理测试源码编译生成的文件。
test（测试）	使用合适的单元测试框架运行测试（Juint是其中之一）。
prepare-package（准备打包）	在实际打包之前，执行任何的必要的操作为打包做准备。
package（打包）	将编译后的代码打包成可分发格式的文件，比如JAR、WAR或者EAR文件。
pre-integration-test（集成测试前）	在执行集成测试前进行必要的动作。比如说，搭建需要的环境。
integration-test（集成测试）	处理和部署项目到可以运行集成测试环境中。
post-integration-test（集成测试后）	在执行集成测试完成后进行必要的动作。比如说，清理集成测试环境。
verify （验证）	运行任意的检查来验证项目包有效且达到质量标准。
install（安装）	安装项目包到本地仓库，这样项目包可以用作其他本地项目的依赖。
deploy（部署）	将最终的项目包复制到远程仓库中与其他开发者和项目共享。

maven项目的构建过程中，顺序由上到下依次执行。
例如执行mvn compile，则该命令前的指令将会被依次执行。

重点指令

mvn compile #编译
mvn clean #清理
mvn test #跑测试
mvn package #测试
mvn install #安装到本地仓库
mvn deploy #发布到远程仓库

#当我们想打包而不需要执行测试用例时,可以执行跳过测试
mvn package -DskipTests #跳过测试打包

---

插件

maven插件地址:https://maven.apache.org/plugins/index.html
插件与对应的生命周期绑定，当执行对应的生命周期时执行对应的插件。
通过插件可以实行自己定义的功能。

 <build>
        <plugins>
            <!--参考文档https://maven.apache.org/plugins/maven-source-plugin/-->
           <plugin>
               <groupId>org.apache.maven.plugins</groupId>
               <artifactId>maven-source-plugin</artifactId>
               <version>3.2.0</version>
                <executions>
                    <execution>
                        <!--需要打包什么?-->
                        <goals>
                            <!--打包jar文件-->
                            <goal>jar</goal>
                            <!--打包测试的jar文件-->
                            <goal>test-jar</goal>
                        </goals>
                        <!--与哪个生命周期绑定-->
                        <phase>generate-test-sources</phase>
                    </execution>
                </executions>
           </plugin>

        </plugins>
    </build>

什么是分模块开发

工作中，一个项目通常是有多人开发，将一个项目分成多模块，各自的开发相对独立，同时提高了项目的可读性。

---

分模块开发实例

1. 新建一个maven的空项目,名称student,空项目所以src目录可以删除。
   
   

2. 新建一个模块student_pojo
   如图创建student_pojo，选择父工程为student
   

3. 新建一个模块student_dao
   (1)新建模块student_pojo
   

(2) 添加依赖pojo

   <dependency>
            <groupId>com.it2</groupId>
            <artifactId>student_pojo</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

4. 新建模块student_service
   (1)新建模块student_service
   （2）添加依赖student_dao

 <dependency>
            <artifactId>student_dao</artifactId>
            <groupId>com.it2</groupId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

5. 新建模块student_controller,需要使用模板
   (1)新建模块student_controller,使用模板maven-archetype-webapp
   
   (2) 添加依赖student_service

<dependency>
           <groupId>com.it2</groupId>
           <artifactId>student_service</artifactId>
           <version>1.0-SNAPSHOT</version>
       </dependency>

(3) 添加tomcat启动插件

 <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <!-- 指定端口 -->
                    <port>8888</port>
                </configuration>
            </plugin>

6. 查看父工程的pom文件(因为创建模块时选择了父工程student,编译器自动将创建的模块添加到了父工程的pom文件里)
   

---

此时maven的分模块工程创建好了

什么是聚合

maven多模块项目，一次性快速构建打包。

操作方式:定义空模块，将packaking设置为pom，项目管理。

 <packaging>pom</packaging>

定义当前模块构建时需要关联的模块

 <modules>
        <module>student_pojo</module>
        <module>student_service</module>
        <module>student_controller</module>
        <module>student_dao</module>
    </modules>

注意:maven聚合打包时,总是按照依赖顺序执行。例如A依赖B，B依赖C，C依赖D，那么加载顺序是Ｄ＞Ｃ＞Ｂ＞Ａ。
添加聚合后，自动设置一个表示root根，在此根下可以快速执行构建操作。

 

什么是继承

子工程继承父工程的依赖。当一个工程中存在多个子工程时，传统方式各个模块管理自己的依赖时，会出现版本冲突，此时我们可以用父工程来管理版本，子工程直接声明依赖即可。

父工程如何管理子工程的依赖

依赖管理

1. 在父工程中定义dependencyManagement标签，表示进行依赖管理。
   
2. 子工程定义引入依赖。子工程中声明父工程，并引入依赖(版本由父工程统一管理，不需要声明)。

插件管理

1.在父工程中声明插件管理，适用标签pluginManagement

2. 子工程直接引用，这样插件的版本管理将会由父工程控制。此时我们启动student_controller工程,子工程的启动端口是父工程声明的。
   结论:子工程除了继承父工程定义的版本外，还继续依赖对应的配置
   
   

 

maven的5种属性

自定义属性

1.适用properties先声明自定义属性，在依赖中使用自定义属性。
注:常见的自定义属性用于依赖的版本管理。

**

内置属性

作用:使用maven内置属性，快速配置
例如
${basedir}

settings属性

作用：
maven配置的settings.xml文件相关的属性。
例如
${settings.localRepository}

---

java系统属性

作用:
读取java系统属性
格式:
${user.name}

查看java系统属性mvn help:system

---

环境变量属性

作用:
读取环境变量的属性。
示例:
${env.JAVA_HOME}

查看环境变量属性mvn help:system

maven资源属性配置

第一节，起步资源配置

1. 新建一个springboot web项目(此步骤略)
   此步骤可见 https://blog.csdn.net/u011628753/article/details/123074142

2. pom文件自定义属性,并声明资源配置文件路径

<properties>
                <server.port>9999</server.port>
                <redis.ip>127.0.0.1</redis.ip>
                <redis.port>6379</redis.port>
                <fastjson.version>1.2.78</fastjson.version>
                <!--还可继续配置其他参数-->
            </properties>

声明资源位置(表示资源所在的路径)
此声明中basedir表示该项目及其子项目的文件夹，当该项目存在子项目时，子项目的配置同样生效。

    <build>
        <resources>
            <resource>
                <directory>${project.basedir}/src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
        </resources>
        <testResources>
            <testResource>
                <directory>${project.basedir}/src/test/resources</directory>
                <filtering>true</filtering>
            </testResource>
        </testResources>
    </build>

3. 在application.yml文件里配置下面内容(如果没有此文件,请先新建)

server:
# port: 7777
  port: @server.port@ # 这里的server.port来自于与pom里的多环境配置里的数据

4. 启动项目(启动日志显示端口为8888,表示配置成功)
   

第二节，不同类型的配置文件怎么配置?

xml文件:

则使用${xxx}形式
例如:${fastjson.version}

<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson.version}</version>
        </dependency>

properties文件:

使用@xxx@
例如:@server.port@

server.port=@server.port@

yml和yaml文件:

使用@xxx@
例如:@server.port@

server:
# port: 7777
  port: @server.port@ # 这里的server.port来自于与pom里的多环境配置里的数据

多环境配置

第一节,如何配置

1.多环境配置(替换上面第二步更改pom文件)

  <!--maven多环境配置-->
    <profiles>
        <profile>
            <!--正式环境-->
            <id>prod</id>
            <properties>
                <server.port>80</server.port>
                <fastjson.version>1.2.78</fastjson.version>
                <!--还可继续配置其他参数-->
            </properties>
        </profile>
        <profile>
            <!--测试环境-->
            <id>dev</id>
            <properties>
                <server.port>8888</server.port>
                <fastjson.version>1.2.79</fastjson.version>
                <!--还可继续配置其他参数-->
            </properties>
            <!--设置此项目为默认启动-->
            <activation><activeByDefault>true</activeByDefault></activation>
        </profile>
        <profile>
            <!--我的测试环境-->
            <id>my_test</id>
            <properties>
                <server.port>9999</server.port>
                <fastjson.version>1.2.78</fastjson.version>
                <!--还可继续配置其他参数-->
            </properties>
        </profile>
    </profiles>

 <!--设置的此配置为默认启动的环境-->
<activation><activeByDefault>true</activeByDefault></activation>

备注：此设置表示默认启动(如果不配置，则表示都不走，此时对应的配置标签将不会被替换)

第二节，如何切换环境

方法一 ：
点击idea窗口右侧的Maven按钮，然后显示Profiles，勾选具体使用哪一套参数，点击需要执行打包或者运行等命令

方法二 ：
对应的环境添加默认启动

 <!--设置的此配置为默认启动的环境-->
<activation><activeByDefault>true</activeByDefault></activation>

方法三: (当然也可以使用其他命令,如package -P prod 打包生产环境，install -P dev 将jar包安装到开发环境）

本地仓库如何访问私服

1. 找到maven的settings.xml文件，配置用户和密码
   
2. 配置仓库路径
   
   

idea发布jar到私服

1. 在项目pom文件配置发布

<!--发布管理-->
    <distributionManagement>
        <repository>
            <id>it2-releases</id>
            <url>http://localhost:8081/repository/it2-releases/</url>
        </repository>
        <snapshotRepository>
            <id>it2-snapshot</id>
            <url>http://localhost:8081/repository/it2-snapshot/</url>
        </snapshotRepository>
    </distributionManagement>

配置的url来自于

2. 点击发布(或者命令mvn deploy)

3. 发布成功，去到仓库可以找到刚刚发布的版本。
   
   

---

遇到的问题

问题1：本地仓库访问认证失败Not authorized

Not authorized , ReasonPhrase: Unauthorized.

解决办法：
修改settings.xml文件，配置私服的账号密码（id是关联的,需要一致）