精华内容
下载资源
问答
  • 新建一个Maven工程 ...到此使用Maven建立聚合工程就OK了 下面看下Maven的依赖传递: 选择上面的Maven父工程,执行install 然后我们假设让api模块依赖model模块,然后service模块依赖api模块 那...

    新建一个Maven工程

    然后建立集合的子模块

    然后依次按照上面的步骤,建立model和service模块

    新建完成后工程结构如下所示

    到此使用Maven建立聚合工程就OK了

     

    下面看下Maven的依赖传递:

    选择上面的Maven父工程,执行install

    然后我们假设让api模块依赖model模块,然后service模块依赖api模块

    那么根据依赖传递性,service将会同时加入api和model两个模块

    在API模块的pom中添加如下:

    <dependency>
    	<groupId>cn.cuit.dubbo</groupId>
    	<artifactId>model</artifactId>
    	<version>0.0.1-SNAPHOT</version>
    </dependency>

    在service模块的pom中添加:

    <dependency>
    	<groupId>cn.cuit.dubbo</groupId>
    	<artifactId>api</artifactId>
    	<version>0.0.1-SNAPHOT</version>
    </dependency>

    然后更新Maven工程:

    查看service模块和api模块的Maven依赖:

    依赖传递就OK了

    ********************************* 不积跬步无以至千里,不积小流无以成江海 *********************************

    展开全文
  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FwwGrtUF-1616806045215)(maven依赖传递聚合工程.assets/屏幕截图 2021-03-26 090723.jpg)] 依赖冲突 由于依赖传递现象的存在, sp

    内容输出来源:拉钩教育Java就业训练营

    1 maven的依赖传递

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

    在这里插入图片描述

    依赖冲突

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

    1.1 解决依赖传递

    1.使用maven提供的依赖调解原则

    ​ 第一声明者优先原则

    ​ 路径近者优先原则

    2.排除依赖

    3.锁定版本

    1.2 依赖调节原则——第一声明者优先原则

    在 pom 文件中定义依赖,以先声明的依赖为准。其实就是根据坐标导入的顺序来确定最终使用哪个传 递过来的依赖。

    1.3 依赖调节原则——路径近者优先原则

    直接依赖大于依赖传递

    1.4 排除依赖

    可以使用exclusions标签将传递过来的依赖排除出去

    在这里插入图片描述

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

    版本锁定的使用方式:

    第一步:在dependencyManagement标签中锁定依赖的版本

    第二步:在dependencies标签中声明需要导入的maven坐标

    ①在dependencyManagement标签中锁定依赖的版本

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ehtO2DNM-1616806045218)(maven依赖传递及聚合工程.assets/屏幕截图 2021-03-26 090723-1616721483205.jpg)]

    ②在dependencies标签中声明需要导入的maven坐标

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Oxglz0QL-1616806045219)(maven依赖传递及聚合工程.assets/屏幕截图 2021-03-26 090723-1616721505921.jpg)]

    PS:

    dependencyManagement标签只有锁定jar包版本的功能,没有导入jar包的功能

    1.6 properties标签的使用

    <properties>
        <spring.version>5.1.5.RELEASE</spring.version>
        <springmvc.version>5.1.5.RELEASE</springmvc.version>
        <mybatis.version>3.5.1</mybatis.version>
    </properties>
    

    该标签将版本进行抽取,在下面用到版本锁定时,可以通过${}的方式提取版本

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

    2 maven聚合工程(分模块)

    2.1 分模块构建maven工程分析

    在企业项目开发中,由于项目规模大,业务复杂,参与的人员比较多,一般会通过合理的模块拆分将一 个大型的项目拆分为N多个小模块,分别进行开发。而且拆分出的模块可以非常容易的被其他模块复用

    常见的拆分方式有两种:

    第一种:按照业务模块进行拆分,每个模块拆分成一个maven工程,例如将一个项目分为用户模块,订 单模块,购物车模块等,每个模块对应就是一个maven工程

    第二种:按照进行拆分,例如持久层、业务层、表现层等,每个层对应就是一个maven工程

    不管上面哪种拆分方式,通常都会提供一个父工程,将一些公共的代码和配置提取到父工程中进行统一 管理和配置。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Cgxl4hsd-1616806045220)(maven依赖传递及聚合工程.assets/屏幕截图 2021-03-26 093856.jpg)]

    2.2 maven工程的继承

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

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qV8QVsWY-1616806045221)(maven依赖传递及聚合工程.assets/屏幕截图 2021-03-26 093856-1616722905213.jpg)]

    2.3 maven工程的聚合

    在maven工程的pom.xml文件中可以使用标签将其他maven工程聚合到一起,聚合的目的是为了进行 统一操作。

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

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VDGEUbrT-1616806045221)(maven依赖传递及聚合工程.assets/屏幕截图 2021-03-26 093856-1616724167548.jpg)]

    。这时就可以使用标签将这些工程统一聚合到maven父工程中,需要打包的时候,只需要在此 工程中执行一次打包命令,其下被聚合的工程就都会被打包了。

    [外链图片转存中...(img-VDGEUbrT-1616806045221)]

    展开全文
  • maven 是一个项目管理工具,主要作用是在项目开发阶段对Java项目进行依赖管理和项目构建。 依赖管理:就是对jar包的管理。通过导入maven坐标,就相当于将仓库中的jar包导入了当前项目中。 项目构建:通过maven的一...

    目录

    Maven

    1.Maven基础(已学习)

    2.Maven高级

    2.1 maven基础知识回顾

    2.1.1 maven介绍

    2.1.2 maven的仓库类型

    2.1.3 maven常用命令

    2.1.4 maven坐标书写规范

    2.2 maven的依赖传递

    2.2.1 什么是依赖传递

    2.2.2 如何解决依赖冲突

    2.2.3 依赖调节原则——第一声明者优先原则(了解)

    2.2.4 依赖调节原则——路径近者优先原则

    2.2.5 排除依赖

    2.2.6 版本锁定

    2.2.7 properties标签的使用

    2.3 maven聚合工程(分模块)

    2.3.1 分模块构建maven工程分析

    2.3.2 maven工程的继承

    2.3.3 maven工程的聚合

    2.3.3 maven聚合工程_搭建拉勾教育后台管理系统


     

    Maven

    1.Maven基础(已学习)

    2.Maven高级

    2.1 maven基础知识回顾

    2.1.1 maven介绍

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

    依赖管理:就是对jar包的管理。通过导入maven坐标,就相当于将仓库中的jar包导入了当前项目中。

    项目构建:通过maven的一个命令就可以完成项目从清理、编译、测试、报告、打包,部署整个过程。

     

    2.1.2 maven的仓库类型

    1.本地仓库

    2.远程仓库
    ①maven中央仓库(地址:http://repo2.maven.org/maven2/
    ②maven私服(公司局域网内的仓库,需要自己搭建)
    ③其他公共远程仓库(例如apache提供的远程仓库,地址:http://repo.maven.apache.org/maven2/

    本地仓库---》maven私服---》maven中央仓库

     

    2.1.3 maven常用命令

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

     

    2.1.4 maven坐标书写规范

     

    2.2 maven的依赖传递

    2.2.1 什么是依赖传递

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

    通过上面的图可以看到,我们的web项目直接依赖了spring-webmvc,而spring-webmvc依赖了sping-aop、spring-beans等。最终的结果就是在我们的web项目中间接依赖了spring-aop、spring-beans等。

    依赖冲突

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

    2.2.2 如何解决依赖冲突

    1.使用maven提供的依赖调解原则

        第一声明者优先原则
           路径近者优先原则

    2.排除依赖

    3.锁定版本

     

    2.2.3 依赖调节原则——第一声明者优先原则(了解)

    在 pom 文件中定义依赖,以先声明的依赖为准。其实就是根据坐标导入的顺序来确定最终使用哪个传递过来的依赖。


    结论:通过上图可以看到,spring-aop和spring-webmvc都传递过来了spring-beans,但是因为spring-aop在前面,所以最终使用的spring-beans是由spring-aop传递过来的,而spring-webmvc传递过来的spring-beans则被忽略了。

     

    2.2.4 依赖调节原则——路径近者优先原则

    总结:直接依赖大于依赖传递

     

    2.2.5 排除依赖

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

    2.2.6 版本锁定

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

    版本锁定的使用方式:

    第一步:在dependencyManagement标签中锁定依赖的版本

    第二步:在dependencies标签中声明需要导入的maven坐标

    ①在dependencyManagement标签中锁定依赖的版本

    ②在dependencies标签中声明需要导入的maven坐标

    2.2.7 properties标签的使用

    方便修改各种相关依赖的版本

    <?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.lagou</groupId>  
      <artifactId>maven_advanced</artifactId>  
      <version>1.0-SNAPSHOT</version>  
      <packaging>war</packaging>
    
      <!--抽取版本号, 以后修改方便-->
      <properties> 
        <spring.version>5.1.7.RELEASE</spring.version> 
      </properties>
    
      <!--锁定jar包版本-->  
      <dependencyManagement> 
        <dependencies> 
          <dependency> 
            <groupId>org.springframework</groupId>  
            <artifactId>spring-beans</artifactId>  
            <version>${spring.version}</version> 
          </dependency>  
          <dependency> 
            <groupId>org.springframework</groupId>  
            <artifactId>spring-context</artifactId>  
            <version>${spring.version}</version> 
          </dependency> 
        </dependencies> 
      </dependencyManagement>  
      <dependencies> 
        <!--  &lt;!&ndash;spring mvc&ndash;&gt;
              <dependency>
                  <groupId>org.springframework</groupId>
                  <artifactId>spring-webmvc</artifactId>
                  <version>5.1.5.RELEASE</version>
                  <exclusions>
                      <exclusion>
                          <groupId>org.springframework</groupId>
                          <artifactId>spring-beans</artifactId>
                      </exclusion>
                  </exclusions>
    
              </dependency>
    
              &lt;!&ndash;spring aop&ndash;&gt;
              <dependency>
                  <groupId>org.springframework</groupId>
                  <artifactId>spring-aop</artifactId>
                  <version>5.1.6.RELEASE</version>
              </dependency>-->
    
        <!--下面不用配置版本号, 因为上面已经锁定了-->
        <dependency> 
          <groupId>org.springframework</groupId>  
          <artifactId>spring-beans</artifactId> 
        </dependency> 
      </dependencies> 
    </project>
    

     

     

    2.3 maven聚合工程(分模块)

    概念:

    在现实生活中,汽车厂家进行汽车生产时,由于整个生产过程非常复杂和繁琐,工作量非常大,所以厂家都会将整个汽车的部件分开生产,最终再将生产好的部件进行组装,形成一台完整的汽车。

     

     

    2.3.1 分模块构建maven工程分析

    在企业项目开发中,由于项目规模大,业务复杂,参与的人员比较多,一般会通过合理的模块拆分将一个大型的项目拆分为N多个小模块,分别进行开发。而且拆分出的模块可以非常容易的被其他模块复用

    常见的拆分方式有两种:
    第一种:按照业务模块进行拆分,每个模块拆分成一个maven工程,例如将一个项目分为用户模块,订
    单模块,购物车模块等,每个模块对应就是一个maven工程
    第二种:按照层进行拆分,例如持久层、业务层、表现层等,每个层对应就是一个maven工程

    不管上面那种拆分方式,通常都会提供一个父工程,将一些公共的代码和配置提取到父工程中进行统一管理和配置。

     

    2.3.2 maven工程的继承

    在Java语言中,类之间是可以继承的,通过继承,子类就可以引用父类中非private的属性和方法。同样,在maven工程之间也可以继承,子工程继承父工程后,就可以使用在父工程中引入的依赖。继承的目的是为了消除重复代码。

    父工程一般不编写代码, 只用来进行资源 统一管理 

     

    2.3.3 maven工程的聚合

    在maven工程的pom.xml文件中可以使用标签将其他maven工程聚合到一起,聚合的目的是为了进行统一操作。

    例如拆分后的maven工程有多个,如果要进行打包,就需要针对每个工程分别执行打包命令,操作起来非常繁琐。

    这时就可以使用 <modules> 标签将这些工程统一聚合到maven父工程中,需要打包的时候,只需要在此工程中执行一次打包命令,其下被聚合的工程就都会被打包了。

     

    2.3.3 maven聚合工程_搭建拉勾教育后台管理系统

    工程整体结构如下:

    1)lagou_edu_home_parent为父工程,其余工程为子工程,都继承父工程lagou_edu_home_parent

    2)lagou_edu_home_parent工程将其子工程都进行了聚合

    3)子工程之间存在依赖关系:

    ssm_domain依赖ssm_utils

    ssm_dao依赖ssm_domain

    ssm_service依赖ssm_dao

    ssm_web依赖ssm_service

    父工程

    <?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.lagou</groupId>
        <artifactId>maven-parent</artifactId>
        <!--pom打包类型-->
        <packaging>pom</packaging>
        <version>1.0-SNAPSHOT</version>
    
        <!--聚合所有工程-->
        <modules>
            <module>maven-domain</module>
            <module>maven_dao</module>
            <module>maven-service</module>
            <module>maven-web</module>
        </modules>
    </project>

    子工程

    ①domain层

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

    ②dao层

    <?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>maven-parent</artifactId>
            <groupId>com.lagou</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>maven_dao</artifactId>
    
        <!--引入domain层的依赖-->
        <dependencies>
            <dependency>
                <groupId>com.lagou</groupId>
                <artifactId>maven-domain</artifactId>
                <version>1.0-SNAPSHOT</version>
            </dependency>
        </dependencies>
    </project>

    ③service层

    <?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>maven-parent</artifactId>
            <groupId>com.lagou</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>maven-service</artifactId>
    
        <!--引入dao层的依赖-->
        <dependencies>
            <dependency>
                <groupId>com.lagou</groupId>
                <artifactId>maven_dao</artifactId>
                <version>1.0-SNAPSHOT</version>
            </dependency>
        </dependencies>
    </project>

    ④web层

    <?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>maven-parent</artifactId>  
        <groupId>com.lagou</groupId>  
        <version>1.0-SNAPSHOT</version> 
      </parent>  
      <modelVersion>4.0.0</modelVersion>  
      <artifactId>maven-web</artifactId>
      <packaging>war</packaging>
    
      <!--引入service层的依赖-->
      <dependencies>
        <dependency>
          <groupId>com.lagou</groupId>
          <artifactId>maven-service</artifactId>
          <version>1.0-SNAPSHOT</version>
        </dependency>
      </dependencies>
    </project>
    

    展开全文
  • 解决依赖冲突,使用版本锁定 1、在 dependencyManagement标签中锁定依赖版本(但不会真正的导入坐标) 2、在 dependencies 标签中声明需要导入的maven坐标 pom.xml <?xml version="1.0" encoding="UTF-8"?&...

    一、概述

               

    二、Maven软件安装

    1、下载Maven管理工具

          下载地址:https://maven.apache.org/download.cgi

          

     2、安装

          将压缩包,解压到一个路径下。(路径中不能有中文或空格)

          文件夹结构:

          

    3、配置 环境变量

        (1)、MAVEN_HOME

               

         (2)、Path

                

       注意:maven 运行,需要安装有 JAVA_HOME 环境变量

    4、测试

              

    三、仓库分类及设置本地仓库地址

          仓库分3类: 本地仓库、远程仓库(私服)、maven中央仓库

    1、 配置本地仓库

          打开maven配置文件(conf/settings.xml),在<settings>标签中添加 <localRepository>D:\apache-maven-repository</localRepository>

          D:\apache-maven-repository是本地仓库地址

    2、maven中央仓库 https://mvnrepository.com/

          (1)、搜索: servlet 

                

           (2)、点击 某版本进入

                

     

                 

    四、maven项目的标准目录结构

           

          

    五、maven在cmd常用命令

          mvn clean       清除生成代码(删除target目录)
          mvn compile   将src/main下的java代码进行编译,放置在target目录下
          mvn test          将src/main和src/test下的java代码进行编译,放置在target目录下
          mvn package   将src/main和src/test下的java代码进行编译,并打包,放置在target目录下

                                    打什么包是根据 pom.xml中的<packaging>war</packaging>决定的
          mvn install       将src/main和src/test下的java代码进行编译,并打包,放置在target目录下。并将项目打包到本地仓库

          mvn tomcat:run    使用maven内置的tomcat运行项目

    六、IDEA集成maven插件

                

               -DarchetypeCatalog=internal

              

    七、maven工程

        1、使用骨架创建java项目

               

         2、 使用骨架创建web项目

              

                  如何把一个包变成资源包?

                   

     3、实例:Maven工程

           (1)、导架包

    <?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.lt</groupId>
      <artifactId>maven_web</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>war</packaging>
    
      <name>maven_web</name>
    
    
      <!--建议 jdk版本-->
      <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
      </properties>
    
      <dependencies>
        <!--servlet-->
        <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>servlet-api</artifactId>
          <version>2.5</version>
        </dependency>
        <!--jsp-->
        <dependency>
          <groupId>javax.servlet.jsp</groupId>
          <artifactId>jsp-api</artifactId>
          <version>2.0</version>
        </dependency>
        <!--注解-->
        <dependency>
          <groupId>org.apache.tomcat</groupId>
          <artifactId>tomcat-servlet-api</artifactId>
          <version>7.0.62</version>
        </dependency>
    
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.11</version>
          <scope>test</scope>
        </dependency>
      </dependencies>
    
      <build>
        <plugins>
          <!--代码生成 jdk11-->
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
              <target>11</target>
              <source>11</source>
            </configuration>
          </plugin>
        </plugins>
      </build>
    
    </project>
    

          (2)、代码

    package com.lt.servlet;
    
    
    
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    
    @WebServlet("/demo")
    public class ServletDemo extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            System.out.println("1111");
        }
    }
    

          (3)、tomcat

              

           (4)、打包 发布

                tomcat 部署方式: https://blog.csdn.net/litao2/article/details/112690521

    八、架包作用域

      <scope></scope>

         

          

    九、版本锁定

           解决依赖冲突,使用版本锁定

    1、在 dependencyManagement标签中锁定依赖版本(但不会真正的导入坐标
    2、在 dependencies 标签中声明需要导入的maven坐标

      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.lt</groupId>
        <artifactId>maven_demo</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <!--锁定jar包的版本-->
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-context</artifactId>
                    <version>5.0.5.RELEASE</version>
                </dependency>
                <dependency>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-beans</artifactId>
                    <version>5.0.5.RELEASE</version>
                </dependency>
            </dependencies>
        </dependencyManagement>
        <!--导入坐标,不需要添加版本-->
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
            </dependency>
        </dependencies>
    
    </project>

    十、Maven继承

           子工程继承父工程后,可以使用父工程依赖(使用父工程的导入的坐标)

    1、指定父工程,使用 <packaging>pom</packaging>

    <project>
        <groupId>com.lt</groupId>
        <artifactId>lt_spring_cloud</artifactId>
        <version>1.0-SNAPSHOT</version>
        <!--父工程的打包方式必须为pom-->
        <packaging>pom</packaging>
    </project>

    2、指定子工程:使用<parent></parent>

           

    <project>
        <!--通过parent标签进行maven工程继承-->
        <parent>
            <artifactId>lt_spring_cloud</artifactId>
            <groupId>com.lt</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
    </project>

    十一、聚合

    聚合:统一进行操作(如:clean、package)

        <!--聚合:统一进行操作(如:clean、package)-->
        <!--聚合其他maven工程(打包时,只需要在此工程中执行一次打包命令,其下被聚合的工程都会被打包)-->
        <modules>
            <module>userservice</module>
            <!--如果不在父工程下,通过../ 聚合-->
            <!--<module>../lt_mybatis_dao</module>-->
            <module>consumer_demo</module>
        </modules>

    十二、依赖传递

        <!--依赖传递(service依赖dao,dao层的jar包都会传递到service层)-->
        <dependencies>
            <dependency>
                <groupId>com.lt</groupId>
                <artifactId>maven_dao</artifactId>
                <version>1.0-SNAPSHOT</version>
            </dependency>
        </dependencies>

    十三、Maven的pom.xml中resources标签的用法

    1、maven-resources-plugin:将 主程序和测试程序所需的源文件,复制到classes目录

       实例: 将.yml文件中的${post} 替换成 properties标签中变量,并拷贝到classes类路径下

         * 如果配置文件中不需要${}替换,不用进行下面的设置,也会放到classes目录下

            

    (1)父工程pom.xml

          <plugins>
               <!--maven-resources-plugin将 主程序与 测试程序所需的源文件复制到输出编译文件夹中-->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-resources-plugin</artifactId>
                    <configuration>
                        <encoding>utf-8</encoding>
                        <useDefaultDelimiters>true</useDefaultDelimiters>
                        <!--
                        <useDefaultDelimiters>true</useDefaultDelimiters>
                        spring-boot为了保护application.yml和application.properties,修改了默认的占位符${...}为@...@,
                        受影响的应该是spring boot 1.3.0以上的版本,
                        加上那句表示使用默认的占位符
                        -->
                    </configuration>
                </plugin>
           <plugins>

      (2)子工程pom.xml

        <!--在properties标签中添加变量port-->
        <properties>
            <port>10086</port>
        </properties>
        <!--在build标签中添加resources标签-->
        <build>
            <resources>
               <!-- 把src/main/resources下的所有.yml文件拷贝到classes类路径下-->
                <resource>
                    <directory>src/main/resources</directory>
                    <filtering>true</filtering><!--进行预编译 替换${}-->
                    <includes>
                        <include>**/*.yml</include>
                    </includes>
                </resource>
                <resource>
                    <directory>src/main/resources</directory>
                    <excludes>
                        <exclude>**/*.yml</exclude>
                    </excludes>
                </resource>
            </resources>
        </build>

    (3)、yml文件

          

     2、maven-compiler-plugin 指定项目源码的jdk版本,编译后的jdk版本,以及编码

               <plugin>
                    <!--maven-compiler-plugin 指定项目源码的jdk版本,编译后的jdk版本,以及编码-->
                    <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>

    3、spring-boot-maven-plugin 

          能够将Springboot应用打包为可执行的jar或war文件,进行相应部署后即可启动Springboot应用

             https://blog.csdn.net/pengjunlee/article/details/90639129

     

    推荐阅读:  

             pom.xml中resources标签的用法 https://blog.csdn.net/wenonepiece/article/details/112721380

             maven-resources-plugin 插件,用表达式替换 resources 文件中的内容 https://www.jianshu.com/p/c485df497db7

             maven-compiler-plugin 插件详解 https://blog.csdn.net/liupeifeng3514/article/details/80236077

     

    展开全文
  • 继承:用在父级工程或聚合工程中,子项目是可以继承父项目中的依赖。用来做jar包的版本控制。 依赖传递:在Maven中,依赖是可以传递的,就是说假设存在三个项目,分别是项目A,项目B以及项目C,假设C依赖于B,B依赖...
  • 2,继承:子工程依赖父工程,我感觉主要是用来进行依赖版本控制操作,父工程可以定义版本,子工程不用自己定义版本,还有依赖的传递,父工程有的依赖,子工程也有。注意依赖的〈scope〉属性,有的属性下,依赖不传递...
  • Maven的继承+聚合工程

    2019-11-14 10:32:22
    由于非compile范围的依赖信息是不能在“依赖链”中传递的,所以有需要的工程只能单独配置。例如: A项目 <dependency> <groupId>junit</groupId> <artifactId>...
  • 一、maven的依赖 1.依赖传递性 ...注意:非compile范围的依赖不能传递,所以在各个工程模块中,如果有需要就得重复声明依赖 2.依赖的排除 <dependency> <groupId>junit</groupId> ...
  • 从开始搭建ssm父子模块整合,本案为基于maven下创建的父子模块,利用maven的依赖传递特性,子模块拥有父模块的所有依赖,子模块与子模块间可以进行依赖,以此完成把传统的垂直式持久层,业务层,视图层等拆分,完成...
  • Maven中各个工程之间的继承和聚合

    千次阅读 2017-09-02 16:38:54
    我们知道Maven工程之间可以完成依赖传递性,实际上就是各个jar包和war包之间存在依赖传递性,但是必须是compile范围的依赖才具有传递性,才可以根据传递性统一的管理一个依赖的版本。而对于test范围的依赖,只是...
  • maven工程解决jar包冲突解决 ...直接依赖路径比传递依赖路径近,最终项目中进入的jar包会是路径近的直接依赖包 直接依赖:项目中直接导入的jar包,就是项目的直接依赖传递依赖:项目中没有直接导入的ja...
  • 文章目录一、Maven基础回顾1.1 Maven的好处1.2 三种仓库1.3 常见的命令1.4 坐标的书写规范1.5 添加坐标的方式1.6 依赖范围二、SSM框架基础案例实现2.1 准备数据库2.2 创建Maven工程(webapp)2.2.1 知识储备(直接...
  • 1 传递依赖下来的包是否能用 2 父子工程填充代码 2.1 DAO 代码添加 DAO 配置文件 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:...
  • Maven依赖解析

    2017-11-17 22:01:00
    依赖传递性解析实例 1. Maven依赖基本结构 上篇文章记录了Maven依赖的聚合与继承,POM中依赖的声明通过dependency进行定义,并且通过groupId、artifactId及version三项定位Maven库中的唯一依赖。除了这三项外,...
  • 1.多模块聚合 多模块聚合的项目也被称为聚合项目,一般情况下由一个父模块和若干个子模块组成。...项目里没有java代码,也不执行任何代码,只是为了聚合工程传递依赖用的 <packaging>p...
  • Maven继承和聚合

    2020-04-01 14:47:26
    由于test范围的依赖不能传递,所以必然会分散在各个模块中,本版可能会不一致 2.需求:统一各个模块工程对junit的依赖的版本。 3.解决思路:将junit依赖统一提取到父工程中,在子工程中声明junit依赖时不指定的版本...
  • 在当下的开发中,结构变得很清晰,我们设计的工程会有明显的模块区分,如通用模块啊,一些系统服务模块啊,还有一些扩展功能模块啊,聚合工程的优势就是在于扩展性高,加功能新建model然后通过pom依赖实现依赖传递,...
  • Maven的继承和聚合

    2020-07-31 19:31:55
    在Maven中,非compile范围的依赖不能在依赖传递,所以需要每个工程单独配置非compile范围的依赖,就比如我们junit依赖。如果现在各个工程的junit版本都需要是4.9,那么这个时候各个工程手动去修改无疑是不可取的,...
  • 文章目录一、聚合项目架构二、依赖传递图解2.1. 常见场景2.2. 企业场景三、结构设计原则3.1. 模块层次清晰3.2. 模块之间耦合度低3.3. 功能互不影响3.4. 定位问题效率高3.5. 灵活易扩展四、架构设计优点4.1. 规范统一...
  • Maven 11.继承和聚合

    2020-02-20 20:54:02
    Maven依赖传递是有局限性的,A---->B------>C,A要用到 jar包 C,是需要B依赖jar 包 C 的范围是complie。这个传递的有限性很消耗精力,但是Maven继承是可以解决这个问题的。A----->B,A可以使用B的所有依赖...
  • Maven-继承、聚合

    热门讨论 2018-02-10 15:36:42
    由于test范围的依赖不能传递,所以必然会分散在各个模块工程中,很容易造成版本不一致。   ②需求:统一管理各个模块工程中对Junit依赖的版本 ③解决思路:将Junit依赖管理提取到“父”工程中,在子工程中声
  • 八、继承和聚合

    2018-07-11 00:28:00
     有三个 Maven 工程,每个工程依赖某个 jar 包,比如 Junit,由于 test 范围的依赖不能传递,它必然会分散在每个工程中,而且每个工程的jar 包版本可能不一致。那么如何管理各个工程中对于某个 jar 包的版本呢? ...
  • 因为test范围的依赖不能传递,所以必然会分散在各个模块工程中,很容易造成版本不一致。 比如,我们每个工程都用了Junit组件,这个组件的依赖范围就是test。 所以我们需要统一管理各个模块工程中对junit依赖的版本。 ...
  • Maven的继承与聚合

    2020-12-06 11:36:40
    由于非 compile 范围的依赖信息是不能在“依赖链”中传递的,所以有需要的工程只能单独配置,很容易造成版本不一致。 比如项目A 依赖Junit4.1版本,项目B依赖Junit4.3版本,现在需要统一为4.9版本,手动到各个项目...
  •  有三个 Maven 工程,每个工程依赖某个 jar 包,比如 Junit,由于 test 范围的依赖不能传递,它必然会分散在每个工程中,而且每个工程的jar 包版本可能不一致。那么如何管理各个工程中对于某个 jar 包的版本呢? ...

空空如也

空空如也

1 2 3 4
收藏数 78
精华内容 31
关键字:

聚合工程依赖传递