IDEA的多模块使用

Module

概念

在 Eclipse 中我们有 Workspace（工作空间）和 Project（工程）的概念，
在 IDEA中只有 Project（工程）和 Module（模块）的概念。这里的对应关系为：
IDEA 官网说明：
- An Eclipse workspace is similar to a project in IntelliJ IDEA
- An Eclipse project maps to a module in IntelliJ IDEA
  翻译：
- Eclipse 中 workspace 相当于 IDEA 中的 Project
- Eclipse 中 Project 相当于 IDEA 中的 Module

与eclipse的区别：

从 Eclipse 转过来的人总是下意识地要在同一个窗口管理 n 个项目，这在IntelliJ IDEA 是无法做到的。IntelliJ IDEA 提供的解决方案是打开多个项目实例，即打开多个项目窗口。即：一个 Project 打开一个 Window 窗口

IDEA项目层次结构

在 IntelliJ IDEA 中 Project 是最顶级的级别，次级别是 Module。一个 Project 可以有多个 Module。目前主流的大型项目都是分布式部署的，结构都是类似这种多 Module 结构。

注意：相比较于多 Module 项目，小项目就无需搞得这么复杂。只有一个 Module 的结构 IntelliJ IDEA 也是支持的，并且 IntelliJ IDEA 创建项目的时候，默认就是单Module 的结构的。

maven多模块优点

复用，划分出来的模块可以供其他项目使用。
固化，划分出来的某个模块可让专人开发，沉淀技术，分工协作。
优化依赖，每个模块有各自的pom。
节省时间，可在单个模块上进行build。

创建Module项目

右击project
选择自己需要的进行构建

注意：之后，我们可以在，我们可以在，我们可以在 ModuleModule 的 src里写代码，此时里写代码，此时里写代码，此时 Project工程下的 src 就没什么就没什么用了，可以删掉。

删除Module项目

选中Module项目，右键删除

模块间依赖

如下创建了父工程下有三个模块工程

项目结构配置依赖

打开项目结构
添加模块依赖
指定要依赖的模块
依赖成功
指定输出
最终项目结构
结果

)

通过座标直接依赖

通过座标直接依赖jar

hr-ui模块的pom文件

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.11</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>com.zhangguo.hr</groupId>
        <artifactId>hr-core</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
</dependencies>

结果，在lib下看到引入的hr-core jar包

依赖继承

指定父模块与默认继承

dependencies即使在子项目中不写该依赖项，那么子项目仍然会从父项目中继承该依赖项（全部继承）
- Dao，Service中指定了父模块就会获取到root的junit依赖

父模块的pom

<?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.zhangguo.maven03</groupId>
  <artifactId>Maven03</artifactId>
  <packaging>pom</packaging>
  <version>1.0-SNAPSHOT</version>
  <modules>
    <module>Maven03-Dao</module>
    <module>Maven03-Service</module>
  </modules>


  <properties>
    <junit.version>4.12</junit.version>
    <spring.version>RELEASE</spring.version>
  </properties>

  <dependencies>
    <!-- junit -->
    <!-- https://mvnrepository.com/artifact/junit/junit -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

</project>

子模块的pom

<?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>Maven03</artifactId>
    <groupId>com.zhangguo.maven03</groupId>
    <version>1.0-SNAPSHOT</version>
  </parent>

  <modelVersion>4.0.0</modelVersion>
  <artifactId>Maven03-Dao</artifactId>

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>${spring.version}</version>
      <!--版本是从父模块依赖过来的properties-->
    </dependency>
  </dependencies>
</project>

依赖管理

dependencyManagement里只是声明依赖，并不实现引入，因此子项目需要显式的声明需要用的依赖。
如果不在子项目中声明依赖，是不会从父项目中继承下来的；
只有在子项目中写了该依赖项，并且没有指定具体版本，才会从父项目中继承该项，并且version和scope都读取自父pom;
另外如果子项目中指定了版本号，那么会使用子项目中指定的jar版本。

dependencyManagement示例

当我把父项目中的依赖放到依赖管理中的效果如下所示：

<?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.zhangguo.maven03</groupId>
  <artifactId>Maven03</artifactId>
  <packaging>pom</packaging>
  <version>1.0-SNAPSHOT</version>
  <modules>
    <module>Maven03-Dao</module>
    <module>Maven03-Service</module>
  </modules>


  <properties>
    <junit.version>4.12</junit.version>
    <spring.version>RELEASE</spring.version>
  </properties>

  <!--dependencyManagement里只是声明依赖，并不实现引入，
    因此子项目需要显式的声明需要用的依赖。
    如果不在子项目中声明依赖，是不会从父项目中继承来的；
    只有在子项目中写了该依赖项，并且没有指定具体版本，才会从父项目中继承该项，
    并且version和scope都读取自父pom;
    另外如果子项目中指定了版本号，那么会使用子项目中指定的jar版本。-->

  <dependencyManagement>
    <dependencies>
      <!-- junit -->
      <!-- https://mvnrepository.com/artifact/junit/junit -->
      <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>${junit.version}</version>
        <scope>test</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>

</project>

这里的父模块与子模块都并没有依赖junit了，这时的依赖只是用于管理，并没有真正依赖。如果子模块不声明依赖的使用，即使该依赖已经在父POM的dependencyManangement中声明了，也不会产生任何实际的效果。

父模块作版本管理

我们要达到的目的是：父模块作版本管理不实际依赖，子模块按需依赖。

父pom

<!--版本管理-->
<properties>
    <junit.version>4.12</junit.version>
    <spring.version>RELEASE</spring.version>
</properties>

<!--依赖声明-->
<dependencyManagement>
    <dependencies>
        <!-- junit -->
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

子模块pom：

<parent>
    <artifactId>Maven03</artifactId>
    <groupId>com.zhangguo.maven03</groupId>
    <version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>

<artifactId>Maven03-Service</artifactId>

<dependencies>
    <!--按需依赖，版本被父模块控制，可以自行声明，优先级更高-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
    </dependency>
</dependencies>