Java 多个maven模块用于分离测试、api和实现

我想创建一个maven项目，在一个api模块中声明的多个接口的独立模块中使用多个实现（在上下文中，我正在编写一个java持久性实验室，在这里，学生必须多次实现服务和存储库，从简单的JDBC到JPA，再到spring数据JPA）

项目中有几个maven模块：

• 根maven

  多个模块

  模块，包括三个子模块
• 包含api接口的

  api

  模块

• api测试

  模块，包含与api接口相关的测试

• main

  模块，包含一个API实现

根项目模块 maven主项目声明了三个子模块：

<?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>org.kartoch.stack</groupId>
    <artifactId>multiple-modules</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>api</module>
        <module>main</module>
        <module>tests</module>
    </modules>

</project>

api子模块的相关

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">
    <parent>
        <artifactId>multiple-modules</artifactId>
        <groupId>org.kartoch.stack</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <packaging>jar</packaging>
    <artifactId>api</artifactId>


</project>

<?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>multiple-modules</artifactId>
        <groupId>org.kartoch.stack</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <packaging>jar</packaging>

    <artifactId>main</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.kartoch.stack</groupId>
            <artifactId>api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.kartoch.stack</groupId>
            <artifactId>api-tests</artifactId>
            <version>1.0-SNAPSHOT</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

由于API接口的实现依赖于子模块，因此测试包中有一个抽象类，需要在每个实现模块中实现：

public abstract class Template {

    public MustReturnTrue mustReturnTrue;
}

对于这两个类，代码都位于

src/main/java

目录中，而不是我使用的

src/test/java

目录中：

tests子模块的相关

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">
    <parent>
        <artifactId>multiple-modules</artifactId>
        <groupId>org.kartoch.stack</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <packaging>jar</packaging>
    <artifactId>api-tests</artifactId>


    <dependencies>
        <dependency>
            <groupId>org.kartoch.stack</groupId>
            <artifactId>api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

</project>

主子模块的相关

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">
    <parent>
        <artifactId>multiple-modules</artifactId>
        <groupId>org.kartoch.stack</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <packaging>jar</packaging>
    <artifactId>api</artifactId>


</project>

<?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>multiple-modules</artifactId>
        <groupId>org.kartoch.stack</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <packaging>jar</packaging>

    <artifactId>main</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.kartoch.stack</groupId>
            <artifactId>api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.kartoch.stack</groupId>
            <artifactId>api-tests</artifactId>
            <version>1.0-SNAPSHOT</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

有什么想法吗

编辑1

---

我的印象是，问题在于她的工作没有按预期进行。由于

TemplateInitialization

是一个不包含任何测试的heriting模板，因此没有执行任何测试：

MustReturnTrueTest

中的测试不会“神奇地”导入。在测试之前，我需要一种在运行时加载TemplateInitialization的方法。

在maven中，标准测试是在测试的项目中编写的，请注意一些符号：

目标
目标/类别
${artifactId}-${version}
目标/测试类
src/main/java
src/main/scripts
src/test/java
src/main/resources
src/测试/资源

---

因此，如果您不想覆盖默认pom配置，您必须在测试模块中的src/test/java中实现test

您的模板初始化应该直接在测试类中完成：

import org.junit.Test;

import static org.junit.Assert.assertTrue;

public class MustReturnTrueTest extends Template {

    @Before
    public void before() {
        mustReturnTrue = new MustReturnTrueImpl();
    }

    @Test
    public void testAskMeTrue() {
        assertTrue(mustReturnTrue.askMeTrue());
    }
}

如果在每次测试之前需要实例化，请使用JUnit

@before

注释

如果需要在测试类中的所有测试之前执行一次实例化，请使用

@BeforeClass

---

编辑：

---

我建议您按照Maven标准将测试放在实现代码中（在主项目中）。

我在github中添加了完整的项目：为什么您将测试放在单独的模块中？这是一个api测试，将它们放入api模块。测试的名称应该像

WhatEverTest.java

（参见maven surefire插件的文档…）。而不是

TemplateInitialization

…所以只需将其命名为

TemplateInitializationTest.java

。@AleksandrM yes，那是个好主意idea@khmarbaise这个类不是测试，只是初始化模板。即使重命名它也不起作用，我使用这种方式创建我的测试，并将它们包含在主模块中：

-------------------------------------------------------
 T E S T S
-------------------------------------------------------

Results :

Tests run: 0, Failures: 0, Errors: 0, Skipped: 0

 <build>
    <directory>target</directory>
    <outputDirectory>target/classes</outputDirectory>
    <finalName>${artifactId}-${version}</finalName>
    <testOutputDirectory>target/test-classes</testOutputDirectory>
    <sourceDirectory>src/main/java</sourceDirectory>
    <scriptSourceDirectory>src/main/scripts</scriptSourceDirectory>
    <testSourceDirectory>src/test/java</testSourceDirectory>
    <resources>
      <resource>
        <directory>src/main/resources</directory>
      </resource>
    </resources>
    <testResources>
      <testResource>
        <directory>src/test/resources</directory>
      </testResource>
    </testResources>
  </build>

import org.junit.Test;

import static org.junit.Assert.assertTrue;

public class MustReturnTrueTest extends Template {

    @Before
    public void before() {
        mustReturnTrue = new MustReturnTrueImpl();
    }

    @Test
    public void testAskMeTrue() {
        assertTrue(mustReturnTrue.askMeTrue());
    }
}