Jak powiedzieć Gradle, aby użyła określonej wersji JDK?


284

Nie mogę wymyślić, żeby to zadziałało.

Scenariusz:

  • Mam aplikację zbudowaną z gradle
  • Aplikacja korzysta z JavaFX

Czego chcę

  • Użyj zmiennej (zdefiniowanej dla maszyny programisty), która wskazuje instalację JDK, która będzie używana do budowania całej aplikacji / testów / ...

Pomyślałem o posiadaniu gradle.propertiespliku, definiowaniu zmiennej. Coś jak

JAVA_HOME_FOR_MY_PROJECT=<path to my desired JDK>

Czego nie chcę

  • wskaż JAVA_HOMEżądany JDK

Mógłbym żyć z wieloma sugestiami:

  • rozwiązanie, które definiuje systemową zmienną środowiskową, którą mogę sprawdzić w skrypcie build.gradle
  • zmienna zdefiniowana w gradle.properties
  • przesłanianie zmiennej JAVA_HOME tylko dla kontekstu kompilacji (coś podobnego use JAVA_HOME=<my special JDK path defined somewhere else defined>)
  • coś innego, o czym nie myślałem

Pytanie:

  • Jak połączyć zmienną (jakkolwiek zdefiniowaną jako zmienną w gradle.propertiessystemowej zmiennej środowiskowej, ...) z procesem kompilacji?

Mam więcej niż jeden JDK7 i muszę wskazać specjalną wersję (minimalna wersja JDK_u).

Każda odpowiedź jest doceniana i jestem wdzięczny za każdą wskazówkę we właściwym kierunku.


6
Czy próbowałeś ustawienia org.gradle.java.homew gradle.propertiespliku? link
Ray Stojonic

w Eclipse możesz utworzyć „plik konfiguracji produktu” w swoim projekcie i możesz spakować jdk z produktem. Nie trzeba określać zmiennych env.
mdanaci

3
@RayStojonic: Właśnie próbowałem, ale gradle nadal używa JAVA_HOME JDK do budowania :(
bully

@mdanaci: Naprawdę miałem nadzieję, że uda mi się tego uniknąć, ponieważ szczerze mówiąc, nie chcę brać JDK pod kontrolę wersji (co byłoby konsekwencją, jeśli skorzystam z twojej sugestii), ponieważ każdy programista musi mieć możliwość spakowania aplikacji. Ponadto widzę w ten sposób problemy z serwerem CI. W każdym razie dziękuję za twoją sugestię :)
tyran

3
Od roku temu org.gradle.java.homeustawienie dotyczy tylko demona gradly, najwyraźniej ... W każdym razie spróbuj ustawić fork na true i forkOptions.executable na jdk, którego chcesz użyć: link
Ray Stojonic

Odpowiedzi:


292

Dwie drogi

  1. W gradle.propertiesw .gradlekatalogu w swoim HOME_DIRECTORYzestawieorg.gradle.java.home=/path_to_jdk_directory

lub:

  1. W Twoim build.gradle

    compileJava.options.fork = true
    compileJava.options.forkOptions.executable = /path_to_javac

23
gradle.propertiesMogą być zdefiniowane na poziomie projektu też zobaczyć gradle.org/docs/current/userguide/build_environment.html
Paolo Fulgoni

143
Jeśli wykonujesz za pomocą owijarki stopniowej, możesz to zrobić podobnie ./gradlew -Dorg.gradle.java.home=/path_to_jdk_directory. Dobrze, jeśli nie chcesz dotykać gradle.properties.
david.schreiber

26
Pytanie brzmiało, jak ustawić VERSION, a nie JDK PATH, prawda?
Przerywa

40
W ten sposób nie mogę współdzielić projektu z innymi programistami, którzy mają Javę na różnych ścieżkach.
Przerywa

10
Istnieje różnica między opcjami 1 i 2, które należy wyjaśnić: w opcji 1 ustawiamy JVM dla samego gradla, w ramach którego będzie on również używany do uruchomienia zadania kompilatora (zwróć uwagę, że sam javac jest aplikacją Java), podczas gdy w opcja 2, po prostu ustawiamy javaca, który ma być spawnowany we własnej JVM. Jeśli z jakiegokolwiek powodu potrzebujemy konkretnej JVM dla gradle (np. Dana wtyczka gradle jest skompilowana dla powiedzmy Java 8), wówczas będziemy zmuszeni uciekać się do opracowania osobnej JVM dla procesu kompilacji.
Basel Shishani,

147

Jeśli dodasz JDK_PATH w gradle.properties, twoja kompilacja stanie się zależna od tej konkretnej ścieżki. Zamiast tego uruchom zadanie gradle z następującym parametrem wiersza poleceń

gradle build -Dorg.gradle.java.home=/JDK_PATH

W ten sposób twoja kompilacja nie zależy od konkretnej ścieżki.


3
W Eclipse (Neon, 4.6) możesz także ustawić Java Home w konfiguracji kompilacji Gradle (patrz zakładka „Java Home”). Jest to dość żmudna praca, jeśli masz ponad 20 zadań kompilacji ... Myślę, że Gradle naprawdę musi wybrać katalog Java Home z konfiguracji systemu!
Markus L

1
To słuszna kwestia. Mam miękkie łącze o nazwie /usr/lib/java/jdk/homewskazujące na zainstalowaną bieżącą wersję. Oczywiście, jeśli chcesz konkretnej wersji (np. U51), musisz dokładnie określić ścieżkę. Także niektóre narzędzia, które chcą rozpocząć grading, wydają się nie ustawiać JDK w środowisku, w którym oceniają. I na przykład nigdy nie ustawiłem JDK jako bieżącego JAVA_HOME, chyba że jest to sesja programistyczna.
będzie

6
Zauważ, że JDK_PATH nie może zawierać spacji w systemie Windows, nawet jeśli jest w cudzysłowie: zmieniłeś „Program Files” na PROGRA~1(wszystkie wielkie litery) lub cokolwiek innego, co mówi DIR / X.
Noumenon

2
Jeśli używasz otoki stopniowej, wywołaj następującą komendę ./gradlew build -Dorg.gradle.java.home = / JDK_PATH Zamień JDK_PATH na swoją lokalizację jdk w swoim środowisku, np. „/Opt/java/jdk1.7.0_79/bin/”
mirmdasif,

3
"... gradle itself (either standalone distribution or wrapper) uses JDK from JAVA_HOME environment variable or (if it is not set) from PATH".Podałem JAVA_HOME przed wywołaniem gradlew, aby to naprawić. (tj. env JAVA_HOME=/path/to/java gradlew war --stacktrace)
TekiusFanatikus

110

Do osób, które znajdą się tutaj, szukając odpowiednika Gradle właściwości Maven maven.compiler.source(lub <source>1.8</source>):

W build.gradle możesz to osiągnąć za pomocą

apply plugin: 'java'
sourceCompatibility = 1.8
targetCompatibility = 1.8

Zobacz dokumentację Gradle na ten temat .


1
To zadziałało dla mnie, ale musiałem zmienić „
Apply

10
@morgwai - poza tym, że nie jest to odpowiedź na pytanie, które wyraźnie pyta: „Chcę [to ustawić] zmienną (zdefiniowaną dla maszyny programisty), która wskazuje na instalację JDK, która będzie używana do budowania cała aplikacja ”. Pozytywne odpowiedzi są poprawne; ta odpowiedź dotyczy zupełnie innego pytania.
Jules,

1
Jest to ignorowane przez narzędzia takie jak zadanie Javadoc (które próbuje wygenerować javadoc zgodnie z Javą 9 z modułami w moim projekcie, który ma używać Java 8)
CLOVIS

20

Jeśli wykonujesz za pomocą wrappera stopni, możesz uruchomić polecenie ze ścieżką JDK w następujący sposób

./gradlew -Dorg.gradle.java.home=/jdk_path_directory


5

Jeśli korzystasz z linuksa i otoki stopni, możesz użyć następującego rozwiązania.

Dodaj ścieżkę do pliku local.properties:

javaHome=<path to JDK>

Dodaj do pliku skryptu gradlew:

DIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
source $DIR/local.properties 2>/dev/null

if ! [ -z "$javaHome" ]
then
  JAVA_HOME=$javaHome
fi

W tym rozwiązaniu każdy programista może ustawić własną ścieżkę JDK. Plik local.propertiesnie powinien być zawarty w systemie kontroli wersji.


5

Dodałem tę linię do mojego pliku GRADLE_HOME / bin / gradle - export JAVA_HOME=/path/to/java/version


4

Jest jeszcze jedna opcja do naśladowania. W zadaniach stopniowych możesz ustawić żądaną ścieżkę jdk. (Wiem, że minęło trochę czasu od opublikowania pytania. Ta odpowiedź może komuś pomóc.)

Kliknij prawym przyciskiem myszy na wdrożenie lub dowolne inne zadanie i wybierz „Otwórz konfigurację uruchamiania stopniowego ...”

wprowadź opis zdjęcia tutaj

Następnie przejdź do „Java Home” i wklej żądaną ścieżkę Java.

wprowadź opis zdjęcia tutaj

Pamiętaj, że bin zostanie dodany przez samo zadanie stopniowania. Więc nie dodawaj „bin” do ścieżki.


Nie widzę zadań stopniowych
Paul McCarthy


1

W systemie Windows uruchom zadanie gradate z parametrem ścieżki jdk 11 w cudzysłowie

gradlew clean build -Dorg.gradle.java.home="c:/Program Files/Java/jdk-11"

0

Jak widać w Gradle (wtyczka Eclipse)

http://www.gradle.org/get-started

Gradle używa dowolnego JDK, który znajdzie na twojej ścieżce (aby to sprawdzić, użyj java -version). Alternatywnie można ustawić zmienną środowiskową JAVA_HOME, aby wskazywała katalog instalacyjny żądanego JDK.


Jeśli używasz tej wtyczki Eclipse lub Enide Studio 2014 , alternatywna JAVA_HOME do użycia (ustawiona w Preferencjach) będzie w wersji 0.15, patrz http://www.nodeclipse.org/history


1
Cześć Paul, właściwie to właśnie jest mój problem. Chcę zdefiniować inny JDK dla zadań budowania stopni niż zdefiniowany w JAVA_HOME. Chociaż dobrze wiedzieć, że będzie w tym wpis we wtyczce Eclipse :)
tyran

Standardowe środowisko Eclipse pozwala definiować zmienne środowiskowe dla konfiguracji uruchamiania. Ale nie tego próbujemy z gradem. Otwórz problem, jeśli poznasz to pytanie dalej github.com/Nodeclipse/nodeclipse-1/issues
Paul Verest

0

Używam Gradle 4.2. Domyślnym pakietem JDK jest Java 9. Na początku Java 9, Gradle 4.2 działa poprawnie na JDK 8 (nie JDK 9).

JDK ustawiam ręcznie w następujący sposób, w pliku %GRADLE_HOME%\bin\gradle.bat:

@if "%DEBUG%" == "" @echo off
@rem ##########################################################################
@rem
@rem  Gradle startup script for Windows
@rem
@rem ##########################################################################

@rem Set local scope for the variables with windows NT shell
if "%OS%"=="Windows_NT" setlocal

set DIRNAME=%~dp0
if "%DIRNAME%" == "" set DIRNAME=.
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%..

@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS=

@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome

@rem VyDN-start.
set JAVA_HOME=C:\Program Files\Java\jdk1.8.0_144\
@rem VyDN-end.

set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if "%ERRORLEVEL%" == "0" goto init

echo.
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.

goto fail

:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%


@rem VyDN-start.
set JAVA_HOME=C:\Program Files\Java\jdk1.8.0_144\
@rem VyDN-end.


set JAVA_EXE=%JAVA_HOME%/bin/java.exe

if exist "%JAVA_EXE%" goto init

echo.
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.

goto fail

:init
@rem Get command-line arguments, handling Windows variants

if not "%OS%" == "Windows_NT" goto win9xME_args

:win9xME_args
@rem Slurp the command line arguments.
set CMD_LINE_ARGS=
set _SKIP=2

:win9xME_args_slurp
if "x%~1" == "x" goto execute

set CMD_LINE_ARGS=%*

:execute
@rem Setup the command line

set CLASSPATH=%APP_HOME%\lib\gradle-launcher-4.2.jar

@rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.launcher.GradleMain %CMD_LINE_ARGS%

:end
@rem End local scope for the variables with windows NT shell
if "%ERRORLEVEL%"=="0" goto mainEnd

:fail
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
rem the _cmd.exe /c_ return code!
if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
exit /b 1

:mainEnd
if "%OS%"=="Windows_NT" endlocal

:omega

0

Jeśli używasz JDK 9+, możesz to zrobić:

java {
    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8
}

tasks.withType<JavaCompile> {
    options.compilerArgs.addAll(arrayOf("--release", "8"))
}

Możesz również zobaczyć następujące powiązane problemy:



0

Jeśli używasz Kotlin DSL, build.gradle.ktsdodaj:

tasks.withType<JavaCompile> {
    options.isFork = true
    options.forkOptions.javaHome = File("C:\\bin\\jdk-13.0.1\\")
}

Oczywiście zakładam, że masz system operacyjny Windows i javackompilator jest na dobrej drodze C:\bin\jdk-13.0.1\bin\javac. W przypadku systemu operacyjnego Linux będzie podobnie.


-1

Jeśli chcesz ustawić to raz, aby uruchomić określone polecenie:

JAVA_HOME=/usr/lib/jvm/java-11-oracle/ gw build
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.