Gradle: Gezippte Dependency verwenden

repositories {
  ivy {
    url 'https://repository.example.com/'

    patternLayout {
      // adapt as needed:
      artifact '/foo/[organisation]/bar/[module]/[revision]/[module]-[revision].[ext]'
    }

    // Required in Gradle 6.0+ as metadata file (ivy.xml) is mandatory:
    metadataSources { artifact() }
  }
}

configurations {
  zipped
}

dependencies {
  // "crusy" maps to "organisation", "MyZipFile" to "module",
  // "1.3" to "revision", "zip" to "ext" in above patternLayout:
  zipped 'crusy:MyZipFile:1.3@zip'
}

tasks.register('unzip', Copy) {
  dependsOn configurations.zipped
  from {
    configurations.zipped.collect { zipTree(it) }
  }
  into "${buildDir}/dependencies"
  include '**/*.jar' // or whatever you want/don't want
}

build.dependsOn tasks.unzip

repositories {

ivy {

url 'https://repository.example.com/'

patternLayout {

// adapt as needed:

artifact '/foo/[organisation]/bar/[module]/[revision]/[module]-[revision].[ext]'

}

// Required in Gradle 6.0+ as metadata file (ivy.xml) is mandatory:

metadataSources { artifact() }

}

configurations {

zipped

}

dependencies {

// "crusy" maps to "organisation", "MyZipFile" to "module",

// "1.3" to "revision", "zip" to "ext" in above patternLayout:

zipped 'crusy:MyZipFile:1.3@zip'

}

tasks.register('unzip', Copy) {

dependsOn configurations.zipped

from {

configurations.zipped.collect { zipTree(it) }

}

into "${buildDir}/dependencies"

include '**/*.jar' // or whatever you want/don't want

}

build.dependsOn tasks.unzip

via, und/bzw.

Darauf zugreifen kann man dann bspw. in anderen Tasks mittels

files("${buildDir}/dependencies/SomeFancyJar.jar")

1	files("${buildDir}/dependencies/SomeFancyJar.jar")

PS: Mir ist bewusst, dass ${buildDir} deprecated ist, aber ${layout.buildDirectory} ging aus irgendeinem Grund nicht.

Gradle: Task mit bestimmtem JRE ausführen

Edit zur Erklärung: Gradle benötigt Java, und bspw. ein installiertes JDK 17 kann natürlich Language Level 8 kompilieren. Aber es ist trotzdem ein JDK 17 und enthält bspw. kein JAXB mehr. Die Aufgabe ist hier, einen Gradle-Task unabhängig von meiner Java Version mit einem 8er JRE auszuführen. Das verwendete Plugin lädt alles dafür benötigte herunter.

Original Post below:

settings.gradle:

plugins {
    id 'org.gradle.toolchains.foojay-resolver-convention' version '0.7.0'
}

plugins {

id 'org.gradle.toolchains.foojay-resolver-convention' version '0.7.0'

}

build.gradle:

apply plugin: 'java'

// https://docs.gradle.org/current/dsl/org.gradle.api.tasks.JavaExec.html
tasks.register('foobar', JavaExec) {
    classpath = files('dependencies/FooBar/foo-bar.jar')
    javaLauncher.set(javaToolchains.launcherFor {
        languageVersion = JavaLanguageVersion.of(8)
    })
}

apply plugin: 'java'

// https://docs.gradle.org/current/dsl/org.gradle.api.tasks.JavaExec.html

tasks.register('foobar', JavaExec) {

classpath = files('dependencies/FooBar/foo-bar.jar')

javaLauncher.set(javaToolchains.launcherFor {

languageVersion = JavaLanguageVersion.of(8)

})

}

via, und, Danke Nils!

IntelliJ: Gradle task mit jedem Reimport ausführen

IntelliJ bietet per Rechtsklick die Möglichkeit, Trigger für Tasks anzuhaken (Screenshot aus der Doku geklaut):

Via build.gradle kann man das über das Plugin “gradle-idea-ext-plugin” automatisieren – im Rootprojekt:

apply plugin: 'org.jetbrains.gradle.plugin.idea-ext'

buildscript {
  dependencies {
    classpath "org.jetbrains.gradle.plugin.idea-ext:org.jetbrains.gradle.plugin.idea-ext.gradle.plugin:0.7"
  }
}

apply plugin: 'org.jetbrains.gradle.plugin.idea-ext'

buildscript {

dependencies {

classpath "org.jetbrains.gradle.plugin.idea-ext:org.jetbrains.gradle.plugin.idea-ext.gradle.plugin:0.7"

}

Und im Unterprojekt dann:

idea.project.settings.taskTriggers {
    beforeSync tasks.getByName("jaxb")
}

idea.project.settings.taskTriggers {

beforeSync tasks.getByName("jaxb")

}

Achtung, in DSL spec v. 0.2 heißt es

beforeSync – before each Gradle project sync. Will NOT be executed on initial import

ka, aber spätestens danach funktioniert es.

Gradle: Replace in Copy task

Eine Ersetzung:

task fooBar(type: Copy) {
  from file("${projectDir}/foo/bar.xml")
  into("${projectDir}/xy/z")
  filter { line -> line.replaceAll('someString', 'someReplacement') }
}

task fooBar(type: Copy) {

from file("${projectDir}/foo/bar.xml")

into("${projectDir}/xy/z")

filter { line -> line.replaceAll('someString', 'someReplacement') }

}

Mehrere Ersetzungen:

import org.apache.tools.ant.filters.ReplaceTokens

task fooBar(type: Copy) {
  from file("${projectDir}/foo/bar.xml")
  into("${projectDir}/xy/z")
  filter(ReplaceTokens, tokens: [
          // requires targets to be wrapped in '@', like '@someString@':
          'someString'     : 'someReplacement',
          'someOtherString': 'someOtherReplacement',
  ])
}

import org.apache.tools.ant.filters.ReplaceTokens

task fooBar(type: Copy) {

from file("${projectDir}/foo/bar.xml")

into("${projectDir}/xy/z")

filter(ReplaceTokens, tokens: [

// requires targets to be wrapped in '@', like '@someString@':

'someString' : 'someReplacement',

'someOtherString': 'someOtherReplacement',

])

}

via

Gradle: Include/exclude tests

Exclude set of tests (via) and/or categories:

task junitSystemTest(type: Test) {
  systemProperties = System.properties
  def runSeparately = ['**/FirstSpec*', '**/SecondSpec*']

  useJUnit {
    includeCategories 'com.acme.SystemTest'
    exclude runSeparately
  }
}

task junitSystemTest(type: Test) {

systemProperties = System.properties

def runSeparately = ['**/FirstSpec*', '**/SecondSpec*']

useJUnit {

includeCategories 'com.acme.SystemTest'

exclude runSeparately

}

Pass collection from shell (via, and):

// ./gradlew junitSystemTest -PexcludeTests=**/FirstSpec*,**/SecondSpec*
task junitSystemTest(type: Test) {
  systemProperties = System.properties

  useJUnit {
    includeCategories 'com.acme.SystemTest'
    if (project.hasProperty('excludeTests')) {
      project.properties['excludeTests'].split(',').each {
        exclude it
      }
    }
  }
}

// ./gradlew junitSystemTest -PexcludeTests=**/FirstSpec*,**/SecondSpec*

task junitSystemTest(type: Test) {

systemProperties = System.properties

useJUnit {

includeCategories 'com.acme.SystemTest'

if (project.hasProperty('excludeTests')) {

project.properties['excludeTests'].split(',').each {

exclude it

}

Run single test only (via):

./gradlew junitSystemTest --tests FirstSpec*

1	./gradlew junitSystemTest --tests FirstSpec*

Exclude all tests from build task:

./gradlew clean build -x test

1	./gradlew clean build -x test

to be completed

Gradle: ordered dependsOn

Statt

task foo(dependsOn: [bar1, bar2, bar3]) {
    // ...
}

task foo(dependsOn: [bar1, bar2, bar3]) {

// ...

}

besser:

task foo() {
    def tasks = [bar1, bar2, bar3]
    for (int i = 0; i < tasks.size() - 1; i++) {
        tasks[i + 1].mustRunAfter(tasks[i])
    }
    dependsOn(tasks)

    // ...
}

task foo() {

def tasks = [bar1, bar2, bar3]

for (int i = 0; i < tasks.size() - 1; i++) {

tasks[i + 1].mustRunAfter(tasks[i])

}

dependsOn(tasks)

// ...

}

Postgres direkt aus Gradle

import groovy.sql.Sql

import java.sql.Driver
import java.sql.DriverManager

configurations {
  driver
}

buildscript {
  ext.postgresVersion = '42.1.1'

  dependencies {
    classpath("org.postgresql:postgresql:${postgresVersion}")
  }
}

dependencies {
  driver "org.postgresql:postgresql:${postgresVersion}"
}

// register jdbc drivers:
URLClassLoader loader = GroovyObject.class.classLoader
configurations.driver.each { File file ->
  loader.addURL(file.toURI().toURL())
}
Class driverClass = loader.loadClass('org.postgresql.Driver')
Driver driverInstance = driverClass.newInstance()
DriverManager.registerDriver(driverInstance)

task fooBar() {
  doLast {
    def sql = Sql.newInstance('jdbc:postgresql://localhost:5432/database', 'user', 'password')
    sql.execute(/* ... */)
    sql.close()
  }
}

import groovy.sql.Sql

import java.sql.Driver

import java.sql.DriverManager

configurations {

driver

}

buildscript {

ext.postgresVersion = '42.1.1'

dependencies {

classpath("org.postgresql:postgresql:${postgresVersion}")

}

dependencies {

driver "org.postgresql:postgresql:${postgresVersion}"

}

// register jdbc drivers:

URLClassLoader loader = GroovyObject.class.classLoader

configurations.driver.each { File file ->

loader.addURL(file.toURI().toURL())

}

Class driverClass = loader.loadClass('org.postgresql.Driver')

Driver driverInstance = driverClass.newInstance()

DriverManager.registerDriver(driverInstance)

task fooBar() {

doLast {

def sql = Sql.newInstance('jdbc:postgresql://localhost:5432/database', 'user', 'password')

sql.execute(/* ... */)

sql.close()

}

im Wesentlichen von hier.

Gradle: Extra properties extensions in buildscript

Extra Properties Extensions sind für globale Properties; mir würde spontan bspw. einfallen, die eine Versionsnummer für meine drölf Spring-Dependencies so zu zentralisieren.

Aber, Folgendes geht nicht:

ext.springVersion = '1.5.6.RELEASE'

buildscript {
  dependencies {
    // doesn't work!
    classpath("org.springframework.boot:spring-boot-gradle-plugin:${springVersion}")
  }
}

dependencies {
  // works:
  compile group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: "${springVersion}"
  // ...
}

ext.springVersion = '1.5.6.RELEASE'

buildscript {

dependencies {

// doesn't work!

classpath("org.springframework.boot:spring-boot-gradle-plugin:${springVersion}")

}

dependencies {

// works:

compile group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: "${springVersion}"

// ...

}

, weil buildscript vor allem anderen ausgewertet wird. Aber so geht’s:

buildscript {
  ext.springVersion = '1.5.6.RELEASE'

  dependencies {
    // works :-)
    classpath("org.springframework.boot:spring-boot-gradle-plugin:${springVersion}")
  }
}

dependencies {
  // still works:
  compile group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: "${springVersion}"
  // ...
}

buildscript {

ext.springVersion = '1.5.6.RELEASE'

dependencies {

// works :-)

classpath("org.springframework.boot:spring-boot-gradle-plugin:${springVersion}")

}

dependencies {

// still works:

compile group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: "${springVersion}"

// ...

}

Achtung: Bei mir ging das ausschließlich in geschweiften Klammern und Quotes.

via

Groovy: Innere, nicht statische Klasse instanziieren

// Outer.java
public class Outer {
  class Inner {
    public Inner(String foo) {
    }
  }
}

// Outer.java

public class Outer {

class Inner {

public Inner(String foo) {

}

Aus Groovy heraus:

def o = new Outer()
def i = new Outer.Inner(o, "bar")

1 2	def o = new Outer() def i = new Outer.Inner(o, "bar")

via

IntelliJ/Gradle/Groovy: “Conflicting module versions.”

java.lang.ExceptionInInitializerError
  at com.acme.utils.SomeSpec.$spock_initializeFields(SomeSpec.groovy)
Caused by: groovy.lang.GroovyRuntimeException: Conflicting module versions. Module [groovy-all is loaded in version 2.4.9 and you are trying to load version 2.4.10
  at groovy.lang.GroovySystem.<clinit>(GroovySystem.java:36)
  ... 1 more

java.lang.ExceptionInInitializerError

at com.acme.utils.SomeSpec.$spock_initializeFields(SomeSpec.groovy)

Caused by: groovy.lang.GroovyRuntimeException: Conflicting module versions. Module [groovy-all is loaded in version 2.4.9 and you are trying to load version 2.4.10

at groovy.lang.GroovySystem.<clinit>(GroovySystem.java:36)

... 1 more

, bei Ausführen des Tests aus IntelliJ heraus; per Kommandozeile geht’s.

Internet sagt, man müsse die Dependency excluden (lokal oder global), um Sie dann in nur der gewünschten Version wieder zu includen, aber das führte bei mir bestenfalls nicht zum Erfolg, und schlimmstenfalls zu

Error:Cannot compile Groovy files: no Groovy library is defined for module ‘my-module_test’

Internet sagt weiterhin, man könne eine bestimme Version forcieren, aber das hat bei mir genau gar keine Auswirkungen.

Geholfen hat dann, das Setup aus compile und testCompile zu überprüfen: Ich hatte ein Modul mit Test-Sourcen als compile project, die Dependency org.codehaus.groovy:groovy-all:2.4.10 aber als test-compile eingebunden. Korrekt ist in dem Fall, das Modul als testCompile project einzubinden (oder alternativ die Dependency als compile, aber hier wäre das “falsch rum”).

Offenbar gilt von der Shell aus die höhere (oder die später deklarierte?) (transitive) Dependency, in IntelliJ aber die zuerst deklarierte.

crusy.net

♪ Commit ins Abenteuerland ♫

Tag Archives for Groovy

Gradle: Gezippte Dependency verwenden

Gradle: Task mit bestimmtem JRE ausführen

IntelliJ: Gradle task mit jedem Reimport ausführen

Gradle: Replace in Copy task

Gradle: Include/exclude tests

Gradle: ordered dependsOn

Postgres direkt aus Gradle

Gradle: Extra properties extensions in buildscript

Groovy: Innere, nicht statische Klasse instanziieren

IntelliJ/Gradle/Groovy: “Conflicting module versions.”