Gradle自定义数据库插件如何获取项目JDBC驱动依赖包

Hey there! I get that you're new to Gradle plugin development and stuck on accessing the JDBC driver JAR from the project that uses your plugin. Let's fix this step by step—your current approach is on the right track, but we can make it more reliable and functional.

First, Let's Fix the Dependency Targeting #

Instead of looping through all project configurations (which is inefficient and risky), we'll create a dedicated configuration in your plugin. This lets users explicitly declare their JDBC driver dependencies for your plugin to use.

1. Add the dedicated configuration in your plugin class
   In your plugin's main class (like GradleDatabasePlugin), create a named configuration so users can attach their JDBC drivers to it:

   public class GradleDatabasePlugin implements Plugin<Project> {
       @Override
       public void apply(Project project) {
           // Create a dedicated configuration for JDBC drivers
           Configuration jdbcDriversConfig = project.getConfigurations().create("jdbcDrivers");
           // Register your extension and task as before
           project.getExtensions().create("gradleDatabase", GradleDatabaseExstension.class);
           project.getTasks().create("createDatabase", CreateDatabaseTask.class);
       }
   }
   

2. Tell users to add drivers to this configuration
   When someone uses your plugin, they'll add their JDBC driver to the jdbcDrivers configuration in their build.gradle/build.gradle.kts:

   // For Groovy DSL
   dependencies {
       jdbcDrivers 'mysql:mysql-connector-java:8.0.33'
       // Or for PostgreSQL: 'org.postgresql:postgresql:42.6.0'
   }
   

Now, Update Your Task Code to Load the Driver Correctly #

Finding the JAR is only half the battle—you need to load the driver class into a classloader that Gradle can use for the database connection. Here's the revised CreateDatabaseTask:

package io.vincentpalazzo.gradledatabase.task;

import io.vincentpalazzo.gradledatabase.exstension.GradleDatabaseExstension;
import io.vincentpalazzo.gradledatabase.persistence.DataSurce;
import org.gradle.api.DefaultTask;
import org.gradle.api.artifacts.Configuration;
import org.gradle.api.tasks.TaskAction;

import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Set;
import java.io.File;

public class CreateDatabaseTask extends DefaultTask {

    @TaskAction
    public void createAction() {
        GradleDatabaseExstension extension = getProject().getExtensions().findByType(GradleDatabaseExstension.class);
        if (extension == null) {
            throw new IllegalStateException("gradleDatabase extension not found!");
        }

        String url = extension.getUrl();
        String driverClass = extension.getDriver();
        String username = extension.getUsername();
        String password = extension.getPassword();
        String nameDatabase = extension.getNameDatabase();

        // Get our dedicated JDBC driver configuration
        Configuration jdbcDriversConfig = getProject().getConfigurations().getByName("jdbcDrivers");
        Set<File> driverJars = jdbcDriversConfig.resolve();

        if (driverJars.isEmpty()) {
            throw new IllegalStateException("No JDBC drivers found in the 'jdbcDrivers' configuration. " +
                    "Please add your database driver dependency to this configuration.");
        }

        // Load the driver JARs into a custom classloader
        try {
            URL[] jarUrls = driverJars.stream()
                    .map(file -> {
                        try {
                            return file.toURI().toURL();
                        } catch (MalformedURLException e) {
                            throw new RuntimeException("Failed to convert JAR file to URL: " + file.getName(), e);
                        }
                    })
                    .toArray(URL[]::new);

            // Use a URLClassLoader that delegates to the plugin's classloader
            URLClassLoader driverClassLoader = new URLClassLoader(jarUrls, getClass().getClassLoader());
            // Explicitly load the driver class to register it with DriverManager
            Class.forName(driverClass, true, driverClassLoader);

        } catch (ClassNotFoundException e) {
            throw new RuntimeException("Could not load JDBC driver class: " + driverClass, e);
        }

        // Now proceed with your database connection
        DataSurce dataSource = new DataSurce();
        if (dataSource.connectionDatabase(driverClass, url, username, password)) {
            if (dataSource.createDatabese(nameDatabase)) {
                System.out.println("Database '" + nameDatabase + "' created successfully!");
            } else {
                System.out.println("Failed to create database '" + nameDatabase + "'.");
            }
        } else {
            System.out.println("Could not connect to the database server.");
        }
    }
}

Key Improvements Explained #

• Dedicated Configuration: Using jdbcDrivers ensures we only look at dependencies the user intended for your plugin, avoiding clutter and errors from unrelated JARs.
• Custom Classloader: Gradle separates plugin and project classloaders, so we need a URLClassLoader to load the driver JARs from the project into our plugin's context.
• Explicit Driver Loading: Calling Class.forName with our custom classloader ensures the JDBC driver is registered with DriverManager, which is required for establishing connections.

Why Your Original Code Had Issues #

• Looping through all configurations could pick up unintended JARs and is inefficient.
• You checked if the JAR exists, but didn't load the driver class—so even if the JAR was found, DriverManager wouldn't know about the driver.

内容的提问来源于stack exchange，提问作者vincenzopalazzo