You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@flink.apache.org by fa...@apache.org on 2024/04/25 01:29:19 UTC

(flink-connector-jdbc) branch main updated: [FLINK-33460][Connector/JDBC] Support property authentication connection. (#115)

This is an automated email from the ASF dual-hosted git repository.

fanrui pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/flink-connector-jdbc.git


The following commit(s) were added to refs/heads/main by this push:
     new bb43b3c1 [FLINK-33460][Connector/JDBC] Support property authentication connection. (#115)
bb43b3c1 is described below

commit bb43b3c18fda6a2e587b3a3941d697803fe86441
Author: Yuepeng Pan <fl...@126.com>
AuthorDate: Thu Apr 25 09:29:15 2024 +0800

    [FLINK-33460][Connector/JDBC] Support property authentication connection. (#115)
---
 .../connector/jdbc/JdbcConnectionOptions.java      | 47 +++++++++++++++-------
 .../connections/JdbcConnectionProvider.java        | 12 ++++++
 .../connections/SimpleJdbcConnectionProvider.java  | 18 ++++-----
 .../options/InternalJdbcConnectionOptions.java     | 43 ++++++++++++--------
 .../connector/jdbc/source/JdbcSourceBuilder.java   |  7 ++++
 .../connector/jdbc/JdbcConnectionOptionsTest.java  | 29 +++++++++++++
 .../SimpleJdbcConnectionProviderTest.java          | 44 ++++++++++++++++++++
 7 files changed, 160 insertions(+), 40 deletions(-)

diff --git a/flink-connector-jdbc/src/main/java/org/apache/flink/connector/jdbc/JdbcConnectionOptions.java b/flink-connector-jdbc/src/main/java/org/apache/flink/connector/jdbc/JdbcConnectionOptions.java
index e6824448..85b12951 100644
--- a/flink-connector-jdbc/src/main/java/org/apache/flink/connector/jdbc/JdbcConnectionOptions.java
+++ b/flink-connector-jdbc/src/main/java/org/apache/flink/connector/jdbc/JdbcConnectionOptions.java
@@ -20,35 +20,39 @@ package org.apache.flink.connector.jdbc;
 import org.apache.flink.annotation.PublicEvolving;
 import org.apache.flink.util.Preconditions;
 
+import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
 import java.io.Serializable;
+import java.util.Objects;
 import java.util.Optional;
+import java.util.Properties;
 
 /** JDBC connection options. */
 @PublicEvolving
 public class JdbcConnectionOptions implements Serializable {
 
+    public static final String USER_KEY = "user";
+    public static final String PASSWORD_KEY = "password";
+
     private static final long serialVersionUID = 1L;
 
     protected final String url;
     @Nullable protected final String driverName;
     protected final int connectionCheckTimeoutSeconds;
-    @Nullable protected final String username;
-    @Nullable protected final String password;
+    @Nonnull protected final Properties properties;
 
     protected JdbcConnectionOptions(
             String url,
             @Nullable String driverName,
-            @Nullable String username,
-            @Nullable String password,
-            int connectionCheckTimeoutSeconds) {
+            int connectionCheckTimeoutSeconds,
+            @Nonnull Properties properties) {
         Preconditions.checkArgument(connectionCheckTimeoutSeconds > 0);
         this.url = Preconditions.checkNotNull(url, "jdbc url is empty");
         this.driverName = driverName;
-        this.username = username;
-        this.password = password;
         this.connectionCheckTimeoutSeconds = connectionCheckTimeoutSeconds;
+        this.properties =
+                Preconditions.checkNotNull(properties, "Connection properties must be non-null");
     }
 
     public String getDbURL() {
@@ -61,24 +65,28 @@ public class JdbcConnectionOptions implements Serializable {
     }
 
     public Optional<String> getUsername() {
-        return Optional.ofNullable(username);
+        return Optional.ofNullable(properties.getProperty(USER_KEY));
     }
 
     public Optional<String> getPassword() {
-        return Optional.ofNullable(password);
+        return Optional.ofNullable(properties.getProperty(PASSWORD_KEY));
     }
 
     public int getConnectionCheckTimeoutSeconds() {
         return connectionCheckTimeoutSeconds;
     }
 
+    @Nonnull
+    public Properties getProperties() {
+        return properties;
+    }
+
     /** Builder for {@link JdbcConnectionOptions}. */
     public static class JdbcConnectionOptionsBuilder {
         private String url;
         private String driverName;
-        private String username;
-        private String password;
         private int connectionCheckTimeoutSeconds = 60;
+        private final Properties properties = new Properties();
 
         public JdbcConnectionOptionsBuilder withUrl(String url) {
             this.url = url;
@@ -90,13 +98,24 @@ public class JdbcConnectionOptions implements Serializable {
             return this;
         }
 
+        public JdbcConnectionOptionsBuilder withProperty(String propKey, String propVal) {
+            Preconditions.checkNotNull(propKey, "Connection property key mustn't be null");
+            Preconditions.checkNotNull(propVal, "Connection property value mustn't be null");
+            this.properties.put(propKey, propVal);
+            return this;
+        }
+
         public JdbcConnectionOptionsBuilder withUsername(String username) {
-            this.username = username;
+            if (Objects.nonNull(username)) {
+                this.properties.put(USER_KEY, username);
+            }
             return this;
         }
 
         public JdbcConnectionOptionsBuilder withPassword(String password) {
-            this.password = password;
+            if (Objects.nonNull(password)) {
+                this.properties.put(PASSWORD_KEY, password);
+            }
             return this;
         }
 
@@ -114,7 +133,7 @@ public class JdbcConnectionOptions implements Serializable {
 
         public JdbcConnectionOptions build() {
             return new JdbcConnectionOptions(
-                    url, driverName, username, password, connectionCheckTimeoutSeconds);
+                    url, driverName, connectionCheckTimeoutSeconds, properties);
         }
     }
 }
diff --git a/flink-connector-jdbc/src/main/java/org/apache/flink/connector/jdbc/datasource/connections/JdbcConnectionProvider.java b/flink-connector-jdbc/src/main/java/org/apache/flink/connector/jdbc/datasource/connections/JdbcConnectionProvider.java
index 0bddb39c..81c6bccb 100644
--- a/flink-connector-jdbc/src/main/java/org/apache/flink/connector/jdbc/datasource/connections/JdbcConnectionProvider.java
+++ b/flink-connector-jdbc/src/main/java/org/apache/flink/connector/jdbc/datasource/connections/JdbcConnectionProvider.java
@@ -19,11 +19,13 @@ package org.apache.flink.connector.jdbc.datasource.connections;
 
 import org.apache.flink.annotation.PublicEvolving;
 
+import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
 import java.io.Serializable;
 import java.sql.Connection;
 import java.sql.SQLException;
+import java.util.Properties;
 
 /** JDBC connection provider. */
 @PublicEvolving
@@ -36,6 +38,16 @@ public interface JdbcConnectionProvider extends Serializable, AutoCloseable {
     @Nullable
     Connection getConnection();
 
+    /**
+     * Get existing connection properties.
+     *
+     * @return existing connection properties
+     */
+    @Nonnull
+    default Properties getProperties() {
+        throw new UnsupportedOperationException();
+    }
+
     /**
      * Check whether possible existing connection is valid or not through {@link
      * Connection#isValid(int)}.
diff --git a/flink-connector-jdbc/src/main/java/org/apache/flink/connector/jdbc/datasource/connections/SimpleJdbcConnectionProvider.java b/flink-connector-jdbc/src/main/java/org/apache/flink/connector/jdbc/datasource/connections/SimpleJdbcConnectionProvider.java
index 6663faaa..811210af 100644
--- a/flink-connector-jdbc/src/main/java/org/apache/flink/connector/jdbc/datasource/connections/SimpleJdbcConnectionProvider.java
+++ b/flink-connector-jdbc/src/main/java/org/apache/flink/connector/jdbc/datasource/connections/SimpleJdbcConnectionProvider.java
@@ -24,6 +24,7 @@ import org.apache.flink.util.Preconditions;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import javax.annotation.Nonnull;
 import javax.annotation.concurrent.NotThreadSafe;
 
 import java.io.Serializable;
@@ -69,6 +70,12 @@ public class SimpleJdbcConnectionProvider implements JdbcConnectionProvider, Ser
         return connection;
     }
 
+    @Nonnull
+    @Override
+    public Properties getProperties() {
+        return jdbcOptions.getProperties();
+    }
+
     @Override
     public boolean isConnectionValid() throws SQLException {
         return connection != null
@@ -109,17 +116,10 @@ public class SimpleJdbcConnectionProvider implements JdbcConnectionProvider, Ser
             return connection;
         }
         if (jdbcOptions.getDriverName() == null) {
-            connection =
-                    DriverManager.getConnection(
-                            jdbcOptions.getDbURL(),
-                            jdbcOptions.getUsername().orElse(null),
-                            jdbcOptions.getPassword().orElse(null));
+            connection = DriverManager.getConnection(jdbcOptions.getDbURL(), getProperties());
         } else {
             Driver driver = getLoadedDriver();
-            Properties info = new Properties();
-            jdbcOptions.getUsername().ifPresent(user -> info.setProperty("user", user));
-            jdbcOptions.getPassword().ifPresent(password -> info.setProperty("password", password));
-            connection = driver.connect(jdbcOptions.getDbURL(), info);
+            connection = driver.connect(jdbcOptions.getDbURL(), getProperties());
             if (connection == null) {
                 // Throw same exception as DriverManager.getConnection when no driver found to match
                 // caller expectation.
diff --git a/flink-connector-jdbc/src/main/java/org/apache/flink/connector/jdbc/internal/options/InternalJdbcConnectionOptions.java b/flink-connector-jdbc/src/main/java/org/apache/flink/connector/jdbc/internal/options/InternalJdbcConnectionOptions.java
index 8158cd8c..2083b437 100644
--- a/flink-connector-jdbc/src/main/java/org/apache/flink/connector/jdbc/internal/options/InternalJdbcConnectionOptions.java
+++ b/flink-connector-jdbc/src/main/java/org/apache/flink/connector/jdbc/internal/options/InternalJdbcConnectionOptions.java
@@ -22,11 +22,14 @@ import org.apache.flink.annotation.Internal;
 import org.apache.flink.connector.jdbc.JdbcConnectionOptions;
 import org.apache.flink.connector.jdbc.dialect.JdbcDialect;
 import org.apache.flink.connector.jdbc.dialect.JdbcDialectLoader;
+import org.apache.flink.util.Preconditions;
 
+import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
 import java.util.Objects;
 import java.util.Optional;
+import java.util.Properties;
 
 import static org.apache.flink.util.Preconditions.checkNotNull;
 
@@ -44,12 +47,11 @@ public class InternalJdbcConnectionOptions extends JdbcConnectionOptions {
             String dbURL,
             String tableName,
             @Nullable String driverName,
-            @Nullable String username,
-            @Nullable String password,
             JdbcDialect dialect,
             @Nullable Integer parallelism,
-            int connectionCheckTimeoutSeconds) {
-        super(dbURL, driverName, username, password, connectionCheckTimeoutSeconds);
+            int connectionCheckTimeoutSeconds,
+            @Nonnull Properties properties) {
+        super(dbURL, driverName, connectionCheckTimeoutSeconds, properties);
         this.tableName = tableName;
         this.dialect = dialect;
         this.parallelism = parallelism;
@@ -78,13 +80,12 @@ public class InternalJdbcConnectionOptions extends JdbcConnectionOptions {
             return Objects.equals(url, options.url)
                     && Objects.equals(tableName, options.tableName)
                     && Objects.equals(driverName, options.driverName)
-                    && Objects.equals(username, options.username)
-                    && Objects.equals(password, options.password)
                     && Objects.equals(
                             dialect.getClass().getName(), options.dialect.getClass().getName())
                     && Objects.equals(parallelism, options.parallelism)
                     && Objects.equals(
-                            connectionCheckTimeoutSeconds, options.connectionCheckTimeoutSeconds);
+                            connectionCheckTimeoutSeconds, options.connectionCheckTimeoutSeconds)
+                    && Objects.equals(properties, options.properties);
         } else {
             return false;
         }
@@ -96,11 +97,10 @@ public class InternalJdbcConnectionOptions extends JdbcConnectionOptions {
                 url,
                 tableName,
                 driverName,
-                username,
-                password,
                 dialect.getClass().getName(),
                 parallelism,
-                connectionCheckTimeoutSeconds);
+                connectionCheckTimeoutSeconds,
+                properties);
     }
 
     /** Builder of {@link InternalJdbcConnectionOptions}. */
@@ -110,11 +110,10 @@ public class InternalJdbcConnectionOptions extends JdbcConnectionOptions {
         private String tableName;
         private String driverName;
         private String compatibleMode;
-        private String username;
-        private String password;
         private JdbcDialect dialect;
         private Integer parallelism;
         private int connectionCheckTimeoutSeconds = 60;
+        private final Properties properties = new Properties();
 
         /**
          * optional, specifies the classloader to use in the planner for load the class in user jar.
@@ -137,13 +136,17 @@ public class InternalJdbcConnectionOptions extends JdbcConnectionOptions {
 
         /** optional, user name. */
         public Builder setUsername(String username) {
-            this.username = username;
+            if (Objects.nonNull(username)) {
+                this.properties.put(USER_KEY, username);
+            }
             return this;
         }
 
         /** optional, password. */
         public Builder setPassword(String password) {
-            this.password = password;
+            if (Objects.nonNull(password)) {
+                this.properties.put(PASSWORD_KEY, password);
+            }
             return this;
         }
 
@@ -188,6 +191,13 @@ public class InternalJdbcConnectionOptions extends JdbcConnectionOptions {
             return this;
         }
 
+        public Builder setProperty(String propKey, String propVal) {
+            Preconditions.checkNotNull(propKey, "Connection property key mustn't be null");
+            Preconditions.checkNotNull(propVal, "Connection property value mustn't be null");
+            this.properties.put(propKey, propVal);
+            return this;
+        }
+
         public InternalJdbcConnectionOptions build() {
             checkNotNull(dbURL, "No dbURL supplied.");
             checkNotNull(tableName, "No tableName supplied.");
@@ -208,11 +218,10 @@ public class InternalJdbcConnectionOptions extends JdbcConnectionOptions {
                     dialect.appendDefaultUrlProperties(dbURL),
                     tableName,
                     driverName,
-                    username,
-                    password,
                     dialect,
                     parallelism,
-                    connectionCheckTimeoutSeconds);
+                    connectionCheckTimeoutSeconds,
+                    properties);
         }
     }
 }
diff --git a/flink-connector-jdbc/src/main/java/org/apache/flink/connector/jdbc/source/JdbcSourceBuilder.java b/flink-connector-jdbc/src/main/java/org/apache/flink/connector/jdbc/source/JdbcSourceBuilder.java
index 39d90460..17e3eb27 100644
--- a/flink-connector-jdbc/src/main/java/org/apache/flink/connector/jdbc/source/JdbcSourceBuilder.java
+++ b/flink-connector-jdbc/src/main/java/org/apache/flink/connector/jdbc/source/JdbcSourceBuilder.java
@@ -180,6 +180,13 @@ public class JdbcSourceBuilder<OUT> {
 
     // ------ Optional ------------------------------------------------------------------
 
+    public JdbcSourceBuilder<OUT> setConnectionProperty(String propKey, String propVal) {
+        Preconditions.checkNotNull(propKey, "Connection property key mustn't be null");
+        Preconditions.checkNotNull(propVal, "Connection property value mustn't be null");
+        connOptionsBuilder.withProperty(propKey, propVal);
+        return this;
+    }
+
     public JdbcSourceBuilder<OUT> setJdbcParameterValuesProvider(
             @Nonnull JdbcParameterValuesProvider parameterValuesProvider) {
         this.jdbcParameterValuesProvider = Preconditions.checkNotNull(parameterValuesProvider);
diff --git a/flink-connector-jdbc/src/test/java/org/apache/flink/connector/jdbc/JdbcConnectionOptionsTest.java b/flink-connector-jdbc/src/test/java/org/apache/flink/connector/jdbc/JdbcConnectionOptionsTest.java
index 985f05a1..bdfa177b 100644
--- a/flink-connector-jdbc/src/test/java/org/apache/flink/connector/jdbc/JdbcConnectionOptionsTest.java
+++ b/flink-connector-jdbc/src/test/java/org/apache/flink/connector/jdbc/JdbcConnectionOptionsTest.java
@@ -21,6 +21,8 @@ import org.apache.flink.connector.jdbc.fakedb.FakeDBUtils;
 
 import org.junit.jupiter.api.Test;
 
+import static org.apache.flink.connector.jdbc.JdbcConnectionOptions.USER_KEY;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 /** Tests for {@link JdbcConnectionOptions}. */
@@ -58,4 +60,31 @@ class JdbcConnectionOptionsTest {
                                         .build())
                 .isInstanceOf(IllegalArgumentException.class);
     }
+
+    @Test
+    void testConnectionProperty() {
+        // test for null connection properties
+        JdbcConnectionOptions options =
+                new JdbcConnectionOptions.JdbcConnectionOptionsBuilder()
+                        .withUrl(FakeDBUtils.TEST_DB_URL)
+                        .build();
+        assertThat(options.getProperties()).isEmpty();
+
+        // test for useful connection properties
+        options =
+                new JdbcConnectionOptions.JdbcConnectionOptionsBuilder()
+                        .withUrl(FakeDBUtils.TEST_DB_URL)
+                        .withProperty("keyA", "valueA")
+                        .build();
+        assertThat(options.getProperties()).hasSize(1);
+
+        options =
+                new JdbcConnectionOptions.JdbcConnectionOptionsBuilder()
+                        .withUrl(FakeDBUtils.TEST_DB_URL)
+                        .withUsername("user")
+                        .withProperty("keyA", "valueA")
+                        .build();
+        assertThat(options.getProperties()).hasSize(2);
+        assertThat(options.getProperties()).hasFieldOrPropertyWithValue(USER_KEY, "user");
+    }
 }
diff --git a/flink-connector-jdbc/src/test/java/org/apache/flink/connector/jdbc/internal/connection/SimpleJdbcConnectionProviderTest.java b/flink-connector-jdbc/src/test/java/org/apache/flink/connector/jdbc/internal/connection/SimpleJdbcConnectionProviderTest.java
index 1b621eb4..1ef7786e 100644
--- a/flink-connector-jdbc/src/test/java/org/apache/flink/connector/jdbc/internal/connection/SimpleJdbcConnectionProviderTest.java
+++ b/flink-connector-jdbc/src/test/java/org/apache/flink/connector/jdbc/internal/connection/SimpleJdbcConnectionProviderTest.java
@@ -36,6 +36,8 @@ import java.util.Collections;
 import java.util.Set;
 import java.util.stream.Collectors;
 
+import static org.apache.flink.connector.jdbc.JdbcConnectionOptions.PASSWORD_KEY;
+import static org.apache.flink.connector.jdbc.JdbcConnectionOptions.USER_KEY;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
@@ -180,4 +182,46 @@ class SimpleJdbcConnectionProviderTest {
         assertThat(connection1.isClosed()).isTrue();
         assertThat(connection2).isNotSameAs(connection1);
     }
+
+    @Test
+    void testConnectionProperties() throws Exception {
+        SimpleJdbcConnectionProvider provider;
+        JdbcConnectionOptions options;
+
+        // test for null connection properties
+        options =
+                new JdbcConnectionOptions.JdbcConnectionOptionsBuilder()
+                        .withUrl(FakeDBUtils.TEST_DB_URL)
+                        .withDriverName(FakeDBUtils.DRIVER1_CLASS_NAME)
+                        .build();
+        provider = new SimpleJdbcConnectionProvider(options);
+        assertThat(provider.getProperties()).isEmpty();
+        provider.close();
+
+        // test for useful connection properties
+        options =
+                new JdbcConnectionOptions.JdbcConnectionOptionsBuilder()
+                        .withUrl(FakeDBUtils.TEST_DB_URL)
+                        .withDriverName(FakeDBUtils.DRIVER1_CLASS_NAME)
+                        .withProperty("ka", "va")
+                        .build();
+        provider = new SimpleJdbcConnectionProvider(options);
+        assertThat(provider.getProperties()).hasSize(1);
+        provider.close();
+
+        // test for username & password with connection properties
+        options =
+                new JdbcConnectionOptions.JdbcConnectionOptionsBuilder()
+                        .withUrl(FakeDBUtils.TEST_DB_URL)
+                        .withDriverName(FakeDBUtils.DRIVER1_CLASS_NAME)
+                        .withProperty("ka", "va")
+                        .withUsername("user")
+                        .withPassword("pwd")
+                        .build();
+        provider = new SimpleJdbcConnectionProvider(options);
+        assertThat(provider.getProperties()).hasSize(3);
+        assertThat(provider.getProperties()).hasFieldOrPropertyWithValue(USER_KEY, "user");
+        assertThat(provider.getProperties()).hasFieldOrPropertyWithValue(PASSWORD_KEY, "pwd");
+        provider.close();
+    }
 }