Maven高级部分讲解，包括：实例演示SSM整合工程、拆分与聚合、分模块开发工程、私服的讲解

本文链接：https://blog.csdn.net/weixin_46322716/article/details/108835570

（1）Maven：演示SSM工程

1、需求

实现 SSM 工程构建，规范依赖管理
场景：根据商品id 查询商品信息

2、准备数据库

创建 maven 数据库和 items 商品表，并插入五条数据：

// 创建 maven数据库
CREATE DATABASE `maven`;

// 如果存在 items表则删除，否则创建 items表
DROP TABLE IF EXISTS `items`;
CREATE TABLE `items` (
  `id` int(10) NOT NULL auto_increment,
  `name` varchar(20) default NULL,
  `price` float(10,0) default NULL,
  `pic` varchar(40) default NULL,
  `createtime` datetime default NULL,
  `detail` varchar(200) default NULL,
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8;

// 插入数据
INSERT INTO `items` VALUES ('1', '传智播客', '1000', null, '2018-03-13 09:29:30', '带我走上人生巅峰');
INSERT INTO `items` VALUES ('2', '黑马310', null, null, '2018-03-28 10:05:52', '插入测试');
INSERT INTO `items` VALUES ('3', '黑马307', '199', null, '2018-03-07 10:08:04', '插入测试');
INSERT INTO `items` VALUES ('7', '插入测试', null, null, null, null);
INSERT INTO `items` VALUES ('8', '插入测试', null, null, null, null);

3、创建 maven工程

新建一个 ssm_maven 项目,使用下图选中的骨架

在这里插入图片描述

添加坐标

在这里插入图片描述

修改 web.xml 文件

自动生成的 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 xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
          http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         version="3.0">
</web-app>

修改 pom.xml 文件

保留 pom.xml 文件中的原始部分，其余部分删掉

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.idea.maven</groupId>
  <artifactId>SSM_maven</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

</project>

添加 java 和 resources 文件夹，并转换为 source root

在这里插入图片描述

添加 test 测试文件夹下的Java文件夹，并转换为 source root

4、知识点准备

1. 依赖传递

当添加 spring-context 的核心依赖坐标时，Maven会将其他依赖包一起导入（aop/beans/core/expression）

在这里插入图片描述

看起来是一个很不错的功能，但存在着很多问题

2. 依赖冲突

由于依赖传递，spring-context 依赖 spring-beans 的jar包添加到工程中，版本是 5.2.8
此时如果添加 4.2.4 版本的该jar包

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.2.4.RELEASE</version>
</dependency>

在这里插入图片描述

问题：依赖冲突
- 如果将新 Jar包依赖信息写在后面， spring-core 的版本不会发生变化（5.2.8）
- 如果将新 Jar包依赖信息写在前面，spring-core 的版本会发生变化（4.2.4）
结论：如果将 spring-beans-4.2.4 加入工程中并提前声明，工程使用的就不是 spring-bean-5.2.8，发生依赖冲突

3. 依赖调解原则

① 第一声明者优先原则

在 pom 文件定义依赖，哪个包的坐标靠上，就是先声明的
- 先声明的jar包坐标下的依赖包，优先进入项目被使用
直接依赖和传递依赖：
- 直接依赖：项目中直接导入的jar包，就是该项目的直接依赖包
- 传递依赖：项目中没有直接导入的jar包，通过项目直接依赖jar包传递到项目中

② 路径近者优先原则

直接依赖路径比传递依赖路径近，最终项目中进入的jar包，是路径近的依赖包
直接将 spring-core-5.0.2 依赖包添加到项目中，会直接引用该版本的 Jar包

③ 依赖排除法（推荐）

如果在不移动配置位置前提下，想要在工程使用 spring-core-5.2.8 版本的依赖包，可以使用依赖排除法
配置 exclusion标签时，可以不写版本号，此时依赖包使用的版本默认和本jar包相同

④ 问题：

Maven工程是可以分父子关系的
- A项目被B项目依赖，则A中的Jar包都会传递到B项目
- 如果，B项目开发者再导入一套SSM框架Jar包
  – 对于B项目是直接依赖，那么会把A项目中传递的Jar包覆盖
为了防止上述情况出现，需要把A项目中主要Jar包的坐标锁定
- 其他依赖该项目的项目中，即使有同名Jar包直接依赖，也无法覆盖

4. 版本锁定

版本锁定：不用考虑依赖路径、声明优化等因素
- 锁定依赖构件的版本
  - 版本锁定后则不考虑依赖的声明顺序或依赖的路径，以锁定的版本的为准添加到工程中
  - 此方法在企业开发中常用
- 优势：方便统一管理 Jar包版本
  - 在Jar包版本升级后，可以直接在版本锁定处修改版本，下方直接引用即可
版本号可以使用标签设置成变量提取出来，在标签引用即可
注意：在工程中锁定依赖的版本 =/= 在工程中添加了依赖
- 如果工程需要锁定版本的依赖，需要单独添加标签

  <properties>
    <spring.version>5.2.8.RELEASE</spring.version>
  </properties>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</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-core</artifactId>
        <version>${spring.version}</version>
      </dependency>
    </dependencies>
  </dependencyManagement>

  <dependencies>
    <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-beans</artifactId>
    </dependency>
  </dependencies>

在这里插入图片描述

上边添加的依赖并没有指定版本
原因：已在< dependencyManagement >标签中锁定版本，所以不需要再指定版本

5. 实际开发

实际开发中，上述三种依赖调解方式不经常使用
- 在项目开发过程中，需要依赖另外一个技术并导依赖包，导包之前先查看是否存在依赖冲突
  - 如果存在依赖冲突，需要进行依赖调解
  - 如果存在冲突但不解决，可能导致项目运行出错
一般情况：直接引用配置好的三大框架的坐标（冲突已解决）到Pom.xml文件中即可

	<!-- 统一管理jar包版本 -->
	<properties>
		<spring.version>5.2.8.RELEASE</spring.version>
		<slf4j.version>1.6.6</slf4j.version>
		<log4j.version>1.2.12</log4j.version>
		<shiro.version>1.2.3</shiro.version>
		<mysql.version>8.0.16</mysql.version>
		<mybatis.version>3.5.5</mybatis.version>
		<spring.security.version>5.0.1.RELEASE</spring.security.version>
	</properties>

	<!-- 锁定jar包版本 -->
	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-context</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-webmvc</artifactId>
				<version>${spring.version}</version>
			</dependency>
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-tx</artifactId>
				<version>${spring.version}</version>
			</dependency>
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-test</artifactId>
				<version>${spring.version}</version>
			</dependency>
			<dependency>
				<groupId>org.mybatis</groupId>
				<artifactId>mybatis</artifactId>
				<version>${mybatis.version}</version>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<!-- 项目依赖jar包 -->
	<dependencies>
		<!-- spring -->
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>1.6.8</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</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-web</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</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-core</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-webmvc</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>${mysql.version}</version>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>3.1.0</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>javax.servlet.jsp</groupId>
			<artifactId>jsp-api</artifactId>
			<version>2.0</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>jstl</groupId>
			<artifactId>jstl</artifactId>
			<version>1.2</version>
		</dependency>
		<!-- log start -->
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>${log4j.version}</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>${slf4j.version}</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>${slf4j.version}</version>
		</dependency>
		<!-- log end -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>${mybatis.version}</version>
		</dependency>
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>1.3.0</version>
		</dependency>
		<dependency>
			<groupId>c3p0</groupId>
			<artifactId>c3p0</artifactId>
			<version>0.9.1.2</version>
			<type>jar</type>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>com.github.pagehelper</groupId>
			<artifactId>pagehelper</artifactId>
			<version>5.1.2</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-web</artifactId>
			<version>${spring.security.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-config</artifactId>
			<version>${spring.security.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-core</artifactId>
			<version>${spring.security.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-taglibs</artifactId>
			<version>${spring.security.version}</version>
		</dependency>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.0.9</version>
		</dependency>
	</dependencies>
	<!-- 添加tomcat7插件 -->
	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.tomcat.maven</groupId>
				<artifactId>tomcat7-maven-plugin</artifactId>
				<version>2.2</version>
			</plugin>
		</plugins>
	</build>

============开始编写SSM工程

5、编写 domain 实体类

在 com.itheima.domain 文件夹下，创建 Items实体类，实现序列化接口

public class Items implements Serializable {

    private Integer id;
    private String name;
    private Double price;
    private String pic;
    private Date createtime;
    private String detail;

    public Items() {
    }

    public Items(Integer id, String name, Double price, String pic, Date createtime, String detail) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.pic = pic;
        this.createtime = createtime;
        this.detail = detail;
    }
======= get / set / tostring 方法省略 ======= 
.......

6、编写 dao 层

1. 编写 dao层接口

public interface ItemsDao {
    // 根据商品ID查询商品信息
    public Items findById(Integer id);
}

2. 编写 dao层对应映射文件

<?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="com.itheima.dao.ItemsDao">
    <select id="findById" parameterType="int" resultType="items">
        select  * from items where id = #{id};
    </select>
</mapper>

3. 编写配置文件

由于后期要实现 Spring框架整合 Mybatis 框架
此处直接在 spring框架的 applicationContext.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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
			    http://www.springframework.org/schema/beans/spring-beans.xsd
			    http://www.springframework.org/schema/context
			    http://www.springframework.org/schema/context/spring-context.xsd
			    http://www.springframework.org/schema/aop
			    http://www.springframework.org/schema/aop/spring-aop.xsd
			    http://www.springframework.org/schema/tx
			    http://www.springframework.org/schema/tx/spring-tx.xsd
			    http://www.springframework.org/schema/mvc
			    http://www.springframework.org/schema/mvc/spring-mvc.xsd">

        <!-- dao层配置文件 -->
        
        <!-- 配置德鲁伊连接池 -->
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
            <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql:///maven"/>
            <property name="username" value="root"/>
            <property name="password" value="123456"/>
        </bean>

        <!-- 配置SqlSessionFactory工厂 -->
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="dataSource"/>
            <!--  扫描domain包，给包中所有对象起别名 -->
            <property name="typeAliasesPackage" value="com.itheima.domain"/>
        </bean>

        <!-- 配置扫描接口包路径，生成包下所有接口的代理对象，并放入spring容器中 -->
        <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <property name="basePackage" value="com.itheima.dao"/>
        </bean>

</beans>

4. 配置 log4j

# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE

# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE

# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=d:\axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

5. 方法测试

public class ItemsTest {
    @Test
    public void findById(){
        //获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        ItemsDao itemsDao = ac.getBean(ItemsDao.class);
        Items items = itemsDao.findById(1);
        System.out.println(items);
    }
}

结果：商品信息查询成功，Mybatis框架、 dao层搭建成功

Items{id=1, name='传智播客', price=1000.0, pic='null', createTime=Tue Mar 13 09:29:30 CST 2018, detail='带我走上人生巅峰'}

7、编写 service 层

1. 编写 service 层接口

public interface ItemsService {
    // 根据id查询商品信息
    public Items findById(Integer id);
}

2. 编写 service 层接口实现类

添加 @Service 注解，将 ItemsServiceImpl 对象存入Spring的IOC容器管理
dao层的代理对象已经存入容器中，可以直接 @Autowired 依赖注入 ItemsDao代理对象

@Service
public class ItemsServiceImpl implements ItemsService {

    @Autowired
    private ItemsDao itemsDao;

    @Override
    public Items findById(Integer id) {
        Items items = itemsDao.findById(id);
        return items;
    }
}

3. 编写 spring框架的配置文件

开启对 service包的注解扫描
配置事务管理器和AOP增强

		<!-- service层配置文件 -->
		
        <!-- 开启spring框架对service层的扫描 -->
        <context:component-scan base-package="com.itheima.service"/>
        
        <!-- 配置事务管理器 ：AOP面向切面编程（切入点和通知）-->
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="dataSource"/>
        </bean>
        
        <!-- 配置事务通知 :尽量避免全局扫描-->
        <tx:advice id="advice" transaction-manager="transactionManager">
            <tx:attributes>
                <tx:method name="save*" propagation="REQUIRED"/>
                <tx:method name="update*" propagation="REQUIRED"/>
                <tx:method name="delete*" propagation="REQUIRED"/>
                <tx:method name="find*" read-only="true"/>
                <tx:method name="*" propagation="REQUIRED"/>
            </tx:attributes>
        </tx:advice>
        
        <!-- 配置AOP增强 -->
        <aop:config>
            <!-- 配置切入点表达式 -->
            <aop:pointcut id="pointcut" expression="execution(* com.itheima.service.Impl.*.*(..))"/>
            <!-- 配置切入点表达式和事务通知的关系 -->
            <aop:advisor advice-ref="advice" pointcut-ref="pointcut"/>
        </aop:config>

4. 方法测试

创建 ItemsTest1 测试类，测试 service层

public class ItemsTest1 {

    @Test
    public void findById(){
        //获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取对象
        ItemsService itemsService = ac.getBean(ItemsService.class);
        //调用方法
        Items items = itemsService.findById(2);
        System.out.println(items);
    }
}

结果：查询商品信息成功，证明Spring框架整合Mybatis框架成功

Items{id=2, name='黑马310', price=null, pic='null', createTime=Wed Mar 28 10:05:52 CST 2018, detail='插入测试'}

8、编写 web 层

1. 编写配置文件

在 resources文件夹下，创建 springmvc.xml 配置文件
- 配置注解扫描 controller包下的注解
- 配置视图解析器
- 配置释放静态资源
- 自动配置处理器映射器和处理器适配器

<?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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
			    http://www.springframework.org/schema/beans/spring-beans.xsd
			    http://www.springframework.org/schema/context
			    http://www.springframework.org/schema/context/spring-context.xsd
			    http://www.springframework.org/schema/aop
			    http://www.springframework.org/schema/aop/spring-aop.xsd
			    http://www.springframework.org/schema/tx
			    http://www.springframework.org/schema/tx/spring-tx.xsd
			    http://www.springframework.org/schema/mvc
			    http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 配置注解扫描 -->
    <context:component-scan base-package="com.itheima.controller"/>

    <!-- 配置视图解析器 -->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!-- 释放静态资源 -->
    <mvc:resources location="/css/" mapping="/css/**"/>
    <mvc:resources location="/images/" mapping="/images/**"/>
    <mvc:resources location="/js/" mapping="/js/**"/>

    <!-- 配置处理器映射器和处理器适配器 -->
    <mvc:annotation-driven/>
</beans>

2. 编写 web.xml 文件

配置 web.xml 配置文件
- 配置核心Servlet前端控制器（服务器启动时，扫描 springmvc.xml 配置文件）
- 配置字符编码过滤器为 UTF-8 格式
- 配置监听器，服务器一旦启动，ApplicationContext对象创建，监听器扫描 applicationContext 配置文件

<!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 xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
          http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         version="3.0">

    <!-- 配置核心Servlet前端控制器 -->
    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 加载springmvc.xml配置文件 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <!-- 启动服务器，创建该Servlet -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!-- 配置过滤器 -->
    <filter>
        <filter-name>characterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- 配置Spring的监听器 ,默认只加载WEB-INF目录下的配置文件-->
    <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>

3. 编写 JSP 页面

先编写 index.jsp 提交访问页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Title</title>
    </head>
    <body>
        <h3>测试表单</h3>
        <form action="items/findDetail" method="post">
            编号:<input type="text" name="id">
            <input type="submit" name="查询">
        </form>
    </body>
</html>

再编写 itemDetail.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>Insert title here</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} </td>
			</tr>
		</table>
	</form>
</body>
</html>

4. 编写 controller

在 controller包，创建 ItemsController
- 接收 index.jsp 发送的请求和 id参数，
- 调用service层的方法查询信息，存放到 model对象中，返回itemDetail.jsp 页面显示查询结果

@Controller
@RequestMapping("/items")
public class ItemsController {

    @Autowired
    private ItemsService itemsService;

    @RequestMapping("findDetail")
    public String findDetail(Model model,Integer id){
        //调用Service层的方法
        Items items = itemsService.findById(id);
        //对象存入model中传递
        model.addAttribute("item",items);
        return "itemDetail";
    }
}

5. 运行测试

由于配置了内置的 tomcat7，直接启动内置服务器即可

在这里插入图片描述

在 index.jsp 页面输入查询商品的ID，点击提交按钮
查询结果：

（2）拆分与聚合

在这里插入图片描述

（3）Maven：分模块演示工程

1、需求描述

将SSM工程拆分为多个模块进行开发

2、父模块

1. 创建父工程

不使用骨架，创建一个普通Maven工程作为父工程

2. 设置打包方式

需要设置父工程项目的打包方式为 pom

3. 编写 pom.xml（依赖整合）

在父工程的 pom.xml 中抽取一些重复的配置的
– 比如：锁定 jar 包的版本、设置编译版本等
每个模块都需要 spring 或者 junit 的 jar，最终 package 打完包生成的项目中的 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>

4. 发布父工程

父工程创建完成，执行 install 将父工程发布到仓库方便子工程继承

3、子模块

1. 创建 dao 子模块

① 右击父工程，创建子模块

在这里插入图片描述

② 设置打包方式

需要设置 dao 子模块的打包方式为 Jar

<?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>MavenProject_parent</artifactId>
        <groupId>com.idea.maven</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>maven_dao</artifactId>
    <packaging>jar</packaging>

</project>

③ 填充代码

将上个工程中的 Dao层接口和映射文件、domain实体类包，以及Spring框架配置Dao层部分转移到该模块

④ 单元测试

需要在 dao子模块的 pom.xml 中添加 junit 的依赖Jar包，添加时 Scope 选择 test

    <!-- junit测试 -->
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

编写 ItemsDaoTest测试类，测试 dao子模块是否可用
- 测试类测试查询，需要导入 log4j 的依赖Jar包

public class ItemsDaoTest {
    @Test
    public void testFindItemsById() {
        //获取 spring 容器
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring/applicationContext-dao.xml");
        //获取 bean对象
        ItemsDao itemsDao = applicationContext.getBean(ItemsDao.class);
        //调用 itemsDao 方法
        Items items = itemsDao.findById(1);
        System.out.println(items);
    }
}

结果：

⑤ 安装到本地仓库

将 dao子模块，执行 install 命令，安装到本地仓库中，供其他子模块引用依赖

2. 创建 service 子模块

① 创建子模块

在这里插入图片描述

② 设置打包方式

需要设置 service 子模块的打包方式为 Jar

<?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>MavenProject_parent</artifactId>
        <groupId>com.idea.maven</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>maven_dao</artifactId>
    <packaging>jar</packaging>

</project>

③ 填充代码

将上个工程中的 Service层接口、实现类以及Spring框架配置Service层部分转移到该模块

④ 依赖注入

问题：在 ItemsServiceImpl 实现类中，自动依赖注入 ItemsDao 对象

@Service
public class ItemsServiceImpl implements ItemsService {

    @Autowired
    private ItemsDao itemsDao;

    @Override
    public Items findById(Integer id) {
        return  itemsDao.findById(id);
    }
}

解决：需要在 applicationContext-service 文件内导入 applicationContext-dao文件，即可实现依赖注入

<import resource="applicationContext-dao.xml"/>

⑤ 单元测试

编写 ItemsServiceTest测试类，测试 service子模块是否可用

public class ItemsServiceTest {
    @Test
    public void testFindItemsById() {
        //获取 spring 容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:spring/applicationContext-service.xml");
        //获取 bean对象
        ItemsService itemsService = ac.getBean(ItemsService.class);
        //调用 itemsService 方法
        Items items = itemsService.findById(1);
        System.out.println(items);
    }
}

结果：

⑥ 安装到本地仓库

3. 创建子模块间关系

Service模块需要使用 Dao模块中资源，配置 Service模块的 Pom.xml

	<artifactId>maven_service</artifactId>
    <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>com.idea.maven</groupId>
            <artifactId>maven_dao</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

Web模块使用 Service模块中资源

	<artifactId>maven_web</artifactId>
    <packaging>war</packaging>
    <dependencies>
        <dependency>
            <groupId>com.idea.maven</groupId>
            <artifactId>maven_service</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

4. 创建 web 子模块

① 创建子模块

使用骨架创建 Maven-Web 子模块，与服务器进行交互

② 设置打包方式

需要设置 web 子模块的打包方式为 War

<?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>MavenProject_parent</artifactId>
        <groupId>com.idea.maven</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>maven_web</artifactId>
    <packaging>war</packaging>

</project>

③ 填充代码

将上个工程中的 Web层、JSP页面、web.xml 和 SpringMVC框架配置文件和log4j配置文件转移到该模块

在这里插入图片描述

还需要将服务器启动时，web.xml配置文件扫描的 applicationContext.xml 配置文件
- 导入 applicationContext-dao / service 配置文件

<import resource="classpath:spring/applicationContext-dao.xml"/>
<import resource="classpath:spring/applicationContext-service.xml"/>

5. 父模块 pom.xml

当 dao / service / web 三层子模块创建完成后，父工程的 pom.xml 文件更改为：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.idea.maven</groupId>
    <artifactId>MavenProject_parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>maven_dao</module>
        <module>maven_service</module>
        <module>maven_web</module>
    </modules>
    <packaging>pom</packaging>

</project>

（4）继承、聚合、传递依赖

1、继承

目的：为了消除重复
问题：如果将 dao、service、web 分开创建独立的工程，则每个工程的 pom.xml 文件中的内容存在重复
- 比如：设置编译版本、锁定 spring 的版本的等
解决：将这些重复的配置提取出来在父工程的 pom.xml 中定义

2、聚合

项目开发通常是分组分模块开发，每个模块开发完成要运行整个工程，需要将每个模块聚合在一起运行
- 比如：dao、service、web 三个工程最终会打一个独立的 war 运行

3、项目与模块

工程与模块的区别：
- 工程不等于完整的项目，模块也不等于完整的项目
- 一个完整的项目看的是代码，代码完整就是一个项目。一个完整项目和是工程还是模块无关
工程：天生只能使用自己内部资源，是独立的，后期可以和其他工程或模块产生关联关系
- 父子工程之间，子模块天生继承父工程，可以使用父工程内所有资源
- 父子工程之间不用建立关系，继承关系是先天的，不需要手动建立
模块：天生不是独立的，是属于父工程的，模块一旦创建，所有父工程的资源都可使用
- 子模块之间，天生是没有任何关系的，后期可以建立关系
平行之间的引用叫做依赖，依赖不是先天的，需要后天手动建立

4、传递依赖（了解）

传递依赖下的包能否使用，查询下图：（以 Junit 包为例）
实际开发中，如果传递依赖丢失，表现为Jar包坐标导入失败
解决方法：直接在子工程的pom.xml文件再次导入Jar包依赖即可

（5）父子工程启动方式

1、父工程集成插件运行

在父工程的 Pom.xml 中配置了 Tomcat7 的插件，自动聚合并执行

在这里插入图片描述

测试结果：启动测试成功

2、 web子模块插件运行

在 maven_web 子模块的 pom.xml 中配置 tomcat7 插件运行（直接继承父工程的 tomcat7 插件配置）
问题：运行web子模块，其依赖于 service子模块，会到本地仓库中下载依赖的 Jar包
- 如果本地仓库不存在该子模块的 Jar包，会提示缺失依赖 Jar包，执行出现问题
解决方法：
- 在完成每个子模块开发后，执行 install 命令，安装到本地仓库中，方便其他子模块依赖
- 或者直接执行父工程的 install 命令，也可以将依赖Jar包安装到本地仓库
注意：
- 当 web 子模块依赖的 jar 包内容修改，必须及时发布到本地仓库
- 比如：web 依赖的 service 修改，需要及时将 service 子模块发布到本地仓库

在这里插入图片描述

3、本地插件运行

不使用配置的 Tomcat7 插件运行，配置本地 tomcat 服务器运行项目

1. 配置本地服务器

在这里插入图片描述

2. 启动服务器测试

在这里插入图片描述

（6）Maven：私服

1、需求

正式项目开发时，不同的项目组开发不同的工程
例如：
- dao 工程开发完毕，发布到私服上
- service 开发组从私服下载 dao 工程使用

2、分析

公司在自己的局域网内搭建自己的远程仓库服务器，称为私服
私服服务器：公司内部的 maven 远程仓库
- 每个员工的电脑上安装 maven 软件并且连接私服服务器
- 员工将开发的项目打成 jar ，并发布到私服服务器，其它项目组从私服服务器下载所依赖 Jar
私服还充当一个代理服务器，当私服上没有 jar 包会从互联网中央仓库自动下载

在这里插入图片描述

3、搭建私服环境

1. 下载 nexus

Nexus 是 Maven 仓库管理器，通过 nexus 可以搭建 maven 仓库
同时 nexus 还提供强大的仓库管理功能，构件搜索功能等
下载 Nexus，下载地址：http://www.sonatype.org/nexus/archived/
- windows：nexus-2.12.0-01-bundle.zip
- linux：nexus-2.12.0-01-bundle.tar.gz

2. 安装 nexus

以 window10系统为例，解压 nexus-2.12.0-01-bundle.zip 到一个目录下
以管理员身份打开 cmd命令行，切换到 bin 目录下，执行 nexus.bat install 命令安装
右击【我的电脑】→【管理】→【服务】，可以查看 nexus 服务

3. 卸载 nexus

以管理员身份打开 cmd命令行，切换到 bin 目录下，执行 nexus.bat uninstall 命令安装

D:\apache-maven-3.6.3\nexus\nexus-2.12.0-01\bin > nexus.bat uninstall

查看 window服务列表 nexus 服务已经被移除

4. 启动 nexus

① 方法一：

cmd 进入 bin 目录，执行 nexus.bat start 命令，启动 nexus 服务

② 方法二：

在 window服务列表中，右击【nexus】服务，点击启动

③ 查看配置文件

查看 nexus 配置文件（conf / nexus.properties）

④ 访问 nexus 页面

根据配置文件，访问 nexus页面：http://localhost:8081/nexus/

⑤ 登录账号

使用 nexus内置账户 admin/ admin123 登录
登录成功：

5. 仓库类型

查看 nexus 的仓库：
nexus 仓库有四种类型：
1. hosted：宿主仓库，部署自己的 jar 到这个类型的仓库，包括 releases、snapshot、3rd party
  - Releases 公司内部发布版本仓库
  - Snapshots 公司内部测试版本仓库
  - 3rd party 第三方仓库
2. proxy：代理仓库，用于代理远程的公共仓库
  - 例如：Central： maven 中央仓库，用户连私服，私服自动去中央仓库下载 jar 包、插件
3. group：仓库组，用来合并多个 hosted/proxy 仓库，通常我们配置自己的 maven 连接仓库组
4. virtual(虚拟)：兼容 Maven1 版本的 jar 或者插件
注意：
- 这里暂时将远程仓库（私服）安装在自己电脑上
- 实际在公司进行项目开发，不能直接打开公司的远程服务器的，只能通过 nexus 页面访问

4、发布项目到私服

1. 需求

企业中多个团队协作开发通常会将一些公用组件、开发模块等发布到私服
- 供其它团队或模块开发人员使用
本例子假设多团队分别开发 maven_dao、maven_service、maven_web，某个团队开发完在 maven_dao 会将其发布到私服供 maven_service 团队使用
本例子会将 maven_dao 工程打成 jar 包发布到私服

2. 配置

① 配置私服环境

需要在客户端电脑上配置 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 仓库
将下列配置文件添加到要上传到私服的 maven_dao 工程的 pom.xml 文件中
注意：
- pom.xml 这里和 settings.xml 配置对应！
- url 地址在公司开发中，应该会修改IP地址（不为 localhost）

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

3. 测试

① 启动 nexus 私服服务

② 执行 deploy命令

对要打包的 maven_dao 工程执行 deploy 命令
根据本项目的 pom.xml 中 version定义决定发布项目到哪个仓库
- 定义 snapshot ，执行 deploy 会发布到 nexus 的 snapshot 仓库
- 定义 release，执行 deploy 会发布到 nexus 的 release 仓库

③ 查看发布结果

本项目是发布在 snapshots 仓库中，可以在私服仓库中查看
也可以通过 http 访问页面查看

4. 注意

由于发布项目到私服执行的是 deploy命令，是默认生命周期最后一站，前面命令会全部执行
- installl 命令也肯定执行了，本地仓库中肯定存在该项目的依赖 Jar包

5、从私服下载 jar包

1. 需求

没有配置 nexus 之前，如果本地仓库没有 Jar 包，就去中央仓库下载
通常在企业中会在局域网内部署一台私服服务器
1. 部署私服后，本地项目首先去本地仓库找 jar，如果没有找到则连接私服从私服下载 jar 包
2. 如果私服没有 jar 包，私服同时作为代理服务器从中央仓库下载 jar 包
好处：
1. 由私服对公司项目的依赖 jar 包统一管理
2. 提高下载速度，项目连接私服下载 jar 包的速度 > 项目连接中央仓库的速度
先删除本地仓库中 maven_dao 的依赖 Jar包，模拟从私服仓库中下载 maven_dao 的依赖 Jar包

2. 配置

从私服仓库下载 Jar包，需要配置客户端 setting.xml 文件

<profiles> 
	<!-- 下载jar包配置 -->
	<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>
		<!-- 插件仓库,maven的运行依赖插件,也需要从私服下载插件 -->
		<pluginRepositories> 
			<!-- 插件仓库的id不允许重复，如果重复后边配置会覆盖前边 -->
			<pluginRepository> 
				<id>public</id>
				<name>Public Repositories</name>
				<url>http://localhost:8081/nexus/content/groups/public/</url>
			</pluginRepository>
		</pluginRepositories>
	</profile>
</profiles>	
<!-- 激活profiles -->
<activeProfiles>
		<activeProfile>dev</activeProfile>
</activeProfiles>

3. 测试

再次运行 maven_web 项目
- 由于 web项目依赖 maven_service 模块，又依赖于 maven_dao 模块，但本地仓库不存在 dao
- 本地仓库会从私服的仓库中下载 maven_dao 的依赖Jar包
结果：下载依赖成功后，项目即可正常运行

6、安装第三方jar包

1. 安装到本地仓库

① 进入jar包所在目录

运行以下命令：

mvn install:install-file -DgroupId=com.alibaba -DartifactId=fastjson -Dversion=1.1.37 -Dfile=fastjson-1.1.37.jar -Dpackaging=jar

在这里插入图片描述

② cmd直接运行

运行以下命令：

C:\Users\jiao>mvn install:install-file -DgroupId=com.alibaba -DartifactId=fastjson -Dversion=1.1.37 -Dpackaging=jar -Dfile=E:\Desktop\Git与Maven\Maven高级\资料\安装第三方jar包\fastjson-1.1.37.jar

在这里插入图片描述

2. 安装到私服仓库

将下载的第三方 Jar包安装到私服仓库的 thirdparty 仓库中

① 配置 settings

需要再 settings 配置文件中添加登录私服第三方的登录信息

<server>
	<id>thirdparty</id>
	<username>admin</username>
	<password>admin123</password>
</server>

② 进入jar包所在目录

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

在这里插入图片描述

③ cmd直接运行

mvn deploy:deploy-file -DgroupId=com.alibaba -DartifactId=fastjson -Dversion=1.1.37 -Dpackaging=jar -Dfile=E:\Desktop\Git与Maven\Maven高级\资料\安装第三方jar包\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 仓库可以看到这包

=如果觉得总结的还可以，评论点赞一个吧，谢谢============================

Maven高级部分讲解，包括：实例演示SSM整合工程、拆分与聚合、分模块开发工程、私服的讲解

（1）Maven：演示SSM工程

1、需求

2、准备数据库

3、创建 maven工程

4、知识点准备

1. 依赖传递

2. 依赖冲突

3. 依赖调解原则

① 第一声明者优先原则

② 路径近者优先原则

③ 依赖排除法（推荐）

④ 问题：

4. 版本锁定

5. 实际开发

5、编写 domain 实体类

6、编写 dao 层

1. 编写 dao层接口

2. 编写 dao层对应映射文件

3. 编写 配置文件

4. 配置 log4j

5. 方法测试

7、编写 service 层

1. 编写 service 层接口

2. 编写 service 层接口实现类

3. 编写 spring框架的配置文件

4. 方法测试

8、编写 web 层

1. 编写配置文件

2. 编写 web.xml 文件

3. 编写 JSP 页面

4. 编写 controller

5. 运行测试

（2）拆分与聚合

（3）Maven：分模块演示工程

1、需求描述

2、父模块

1. 创建父工程

2. 设置打包方式

3. 编写 pom.xml（依赖整合）

4. 发布父工程

3、子模块

1. 创建 dao 子模块

① 右击父工程，创建子模块

② 设置打包方式

③ 填充代码

④ 单元测试

⑤ 安装到本地仓库

2. 创建 service 子模块

① 创建子模块

② 设置打包方式

③ 填充代码

④ 依赖注入

⑤ 单元测试

⑥ 安装到本地仓库

3. 创建子模块间关系

4. 创建 web 子模块

① 创建子模块

② 设置打包方式

③ 填充代码

5. 父模块 pom.xml

（4）继承、聚合、传递依赖

1、继承

2、聚合

3、项目与模块

4、传递依赖（了解）

（5）父子工程启动方式

1、父工程集成插件运行

2、 web子模块插件运行

3、本地插件运行

1. 配置本地服务器

2. 启动服务器测试

（6）Maven：私服

1、需求

2、分析

3、搭建私服环境

1. 下载 nexus

2. 安装 nexus

3. 卸载 nexus

4. 启动 nexus

3. 编写配置文件