从单个源文件夹中分级多个jar [英] Gradle multiple jars from single source folder

问题描述

目前我们有一个项目结构，它包含一个名为 src 的源文件夹，其中包含三个模块的源代码。我想要做的是：

1）编译源代码。这很容易通过sourceSets定义完成：

  sourceSets {
 main {
 java {
 srcDir'src'
} 
} 
} 
  

<2>将编辑结果分成三个罐子。我通过三种'jar'类型的任务来做到这一点：

我现在通过三个独立的任务来完成这个任务：

• util.jar

    task utilJar（type：Jar）{
   from（sourceSets.main.output）{
   includemy / util / package / **
  } 
  } 
     
   
   client.jar 
   任务clientJar（类型：Jar ）{来自（sourceSets.main.output）的
   {
  包含my / client / package / **
  } 
  } 
    
    
   
   
   server.jar  
   
   
   任务serverJar（类型：Jar）{来自（sourceSets.main.output）的
   {
  包含**
  } 
   excludes.addAll（utilJar.includes）
   excludes.addAll（clientJar.includes）
  } 
    
   
   
   

事情是 server.jar 应该包含所有不在 client.jar 中的类，而 util.jar 。在ant构建脚本中，我们使用 difference ant任务来解决此问题。如何在gradle中完成这项工作（我目前的方法无效）？

也许我的方法是完全错误的。请咨询。

至于现在我们不能更改项目源代码文件夹结构。

解决方案

我将在此处发布我的工作解决方案作为答案

gradle中的范围非常奇怪:)我认为每个任务定义都会创建一个'Task'对象，在这种情况下，类似'JarTask'。然后，我可以从我的build.gradle脚本中的任何地方访问该类的任何属性。但是，我发现唯一可以看到包含在jar文件中的模式的地方 - 在任务的块中的内。因此，我现在的工作解决方案是：1）定义一个项目级集合以包含要从 server.jar中排除的模式 code $
$ b <2>从> 的所有块中排除中的所有模式serverJar 任务。

请参阅下面的最终版本

  sourceSets {
 main {
 java {
 srcDir'src'
} 
} 
} 
 
 //保存包含在client.jar和util.jar中的类，所以它们将被排除在server.jar 
 ext.serverExcludes = [] 
 
 // util.jar 
任务utilJar （类型：Jar）{
 from（sourceSets.main.output）{
 includemy / util / package / **
 project.ext.serverExcludes.addAll（includes）
 
 
 
 // client.jar 
任务clientJar（类型：Jar）{
 from（sourceSets.main.output）{
包含my / client / package / **
 project.ext.serverExc ludes.addAll（includes）
} 
} 
 
 // server.jar 
 taskSar（type：Jar）{
 from（sourceSets.main .output）{
 exclude project.ext.serverExcludes 
} 
} 
  

As for now we have a project structure with single source folder named src, which contains source code for three modules. What I want to do is:

1) Compile source code. This is easily done with sourceSets definition:

sourceSets {
    main {
        java {
            srcDir 'src'
        }
    }
}

2) Put compilation results into three jars. I am doing this via three 'jar' type tasks:

I am doing this now via three separate tasks:

• util.jar

  task utilJar(type: Jar) {
      from(sourceSets.main.output) {
          include "my/util/package/**"
      }
  }
  

• client.jar

  task clientJar(type: Jar) {
      from(sourceSets.main.output) {
          include "my/client/package/**"
      }
  }
  

• server.jar

  task serverJar(type: Jar) {
      from(sourceSets.main.output) {
          include "**"
      }
      excludes.addAll(utilJar.includes)
      excludes.addAll(clientJar.includes)
  }
  

The thing is that server.jar should contain all classes that are not contained within client.jar and util.jar. In ant build script we solve this problem by using difference ant task. How this can be done in gradle (my current approach doesn't work)?

Maybe my approach is completely wrong. Please advice.

P.S. as for now we CAN NOT change the project source code folder structure.

解决方案

I will post my working solution here as an answer (I've got a hint on gradle's forum).

The scopes in gradle are very strange thing :) I thought that every task definition creates an object of some 'Task' class, which is something like 'JarTask' in this particular case. Then I can access any property of the class from anywhere in my build.gradle script. However, I found the only place where I can see the patterns, which are included in jar file - inside a from block of a task. So my working solution for now is to:

1) Define a project-level collection to contain patterns to be excluded from server.jar

2) Exclude all patterns in from block of serverJar task.

Please see final version below

sourceSets {  
    main {  
        java {  
            srcDir 'src'  
        }  
    }  
} 

// holds classes included into client.jar and util.jar, so they are to be excluded from server.jar
ext.serverExcludes = []

// util.jar
task utilJar(type: Jar) {  
    from(sourceSets.main.output) {  
        include "my/util/package/**" 
        project.ext.serverExcludes.addAll(includes)
    }  
}

// client.jar
task clientJar(type: Jar) {  
    from(sourceSets.main.output) {  
        include "my/client/package/**"
        project.ext.serverExcludes.addAll(includes)
    }  
}

// server.jar
task serverJar(type: Jar) {  
    from(sourceSets.main.output) {  
        exclude project.ext.serverExcludes
    }  
}

这篇关于从单个源文件夹中分级多个jar的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！