java学习day37（Maven）Maven高级

于 2022-10-09 16:40:46 发布
阅读量235 收藏
点赞数
分类专栏： JAVA学习笔记 文章标签： maven java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gaosong0623/article/details/127216806
版权

maven高级应用概览：
1，maven基础回顾。
2，maven传统的web工程做一个数据查询操作。
3，maven工程拆分与聚合的思想。
4，把第二阶段做好的web工程修改成maven拆分与聚合的形式。
5，私服【远程仓库】。
6，如何安装第三方jar包。【把第三方jar包安装到本地仓库，把第三方jar包安装到私服。】

maven基础知识回顾：
maven是一个项目管理工具。
依赖管理：maven对项目中jar包的管理过程。传统工程我们直接把jar包放置在项目中。
          maven工程真正的jar包放置在仓库中，项目中只用放置jar包的坐标。
仓库的种类：本地仓库，远程仓库【私服】，中央仓库。
仓库之间的关系：当我们启动一个maven工程的时候，maven工程会通过pom文件中jar包的坐标去本地仓库找对应jar包。
        默认情况下，如果本地仓库没有对应jar包，maven工程会自动去中央仓库下载jar包到本地仓库。
        在公司中，如果本地没有对应jar包，会先从私服下载jar包，
        如果私服没有jar包，可以从中央仓库下载，也可以从本地上传。
一键构建：maven自身集成了tomcat插件，可以对项目进行编译，测试，打包，安装，发布等操作。
maven常用命令：clean，compile，test，package，install，deploy。
maven三套生命周期：清理生命周期，默认生命周期，站点生命周期。

maven 构建 SSM 工程 [ 应用 ]
1. 需求
实现 SSM 工程构建，规范依赖管理。场景：根据 id 展示商品信息
2. 准备数据库
首先将案例所需sql语句导入

 

3. 创建一个 maven 工程
1 、新建一个 ssm_maven 项目 , 使用下图选中的骨架

 2、填写坐标

 3、查看是否使用的自己的私服

 5、在 main 目录下新建 java 和 resources 文件夹

 6、把 java 和 resources 文件夹转成 source root

 7、修改编译版本，在 pom.xml 文件中添加

 

4. 知识点准备
4.1 什么是依赖传递
先添加 springmvc 的核心依赖的坐标

 

会发现出现除了 spring-webmvc 以外的其他 jar 。因为我们的项目依赖 spring-webmv.jar ，而
spring-webmv.jar 会依赖 spring-beans.jar 等等，所以 spring-beans.jar 这些 jar 包也出现在了我
们的 maven 工程中，这种现象我们称为依赖传递。从下图中可看到他们的关系：（请注意
spring-beans 的版本）

 

4.2 依赖冲突的解决
接着添加一个依赖

 我们会发现这两个 jar 包同时都依赖了 spring-beans

 但是

spring-webmvc 依赖 spirng-beans-4.2.4 ， spring-context 依赖 spring-beans-5.0.2 ，但是发现
spirng-beans-4.2.4 加入到工程中

 

而我们希望 spring-beans-5.0.2 加入工程。这就造成了依赖冲突。解决依赖冲突有以下原则：
4.2.1 依赖调解原则
maven 自动按照下边的原则调解：
1 、第一声明者优先原则
在 pom 文件定义依赖，先声明的依赖为准。
测试：
如果将上边 spring-webmvc 和 spring-context 顺序颠倒，系统将导入 spring-beans-5.0.2 。
分析：
由于 spring-webmvc 在前边以 spring-webmvc 依赖的 spring-beans-5.0.2 为准，所以最终
spring-beans-5.0.2 添加到了工程中。
2 、路径近者优先原则
例如：还是上述情况， spring-contex 和 spring-webmvc 都会传递过来 spirng-beans ，那
如果直接把 spring-beans 的依赖直接写到 pom 文件中，那么项目就不会再使用其他依赖传
递来的 spring-beans ，因为自己直接在 pom 中定义 spring-beans 要比其他依赖传递过来的路
径要近。
在本工程中的 pom 中加入 spirng-beans-5.0.2 的依赖，根据路径近者优先原则，系统将导入
spirng-beans-5.0.2 ：

 

4.2.2 排除依赖
上边的问题也可以通过排除依赖方法辅助依赖调解，如下：
比如在依赖 spring-webmvc 的设置中添加排除依赖，排除 spring-beans ，
下边的配置表示：依赖 spring-webmvc ，但排除 spring-webmvc 所依赖的 spring-beans 。

 

4.2.3 锁定版本
面对众多的依赖，有一种方法不用考虑依赖路径、声明优化等因素可以采用直接锁定版
本的方法确定依赖构件的版本，版本锁定后则不考虑依赖的声明顺序或依赖的路径，以锁定
的版本的为准添加到工程中，此方法在企业开发中常用。
如下的配置是锁定了 spring-beans 和 spring-context 的版本：

 还可以把版本号提取出来，使用<properties>标签设置成变量。

 

注意：在工程中锁定依赖的版本并不代表在工程中添加了依赖，如果工程需要添加锁定版本
的依赖则需要单独添加 < dependencies ></ dependencies > 标签，如下：

 

上边添加的依赖并没有指定版本，原因是已在 < dependencyManagement > 中锁定了版本，
所以在 < dependency > 下不需要再指定版本。
5. 定义 pom.xml
maven 工程首先要识别依赖， web 工程实现 SSM 整合，需要依赖 spring-webmvc5.0.2 、
spring5.0.2 、 mybatis3.4.5 等，在 pom.xml 添加工程如下依赖：
（在实际企业开发中会有架构师专门来编写 pom.xml ）
分两步：
1 ）锁定依赖版本
2 ）添加依赖 
<?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>cn.itcast.ssm_maven</groupId>
 <artifactId>ssm_maven</artifactId>
 <version>1.0-SNAPSHOT</version>
 <packaging>war</packaging>
 <properties>
 <spring.version>5.0.2.RELEASE</spring.version>
 <springmvc.version>5.0.2.RELEASE</springmvc.version>
 <mybatis.version>3.4.5</mybatis.version>
 </properties>
<!--锁定依赖版本-->
 <dependencyManagement>
 <dependencies>
 <!-- Mybatis -->
 <dependency>
 <groupId>org.mybatis</groupId>
 <artifactId>mybatis</artifactId>
 <version>${mybatis.version}</version>
 </dependency>
 <!-- springMVC -->
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-webmvc</artifactId>
 <version>${springmvc.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <!-- spring -->
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-core</artifactId>

 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-aop</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-web</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-expression</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-beans</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-aspects</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context-support</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-test</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-tx</artifactId>
 <version>${spring.version}</version>
 </dependency>
 </dependencies>
 </dependencyManagement>
<!--添加依赖-->
 <dependencies>
 <!-- Mybatis 和 mybatis 与 spring 的整合 -->
 <dependency>
 <groupId>org.mybatis</groupId>
 <artifactId>mybatis</artifactId>
 </dependency>
 <dependency>
 <groupId>org.mybatis</groupId>
 <artifactId>mybatis-spring</artifactId>
 <version>1.3.1</version>
 </dependency>
 <!-- MySql 驱动 -->
 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 <version>5.1.32</version>
 </dependency>
 <!-- druid 数据库连接池 -->
 <dependency>
 <groupId>com.alibaba</groupId>
 <artifactId>druid</artifactId>
 <version>1.0.9</version>
 </dependency>
 <!-- springMVC 核心-->
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-webmvc</artifactId>
 </dependency>
 <!-- spring 相关 -->
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context</artifactId>
 </dependency>
<dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-core</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-aop</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-web</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-expression</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-beans</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-aspects</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context-support</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-test</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-jdbc</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-tx</artifactId>
 </dependency>
 <!-- junit 测试 -->
 <dependency>
<groupId>junit</groupId>
 <artifactId>junit</artifactId>
 <version>4.12</version>
 </dependency>
 <dependency>
 <groupId>javax.servlet</groupId>
 <artifactId>servlet-api</artifactId>
 <version>2.5</version>
 <scope>provided</scope>
 </dependency>
 <dependency>
 <groupId>javax.servlet</groupId>
 <artifactId>jsp-api</artifactId>
 <version>2.0</version>
 <scope>provided</scope>
 </dependency>
 <!-- jstl -->
 <dependency>
 <groupId>javax.servlet</groupId>
 <artifactId>jstl</artifactId>
 <version>1.2</version>
 </dependency>
 </dependencies>
 <build>
 <plugins>
 <!-- 设置编译版本为 1.8 -->
 <plugin>
 <groupId>org.apache.maven.plugins</groupId>
 <artifactId>maven-compiler-plugin</artifactId>
 <version>3.1</version >
 <configuration>
 <source>1.8</source>
 <target>1.8</target>
 <encoding>UTF-8</encoding>
 </configuration>
 </plugin>
 <plugin>
 <groupId>org.apache.tomcat.maven</groupId>
 <artifactId>tomcat7-maven-plugin</artifactId>
 <version>2.2</version>
 <configuration>
 <path>/</path>
 <port>8080</port>
 </configuration>
</plugin>
 </plugins>
 </build>
</project>
6. Dao 层
在 src/main/java 中定义 dao 接口，实现根据 id 查询商品信息：
6.1 pojo 模型类
在 src/main/java 创建模型类

 

 6.2dao 层代码

 

6.3 配置文件
注意配置文件的位置

 内容如下

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
"http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="cn.itcast.ssm.dao.ItemsMapper" >
 <select id="findById" parameterType="int" resultType="items">
 select * from items where id=#{id}
 </select>
</mapper>
在 src/main/resources 创建 applicationContext.xml 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:context="http://www.springframework.org/schema/context" 
xmlns:p="http://www.springframework.org/schema/p"
 xmlns:aop="http://www.springframework.org/schema/aop" 
xmlns:tx="http://www.springframework.org/schema/tx"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
 http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.0.xsd
 http://www.springframework.org/schema/aop 
http://www.springframework.org/schema/aop/spring-aop-4.0.xsd 
http://www.springframework.org/schema/tx 
http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
 http://www.springframework.org/schema/util 
http://www.springframework.org/schema/util/spring-util-4.0.xsd">
 <!-- 数据库连接池 -->
 <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
 <!-- 驱动 -->
 <property name="driverClassName" value="com.mysql.jdbc.Driver" />
 <!-- url -->
 <property name="url" value="jdbc:mysql://localhost:3306/maven" />
 <!-- 用户名 -->
 <property name="username" value="root" />
 <!-- 密码 -->
 <property name="password" value="root" />
 </bean>
 <!-- mapper 配置 -->
 <!-- 让 spring 管理 sqlsessionfactory 使用 mybatis 和 spring 整合包中的 -->
 <bean id="sqlSessionFactory" 
class="org.mybatis.spring.SqlSessionFactoryBean">
 <!-- 数据库连接池 -->
 <property name="dataSource" ref="dataSource" />
 <property name="typeAliasesPackage" 
value="cn.itcast.ssm.pojo"></property>
 </bean>
 <!-- mapper 扫描器 ：用来产生代理对象-->
 <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
 <property name="basePackage" value="cn.itcast.ssm.dao"></property>
 </bean>
</beans>
在 src/main/resources 配置 log4j.properties 
### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5
p %c{1}:%L - %m%n
### set log levels - for more verbose logging change 'info' to 
'debug' ###
#在开发阶段日志级别使用 debug
log4j.rootLogger=debug, stdout
### 在日志中输出 sql 的输入参数 ###
log4j.logger.org.hibernate.type=TRACE
6.4 单元测试
在 src/test/java 创建单元测试类 
public class ItemsMapperTest {
 @Test
 public void testFindItemsById() {
 //获取 spring 容器
 ApplicationContext applicationContext = new 
ClassPathXmlApplicationContext("classpath:applicationContext.xml");
 //获取 Mapper
 ItemsMapper itemsMapper = 
applicationContext.getBean(ItemsMapper.class);
 //调用 Mapper 方法
 Items items = itemsMapper.findById(1);
 System.out.println(items);
 } }
7. Service 层
7.1 代码 
@Service
@Transactional
public class ItemsServiceImpl implements ItemsService {
 @Autowired
 private ItemsMapper itemsMapper;
 @Override
 public Items findById(int itemId) {
 return itemsMapper.findById(itemId);
 } }
7.2 配置文件
在 applicationContext.xml 中配置 service 
<context:component-scan base-package="cn.itcast.ssm.service"/>
8. Web 层
8.1 代码 
@Controller
@RequestMapping("/items/")
public class ItemsController {
 @Autowired
 private ItemsService itemsService ;
// 展示商品信息页面
 @RequestMapping("/showItem") 
 public String showItem(int id,Model model){
 Items items = itemsService.findById(id);
 model.addAttribute("item", items);
 return "viewItem";
 } }
8.2 配置文件
在 springmvc.xml 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:p="http://www.springframework.org/schema/p"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:mvc="http://www.springframework.org/schema/mvc"
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
 http://www.springframework.org/schema/mvc 
http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd
 http://www.springframework.org/schema/context 
http://www.springframework.org/schema/context/spring-context-4.2.xsd">
 <context:component-scan 
base-package="cn.itcast.ssm.controller"></context:component-scan>
 <!-- 配置视图解析器的前缀和后缀 -->
 <bean 
class="org.springframework.web.servlet.view.InternalResourceViewResolve
r">
 <property name="prefix" value="/WEB-INF/jsp/"></property>
 <property name="suffix" value=".jsp"></property>
 </bean>
</beans>
Web.xml
加载 spring 容器，配置 springmvc 前端控制器 
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns="http://java.sun.com/xml/ns/javaee" 
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" 
version="2.5">
 <!-- 前端控制器 加载 springmvc 容器 -->
 <servlet>
 <servlet-name>springmvc</servlet-name>
 
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servl
et-class>
 <init-param>
 <param-name>contextConfigLocation</param-name>
 <param-value>classpath:springmvc.xml</param-value>
 </init-param>
 </servlet>
 <servlet-mapping>
 <servlet-name>springmvc</servlet-name>
 <url-pattern>*.action</url-pattern>
 </servlet-mapping>
 <!-- 监听器 加载 spring 容器 -->
 <listener>
 
<listener-class>org.springframework.web.context.ContextLoaderListener</
listener-class>
 </listener>
 <context-param>
 <param-name>contextConfigLocation</param-name>
 <param-value>classpath*:applicationContext*.xml</param-value>
 </context-param>
</web-app>
9. Jsp
/WEB-INF/jsp/viewItem.jsp 如下： 
<%@ page language="java" contentType="text/html; charset=UTF-8"
 pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>商品信息</title>
</head>
<body>
<form>
 <table width="100%" border=1>
 <tr>
 <td>商品名称</td>
 <td> ${item.name } </td>
 </tr>
 <tr>
 <td>商品价格</td>
 <td> ${item.price } </td>
 </tr>
 <tr>
 <td>生成日期</td>
 <td> <fmt:formatDate value="${item.createtime}" 
pattern="yyyy-MM-dd HH:mm:ss"/> </td>
 </tr>
 <tr>
 <td>商品简介</td>
 <td>${item.detail} </textarea>
 </td>
 </tr>
 </table>
</form>
</body>
</html>
10. 运行与调试
添加 tomcat7 插件，双击右侧 tomcat7 运行

 运行结果如下：

 

三、 分模块构建工程 [ 应用 ]
基于上边的三个工程分析
继承：创建一个 parent 工程将所需的依赖都配置在 pom 中
聚合：聚合多个模块运行。
1. 需求
需求描述
将 SSM 工程拆分为多个模块开发：
ssm_dao
ssm_service
ssm_web

 

理解继承和聚合
通常继承和聚合同时使用。
何为继承？
继承是为了消除重复，如果将 dao 、 service 、 web 分开创建独立的工程则每个工程的 pom.xml
文件中的内容存在重复，比如：设置编译版本、锁定 spring 的版本的等，可以将这些重复的
配置提取出来在父工程的 pom.xml 中定义。
何为聚合？
项目开发通常是分组分模块开发，每个模块开发完成要运行整个工程需要将每个模块聚合在
一起运行，比如： dao 、 service 、 web 三个工程最终会打一个独立的 war 运行。
2. 案例实现
2.1 maven-parent 父模块
2.1.1 创建父工程
1 、选择骨架创建父工程

 2、填写坐标

 3、确认使用的是本地仓库

 5、注意代码所在的路径（默认）

 6、设置项目的打包方式

 

2.1.2 定义 pom.xml
在父工程的 pom.xml 中抽取一些重复的配置的，比如：锁定 jar 包的版本、设置编译版本等。 
<properties>
 <spring.version>5.0.2.RELEASE</spring.version>
 <springmvc.version>5.0.4.RELEASE</springmvc.version>
 <mybatis.version>3.4.5</mybatis.version>
</properties>
<dependencyManagement>
 <dependencies>
 <!-- Mybatis -->
 <dependency>
 <groupId>org.mybatis</groupId>
 <artifactId>mybatis</artifactId>
 <version>${mybatis.version}</version>
 </dependency>
 <!-- springMVC -->
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-webmvc</artifactId>
 <version>${springmvc.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <!-- spring -->
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-core</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-aop</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-web</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-expression</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
<groupId>org.springframework</groupId>
 <artifactId>spring-beans</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-aspects</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context-support</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-test</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-jdbc</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-tx</artifactId>
 <version>${spring.version}</version>
 </dependency>
 </dependencies>
</dependencyManagement>
<build>
 <plugins>
 <plugin>
 <groupId>org.apache.maven.plugins</groupId>
 <artifactId>maven-compiler-plugin</artifactId>
 <version>3.1</version>
 <configuration>
 <target>1.8</target>
 <source>1.8</source>
 </configuration>
 </plugin>
 </plugins>
</build>
2.1.3 将父工程发布至仓库
父工程创建完成执行 install 将父工程发布到仓库方便子工程继承：

 

2.2 ssm_dao 子模块
2.2.1 创建 dao 子模块
1 、在父工程上右击创建 maven 模块：

2、选择“跳过骨架选择”：

 

 3、填写模块名称

 4、下一步，确定项目的目录

 5、打包方式是 jar

 

2.2.2 定义 pom.xml
只添加到层的 pom ， mybatis 和 spring 的整合相关依赖 
<dependencies>
 <!-- Mybatis 和 mybatis 与 spring 的整合 -->
 <dependency>
 <groupId>org.mybatis</groupId>
 <artifactId>mybatis</artifactId>
 </dependency>
 <dependency>
 <groupId>org.mybatis</groupId>
 <artifactId>mybatis-spring</artifactId>
 <version>1.3.1</version>
 </dependency>
 <!-- MySql 驱动 -->
 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 <version>5.1.32</version>
 </dependency>
 <!-- druid 数据库连接池 -->
 <dependency>
 <groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
 <version>1.0.9</version>
 </dependency>
 <!-- spring 相关 -->
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-core</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-aop</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-web</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-expression</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-beans</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-aspects</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context-support</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-test</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-jdbc</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-tx</artifactId>
 </dependency>
 </dependencies>
2.2.3 dao 代码
把文件夹转成 sources root

 将 ssm_maven 工程中的 dao 接口、映射文件及 pojo 类拷贝到 src/main/java 中：

 

2.2.4 配置文件
将 applicationContext.xml 拆分出一个 applicationContext-dao.xml ，此文件中只配置 dao 相关 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:context="http://www.springframework.org/schema/context" 
xmlns:p="http://www.springframework.org/schema/p"
 xmlns:aop="http://www.springframework.org/schema/aop" 
xmlns:tx="http://www.springframework.org/schema/tx"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
 http://www.springframework.org/schema/context 
http://www.springframework.org/schema/context/spring-context-4.0.xsd
 http://www.springframework.org/schema/aop 
http://www.springframework.org/schema/aop/spring-aop-4.0.xsd 
http://www.springframework.org/schema/tx 
http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
 http://www.springframework.org/schema/util 
http://www.springframework.org/schema/util/spring-util-4.0.xsd">
 <!-- 数据库连接池 -->
 <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
 <!-- 驱动 -->
 <property name="driverClassName" value="com.mysql.jdbc.Driver" />
 <!-- url -->
 <property name="url" value="jdbc:mysql://localhost:3306/maven" />
 <!-- 用户名 -->
 <property name="username" value="root" />
 <!-- 密码 -->
 <property name="password" value="root" />
 </bean>
 <!-- mapper 配置 -->
 <!-- 让 spring 管理 sqlsessionfactory 使用 mybatis 和 spring 整合包中的 -->
 <bean id="sqlSessionFactory" 
class="org.mybatis.spring.SqlSessionFactoryBean">
 <!-- 数据库连接池 -->
 <property name="dataSource" ref="dataSource" />
 <property name="typeAliasesPackage" 
value="cn.itcast.ssm.pojo"></property>
 </bean>
 <!-- mapper 扫描器 ：用来产生代理对象-->
 <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
 <property name="basePackage" value="cn.itcast.ssm.dao"></property>
 </bean>
</beans>
2.2.5 单元测试
1 、首先在 dao 模块的 pom.xml 添加 junit 的依赖，添加时 Scope 选择 test

  2、编写 junit 测试代码

public class ItemsMapperTest {
 @Test
 public void testFindItemsById() {
 //获取 spring 容器
 ApplicationContext applicationContext = new 
ClassPathXmlApplicationContext("classpath:applicationContext-dao.xml");
 //获取 Mapper
 ItemsMapper itemsMapper = 
applicationContext.getBean(ItemsMapper.class);
 //调用 Mapper 方法
 Items items = itemsMapper.findById(1);
 System.out.println(items);
 } }
2.2.6 把 dao 模块 install 到本地仓库
调过测试， install 到本地仓库

 

2.3 ssm_service 子模块
2.3.1 创建 service 子模块
方法同 ssm_dao 模块创建方法，模块名称为 ssm_service 。
2.3.2 定义 pom.xml
ssm_service 模块的 pom.xml 文件中需要继承父模块， ssm_service 依赖 ssm_dao 模块，添加
spring 相关的依赖： 
<dependencies>
 <!-- spring 相关 -->
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-jdbc</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-tx</artifactId>
 </dependency>
 <!-- dao 层的依赖 -->
 <dependency>
 <groupId>cn.itcast.ssm</groupId>
 <artifactId>ssm_dao</artifactId>
 <version>1.0-SNAPSHOT</version>
 </dependency>
</dependencies>
2.3.3 service 接口
将 ssm_maven 工程中的 service 接口拷贝到 src/main/java 中：

 

2.3.4 配置文件
创建 applicationContext-service.xml ，此文件中定义的 service 。 
<context:component-scan base-package="cn.itcast.ssm"/>
2.3.5 依赖范围对传递依赖的影响（了解）
2.3.5.1 问题描述
当在写 junit 测试时发现，代码报出没有找不到类的错误信息：

 

是因为没有 junit.jar 引起的 ! 为什么会这样呢？我们 ssm_dao 模块中有 junit 依赖而
ssm_service 模块依赖了 ssm_dao ，难道 junit 不应该传递过来吗？
2.3.5.3 依赖范围对传递依赖的影响
是因为依赖会有依赖范围，依赖范围对传递依赖也有影响，例如有 A 、 B 、 C ， A 依赖 B 、 B
依赖 C ， C 可能是 A 的传递依赖，如下图：

 

最左边一列为直接依赖，理解为 A 依赖 B 的范围，最顶层一行为传递依赖，理解为 B
依赖 C 的范围，行与列的交叉即为 A 传递依赖 C 的范围。
举例 1 ：
比如 A 对 B 有 compile 依赖， B 对 C 有 runtime 依赖，那么根据表格所示 A 对 C 有
runtime 依赖。
ssm_dao 依赖 junit ， scop 为 test
ssm_service 依赖 ssm_dao.
查看下图红色框内所示传递依赖范围：

 所以 ssm_dao 工程所依赖的 junit 的 jar 没有加入到 ssm_service 工程。

举例 2 ：如果修改 ssm_dao 工程依赖 junit 的 scop 为 compile ， ssm_dao 工程所依赖的 junit
的 jar 包会加入到 ssm_service 工程中，符合上边表格所示，查看下图红色框内所示：

 

2.3.6 单元测试
遇到依赖没有传递过来的问题我们通常的解决方案是在本工程中直接添加依赖：
把如下依赖添加到 ssm_service 的工程中：

 再看测试代码也不报错了

 2.3.7 Install 到本地仓库

 2.4 ssm_web 子模块

2.4.1 创建 web 子模块
1 、选择骨架创建 web 子模块

 2、确认使用自己的本地仓库

 3、填写模块名称

 4、创建 java 和 resources 文件夹，转成 source root

 5、添加打包方式 war

 

2.4.2 定义 pom.xml
ssm_web 模块的 pom.xml 文件中需要继承父模块， ssm_web 依赖 ssm_service 模块 , 和
springmvc 的依赖 
<?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>ssm_parent</artifactId>
 <groupId>cn.itcast.ssm</groupId>
 <version>1.0-SNAPSHOT</version>
 </parent>
 <modelVersion>4.0.0</modelVersion>
 <artifactId>ssm_web</artifactId>
 <packaging>war</packaging>
 <dependencies>
 <!-- 依赖 service -->
 <dependency>
 <groupId>cn.itcast.ssm</groupId>
 <artifactId>ssm_service</artifactId>
 <version>1.0-SNAPSHOT</version>
 </dependency>
 <!-- springMVC -->
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-webmvc</artifactId>
 <version>${springmvc.version}</version>
 </dependency>
 </dependencies>
</project>
2.4.3 controller
将 ssm_web 工程中的 controller 代码拷贝到 src/main/java 中：

 

2.4.4 配置文件
拷贝 ssm_web 工程中如下配置文件：

 

2.5 运行调试
方法 1 ：在 ssm_web 工程的 pom.xml 中配置 tomcat 插件运行
运行 ssm_web 工程它会从本地仓库下载依赖的 jar 包，所以当 ssm_web 依赖的 jar 包内容修
改了必须及时发布到本地仓库，比如： ssm_web 依赖的 ssm_service 修改了，需要及时将
ssm_service 发布到本地仓库。
方法 2 ：在父工程的 pom.xml 中配置 tomcat 插件运行，自动聚合并执行
推荐方法 2 ，如果子工程都在本地，采用方法 2 则不需要子工程修改就立即发布到本地仓库，
父工程会自动聚合并使用最新代码执行。
注意：如果子工程和父工程中都配置了 tomcat 插件，运行的端口和路径以子工程为准。
3. 分模块构建工程 - 依赖整合
每个模块都需要 spring 或者 junit 的 jar ，况且最终 package 打完包最后生成的项目中的
jar 就是各个模块依赖的整合，所以我们可以把项目中所需的依赖都可以放到父工程中 , 模块
中只留模块和模块之间的依赖，那父工程的 pom.xml 可以如下配置： 
<properties>
 <spring.version>5.0.2.RELEASE</spring.version>
 <springmvc.version>5.0.2.RELEASE</springmvc.version>
 <mybatis.version>3.4.5</mybatis.version>
</properties>
<dependencyManagement>
 <dependencies>
 <!-- Mybatis -->
 <dependency>
 <groupId>org.mybatis</groupId>
 <artifactId>mybatis</artifactId>
 <version>${mybatis.version}</version>
 </dependency>
 <!-- springMVC -->
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-webmvc</artifactId>
 <version>${springmvc.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <!-- spring -->
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-core</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-aop</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-web</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-expression</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-beans</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-aspects</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context-support</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-test</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-jdbc</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-tx</artifactId>
 <version>${spring.version}</version>
 </dependency>
 </dependencies>
</dependencyManagement>
<dependencies>
 <!-- Mybatis 和 mybatis 与 spring 的整合 -->
 <dependency>
 <groupId>org.mybatis</groupId>
 <artifactId>mybatis</artifactId>
 </dependency>
 <dependency>
 <groupId>org.mybatis</groupId>
 <artifactId>mybatis-spring</artifactId>
 <version>1.3.1</version>
 </dependency>
 <!-- MySql 驱动 -->
 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 <version>5.1.32</version>
 </dependency>
 <!-- druid 数据库连接池 -->
 <dependency>
 <groupId>com.alibaba</groupId>
 <artifactId>druid</artifactId>
 <version>1.0.9</version>
 </dependency>
 <!-- springMVC -->
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-webmvc</artifactId>
 <version>${springmvc.version}</version>
 </dependency>
 <!-- spring 相关 -->
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-core</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-aop</artifactId>
 </dependency>
 <dependency>
<groupId>org.springframework</groupId>
 <artifactId>spring-web</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-expression</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-beans</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-aspects</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context-support</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-test</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-jdbc</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-tx</artifactId>
 </dependency>
 <!-- spring 相关 事务相关 -->
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-jdbc</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-tx</artifactId>
 </dependency>
 <!-- junit 测试 -->
 <dependency>
 <groupId>junit</groupId>
 <artifactId>junit</artifactId>
 <version>4.12</version>
 <scope>test</scope>
 </dependency>
<dependency>
 <groupId>javax.servlet</groupId>
 <artifactId>servlet-api</artifactId>
 <version>2.5</version>
 <scope>provided</scope>
 </dependency>
 <dependency>
 <groupId>javax.servlet</groupId>
 <artifactId>jsp-api</artifactId>
 <version>2.0</version>
 <scope>provided</scope>
 </dependency>
 <!-- jstl -->
 <dependency>
 <groupId>javax.servlet</groupId>
 <artifactId>jstl</artifactId>
 <version>1.2</version>
 </dependency>
</dependencies>
<build>
 <plugins>
 <plugin>
 <groupId>org.apache.maven.plugins</groupId>
 <artifactId>maven-compiler-plugin</artifactId>
 <version>3.1</version>
 <configuration>
 <target>1.8</target>
 <source>1.8</source>
 </configuration>
 </plugin>
 <plugin>
 <groupId>org.apache.tomcat.maven</groupId>
 <artifactId>tomcat7-maven-plugin</artifactId>
 <version>2.2</version>
 </plugin>
 </plugins>
</build>
四、 maven 私服 [ 了解 ]
1. 需求
正式开发，不同的项目组开发不同的工程。
ssm_dao 工程开发完毕，发布到私服。
ssm_service 从私服下载 dao
2. 分析
公司在自己的局域网内搭建自己的远程仓库服务器，称为私服，私服服务器即是公司内
部的 maven 远程仓库，每个员工的电脑上安装 maven 软件并且连接私服服务器，员工将自
己开发的项目打成 jar 并发布到私服服务器，其它项目组从私服服务器下载所依赖的构件
（ jar ）。
私服还充当一个代理服务器，当私服上没有 jar 包会从互联网中央仓库自动下载，如下
图：

 

3. 搭建私服环境
3.1 下载 nexus
Nexus 是 Maven 仓库管理器，通过 nexus 可以搭建 maven 仓库，同时 nexus 还提供强
大的仓库管理功能，构件搜索功能等。
下载 Nexus ， 下载地址： http://www.sonatype.org/nexus/archived/

 下载：nexus-2.12.0-01-bundle.zip

3.2 安装 nexus
解压 nexus-2.12.0-01-bundle.zip ，本教程将它解压在 F 盘，进入 bin 目录：

 cmd 进入 bin 目录，执行 nexus.bat install

 安装成功在服务中查看有 nexus 服务：

 

3.3 卸载 nexus
cmd 进入 nexus 的 bin 目录，执行： nexus.bat uninstall

 

查看 window 服务列表 nexus 已被删除。
3.4 启动 nexus
方法 1 ：
cmd 进入 bin 目录，执行 nexus.bat start
方法 2 ：
直接启动 nexus 服务

 查看 nexus 的配置文件 conf/nexus.properties

 

# Jetty section
application-port=8081
# nexus 的访问端口配置
application-host=0.0.0.0
# nexus 主机监听配置 ( 不用修改 )
nexus-webapp=${bundleBasedir}/nexus
# nexus 工程目录
nexus-webapp-context-path=/nexus
# nexus 的 web 访问路径
# Nexus section
nexus-work=${bundleBasedir}/../sonatype-work/nexus # nexus 仓库目录
runtime=${bundleBasedir}/nexus/WEB-INF # nexus 运行程序目录
访问：
http://localhost:8081/nexus/

 

使用 Nexus 内置账户 admin/admin123 登陆：
点击右上角的 Log in ，输入账号和密码 登陆

 登陆成功：

 

3.5 仓库类型
nexus
查看 nexus 的仓库：

nexus 的仓库有 4 种类型：

 

 

1. hosted ，宿主仓库，部署自己的 jar 到这个类型的仓库，包括 releases 和 snapshot 两部
分， Releases 公司内部发布版本仓库、 Snapshots 公司内部测试版本仓库
2. proxy ，代理仓库，用于代理远程的公共仓库，如 maven 中央仓库，用户连接私服，私
服自动去中央仓库下载 jar 包或者插件。
3. group ，仓库组，用来合并多个 hosted/proxy 仓库，通常我们配置自己的 maven 连接仓
库组。
4. virtual( 虚拟 ) ：兼容 Maven1 版本的 jar 或者插件
nexus 仓库默认在 sonatype-work 目录中：

 central：代理仓库，代理中央仓库

 

apache-snapshots ：代理仓库
存储 snapshots 构件，代理地址 https://repository.apache.org/snapshots/
central-m1 ： virtual 类型仓库，兼容 Maven1 版本的 jar 或者插件
releases ：本地仓库，存储 releases 构件。
snapshots ：本地仓库，存储 snapshots 构件。
thirdparty ：第三方仓库
public ：仓库组
4. 将项目发布到私服
4.1 需求
企业中多个团队协作开发通常会将一些公用的组件、开发模块等发布到私服供其它团队
或模块开发人员使用。
本例子假设多团队分别开发 ssm_dao 、 ssm_service 、 ssm_web ，某个团队开发完在
ssm_dao 会将 ssm_dao 发布到私服供 ssm_service 团队使用，本例子会将 ssm_dao 工程打成
jar 包发布到私服。

 

4.2 配置
第一步：
需要在客户端即部署 ssm_dao 工程的电脑上配置 maven 环境，并 修改 settings.xml
文件，配置连接私服的用户和密码 。
此用户名和密码用于私服校验，因为私服需要知道上传的账号和密码是否和私服中的账号和
密码一致。 
<server>
 <id>releases</id>
 <username>admin</username>
 <password>admin123</password>
 </server>
<server>
 <id>snapshots</id>
<username>admin</username>
 <password>admin123</password>
 </server>

releases 连接发布版本项目仓库
snapshots 连接测试版本项目仓库

 

第二步： 配置项目 pom.xml
配置私服仓库的地址，本公司的自己的 jar 包会上传到私服的宿主仓库，根据工程的版本号
决定上传到哪个宿主仓库，如果版本为 release 则上传到私服的 release 仓库，如果版本为
snapshot 则上传到私服的 snapshot 仓库 
<distributionManagement>
 <repository>
 <id>releases</id>
 
<url>http://localhost:8081/nexus/content/repositories/releases/</url>
 </repository>
 <snapshotRepository>
 <id>snapshots</id>
 
<url>http://localhost:8081/nexus/content/repositories/snapshots/</url>
 </snapshotRepository>
</distributionManagement>
注意： pom.xml 这里 <id> 和 settings.xml 配置 <id> 对应！
4.3 测试
将项目 dao 工程打成 jar 包发布到私服：
1 、首先启动 nexus
2 、对 ssm_dao 工程执行 deploy 命令

 

根据本项目 pom.xml 中 version 定义决定发布到哪个仓库，如果 version 定义为 snapshot ，
执行 deploy 后查看 nexus 的 snapshot 仓库，如果 version 定义为 release 则项目将发布到 nexus
的 release 仓库，本项目将发布到 snapshot 仓库：

 也可以通过 http 方式查看：

 

5. 从私服下载 jar 包
5.1 需求
没有配置 nexus 之前，如果本地仓库没有，去中央仓库下载，通常在企业中会在局域网
内部署一台私服服务器，有了私服本地项目首先去本地仓库找 jar ，如果没有找到则连接私
服从私服下载 jar 包，如果私服没有 jar 包私服同时作为代理服务器从中央仓库下载 jar 包，
这样做的好处是一方面由私服对公司项目的依赖 jar 包统一管理，一方面提高下载速度，项
目连接私服下载 jar 包的速度要比项目连接中央仓库的速度快的多。
本例子测试从私服下载 ssm_dao 工程 jar 包。
5.2 管理仓库组
nexus 中包括很多仓库， hosted 中存放的是企业自己发布的 jar 包及第三方公司的 jar 包，
proxy 中存放的是中央仓库的 jar ，为了方便从私服下载 jar 包可以将多个仓库组成一个仓库
组，每个工程需要连接私服的仓库组下载 jar 包。
打开 nexus 配置仓库组，如下图：

 上图中仓库组包括了本地仓库、代理仓库等。

5.3 在 setting.xml 中配置仓库
在客户端的 setting.xml 中配置私服的仓库，由于 setting.xml 中没有 repositories 的配置
标签需要使用 profile 定义仓库。 
<profile> 
<!--profile 的 id-->
 <id>dev</id> 
 <repositories> 
 <repository> 
<!--仓库 id，repositories 可以配置多个仓库，保证 id 不重复-->
 <id>nexus</id>
<!--仓库地址，即 nexus 仓库组的地址-->
 <url>http://localhost:8081/nexus/content/groups/public/</url> 
<!--是否下载 releases 构件-->
 <releases> 
 <enabled>true</enabled> 
 </releases> 
<!--是否下载 snapshots 构件-->
 <snapshots> 
 <enabled>true</enabled> 
 </snapshots> 
 </repository> 
 </repositories> 
<pluginRepositories> 
 <!-- 插件仓库，maven 的运行依赖插件，也需要从私服下载插件 -->
 <pluginRepository> 
 <!-- 插件仓库的 id 不允许重复，如果重复后边配置会覆盖前边 -->
 <id>public</id> 
 <name>Public Repositories</name> 
 <url>http://localhost:8081/nexus/content/groups/public/</url> 
 </pluginRepository> 
 </pluginRepositories> 
 </profile>
使用 profile 定义仓库需要激活才可生效。 
 <activeProfiles>
 <activeProfile>dev</activeProfile>
 </activeProfiles>
配置成功后通过 eclipse 查看有效 pom ，有效 pom 是 maven 软件最终使用的 pom 内容，程
序员不直接编辑有效 pom ，打开有效 pom

 

有效 pom 内容如下：
下边的 pom 内容中有两个仓库地址， maven 会先从前边的仓库的找，如果找不到 jar 包再从
下边的找，从而就实现了从私服下载 jar 包。 
<repositories>
 <repository>
 <releases>
 <enabled>true</enabled>
 </releases>
 <snapshots>
 <enabled>true</enabled>
 </snapshots>
 <id>public</id>
 <name>Public Repositories</name>
 <url>http://localhost:8081/nexus/content/groups/public/</url>
 </repository>
 <repository>
 <snapshots>
 <enabled>false</enabled>
 </snapshots>
 <id>central</id>
 <name>Central Repository</name>
 <url>https://repo.maven.apache.org/maven2</url>
 </repository>
 </repositories>
 <pluginRepositories>
 <pluginRepository>
 <id>public</id>
 <name>Public Repositories</name>
 <url>http://localhost:8081/nexus/content/groups/public/</url>
 </pluginRepository>
 <pluginRepository>
 <releases>
 <updatePolicy>never</updatePolicy>
 </releases>
 <snapshots>
 <enabled>false</enabled>
 </snapshots>
 <id>central</id>
 <name>Central Repository</name>
 <url>https://repo.maven.apache.org/maven2</url>
 </pluginRepository>
 </pluginRepositories>
5.4 测试从私服下载 jar 包
测试 1 ：局域网环境或本地网络即可
在 ssm_service 工程中添加以上配置后，添加 ssm_dao 工程的依赖，删除本地仓库中 ssm_dao
工程，同时在 eclipse 中关闭 ssm_dao 工程。
观察控制台：

 

项目先从本地仓库找 ssm_dao ，找不到从私服找，由于之前执行 deploy 将 ssm_dao 部署到
私服中，所以成功从私服下载 ssm_dao 并在本地仓库保存一份。
如果此时删除私服中的 ssm_dao ，执行 update project 之后是否正常？
如果将本地仓库的 ssm_dao 和私服的 ssm_dao 全部删除是否正常？
测试 2 ：需要互联网环境
在项目的 pom.xml 添加一个依赖，此依赖在本地仓库和私服都不存在， maven 会先从本
地仓库找，本地仓库没有再从私服找，私服没有再去中央仓库下载， jar 包下载成功在私服、
本地仓库分别存储一份。
五、 把第三方 jar 包放入本地仓库或私服
1. 导入本地库
随便找一个 jar 包测试，可以先 CMD进入到 jar 包所在位置，运行 
mvn install:install-file -DgroupId=com.alibaba -DartifactId=fastjson -Dversion=1.1.37
-Dfile= fastjson-1.1.37.jar -Dpackaging=jar

 

 

2. 导入私服
需要在 maven 软件的核心配置文件 settings.xml 中配置第三方仓库的 server 信息 
 <server> 
 <id>thirdparty</id> 
 <username>admin</username>
 <password>admin123</password> 
 </server>
才能执行以下命令 
mvn deploy:deploy-file -DgroupId=com.alibaba -DartifactId=fastjson -Dversion=1.1.37 
-Dpackaging=jar -Dfile=fastjson-1.1.37.jar 
-Durl=http://localhost:8081/nexus/content/repositories/thirdparty/ 
-DrepositoryId=thirdparty

 

 

3. 参数说明
DgroupId 和 DartifactId 构成了该 jar 包在 pom.xml 的坐标，项目就是依靠这两个属性定位。
自己起名字也行。
Dfile 表示需要上传的 jar 包的绝对路径。
Durl 私服上仓库的位置，打开 nexus —— >repositories 菜单，可以看到该路径。
DrepositoryId 服务器的表示 id ，在 nexus 的 configuration 可以看到。
Dversion 表示版本信息，
关于 jar 包准确的版本：
包的名字上一般会带版本号，如果没有那可以解压该包，会发现一个叫 MANIFEST.MF 的文件，
这个文件就有描述该包的版本信息。
比如 Specification-Version: 2.2 可以知道该包的版本了。
上传成功后，在 nexus 界面点击 3rd party 仓库可以看到这包。
Andy393939
关注
专栏目录
maven高级（一）
huangyh技术栈
10-31 1342
1.maven核心概念 1.1maven介绍 Maven翻译为“专家”、“内行”；是一个采用纯Java编写的开源项目管理工具，Maven采用了一种被称之为Project Object Model (POM)概念来管理项目，所有的项目配置信息都被定义在一个叫做POM.xml的文件中, 通过该文件Maven可以管理项目的整个声明周期，包括清除、编译、测试、报告、打包、部署等。目前Apache...
【Java项目学习 Day01】创建JavaWeb的Maven项目
weixin_51617671的博客
07-06 718
maven搭建等等基础学习。
Java_Maven高级
SUIT THUG!的博客
09-24 136
回顾 1，文件上传 fileupload MultipartFile 将上传的文件保存到硬盘上 获取文件名 2，restful url书写的一种风格。 http://localhost/user/1 springmvc支持restful。 @PostMapping("/{id}") public User save(@PathVariable Integer id) { } 3，校验框架 4，ssm整合（重点） 4.1 spring整合mybatis SqlSessionFactoryBean
JAVA—— Maven高级
weixin_50594210的博客
12-03 845
文章目录目标1)分模块开发与设计1.1)工程模块划分1.2)ssm_pojo拆分1.3)ssm_dao拆分1.4)ssm_service拆分1.5)ssm_controller拆分小结2)聚合2.1)多模块构建维护2.2)聚合3)继承3.1)模块依赖关系维护3.2)继承3.3)继承依赖定义3.4)继承依赖使用3.5)继承的资源3.6)继承与聚合对比(了解)4)属性4.1)版本统一的重要性4.2)属性类别4.3)自定义属性4.4)内置属性(了解)4.5)Setting属性(了解)4.6)Java系统属性(了解
Maven的高级应用--依赖，聚合，继承
maomaochong91的专栏
05-01 755
Maven高级应用（依赖，聚合，继承） 依赖：（在当前项目的pom文件中引入要依赖的项目的坐标）   dependency>       groupId>cn.itcast.babasportgroupId>       artifactId>babasport-coreartifactId>       version>0.0.1-SNAPSHOTversion> dependenc
Maven的高级使用
LXL2790的博客
09-24 514
Maven的高级使用
高级软件人才培训专家-day15-Maven高级
03-10
### Maven高级知识点详解 #### 一、Maven高级概述 Maven是一款强大的自动化构建工具，主要用于Java项目的构建和依赖管理。随着技术的发展和项目规模的增长，Maven也提供了丰富的高级功能来支持更复杂的项目需求。...
高级软件人才培训专家-day04-Maven
最新发布
03-10
高级软件人才培训专家-day04-Maven
day04-Maven&MyBatis.zip
03-01
在"day04-Maven&MyBatis.zip"这个压缩包中，我们很可能会找到关于这两个技术的学习资料或者示例项目。 Maven是一个项目管理工具，由Apache软件基金会开发。它通过一个中央仓库管理依赖关系，使得Java项目的构建过程...
day02Maven-教案-实战(IDEA).pdf
07-14
### Maven基础知识点 ...通过掌握Maven的基础知识和高级应用，可以有效提升Java项目的开发和维护效率。同时，了解如何配置和使用Nexus私服，可以进一步优化公司的开发环境，确保依赖库的快速和安全访问。
maven高级应用
qq_25083447的博客
04-24 788
  想看Maven的基础应用可以查看文章：【Java Web基础】Maven基础应用 内容还是比较全的，这里结合IDEA，去熟悉熟悉这些高级运用，首先简单回顾一下相关的基础吧。 文章目录基础回顾Maven的依赖管理Maven的好处三种仓库常见的命令坐标的书写规范依赖配置依赖范围传递性依赖maven高级应用环境准备maven导入jar包时冲突的解决（重要）Maven锁定jar包DAO层编码servi...
Maven高级应用
qq_24545959的博客
03-31 164
目录： 1.基础回顾 2.传统web工程做一个数据查询操作 3.maven工程拆分与聚合的思想 4.把web工程拆分与聚合 5.私服【远程仓库】 6.如何安装第三方jar包 1.基础回顾: 依赖管理：传统的jar放置在项目中，maven的jar包放置在仓库中，项目中只放置指向jar包的坐标 仓库的种类：本地仓库、远程仓库（私服）、中央仓库 仓库之间的关系：启动一个maven工程...
maven基础和maven高级应用
Jancy2265的博客
10-15 304
maven基础和maven高级应用 maven基础 https://www.bilibili.com/video/BV1uJ411k7wy?p=892 892概述 (废话) 893 核心功能一-依赖管理： 只需要导入jar包坐标，自动引入maven仓库中的文件，不需要放入项目中，节省空间 894 核心功能二-一键构建(项目构建)： 构建概念： 一键构建： 895 maven安装 ：(视频略) blog:https://www.jianshu.com/p/245f22be230
Maven高级应用（一）
weixin_56697114的博客
07-02 499
1、分模块开发与设计 1、工程模块与模块划分 1准备一个项目 能成功运行compile说明配置成功
maven高级特性
houhow的专栏
07-21 838
1.SpringBoot打包时包含工程中jar文件 相应maven配置 参考资料：springBoot打包引入外部jar包问题 2.设置多profile部署 首先要在build中增加一个resource节点，deploy.type标识相对于resources的子目录的名称；然后新增profiles节点，分别定义有哪些profile；最后在编译打包时使用-P后加相应的profile环境即可；...
【Java Web基础】maven高级应用
明月沉江春雾晓
07-30 3641
最近在模仿学习做一个企业级的项目，很想感受一下一个大而完整的项目是什么样子的。但是在学习中发现项目其中maven的操作有点奇特，搜索相关的资料发现都是一些Maven比较高级运用，之前写过maven相关的文章【Java Web基础】Maven 内容还是比较全的，这里结合IDEA，去熟悉熟悉这些高级运用，首先简单回顾一下相关的基础吧。 文章目录基础回顾Maven的依赖管理Maven的好处三种仓库常...
maven高级
wwzzh1989的博客
04-16 221
maven中依赖传递的原则 1.路径优先原则 如果我们直接在pom文件中引入了某依赖,而pom中其他jar包也依赖了同一jar包,那么以我们自己引入的为准,因为它的路径最近 2.声明优先原则 如果我们引入的两个jar包中都依赖了某一jar包,那么它的版本以第一个声明的jar包所依赖的jar版版本为准 在依赖中可以使用标签来排除本jar包所依赖的某jar包 锁定依赖版本 版本可以提取到标签内,但...
Maven高级应用思想
weixin_44472627的博客
03-12 154
基础知识 maven是一个项目管理工具。 依赖管理：maven对项目中jar包的管理过程。传统工程我们直接把jar包放置在项目中。 maven工程真正的jar包放置在仓库中，项目中只用放置jar包的坐标。 仓库的种类：本地仓库，远程仓库【私服】，中央仓库。 仓库之间的关系：当我们启动一个maven工程的时候，maven工程会通过pom文件中jar包的坐标去本地仓库找对应jar包。 默认情况下，如果本地仓库没有对应jar包，maven工程会自动去中央仓库下载jar包到本地仓库。 在公司中，如果本地没有对应ja
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Andy393939

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值