配置

.level = INFO
handlers=java.util.logging.ConsoleHandler

# The handler must be configured for the lowest level it should catch
java.util.logging.ConsoleHandler.level=FINEST

# Enables all Logging for the JDBC Driver
org.neo4j.jdbc.level=ALL
# But reduces the noise on the network and the result set
org.neo4j.jdbc.result-set.level=WARNING
org.neo4j.jdbc.network.level=WARNING
# This is an example how to configure the outbound and inbound messages
org.neo4j.jdbc.network.OutboundMessageHandler.level=FINE
org.neo4j.jdbc.network.InboundMessageHandler.level=FINE

# This produces a date, followed by the level, 3 dashes, the message and the source of the log if available
java.util.logging.SimpleFormatter.format = %1$tFT%1$tk:%1$tM:%1$tS.%1$tL%1$tz %4$-15s --- %5$s [%2$s]%n

java -Djava.util.logging.config.file=docs/src/main/resources/logging-to-console.properties <your program>

.level = INFO
handlers=java.util.logging.ConsoleHandler

# Keep everything by default at INFO
java.util.logging.ConsoleHandler.level=INFO

# The handler must be configured for the lowest level it should catch
java.util.logging.FileHandler.level=FINEST
java.util.logging.FileHandler.pattern=jdbc.log
# XML Format by default
# java.util.logging.FileHandler.formatter=java.util.logging.SimpleFormatter

# Change the handler for JDBC
org.neo4j.jdbc.handlers=java.util.logging.FileHandler
# Keep the rest as above
org.neo4j.jdbc.level=ALL
org.neo4j.jdbc.result-set.level=WARNING
org.neo4j.jdbc.network.level=WARNING
org.neo4j.jdbc.network.OutboundMessageHandler.level=FINE
org.neo4j.jdbc.network.InboundMessageHandler.level=FINE

java.util.logging.SimpleFormatter.format = %1$tFT%1$tk:%1$tM:%1$tS.%1$tL%1$tz %4$-15s --- %5$s [%2$s]%n

logging.level.org.neo4j.jdbc=trace
logging.level.org.neo4j.jdbc.result-set=warn
logging.level.org.neo4j.jdbc.network=warn
logging.level.org.neo4j.jdbc.network.OutboundMessageHandler=debug
logging.level.org.neo4j.jdbc.network.InboundMessageHandler=debug

quarkus.log.category."org.neo4j.jdbc".min-level=TRACE
quarkus.log.category."org.neo4j.jdbc".level=TRACE
quarkus.log.category."org.neo4j.jdbc.result-set".level=DEBUG
quarkus.log.category."org.neo4j.jdbc.network".level=WARNING
quarkus.log.category."org.neo4j.jdbc.network.OutboundMessageHandler".level=DEBUG
quarkus.log.category."org.neo4j.jdbc.network.InboundMessageHandler".level=DEBUG

import io.micrometer.tracing.Tracer;
import org.neo4j.jdbc.tracing.micrometer.Neo4jTracingBridge;

import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class TracingConfiguration {

    @Bean
    InitializingBean neo4jTracingInitializer(Tracer tracer) {
        return () -> Neo4jDriver.registerTracer(Neo4jTracingBridge.to(tracer));
    }
}

import java.io.IOException;
import java.io.UncheckedIOException;
import java.time.Instant;
import java.util.Base64;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Supplier;

import com.fasterxml.jackson.jr.ob.JSON;
import org.keycloak.authorization.client.AuthzClient;
import org.keycloak.authorization.client.Configuration;
import org.keycloak.authorization.client.util.Http;
import org.keycloak.representations.AccessTokenResponse;
import org.neo4j.jdbc.authn.spi.Authentication;

public final class KCAuthenticationSupplier implements Supplier<Authentication> {

    public static Supplier<Authentication> of(String user, String password, Configuration configuration) {
        return new KCAuthenticationSupplier(user, password, configuration);
    }

    private final String username;

    private final String password;

    private final Configuration cfg;

    private final AuthzClient authzClient;

    private final Http http;

    private final String url;

    private final AtomicReference<TokensAndExpirationTime> currentToken = new AtomicReference<>();

    KCAuthenticationSupplier(String user, String password, Configuration cfg) {
        this.username = user;
        this.password = password;
        this.cfg = cfg;
        this.authzClient = AuthzClient.create(cfg);
        this.url = "%s/realms/%s/protocol/openid-connect/token".formatted(cfg.getAuthServerUrl(), cfg.getRealm());
        this.http = new Http(cfg, cfg.getClientCredentialsProvider());
    }

    @Override
    public Authentication get() {
        return this.currentToken.updateAndGet(previous -> {
            if (previous == null) {
                return get0();
            }
            return refresh0(previous.refreshToken());
        }).toAuthentication();
    }

    TokensAndExpirationTime get0() {
        try {
            return TokensAndExpirationTime.of(this.authzClient.obtainAccessToken(this.username, this.password));
        }
        catch (IOException ex) {
            throw new UncheckedIOException(ex);
        }
    }

    TokensAndExpirationTime refresh0(String refreshToken) {
        try {
            return TokensAndExpirationTime.of(this.http.<AccessTokenResponse>post(this.url)
                .authentication()
                .client()
                .form()
                .param("grant_type", "refresh_token")
                .param("refresh_token", refreshToken)
                .param("client_id", this.cfg.getResource())
                .param("client_secret", (String) this.cfg.getCredentials().get("secret"))
                .response()
                .json(AccessTokenResponse.class)
                .execute());
        }
        catch (IOException ex) {
            throw new UncheckedIOException(ex);
        }
    }

    record TokensAndExpirationTime(String accessToken, Instant expiresAt, String refreshToken) {

        static final Base64.Decoder DECODER = Base64.getDecoder();

        static TokensAndExpirationTime of(AccessTokenResponse accessTokenResponse) throws IOException {
            var chunks = accessTokenResponse.getToken().split("\\.");
            var payload = JSON.std.mapFrom(DECODER.decode(chunks[1]));
            var exp = Instant.ofEpochSecond(((Number) payload.get("exp")).longValue());
            return new TokensAndExpirationTime(accessTokenResponse.getToken(), exp,
                    accessTokenResponse.getRefreshToken());
        }

        Authentication toAuthentication() {
            return Authentication.bearer(this.accessToken, this.expiresAt);
        }

    }

}

<dependency>
    <groupId>org.neo4j</groupId>
    <artifactId>neo4j-jdbc-authn-kc</artifactId>
    <version>6.9.1</version>
</dependency>

@Test
void authenticationSupplierFactoriesShouldWork() throws SQLException {

    var properties = new Properties();
    properties.put("enableSQLTranslation", "true");

    properties.put("user", "william.foster");
    properties.put("password", "d-fens");

    properties.put("authn.supplier", "kc"); (1)
    properties.put("authn.kc.authServerUrl", "https://:%d".formatted(KEYCLOAK.getHttpPort())); (2)
    properties.put("authn.kc.realm", "neo4j-sso-test");
    properties.put("authn.kc.clientId", "neo4j-jdbc-driver");
    properties.put("authn.kc.clientSecret", "QcWXnTg8qJpVMnIvm8Ev8gp1PqJitZu4");

    try (var connection = DriverManager.getConnection(neo4jUri, properties); (3)
            var stmt = connection.createStatement();
            var rs = stmt.executeQuery("SELECT 1")) {
        assertThat(rs.next()).isTrue();
        assertThat(rs.getInt(1)).isOne();
    }
}

import java.sql.Connection;
import java.sql.DriverManager;
import java.util.function.Supplier;

import org.keycloak.authorization.client.Configuration;
import org.neo4j.jdbc.authn.kc.KCAuthenticationSupplier;
import org.neo4j.jdbc.authn.spi.Authentication;
import org.neo4j.jdbc.Neo4jDriver;

class Example {

	public static void main(String...a) throws Exception {
		Supplier<Authentication> authenticationSupplier = KCAuthenticationSupplier.of("user", "pass", new Configuration());
        Neo4jDriver.registerAuthenticationSupplier(authenticationSupplier);
        Connection connection = DriverManager.getConnection("neo4j+s://xyz.databases.neo4j.io");
    }
}

import java.sql.Connection;
import java.sql.DriverManager;
import java.util.Properties;
import java.util.function.Supplier;

import org.keycloak.authorization.client.Configuration;
import org.neo4j.jdbc.authn.kc.KCAuthenticationSupplier;
import org.neo4j.jdbc.authn.spi.Authentication;
import org.neo4j.jdbc.Neo4jDriver;

class Example {

    public static void main(String...a) throws Exception {
        Supplier<Authentication> authenticationSupplier = KCAuthenticationSupplier.of("user", "pass", new Configuration());
        Neo4jDriver.registerAuthenticationSupplier(authenticationSupplier);
        Neo4jDriver driver = new Neo4jDriver();
        Connection connection = driver.connect("neo4j+s://xyz.databases.neo4j.io", new Properties(), authenticationSupplier);
    }
}