Gradle java plugin java version

The Java Platform Plugin

The Java Platform plugin brings the ability to declare platforms for the Java ecosystem. A platform can be used for different purposes:

• a description of modules which are published together (and for example, share the same version)
• a set of recommended versions for heterogeneous libraries. A typical example includes the Spring Boot BOM
• sharing a set of dependency versions between subprojects

A platform is a special kind of software component which doesn’t contain any sources: it is only used to reference other libraries, so that they play well together during dependency resolution.

Platforms can be published as Gradle Module Metadata and Maven BOMs.

The java-platform plugin cannot be used in combination with the java or java-library plugins in a given project. Conceptually a project is either a platform, with no binaries, or produces binaries.

Usage

To use the Java Platform plugin, include the following in your build script:

API and runtime separation

A major difference between a Maven BOM and a Java platform is that in Gradle dependencies and constraints are declared and scoped to a configuration and the ones extending it. While many users will only care about declaring constraints for compile time dependencies, thus inherited by runtime and tests ones, it allows declaring dependencies or constraints that only apply to runtime or test.

For this purpose, the plugin exposes two configurations that can be used to declare dependencies: api and runtime . The api configuration should be used to declare constraints and dependencies which should be used when compiling against the platform, whereas the runtime configuration should be used to declare constraints or dependencies which are visible at runtime.

Note that this example makes use of constraints and not dependencies. In general, this is what you would like to do: constraints will only apply if such a component is added to the dependency graph, either directly or transitively. This means that all constraints listed in a platform would not add a dependency unless another component brings it in: they can be seen as recommendations.

For example, if a platform declares a constraint on org:foo:1.1 , and that nothing else brings in a dependency on foo , foo will not appear in the graph. However, if foo appears, then usual conflict resolution would kick in. If a dependency brings in org:foo:1.0 , then we would select org:foo:1.1 to satisfy the platform constraint.

By default, in order to avoid the common mistake of adding a dependency in a platform instead of a constraint, Gradle will fail if you try to do so. If, for some reason, you also want to add dependencies in addition to constraints, you need to enable it explicitly:

Источник

Different ways to configure java or JDK version in Gradle project

This tutorial talks about different ways of configuring the java version in Gradle projects.

In java projects, Source projects are compiled and generated class files.

In Gradle, For the java plugin, We need to provide the java version in build Gradle for compiling and generating class files.

Java installation is required for building the Gradle project and running the Gradle build.

How to configure source and target JDK version in gradle build

to compile files in java, we use the javac command and which has source and target arguments for the javac command.

javac Emp.java -source 1.9 -target 1.8

source tells the compiler to compile with a specific version target tells the compiler to support the lowest java version to support

In the above program, Emp.java code is compiled with the java 1.9 version, and generated class file has compatible with 1.8 or more, but not 1.7 or newer versions.

Does Gradle support this property? Yes, It supports the same approach with different properties.

It has sourceCompatibility and targetCompatibility properties.

To configure in build.gradle

sourceCompatibility = '1.10' targetCompatibility = '1.8'

sourceCompatibility uses the java version to compile java files targetCompatibility tells generate class supports minimum java version that has support

This option enables the running of all tasks with specific versions.

Suppose you want different versions for each task, you can configure the build script as follows

tasks.withType  options.compilerArgs.addAll(arrayOf("--release", "12")) >

The above script tells us to use java version 12 to compile java files in a Gradle project.

How to install and configure the java version with gradle build?

By default, Gradle uses the java version from the JAVA_HOME environment variable path configured in the machine, and JAVA_HOME points to JDK installed on the machine.

For example, the machine is installed with the JDK 1.8 version and the Gradle project needs a java 11 version.

• install the java 11 version on the machine and it is straightforward
• Gradle project has a configuration to install the required Java version and configure.

How do you configure gradle build with java installation and configuration?

with Gradle 6.7 version, It has support for java toolchains

• It ignores the java version on the machine
• In the build file, configure the java version
• It installs JDK if not installed
• Gradle build runs with that version.
• No configuration required for sourceCompatibility and targetCompatibility properties

• First configure plugins for java-library
• next, configure the toolchain with the required java version

In the build.gradle file, configure the below code.

plugins  id("java-library") // id("application") > java  toolchain  languageVersion.set(JavaLanguageVersion.of(12)) > >

• Installs java 12 versions from remote locations, Locations can be configurable
• check for valid installation
• All java related tasks use the java 12 version to compile and generate class files
• All test-related tasks use the java 12 version
• documentation relate tasks use the java 12 version.

It has the flexibility to configure the java version at the task level.

For example, Configure java Compilation requires 12 versions and test requires 15 versions.

tasks.register("extraTests")  javaLauncher.set(javaToolchains.launcherFor  languageVersion.set(JavaLanguageVersion.of(15)) >) >

Conclusion

In this tutorial, You learned different ways to configure the java version.

• using sourceCompatibility and targetCompatibility options in the build.gradle
• java toolchain support

With the above two options, You can choose to use the java version differently either at the project level or task level with examples.

Источник

Gradle Plugin Development Plugin

The Java Gradle Plugin development plugin can be used to assist in the development of Gradle plugins. It automatically applies the Java Library ( java-library ) plugin, adds the gradleApi() dependency to the api configuration and performs validation of plugin metadata during jar task execution.

The plugin also integrates with TestKit, a library that aids in writing and executing functional tests for plugin code. It automatically adds the gradleTestKit() dependency to the testImplementation configuration and generates a plugin classpath manifest file consumed by a GradleRunner instance if found. Please refer to Automatic classpath injection with the Plugin Development Plugin for more on its usage, configuration options and samples.

Usage

To use the Java Gradle Plugin Development plugin, include the following in your build script:

Applying the plugin automatically applies the Java Library( java-library ) plugin and adds the gradleApi() dependency to the api configuration. It also adds some validations to the build.

The following validations are performed:

• There is a plugin descriptor defined for the plugin.
• The plugin descriptor contains an implementation-class property.
• The implementation-class property references a valid class file in the jar.
• Each property getter or the corresponding field must be annotated with a property annotation like @InputFile and @OutputDirectory . Properties that don’t participate in up-to-date checks should be annotated with @Internal .

Any failed validations will result in a warning message.

For each plugin you are developing, add an entry to the gradlePlugin <> script block:

The gradlePlugin <> block defines the plugins being built by the project including the id and implementationClass of the plugin. From this data about the plugins being developed, Gradle can automatically:

• Generate the plugin descriptor in the jar file’s META-INF directory.
• Configure the Plugin Marker Artifact publications (Maven or Ivy) for each plugin.
• Publish each plugin to the Gradle Plugin Portal (see Publishing Plugins to Gradle Plugin Portal for details), but only if the Plugin Publishing Plugin has also been applied.

Interactions

Some of the plugin’s behaviour depends on other, related plugins also being applied in your build, namely the Maven Publish ( maven-publish ) and Ivy Publish ( ivy-publish ) plugins.

Other plugins auto apply the Java Gradle Plugin, like the Plugin Publishing Plugin.

Maven Publish Plugin

When the Java Gradle Plugin ( java-gradle-plugin ) detects that the Maven Publish Plugin ( maven-publish ) is also applied by the build, it will automatically configure the following MavenPublications:

• a single «main» publication, named pluginMaven , based on the main Java component
• multiple «marker» publications (one for each plugin defined in the gradlePlugin <> block), named PluginMarkerMaven (for example in the above example it would be simplePluginPluginMarkerMaven )

This automatic configuration happens in a Project.afterEvaluate() block (so at the end of the build configuration phase), and only if these publications haven’t already been defined, so it’s possible to create and customise them during the earlier stages of build configuration.

Ivy Publish Plugin

When the Java Gradle Plugin( java-gradle-plugin ) detects that the Ivy Publish Plugin ( ivy-publish ) is also applied by the build, it will automatically configure the following IvyPublications:

• a single «main» publication, named pluginIvy , based on the main Java component
• multiple «marker» publications (one for each plugin defined in the gradlePlugin <> block), named PluginMarkerIvy (for example in the above example it would be simplePluginPluginMarkerIvy )

This automatic configuration happens in a Project.afterEvaluate() block (so at the end of the build configuration phase), and only if these publications haven’t already been defined, so it’s possible to create and customise them during the earlier stages of build configuration.

Plugin Publish Plugin

Starting from version 1.0.0, the Plugin Publish Plugin always auto-applies the Java Gradle Plugin ( java-gradle-plugin ) and the Maven Publish Plugin ( maven-publish ).

Источник