I'm using the shadowJar Gradle target provided by the com.github.johnrengelman.shadow Gradle plugin to build up an application, which requires an org.apache.hive.jdbc.HiveDriver to connect to Kudu using Impala.
The problem is that when I use standard approach to import the driver in Scala:
Class.forName("org.apache.hive.jdbc.HiveDriver")
the shadow plugin removes it from the resulting JAR, implying an runtime error of:
java.lang.ClassNotFoundException: org.apache.hadoop.hive.jdbc.HiveDriver.
My build.gradle contains:
dependencies {
implementation {
"org.apache.hive:hive-jdbc:1.2.1"
}
}
How do I instruct the shadow plugin not to delete the required dependency injected via a String?
I found out the solution is to include the static type not via Class.forName, but using code by importing it:
import java.sql.DriverManager
import org.apache.hive.jdbc.{HiveConnection, HiveDriver}
class Foo {
// Register Hive Driver this way to prevent shadowing to cut it off
new HiveDriver()
DriverManager.getConnection(connectionUrl, user, password) match {
case connection: HiveConnection =>
...
}
}
This way, the shadow plugin is officially informed about the fact that the Driver is actually required.
Related
The official Elasticsearch docs tell to instantiate ElasticsearchClient like this:
ElasticsearchClient client = new ElasticsearchClient(transport);
Once I write this in my Grails 3 application with Gradle build management, I get the following compilation error: Cannot instantiate interface 'ElasticsearchClient'
The import statement is: import org.elasticsearch.client.ElasticsearchClient.
Indeed, ElasticsearchClient gets resolved to:
package org.elasticsearch.client;
// ...
public interface ElasticsearchClient {
The Gradle dependency is: compile 'org.elasticsearch:elasticsearch:7.17.2'
Why do they propose to instantiate an interface in their docs?
What can I do to make it compile and use the Elasticsearch client?
The reason for this was: ElasticsearchClient was mis-resolved to an old elasticsearch JAR file that had still been in my local user's .gradle directory. Removing the old JAR from .gradle enabled me to do the correct import.
The correct import is
import co.elastic.clients.elasticsearch.ElasticsearchClient
instead of
import org.elasticsearch.client.ElasticsearchClient
I keep getting "Deprecated Gradle features were used in this build, making it incompatible with Gradle 8.0."
I've looked and tried a dozen fixes and tutorials all with the same error. I've moved the view to the every folder and renamed it incase underscores aren't allowed. I've tried every permutation of "/path/file.fxml" I can think of
I have a feeling my code is depreciated but all I can do is get intellij to highlight .load()
Here is my code:
import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.stage.Stage;
public class ScoreSheet extends Application {
#Override
public void start(Stage primaryStage) throws Exception {
FXMLLoader fxmlLoader = new
FXMLLoader(ScoreSheet.class.getResource("views/main_menu.fxml"));
primaryStage.setTitle("Score Sheet");
Group root = new Group();
Scene scene = new Scene(fxmlLoader.load(), 405, 720);
primaryStage.setScene(scene);
primaryStage.show();
}
}
Here is my stacktrace:
Starting Gradle Daemon...
Connected to the target VM, address: '127.0.0.1:51285', transport: 'socket'
Gradle Daemon started in 616 ms
> Configure project :
Found module name 'ScoreSheetTest.main'
Disconnected from the target VM, address: '127.0.0.1:51285', transport: 'socket'
> Task :compileJava UP-TO-DATE
> Task :processResources NO-SOURCE
> Task :classes UP-TO-DATE
> Task :jar UP-TO-DATE
Connected to the target VM, address: 'localhost:51290', transport: 'socket'
Disconnected from the target VM, address: 'localhost:51290', transport: 'socket'
Connected to the target VM, address: '127.0.0.1:51285', transport: 'socket'
> Task :ScoreSheet.main() FAILED
Deprecated Gradle features were used in this build, making it incompatible with Gradle 8.0.
You can use '--warning-mode all' to show the individual deprecation warnings and determine if they come from your own scripts or plugins.
See https://docs.gradle.org/7.2/userguide/command_line_interface.html#sec:command_line_warnings
3 actionable tasks: 1 executed, 2 up-to-date
Exception in Application start method
Exception in thread "main" java.lang.reflect.InvocationTargetException
at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:77)
at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.base/java.lang.reflect.Method.invoke(Method.java:568)
at java.base/sun.launcher.LauncherHelper$FXHelper.main(LauncherHelper.java:1071)
Caused by: java.lang.RuntimeException: Exception in Application start method
at javafx.graphics/com.sun.javafx.application.LauncherImpl.launchApplication1(LauncherImpl.java:901)
at javafx.graphics/com.sun.javafx.application.LauncherImpl.lambda$launchApplication$2(LauncherImpl.java:196)
at java.base/java.lang.Thread.run(Thread.java:833)
Caused by: java.lang.IllegalStateException: Location is not set.
at javafx.fxml/javafx.fxml.FXMLLoader.loadImpl(FXMLLoader.java:2541)
at javafx.fxml/javafx.fxml.FXMLLoader.load(FXMLLoader.java:2516)
at ScoreSheetTest.main/com.company.scoresheet.ScoreSheet.start(ScoreSheet.java:16)
at javafx.graphics/com.sun.javafx.application.LauncherImpl.lambda$launchApplication1$9(LauncherImpl.java:847)
at javafx.graphics/com.sun.javafx.application.PlatformImpl.lambda$runAndWait$12(PlatformImpl.java:484)
at javafx.graphics/com.sun.javafx.application.PlatformImpl.lambda$runLater$10(PlatformImpl.java:457)
at java.base/java.security.AccessController.doPrivileged(AccessController.java:399)
at javafx.graphics/com.sun.javafx.application.PlatformImpl.lambda$runLater$11(PlatformImpl.java:456)
at javafx.graphics/com.sun.glass.ui.InvokeLaterDispatcher$Future.run(InvokeLaterDispatcher.java:96)
FAILURE: Build failed with an exception.
* What went wrong:
Execution failed for task ':ScoreSheet.main()'.
> Process 'command '/Users/username/Library/Java/JavaVirtualMachines/zulu-17.jdk/Contents/Home/bin/java'' finished with non-zero exit value 1
BUILD FAILED in 4s
Disconnected from the target VM, address: '127.0.0.1:51285', transport: 'socket'
2:05:57 PM: Execution finished ':ScoreSheet.main()'.
Edit: File structure image
Edit 2: Here is my build.gradle:
plugins {
id 'java'
id 'application'
id 'org.openjfx.javafxplugin' version '0.0.8'
}
group 'com.iharptech'
version '1.0-SNAPSHOT'
repositories {
mavenCentral()
}
dependencies {
testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
implementation 'org.openjfx:javafx-controls:18'
}
test {
useJUnitPlatform()
}
sourceSets {
main {
resources {
srcDirs = ["src/main/java"]
includes = ["**/*.fxml"]
}
}
}
Gradle Deprecation Warnings
These warnings are almost certainly not related to your IllegalStateException.
If you want to know which deprecated features were used, then you can do what the warning message says and use --warning-mode all. If the features were used by your own build script, then you can look up the replacements and fix the problem yourself. However, if the features were used by a plugin then really your only options are: (1) Update to use the latest version of the plugin; (2) If already using the latest version, submit a bug report with the plugin authors (if one doesn't already exist); (3) Maybe, if possible, use a different plugin.
Using Gradle with an IDE
When you use a build tool such as Gradle (or e.g., Maven), then you should let the build tool handle all dependencies and other configurations (as much as is possible). In other words, you should be declaring the JavaFX dependencies in your build script, not in IntelliJ.
You should also have the IDE delegate build and run tasks to Gradle. That way Gradle is responsible for everything build related, and the IDE is only responsible for making it easier to write code.
IntelliJ works really well with Gradle. Any dependencies you add to Gradle will be known by IntelliJ. And any tasks supplied by Gradle will also be known by IntelliJ.
Declare JavaFX Dependencies in Gradle
You're using the OpenJFX javafx-gradle-plugin. That project's README has documentation for how to declare which JavaFX modules you need for your project. Note the latest version of this plugin is 0.0.12. You should update your build script to use that version.
Local JavaFX SDK
If you're using a downloaded JavaFX SDK, as your comments seem to imply, then you can use:
javafx {
sdk = '/path/to/sdk' // replace with your own path
modules = ['javafx.controls', 'javafx.fxml'] // modify list as needed
}
For the sdk path, you may want to setup a variable that is then passed by the person who invokes Gradle. That way people on other computers can still build your project without modifying the build script. Though if this is a personal project on a single computer then a static, absolute path should be fine for now.
I don't know when this feature was added to the plugin, so you may need to update to the latest version.
Maven Central JavaFX JARs
You could instead have Gradle download the needed JavaFX JAR files from Maven Central.
javafx {
modules = ['javafx.controls', 'javafx.fxml'] // modify list as needed
version = '18' // change version as needed
}
repositories {
mavenCentral()
}
Executing Gradle Tasks
You should make run configurations to execute Gradle tasks, rather than letting the IDE use its own build and execution system.
To execute any Gradle task via IntelliJ, you can open up the Gradle tab (typically on the right side of IntelliJ, if I'm not mistaken), select a task, and execute it.
Or you could manually create a "run configuration". Make sure to choose "Gradle" when selecting the type of configuration. Tell it which project the task is for and which task to execute.
The Application Plugin
Typically, with JVM projects, when you want to be able to execute your project you should apply the application plugin.
plugins {
// other plugins...
'application'
}
You already do this. But you also need to configure the main class and, if present, the main module.
application {
mainModule = '<module-name>'
mainClass = '<fully-qualified-class-name>'
}
The application plugin adds the run task. To execute your project, have IntelliJ execute the run task.
Resources
For general information about resources, how to load them, what paths to use, and some troubleshooting techniques, I recommend this Q&A:
How do I determine the correct path for FXML files, CSS files, Images, and other resources needed by my JavaFX Application?
But specifically regarding your setup, you should remove this part from your Gradle build script:
sourceSets {
main {
resources {
srcDirs = ["src/main/java"]
includes = ["**/*.fxml"]
}
}
}
It's not needed. Keeping it means src/main/resources is no longer considered a resource root, which you probably do not want.
With that change, and executing the project via the run task, using "/views/main_menu.fxml" should work for you as the resource path.
I'm working on a Java 11 application that uses the java module system. I need to use reflection to access an internal function of the JavaFX library. The java module containing that function doesn't export it, so I get the following error when I run the gradle build task:
import com.sun.javafx.tk.TKStage;
^
(package com.sun.javafx.tk is declared in module javafx.graphics, which does not export it to module com.sampleapp)
I believe that means I need to do --add-exports javafx.graphics/com.sun.javafx.tk=com.sampleapp, however, I'm not sure how to do this in gradle. I've tried adding it to the applicationDefaultJvmArgs, which didn't work.
application {
...
applicationDefaultJvmArgs = listOf(
"--add-exports javafx.graphics/com.sun.javafx.tk=com.sampleapp"
)
}
I've also tried adding it to gradle.properties.kts and it didn't work.
org.gradle.jvmargs = listOf(
"--add-exports javafx.graphics/com.sun.javafx.tk=com.sampleapp"
)
I was able to solve the issue by adding:
tasks.withType<JavaCompile> {
options.compilerArgs.addAll(arrayOf(
"--add-exports", "javafx.graphics/com.sun.javafx.tk=com.sampleapp"
))
}
This article describes an interesting feature of Gradle 4.10+ called a source dependency:
https://blog.gradle.org/introducing-source-dependencies
It allows to use a Git (for example a GitHub) source code repository to build a dependency from it. However it seems like it supports only Gradle projects as source dependencies. Is it possible to use a Maven project as well and if it's possible, please show an example.
When I try to use this feature with Maven project Gradle tries to find the build.gradle file there anyway (I see it when run Gradle with the --info option) and fails with an error message like:
Git repository at https://github.com/something/something.git did not contain a project publishing the specified dependency.
The short answer
... is: "no".
Under the hood, source dependencies are composite builds. These needs to be Gradle projects as the external projects are sort of merged with the main project.
The long answer
... is: "yes but it is hard".
It is actually mentioned in the same blog post you linked to (emphasis mine):
Source dependencies make these use cases simpler to implement. Gradle takes care of automatically checking out the correct versions of dependencies, making sure the binaries are built when required. It does this everywhere that the build is run. The checked out project doesn’t even need to have an existing Gradle build. This example shows a Gradle build consuming two source dependencies that have no build system by injecting a Gradle build via plugins. The injected configuration could do anything a regular Gradle plugin can do, such as wrapping an existing CMake or Maven build.
Because it sounded like it wasn't the biggest thing in the world to create bridge between a Maven and a Gradle project in source dependencies, I gave it a shot. And I have it working except for transitive dependencies. You will basically need to do what is shown in the examples linked to above, but instead of building native libraries, you make a call-out to Maven (e.g. using a Maven plugin for Gradle).
However, the scripts I ended up with are complex enough that I would suggest you instead build the Maven project yourself, deploy it to a local Maven repository and then add that repository to the Gradle project.
<edit>
The loooooooong answer
Alright, so here is how to actually do it. The feature is poorly documented, and appears to be mostly targeted towards native projects (like C++ or Swift).
Root project setup
Take a normal Gradle project with the Java plugin applied. I did a "gradle init" in an empty folder. Assume that in this project, you are depending on a library called `` that you later want to include as a source dependency:
// [root]/build.gradle
dependencies {
implementation 'org.example:my-maven-project:1.1'
}
Note that the version number defined here must match a Git tag in the repository. This is the code revision that will be checkout out.
Then in the settings file, we define a source dependency mapping for it:
// [root]/settings.gradle
rootProject.name = 'my-project'
includeBuild('plugins') // [1]
sourceControl {
gitRepository("https://github.com/jitpack/maven-simple") { // [2]
producesModule("org.example:my-maven-project") // [3]
plugins {
id "external-maven-build" // [4]
}
}
}
[1]: This includes a Gradle project called plugins that will be explained later.
[2]: This is just an arbitrary Maven project that I found, which was relatively simple. Substitute with the actual repository you have.
[3]: This is the name of the Maven module (the same as in the dependency block) that we are defining a source build for
[4]: This defines a custom settings plugin called external-maven-build that is defined in the plugins project, which will be explained later.
Plugins project structure
Inside the root project, we define a new Gradle project. Again, you can use gradle init to initialize it as a Groovy (or whatever you like) project. Delete all generated sources and tests.
// [root]/plugins/settings.gradle
// Empty, but used to mark this as a stand-alone project (and not part of a multi-build)
// [root]/plugins/build.gradle
plugins {
id 'groovy'
id 'java-gradle-plugin' // [1]
}
repositories {
gradlePluginPortal() // [2]
}
dependencies {
implementation "gradle.plugin.com.github.dkorotych.gradle.maven.exec:gradle-maven-exec-plugin:2.2.1" // [3]
}
gradlePlugin {
plugins {
"external-maven-build" { // [4]
id = "external-maven-build"
implementationClass = "org.example.ExternalMavenBuilder"
}
}
}
[1]: In this project, we are defining a new Gradle plugin. This is a standard way to do that.
[2]: To invoke Maven, I am using another 3rd party plugin, so we need to add the Gradle plugin portal as a repository.
[3]: This is the plugin used to invoke Maven. I am not too familiar with it, and I don't know how production ready it is. One thing I noticed is that it does not model inputs and outputs, so there are no built-in support for up-to-date checking. But this can be added retrospectively.
[4]: This defines the custom plugin. Notice that it has the same ID as used in the settings file in the root project.
Plugin implementation class
Now comes the fun stuff. I chose to do it in Groovy, but it can be done in any supported JVM languages of cause.
The plugin structure is just like any other Gradle plugin. One thing to note is that it is a Settings plugin, whereas you normally do Project plugins. This is needed as it we are basically defining a Gradle project at run-time, which needs to be done as part of the initialization phase.
// [root]/plugins/src/main/groovy/org/example/ExternalMavenBuilder.groovy
package org.example
import com.github.dkorotych.gradle.maven.exec.MavenExec
import org.gradle.api.Plugin
import org.gradle.api.artifacts.ConfigurablePublishArtifact
import org.gradle.api.initialization.Settings
class ExternalMavenBuilder implements Plugin<Settings> {
void apply(Settings settings) {
settings.with {
rootProject.name = 'my-maven-project' // [1]
gradle.rootProject {
group = "org.example" //[2]
pluginManager.apply("base") // [3]
pluginManager.apply("com.github.dkorotych.gradle-maven-exec") // [4]
def mavenBuild = tasks.register("mavenBuild", MavenExec) {
goals('clean', 'package') // [5]
}
artifacts.add("default", file("$projectDir/target/maven-simple-0.2-SNAPSHOT.jar")) { ConfigurablePublishArtifact a ->
a.builtBy(mavenBuild) // [6]
}
}
}
}
}
[1]: Must match the Maven module name
[2]: Must match the Maven module group
[3]: Defines tasks like "build" and "clean"
[4]: The 3rd party plugin that makes it more easy to invoke Maven
[5]: For options, see https://github.com/dkorotych/gradle-maven-exec-plugin
[6]: Adds the Maven output as an artifact in the "default" configuration
Be aware that it does not model transitive dependencies, and it is never up-to-date due to missing inputs and outputs.
This is as far as I got with a few hours of playing around with it. I think it can be generalized into a generic plugin published to the Gradle portal. But I think I have too much on my plate as it is already. If anyone would like to continue on from here, you have my blessing :)
I've been creating my own gradle plugin for the last few days (partly for learning, and partly to clean up some gradle build scripts I have laying around), however I've run into a problem that I can't figure out how to fix. In my plugin jar there is an interface named me.alxandr.gradle.bintray.maven.MavenPackage, yet when I try to import it I get an error saying that it can't be found. This is really weird, because the plugin is obviously running (I'm seeing output from it, and it's tasks are registering).
Currently I've done a hack to get around this as following:
project.ext.MavenPackage = MavenPackage
This just makes MavenPackage an available name in the buildscript, which works, but I loose any editor support for it cause it's entirely dynamic. Is there any way I can (from my plugin) get the buildscript to import a package when it's applied? Like how MavenPublication is in scope without me needing to import it. If not, why can I not import classes from my plugin package?
The entire source code is available at https://github.com/Alxandr/gradle-utils. You can see an attempted here: https://github.com/Alxandr/gradle-utils/blob/master/gradle/publish.gradle#L1. The current code works as is (with the hack explained above), but I'm just looking for a better way to do this.
In order to use a class from your plugin in your Gradle script, you must add the plugin JAR to the buildscript classpath.
Here's how to do just that:
buildscript {
repositories { /* where to get your plugin jar from, e.g. mavenLocal() */ }
dependencies {
classpath 'some_group:me.alxandr.plugin:1.0.0'
}
}
import me.alxandr.gradle.bintray.maven.MavenPackage
You can find more information in the Gradle User Guide about using external dependencies in your build script