多模块Maven工程

最新推荐文章于 2024-03-20 20:52:45 发布
最新推荐文章于 2024-03-20 20:52:45 发布
阅读量218 收藏 1
点赞数
文章标签： java 测试 web.xml
原文链接：http://www.cnblogs.com/ppvir/p/11448612.html
版权

0.maven基础回顾

maven作为项目管理工具

  • 依赖管理
    • 对jar包的管理过程,传统工程项目中是直接防止jar包,maven真正的jar包在仓库中放置,项目中只防止jar包的坐标
    • 仓库三类: 本地仓库,远程私服仓库与中央仓库
    • 本地仓库:运行项目,必须保证本地仓库中有对应的jarbao
      如果本地仓库没有,会默认去中央仓库下载,在个公司中会先从远程仓库中下载,远程仓库中没有,会从中央仓库下载或者从本地上传
  • 一键构建
    • 就是使用maven集成的tomcat插件对项目进行编译,测试,打包,安装等
    • maven有三套生命周期,
      • 清理生命周期:clean.
      • default默认生命周期:complie(编译src-main),test(采用合适的测试框架,来测试编译好的源代码),package(将项目打包jar/war),install(安装,执行前三个命令之后,将项目打包安装到本地仓库),deploy:部署 将项目打包发布到远程仓库
      • site生命周期:构建站点文档

1.ssm整合

  1. 创建数据库表 items.sql
  2. 创建maven的web工程

  3. 导入pom.xml

    maven依赖传递_间接依赖

    直接依赖 a项目中导入了b包或坐标, a直接依赖于b
    传递依赖: a项目中导入了b包,b包直接依赖于c,最终a项目中也可以使用c,那么a和c就是传递依赖

解决jar包版本冲突的四个原则:
1_第一声明,优先原则
哪个jar包的坐标在靠上的位置,哪个就是第一声明的包,最后进入项目的就是哪个包的依赖
2_路径近者,优先原则
直接依赖路径并传递依赖路径近,哪个路径近,进入到项目中的就是哪个包
3_直接排除法
使用exclustion标签直接排除某个包下的依赖包

4_锁定jar包版本`

`

统一jar包管理包,统一定义jar包版本

pom.xml
    <properties>
        <spring.version>5.0.2.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>5.1.6</mysql.version>
        <mybatis.version>3.4.5</mybatis.version>
        <spring.security.version>5.0.1.RELEASE</spring.security.version>
    </properties>

锁定jar包版本

pom.xml
<!-- 锁定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>

项目运行的环境

pom.xml
<!-- 添加tomcat7插件 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
            </plugin>
        </plugins>
    </build>

项目依赖jar包

pom.xml
<!-- 项目依赖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>

ssm整合代码编写

1_创建itemsDao接口,定义方法

public interface ItemMapper{
    @select("")
    Items findById(Integer id);
}
2_创建POJO Items
字段名:id name price  pic createtime datail
3_创建applicationContext.xml
1)数据源 2)sqlSessionFactory 3)mapper映射扫描
<!--1.dao层配置-->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!--数据源dataSource-->
<bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource">
    <property name="driverClass" value="${jdbc.driver}"/>
    <property name="jdbcUrl" value="${jdbc.url}"/>
    <property name="user" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
</bean>

<!--2.mybatis操作,创建一个生产sqlSession对象的工厂对象-->
<!--1)引入数据源-->
<bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactory">
    <property name="dataSource" ref="dataSource"/>
<!--2)给POJO对象起别名-->
    <property name="typeAliasesPackage" value="cn.ppvir.domain"/>
</bean>
<!--3.扫描dao接口下的包,使用sqlSession对象给其创建代理对象,并放到容器中-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer" id="mapperScannerConfigurer">
    <property name="basePackage" value="cn.ppvir.dao"/>
</bean>
<!--/dao层配置-->
4_单元测试
@test
public void daoTest(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    ItemMapper itemMapper = applicationContext.getBean();
}
5_service层
  1. 创建ItemsService接口及实现类:注入ItemsMapper
  2. 实现类上添加@service
  3. 实现类上添加@transactional

  4. 编写applicationContext.xml service层部分

    1) Ioc注解扫描 2)平台事务管理器 3)事务注解

applicationContext.xml
<!--service层配置开始-->
<!--1.组件扫描-->
<context:component-scan base-package="cn.ppvir.service"></context:component-scan>
<!--2.配置事务管理器-->
<!--2.1事务平台管理器-->
<!--2.1.1注入连接池-->
 <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="transactionManager">
    <property name="dataSource" ref="dataSource"></property>

</bean>
<!--2.2.1开启事务注解-->
<!--2.2.2事务增强-->
<tx:annotation-driven transaction-manager="transactionManager"/>
<tx:advice id="txAdvice">
    <tx:attributes>
        <tx:method name="*"/>
    </tx:attributes>
</tx:advice>
<!--service层配置结束-->
6_service层单元测试
 /**
     * service层测试
     */
    @Autowired
    private ItemsService itemsService;
    @Test
    public void serviceTest(){
        Items items = itemsService.findById(2);
        System.out.println(items.getName());
    }
7_编写web层

1_创建ItemsController 添加@controller 添加@Requestmapping("/items")
2_方法上添加@requestMapping
3_注入service调用方法

4_创建SpringMVC.xml

1)ioc Controller 2)视图解析器 3)注解驱动 4)静态资源放行

springMVC.xml
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       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
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">

    <!--组件扫描 只扫描controller-->
    <context:component-scan base-package="cn.ppvir.controller"/>
    <!--配置mvc注解驱动，相当于配置处理器映射器，处理器适配器-->
    <mvc:annotation-driven />
    <!--内部资源视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="viewResolver">
        <property name="prefix" value="/WEB-INF/pages/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
    <!--开放静态资源访问权限-->
    <mvc:default-servlet-handler/>
</beans>

5_配置web.xml

1)spring监听器 2)springMVC前端控制器 3)乱码解析器

web.xml
<!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app 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">
    <display-name>Archetype Created Web Application</display-name>
    <!--中文乱码过滤器-->
    <filter>
        <filter-name>encodingFilter</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>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <!--前端控制器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springMVC.xml</param-value>
        </init-param>
        <load-on-startup>2</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</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>
    <!--首页-->
    <welcome-file-list>
        <welcome-file>index.html</welcome-file>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
</web-app>

6_编写jsp页面

<%--欢迎页面--%>>
<html>
<head>
    <title>Title</title>
</head>
<body>
hello!
<jsp:forward page="items/show"/>
</body>
</html>

<%--跳转页面--%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8" isELIgnored="false" %>
<%@ 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>

2.maven的聚合和拆分思想

拆分: 把每一层的代码抽取成单独的模块,提高代码的复用性
聚合: 让每一层的子模块产生依赖关系

父工程 : 统一公共资源管理(jar坐标),以及把多个子模块合并成一个项,父工程所有的公共资源都可以直接被子模块使用
多子工程 : 继承父工程,依赖传递了父工程引入的jar包
子工程之间的关系 : 依赖与传递依赖的关系,一开始没有关系,如果要建立关系,我们可以引入其他子模块.

代码可重用:为了便于维护和升级,实现代码可重用与否,关键在于是复制jar包还是引用坐标
把一个项目拆分成多个模块,主要目的就是实现代码的可重用
拆分后的模块,不能完成一个完整的功能.
为了实现完成操作,我们必须再把这些模块聚合到一起变成一个完整的项目

说明:
如果每个项目中都放置一份独立的代码,升级维护时,有几个项目就得修改几次代码.
如果所有的项目都引用一份jar,那么升级维护时,只需要修改jar.

1_不是代码可重用:  
    写了一个工具类编号为tool1,  
    项目a需要tool1,把tool1复制到项目a中  
    项目b需要tool1,把tool1复制到项目b中    
    项目c需要tool1,把tool1复制到项目c中  
    
2_是代码可重用:  
    将tool1打成jar包,每个项目都引入改jar的坐标

任何一个项目分为前后台, 前台项目面向客户端,后台项目是开发维护人员使用的,
前后台所使用的数据表是一样的,前台订单是展示给客户的,后台拿到的订单数据是展示给公司内部客服.
由此可见,为了实现代码可重用,必须让dao层代码单独是一个模块,前后台项目都可以使用,

创建多模块的maven工程(重要)

  1. 创建父工程 pom包
  2. 创建子模块,子模块要继承父工程
  3. 让子模块产生依赖关系 domain被dao依赖，dao被service依赖，service被web依赖
  4. 粘贴ssm整合代码粘贴到多模块工程
  5. 测试(3种)

传递依赖包丢失
dao直接依赖于父工程,作用域是compile
父工程模块种直接依赖junit,作用域是test
那么我们就可以说dao传递依赖了junit,作用域是test
如果传递依赖到某个子模块中的包不能用,那么表现形式就是无法导入jar包,此时我们只需要在该模块中再次导入该jar包即可

转载于:https://www.cnblogs.com/ppvir/p/11448612.html

A12345655002
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot多模块项目开发（Maven多模块项目）
m0_64363449的博客
08-09 3245
在需要统一版本的位置,使用 ${自定义标签名} 引用声明的版本号。另外，自定义标签声明数据的配置并不是只能用于声明依赖的版本号,凡是需要统一声明后再引用的场合都可以使用,例如:统一配置项目构建的源码的字符集格式。xml复制代码。
Java maven 多模块工程
thanksm1的博客
01-14 754
Java maven 多模块工程 利用Maven可以方便的构建Java项目的多模块工程，例如，一个多模块工程包括：公共代码模块、web服务模块、独立java应用模块。 root: common_module web_module jar_module 1. 根项目(root) 根项目用来管理各个子模块，定义公共依赖的版本。这里将根项目继承自spring-boot-starter-parent...
Maven环境下构建多模块项目
L170311的博客
03-06 1956
maven创建父子项目，希望对您有用，不足请补充指正！ &&发奋识遍天下字，立志读尽人间书。----苏轼
Maven工程多模块开发步骤（IDEA）
Selma003的博客
07-28 1026
使用IDEA进行Maven工程多模块开发。
Maven多模块开发
个人学习笔记库，一篇一篇记录成长的足迹
03-02 1192
maven的多模块开发及其实现步骤
6.Maven分模块开发
相互学习 共同进步
04-26 1374
当dependency A自身的依赖B，与其他dependency存在冲突的时候（最常见的就是版本冲突），我们就需要把B排除掉，这时就需要使用exclusions元素。继承是maven中很强大的一种功能，继承可以使子pom获得parent中的各项配置，对子pom进行统一的配置和依赖管理。多模块项目中，父模块打包类型必须是pom，同时以给出所有的子模块，其中每个module，都是另外一个maven项目。父pom是为了抽取统一的配置信息和依赖版本控制，方便子pom直接引用，简化子pom的配置。
Maven项目多模块拆分
热门推荐
北海飞舞
10-12 1万+
使用Java技术开发的
IntelliJ IDEA 构建maven多模块工程项目(详细多图)
08-19
IntelliJ IDEA 构建 Maven 多模块工程项目详解 IntelliJ IDEA 是一款功能强大且广泛应用的集成开发环境（IDE），Maven 是一个基于项目对象模型（POM）的项目管理工具。构建 Maven 多模块工程项目是使用 IntelliJ ...
读书笔记：多模块maven工程实战.zip
最新发布
07-26
读书笔记：多模块maven工程实战
maven多工程搭建过程
11-26
三、创建多模块Maven工程 1. **新建父工程** - 打开Idea，选择“New Project”，然后在左侧列表中选择“Maven”。 - 勾选“Create from archetype”，并选择“maven-archetype-aggregator”模板，这将创建一个空的...
maven多模块项目（简单实例）
09-26
所有用Maven管理的真实的项目都应该是分模块的，每个模块都对应着一个pom.xml。它们之间通过继承和聚合（也称作多模块，multi-module）相互关联。 提供了一个简单的Maven多模块实例
maven多模块项目构建过程
06-10
NULL 博文链接：https://yansxjl.iteye.com/blog/2333900
SpringBoot使用Maven建立多模块工程
08-10
本文将深入探讨如何利用Maven来创建一个多模块的SpringBoot工程。 首先，我们从【标题】"SpringBoot使用Maven建立多模块工程"出发，了解其核心概念。Maven是一个项目管理和综合工具，它管理项目的构建、报告和文档...
maven多模块项目工程-已搭建好
04-26
总之，"maven多模块项目工程-已搭建好"是一个已经配置好的、使用Eclipse开发的项目结构，通过"xd-parent"模块实现了依赖和插件的集中管理，方便开发者进行模块化开发，提高了项目的可维护性和开发效率。在实际使用中...
如何使用Maven创建多模块项目
来都来了
12-20 2081
使⽤maven 提供的多模块构建的特性完成maven 环境下多个模块的项⽬的管理与构建。这⾥以四个模块为例来搭建项⽬,以达到通俗易懂的初衷模块 maven_parent —– 基模块,就是常说的parent （pom）模块 maven_dao —– 数据库的访问层，例如jdbc操作（jar）模 块 maven_service —– 项⽬的业务逻辑层 （jar）模块 maven_controller —– ⽤来接收请求，响应数据 （war）
【 Maven 】花式玩法之多模块项目
2301_79456272的博客
02-20 1360
Maven 通过使用插件和配置文件来定义项目的发布策略。项目的发布策略包括了构建、版本管理、部署和发布等方面的规则和流程。下面介绍一下Maven中常用的发布策略的定义方式：Maven多模块的发布使得项目的管理、构建和部署更加灵活、高效和可维护。它提供了一种组织和管理复杂应用程序的有效方式，同时也促进了代码的重用和模块的解耦，提高了开发团队的效率和项目的质量。提高了代码结构清晰度、可维护性，加快了部署速度，并促进了代码的复用。希望本文对您有所帮助。如果有任何错误或建议，请随时指正和提出。
Maven多模块项目构建
webxxs的博客
03-20 1057
POM（Project Object Model）：POM是Maven项目的基本工作单元，它是一个XML文件，描述了项目的元数据信息，如依赖项、构建插件、目标等。构建生命周期：Maven定义了一系列标准的构建阶段，如编译、测试、打包、部署等，开发者可以通过执行相应的Maven命令来触发这些构建阶段。多模块项目管理：对于复杂的项目结构，Maven支持多模块项目的管理，能够统一管理各个子模块的依赖和构建。项目构建：Maven可以自动化执行项目的构建过程，包括编译、测试、打包等，大大简化了项目构建的流程。
Java--Maven多模块管理
MinggeQingchun的博客
04-05 5570
超大侧率 maven父工程必须遵循两点要求: 1、packaging标签的文本内容必须设置为pom 2、将src目录删除掉 一、空工程Empty Project设置 1、创建一个空工程Empty Project （1）File----New----Project，选择Empty Project，点击Next （2）输入工程名，以及存放路径 Project name：项目名称 Project location：项目存放位置路径 2、创建Maven父工程 （1）File----
maven多模块工程打包部署
04-29
Maven是一个非常常用的构建工具，在使用它构建多模块工程时，可以减少一些重复的工作，提高工程构建的效率。多模块工程即将一个大型工程分成多个模块，每个模块有自己的代码、配置文件和构建规则，模块可以独立构建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值