我有一个简单的Java 9 SE项目,其中一个依赖于非模块化项目(在本例中选择了Weld SE),我正在尝试使用Maven(clean install)构建它.为了使Java 9能够启动,我已经添加了module-info.java.最初,此文件仅包含模块名称,并且没有requires公式.

请记住,我唯一的依赖是不是一个模块化的项目,因此,我认为Maven会放在类路径中(不模块路径),因此它会在结束unnamed module中描述的模块化系统的状态.

现在,我的Maven版本是3.3.9,我知道我需要在版本3.6中使用Maven编译器插件,如此处所述当然我已经使用jigsaw下载了JDK 9 EA bu​​ild并设置了Maven来使用它.

如果我没有构建我的项目module-info.java,一切正常,将东西添加到类路径并构建成功.我想只要你遗漏那个文件,Maven就会坚持旧的方式.

但是,建造它有 module-info.java告诉我,从我的依赖的类不能在类路径中找到.所以我在调试模式下运行Maven(使用-X),确实 - 所有jar都在module-path下,classpath为空.这实际上意味着我的所有依赖项都被转移到自动模块中,我需要声明它们module-info.java.

一旦我声明了自动模块要求(链接到项目的module-info),我就可以在JDK 9上构建它.但它有点混乱 - 我唯一的pom.xml依赖是weld-se-core,但我module-info要求我宣布更多的编译要求通过.

这是一个完整的GitHub项目,可以观察到所有这些.

所以我的问题是:

1. 如果我知道它们没有模块化,我可以告诉Maven在类路径上放置一些工件吗？这样我就可以避免automatic module并且需要声明它们？
2. 如果我坚持automatic module,我可以告诉Maven以某种方式过渡性地允许我的依赖需要引入的任何东西吗？例如Weld的其他部分,CDI API等.
3. 实际的原因是什么,为什么我需要声明,我的项目requires模块,我不直接使用？例如weld.environment.common

我已经阅读了一段时间关于Maven中的显式与传递(隐式)依赖声明.大多数人倾向于同意您应该始终明确声明项目所依赖的库,主要是为了避免版本不匹配.

这是完全合理的,但我们应该如何处理我们的内部依赖？我认为绝对没有理由保持模块之间的显式依赖关系,如果它们可以通过传递机制解决.

我的用例场景:

• 我的团队在major.minor.micro发布周期中开发软件,例如:1.1.1,1.1.2,1.3.0等......
• 在每个版本中,我们为项目中的所有模块增加版本控制方案(因此A:1.0,B:1.0变为A:1.1,B:1.1)
• 我们正在使用反应堆项目,嵌套到两层深

我的直觉告诉我 - 摆脱依赖意大利面条.谁会证明我错了？Reactor(依赖)图表非常受欢迎:-)

一个例子:

我的父项目使用以下模块(省略外部依赖项):

Project:1.1   
 - core:1.1
 - +-- util:1.1 
 -   +-- xml-helper:1.1
 - logic:1.1
 - +-- util:1.1 
 -   +-- xml-helper:1.1
 - gui:1.1

问题是:我应该xml-helper:1.1在core's和logicpom.xml中声明为依赖吗？当我使用util模块时,该依赖关系将自动解决(传递).

如果我宣布它,我会得到一个更大的pom来维持.

如果我跳过它,当依赖关系随着时间的推移而演变时,我可能会遇到麻烦.

我在pom.xml中定义数据时尝试遵循最佳实践,所以我开始研究Spring源代码,我看到:

<project xmlns="http://maven.apache.org/POM/4.0.0"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aop</artifactId>
  <packaging>jar</packaging>
  <version>3.1.1.RELEASE</version>
.....

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>${project.version}</version>
      <scope>compile</scope>
</dependency>

---

<dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <scope>test</scope>
</dependency>
-----

但是,spring-bean也依赖于log4j.

你能告诉我,对于最佳实践方法,你应该在多大程度上依赖传递依赖？

我问这个是因为我的第一个想法是不重新声明log4j依赖,因为spring-beans已经声明了它.

我正在使用AppCompatActivity和更多像碎片等的东西......这些是我的活动的一些导入:

import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentStatePagerAdapter;
import android.support.v4.view.GravityCompat;
import android.support.v4.view.ViewPager;
import android.support.v4.widget.DrawerLayout;
import android.support.v7.app.ActionBarDrawerToggle;
import android.support.v7.app.AppCompatActivity;

我从谷歌样本中复制了这些依赖项:

dependencies {
    compile 'com.google.android.gms:play-services-ads:9.4.0'
    compile 'com.android.support:support-v4:23.1.1'
    compile 'com.android.support:appcompat-v7:23.4.0'
    compile 'com.android.support:design:23.4.0'
}

现在我想删除它们,我注意到我可以删除它们:

compile 'com.android.support:support-v4:23.1.1'
compile 'com.android.support:appcompat-v7:23.4.0'

删除它们,我的项目完美运作......为什么？

我正在编译:

compileSdkVersion 23
buildToolsVersion "23.0.3"
minSdkVersion 14
targetSdkVersion 22

我有一个名为"A"的JAR项目,它有一些将由wildfly 10提供的库:

 <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.core.version}</version>
            <scope>provided</scope>
        </dependency>

我有另一个名为"B"的项目,它是一个WAR项目.第二个项目不应该再次插入hibernate依赖项,但如果我不这样做,我就不能使用@Entity和其他类.我应该再次提供项目"B"中的"重新导入"hibernate-core.有没有办法从项目"A"继承它？

假设我们正在研究抵押子模块，并且直接Google Guava在模块代码中使用这些类，但是的依赖关系guava是在同一父对象下的其他子模块中定义的，并且只能通过对“投资”模块：

banking-system (parent pom.xml)
|
|-- investment (pom.xml defines <dependency>guava</dependency>)
|
|-- mortgage (pom.xml defiens <dependency>investment</dependency>)

我们还应该<dependency>在抵押pom.xml中为Guava 放置一个吗？

缺点看起来像我们pom.xml中的副本，优点是：如果开发“投资”的人会丢弃番石榴，那么它不会阻止我们的抵押子模块成功构建。

如果是，那么<version>我们指定什么方法？（<dependencyManagement>在父pom中没有+ ？）

如果是，那么我们应该<provided>在某个模块中使用范围吗？

注意：请记住，我是在特定情况下询问模块具有共同的父pom（例如，作为一个整体的应用程序）。

想象一下，也许这种结构不是最好的例子：

banking-app
    banking-core (dep.on: guava, commons, spring)
    investment (dep.on: banking-core)
    mortgage (dep.on: banking-core)

Investment使用Spring时仍应该显式声明Spring @Component，如果使用Guava则声明Guava LoadedCache？