JavaWeb——（19）Maven高级

小唐要努力

于 2021-12-10 10:08:29 发布

阅读量463

点赞数 1

分类专栏： # JavaWeb 文章标签： maven

本文链接：https://blog.csdn.net/weixin_39478524/article/details/121750601

版权

JavaWeb 专栏收录该内容

22 篇文章 4 订阅

订阅专栏

一、Maven基础回顾

1.1Maven介绍

Maven 是一个项目管理工具，主要作用是在项目开发阶段对Java项目进行依赖管理和项目构建。

依赖管理：即对jar包的管理。通过导入maven坐标，就相当于将仓库中的jar包导入到项目中
项目构建：通过maven的命令就可以完成项目从清理、编译、测试、报告、打包，部署整个过程

1.2Maven仓库类型

Maven的仓库主要分为本地仓库和远程仓库两种。

本地仓库就是我们本地Maven管理的仓库，存储在我们pc端，而远程仓库一般需要网络连接进行jar包的获取，

远程仓库又分为：

maven中央仓库（http://repo2.maven.org/maven2/）
maven私服（公司局域网内的仓库，需要自己搭建）
其他公共远程仓库（例如apache提供的远程仓库：http://repo.maven.apache.org/maven2/）

1.3Maven常用命令

Maven中一些常用的命令及其作用如下：

clean：清理
compile：编译
test：测试
package：打包
install：安装

1.4Maven坐标书写规范

我们以常用的mysql连接数据库jar包为例，

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.6</version>
</dependency>

1.5Maven的依赖范围

依赖范围描述的是jar包在哪些周期生效，即项目在这些周期需要依赖该jar包。

依赖范围	对于编译classpath有效	对于测试classpath有效	对于运行时classpath有效	例子
compile	Y	Y	Y	spring-core
test	-	Y	-	Junit
provided	Y	Y	-	servlet-api
runtime	-	Y	Y	JDBC驱动
system	Y	Y	-	本地的，maven仓库之外的类库

二、Maven的依赖传递

2.1依赖传递

在maven中，依赖是可以传递的，假设存在三个项目，分别是项目A，项目B以及项目C。假设C依赖B，B依赖A，那么我们可以根据maven项目依赖的特征不难推出项目C也依赖A。

例如我们在导入spring-webmvc这个jar包时，会同时导入这个包所依赖的一些其他包（例如spring-aop、spring-beans等）

2.2依赖冲突

假设我们要导入两个包spring-webmvc-5.0.2 和 spring-aop-5.0.0

由于依赖传递现象的存在， spring-webmvc-5.0.2 依赖 spirng-beans-5.0.2，而spring-aop-5.0.0 依赖 spring-beans-5.0.0，但是发现 spirng-beans-5.0.2 加入到了工程中，而我们希望 spring-beans-5.0.0 加入工程。这就造成了依赖冲突。

简单来说，依赖冲突是指项目依赖的某一个jar包，有多个不同的版本，因而造成类包版本冲突。

依赖冲突很经常是类包之间的间接依赖引起的。每个显式声明的类包都会依赖于一些其它的隐式类包，这些隐式的类包会被maven间接引入进来，从而造成类包冲突。

2.3解决依赖冲突

解决依赖冲突有三种方式：

使用maven提供的依赖调解原则
1. 第一声明者优先原则
2. 路径近者优先原则
排除依赖
锁定版本

2.3.1依赖调解原则

1、第一声明者优先原则

在 pom 文件中定义依赖，以先声明的依赖为准。

其实就是根据坐标导入的顺序来确定最终使用哪个传递过来的依赖。

从上图我们可以看出，我们首先导入的spring-aop-5.0.0，此时该包间接依赖了spring-beans，所以把spring-beans-5.0.0也导入进来了，然后我们又导入了spring-webmvc-5.0.2，该包也对spring-beans有间接依赖关系，所以它导入了spring-beans-5.0.2，

但是项目最后生效的是spring-beans-5.0.0，因为该包是先导入进来的。

所以我们可以修改pom.xml文件，颠倒两个包的导入顺序就可以更改最后使用包的版本，但是这种解决依赖冲突的办法费时费力，不推荐开发使用。

2、路径近者优先原则

在 pom.xml 文件中定义依赖，以路径近者为准。

还是上述情况，spring-aop 和 spring-webmvc 都会传递过来 spirng-beans，那如果直接把 spring-beans 的依赖直接写到 pom.xml 文件中，那么项目就不会再使用其他依赖传递来的 spring-beans

因为自己在 pom.xml 文件中导入的 spirng-beans 依赖属于直接依赖，比其他两个 spring-aop 和 spring-webmvc 传递的间接依赖距离要近，所以我们会优先选择自己定义的版本。

2.3.2排除依赖

排除依赖就是使用exclusions标签将传递过来的依赖排除出去。

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.0.5.RELEASE</version>
    <!--指定不需要传递的依赖-->
    <exclusions>
        <exclusion>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
        </exclusion>
    </exclusions>
</dependency>

2.3.3锁定版本

版本锁定即采用直接锁定版本的方法确定依赖jar包的版本，版本锁定后则不考虑依赖的声明顺序或依赖的路径，以锁定的版本为准添加到工程中，此方法在企业开发中经常使用。

版本锁定的步骤如下：

第一步在pom.xml中定义dependencyManagement标签，在标签中锁定依赖的版本
第二步在dependencies标签中声明需要导入的maven坐标

<dependencyManagement>
    <dependencies>
        <!--对jar包的版本进行锁定，但是此时没有导入相应的jar包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
    </dependencies>
</dependencyManagement>
<dependencies>
    <!--导入相应jar包时只用写名称，无需再指定版本-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
    </dependency>
</dependencies>

三、基于Maven构建SSM工程案例

本案例基于maven构建 SSM（Spring+SpringMVC+Mybatis）工程，通过maven坐标进行依赖管理。最终实现根据 id 查询商品信息的功能。

3.1搭建数据库环境

我们要在数据库中创建商品表item，

DROP TABLE IF EXISTS item;
CREATE TABLE item(
  id INT(11) NOT NULL AUTO_INCREMENT,
  NAME VARCHAR(255) DEFAULT NULL,
  price FLOAT DEFAULT NULL,
  createtime DATETIME DEFAULT NULL,
  detail VARCHAR(255) DEFAULT NULL,
  PRIMARY KEY (id)
)

为了方便后续的查询，我们向item表插入一条电视机的数据，

INSERT INTO item VALUES(1,'电视机',4500,'2021-12-08 09:27:00','电视机')

3.2Maven项目构建

Maven的项目构建主要包括：

创建maven web项目，配置pom.xml文件
实现spring+mybatis整合
- 创建POJO类
- 持久层DAO接口编写
- Mapper映射文件编写
- 业务层Service编写
- spring配置文件applicationContext.xml编写
加入springmvc相关配置
- 表现层Controller编写
- springmvc.xml文件编写
- jsp页面编写
- 配置web.xml文件

第一步我们首先创建maven的web项目，配置好web环境，然后配置pom.xml文件导入jar包坐标（提取码：fxjw），这里我们可以用版本锁定的方式锁定一些jar包的版本，避免jar包冲突。

第二步我们实现对spring和mybatis的整合，

首先是创建实体类对象item，

class Item {
    private int id;
    private String name;
    private float price;
    private Date createtime;
    private String detail;
    
    //生成对应的set、get方法
}

接着是对持久层DAO接口的编写，

interface ItemMapper {
    public Item findById(int id);
}

然后是编写mapper映射文件，利用mybatis的动态代理自动生成实现类，

<?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="mapper.ItemMapper">
    <select id="findById" parameterType="int" resultType="Item">
        select * from item where id = #{id}
    </select>
</mapper>

dao层写好之后就是service业务层的实现，包括接口和对应的实现类，

interface ItemService {
    public Item findById(int id);
}

@Service//指定service层的bean对象，将该对象放置到spring容器中
@Transactional//进行事务控制
class ItemServiceImpl implements ItemService {
    @Autowired//自动注入
    private ItemMapper itemMapper;

    public Item findById(int id) {
        return itemMapper.findById(id);
    }
}

接着是配置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:tx="http://www.springframework.org/schema/tx"
       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/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!--配置数据源信息，使用druid连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mydb1"/>
        <property name="username" value="root"/>
        <property name="password" value="3837"/>
    </bean>

    <!--配置sessionFactory对象-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--扫描domain实体类的包，为实体类创建别名-->
        <property name="typeAliasesPackage" value="domain"/>
    </bean>

    <!--扫描mapper所在的包，并为mapper创建实现类，放置到spring容器中-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="mapper"/>
    </bean>

    <!--配置组件扫描，扫描包下的注解-->
    <context:component-scan base-package="service"/>

    <!--配置声明式事务控制-->
    <!--事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--事务注解驱动-->
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

配好了之后我们可以简单测试一下，

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
class SpringMyBatisTest {
    @Autowired
    private ItemService itemService;

    @Test
    public void test1(){
        Item item = itemService.findById(1);
        System.out.println(item);
    }
}

第三步我们加入SpringMVC相关的配置，

首先我们实现表现层Controller，创建对应的类，

@Controller
@RequestMapping("/item")
public class ItemController {
    @Autowired//自动注入
    private ItemService itemService;

    @RequestMapping("/showItem/{id}")
    public String findById(@PathVariable("id") int id, Model model){//从url中取id赋值给参数id
        Item item = itemService.findById(id);//根据id查找商品
        model.addAttribute("item",item);//将商品数据添加到模型中
        return "item";//跳转相应视图
    }
}

接着我们配置SpringMVC的核心配置文件spring-mvc.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: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/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--配置组件扫描，扫描controller包-->
    <context:component-scan base-package="controller"/>

    <!--配置mvc注解驱动-->
    <mvc:annotation-driven/>

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

    <!--开放静态资源访问权限-->
    <mvc:default-servlet-handler/>
</beans>

然后我们需要编写jsp页面，用于展示获取到的数据，

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    ${item}
</body>
</html>

最后我们要配置web.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <!--指定Spring核心配置文件位置-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>

    <!--配置spring框架启动时的监听器-->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    
    <!--配置SpringMVC的前端控制器-->
    <servlet>
        <servlet-name>DispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--指定SpringMVC的核心配置文件-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

最后我们配置好tomcat服务器，启动运行，

四、分模块构建Maven工程

在企业项目开发过程中，由于项目规模庞大，业务复杂，参与的人员也比较多，所以一般会通过合理的模块差分将大型的项目拆分为很多小模块，分别进行开发，并且这样拆分出来的模块非常容易被其他模块复用。

4.1拆分方式

常见的拆分方式有两种：

1、按照业务模块进行拆分

我们按照业务模块对项目进行拆分，每个模块都拆分为一个maven工程，例如网上商城项目就可以分为用户模块、订单模块、购物车模块等，每个模块对应一个maven工程。

2、按照层进行拆分

我们按照持久层、业务层、表现层的划分，将项目拆分为不同的模块，每个层就对应一个maven工程。

不管是哪种拆分方式，我们都会有一个父工程，将一些公共的代码和配置提取到父工程中进行统一的管理和配置。

4.2Maven工程的继承

在Java语言中，类之间是可以继承的，通过继承，子类就可以引用父类中非private的属性和方法。

同样，在maven工程之间也可以继承，子工程继承父工程后，就可以使用在父工程中引入的依赖。继承的目的是为了消除重复代码。

通过上图我们可以看出，要想实现Maven工程中的继承，需要：

父工程中打包的方式为pom
子工程通过parent标签对父工程进行继承

我们可以新建一个maven_Parent工程作为父工程，在pom文件中导入mysql的jar包，

<groupId>aoylaotang</groupId>
<artifactId>maven_Parent</artifactId>
<version>1.0-SNAPSHOT</version>
<!--父工程的打包方式必须为pom-->
<packaging>pom</packaging>

<dependencies>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.32</version>
    </dependency>
</dependencies>

然后我们新建一个maven_Child工程作为子工程，注意新建的时候选择Parent为 maven_Parent 工程，

新建好了之后我们没有在子工程的pom.xml文件中导入过任何jar包，但是我们查看该项目的依赖会发现有mysql的包，

4.3Maven工程的聚合

在Maven工程的pom.xml文件中可以使用<modules>标签将其他maven工程聚合到一起，聚合的目的是为了进行统一操作（打包发布）。

例如拆分后的maven工程有多个，如果要进行打包，就需要针对每个工程分别执行打包命令，操作起来非常繁琐。这时就可以使用<modules>标签将这些工程统一聚合到maven工程中，需要打包的时候，只需要在此工程中执行一次打包命令，其下被聚合的工程就都会被打包了。

假设我们想把刚刚创建的子工程 maven_Child 聚合到父工程 maven_Parent 中，那么就要修改父工程 maven_Parent 中的pom.xml文件，利用modules标签聚合子工程，

<!--聚合其他工程-->
<modules>
    <!--聚合工程（注意即使二者之间不存在继承关系也可以进行聚合）-->
    <module>../maven_Child</module>
</modules>

注意：即使两个工程之间没有继承关系，但是我们仍然可以进行聚合操作。

当我们在maven_Parent执行清理操作时，发现聚合的模块也进行了清理。

4.4分模块构建Maven工程实现

接下来我们用上述查询商品的例子进行分模块构建。

首先我们创建一个父工程 maven_Parent，在父工程的 pom.xml 中一般只进行jar包版本的锁定，在子工程中进行jar包的导入，用什么包就导入什么包。

然后我们在 maven_Parent 模块右键，新建模块，模块默认的父工程就是 maven_Parent 工程。利用这种方式我们创建好maven_pojo、maven_dao、maven_service、maven_web这几个模块。

因为 maven_pojo 中都是一些对实体的操作，所以我们在 maven_pojo 模块中不需要用到什么饿啊外的jar包，真正要使用到jar包的从 maven_dao 模块开始。我们在 maven_dao 模块中导入需要的jar包，然后在 maven_service 中调用 maven_service 包，

<dependencies>
    <dependency>
        <groupId>aoylaotang</groupId>
        <artifactId>maven_dao</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
</dependencies>

同理我们在 maven_web 中调用 maven_service 模块，依次传递下去，这样只用在 maven_dao 中导入jar包，其他模块依靠传递就可以用到了。

需要注意的是 maven_web 模块需要用到springmvc的jar包，所以还要额外导入mvc的包，

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
</dependency>

完成了pom.xml文件的导包操作，接下来我们完善每个工程内部的业务代码。

首先是 maven_pojo 模块，在该模块主要是定义实体类对象Item，确定好对应属性和getset方法。

然后是 maven_dao 模块，该模块主要是负责dao接口的定义以及映射文件的定义，此时我们还需要将applicationContext.xml核心配置文件拆分，将dao部分的配置放置到 maven_dao 模块中，主要包括了配置数据源信息，配置sqlsessionFactory对象以及扫描mapper包为接口创建实现类。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--配置数据源信息，使用druid连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mydb1"/>
        <property name="username" value="root"/>
        <property name="password" value="3837"/>
    </bean>

    <!--配置sessionFactory对象-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--扫描domain实体类的包，为实体类创建别名-->
        <property name="typeAliasesPackage" value="domain"/>
    </bean>

    <!--扫描mapper所在的包，并为mapper创建实现类，放置到spring容器中-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="mapper"/>
    </bean>
</beans>

然后是 maven_service 模块，该模块负责的是service层的代码，主要包含service接口和实现类，以及applicationContext.xml核心配置文件中的service部分配置，主要有配置service包的组件扫描，以及声明式事务控制的配置和事务注解驱动：

<?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:tx="http://www.springframework.org/schema/tx"
       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/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!--配置组件扫描，扫描包下的注解-->
    <context:component-scan base-package="service"/>

    <!--配置声明式事务控制-->
    <!--事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--事务注解驱动-->
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

最后是我们的显示web层，主要是controller包下的代码，用于处理url与调用对应方法，其核心与servlet类似，spring-mvc.xml配置文件和web.xml也需要放置到web层的资源文件下，还有用于显示的jsp等页面也需要加入进来，

需要注意的是，在web.xml中加载spring核心配置文件时，可以利用通配符*来加载applicationContext-dao.xml和applicationContext-service.xml这两个配置文件。

<!--指定Spring核心配置文件位置-->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext*.xml</param-value>
</context-param>

部署完成之后我们给 maven_web 模块配置tomcat服务器，然后启动服务器，访问url

小唐要努力

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
JavaWeb——（19）Maven高级

一、Maven基础回顾1.1Maven介绍Maven 是一个项目管理工具，主要作用是在项目开发阶段对Java项目进行依赖管理和项目构建。依赖管理：即对jar包的管理。通过导入maven坐标，就相当于将仓库中的jar包导入到项目中项目构建：通过maven的命令就可以完成项目从清理、编译、测试、报告、打包，部署整个过程1.2Maven仓库类型Maven的仓库主要分为本地仓库和远程仓库两种。本地仓库就是我们本地Maven管理的仓库，存储在我们pc端，而远程仓库一般需要网络...
复制链接

扫一扫