Neo4j Spring Boot Starter

curl https://start.spring.io/starter.tgz \
  -d dependencies=web,actuator \
  -d bootVersion=2.3.12.RELEASE \
  -d baseDir=Neo4jSpringBootExample \
  -d name=Neo4j%20SpringBoot%20Example | tar -xzvf -

<dependency>
        <groupId>org.neo4j.driver</groupId>
        <artifactId>neo4j-java-driver-spring-boot-starter</artifactId>
        <version>4.3.6.0</version>
</dependency>

curl https://start.spring.io/starter.tgz \
  -d dependencies=web,actuator \
  -d type=gradle-project \
  -d bootVersion=2.3.12.RELEASE \
  -d baseDir=Neo4jSpringBootExampleGradle \
  -d name=Neo4j%20SpringBoot%20Example | tar -xzvf -

dependencies {
    compile 'org.neo4j.driver:neo4j-java-driver-spring-boot-starter:4.3.6.0'
}

org.neo4j.driver.uri=bolt://localhost:7687
org.neo4j.driver.authentication.username=neo4j
org.neo4j.driver.authentication.password=secret

package com.example.demo;

import java.util.List;

import org.neo4j.driver.AccessMode;
import org.neo4j.driver.Driver;
import org.neo4j.driver.Session;
import org.neo4j.driver.SessionConfig;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MoviesController {

        private final Driver driver; (1)

        public MoviesController(Driver driver) { (2)
                this.driver = driver;
        }

        @GetMapping(path = "/movies", produces = MediaType.APPLICATION_JSON_VALUE) (3)
        public List<String> getMovieTitles() {

                try (Session session = driver.session()) { (4)
                        return session.run("MATCH (m:Movie) RETURN m ORDER BY m.name ASC")
                                .list(r -> r.get("m").asNode().get("title").asString());
                }
        }
}

<dependencies>
    <!-- Embbedded instance -->
    <dependency>
        <groupId>org.neo4j</groupId>
        <artifactId>neo4j</artifactId>
        <version>4.3.6</version>
    </dependency>
    <!-- Necessary bolt server -->
    <dependency>
        <groupId>org.neo4j</groupId>
        <artifactId>neo4j-bolt</artifactId>
        <version>4.3.6</version>
    </dependency>
</dependencies>

import java.io.File;
import java.util.Optional;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "org.neo4j.database-management-service") (1)
public class DatabaseManagementServiceProperties {

        /**
         * The default home directory. If not configured, a random, temporary directory is used.
         * If you want to keep your data around, please set it to a writeable path in your configuration.
         */
        private Optional<File> homeDirectory = Optional.empty(); (2)

        public Optional<File> getHomeDirectory() {
                return homeDirectory;
        }

        public void setHomeDirectory(Optional<File> homeDirectory) {
                this.homeDirectory = homeDirectory;
        }
}

import static java.lang.System.Logger.Level.*;

import java.io.IOException;
import java.io.UncheckedIOException;
import java.lang.System.Logger;
import java.net.URI;
import java.nio.file.Files;

import org.neo4j.configuration.connectors.BoltConnector;
import org.neo4j.configuration.helpers.SocketAddress;
import org.neo4j.dbms.api.DatabaseManagementService;
import org.neo4j.dbms.api.DatabaseManagementServiceBuilder;
import org.neo4j.driver.springframework.boot.autoconfigure.Neo4jDriverProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.type.AnnotatedTypeMetadata;

@Configuration(proxyBeanMethods = false) (1)
@EnableConfigurationProperties(DatabaseManagementServiceProperties.class)  (2)
public class Neo4jConfig {

        private static final Logger LOGGER = System.getLogger(Neo4jConfig.class.getName());

        @Bean (3)
        @Conditional(OnDriverCouldConnectToEmbedded.class) (4)
        DatabaseManagementService databaseManagementService(
                Neo4jDriverProperties driverProperties,
                DatabaseManagementServiceProperties serviceProperties
        ) {
                (5)
                var homeDirectory = serviceProperties.getHomeDirectory().orElseGet(() -> {
                        try {
                                return Files.createTempDirectory("neo4j").toFile();
                        } catch (IOException e) {
                                throw new UncheckedIOException(e);
                        }
                });
                LOGGER.log(
                        INFO,
                        "Configuring {0} as home directory for the embedded instance.",
                        homeDirectory
                );

                var driverPort = driverProperties.getUri().getPort();
                var address = new SocketAddress("localhost", driverPort); (6)
                return new DatabaseManagementServiceBuilder(homeDirectory)
                        .setConfig(BoltConnector.enabled, true)
                        .setConfig(BoltConnector.listen_address, address)
                        .build();
        }

        static class OnDriverCouldConnectToEmbedded implements Condition { (7)

                @Override
                public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {

                        // @formatter:off
                        boolean outcome = false;
                        URI configuredBoltUri = context.getEnvironment().getProperty("org.neo4j.driver.uri", URI.class);
                        if (configuredBoltUri == null) {
                                LOGGER.log(WARNING, "Driver is not configured, skipping embedded instance as well.");
                        } else if (!"bolt".equalsIgnoreCase(configuredBoltUri.getScheme())) {
                                LOGGER.log(WARNING, "Driver configured to use `{0}`, but embedded only supports bolt. Not configuring embedded.",  configuredBoltUri);
                        } else if (!"localhost".equalsIgnoreCase(configuredBoltUri.getHost())) {
                                LOGGER.log(WARNING, "Driver configured to connect to `{0}`, not a local instance. Not configuring embedded.", configuredBoltUri.getHost());
                        } else {
                                outcome = true;
                        }
                        // @formatter:on

                        return outcome;
                }
        }
}

import java.util.List;
import java.util.stream.Collectors;

import org.neo4j.dbms.api.DatabaseManagementService;
import org.neo4j.driver.Driver;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class MoviesService {

        private final Driver driver;

        public MoviesService(Driver driver) {
                this.driver = driver;
        }

        @Autowired
        DatabaseManagementService databaseManagementService;

        public List<String> getMovieTitles() {

                try (var session = driver.session()) {
                        return session.run("MATCH (m:Movie) RETURN m ORDER BY m.name ASC").stream()
                                .map(r -> r.get("m").asNode())
                                .map(n -> n.get("title").asString())
                                .collect(Collectors.toList());
                }
        }
}

import static org.assertj.core.api.Assertions.*;

import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.neo4j.dbms.api.DatabaseManagementService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;
import org.springframework.util.SocketUtils;

@SpringBootTest (1)
class MoviesServiceTest {

        @DynamicPropertySource (2)
        static void neo4jProperties(DynamicPropertyRegistry registry) {

                // Configure a free port
                registry.add("org.neo4j.driver.uri", () -> "bolt://localhost:" + SocketUtils.findAvailableTcpPort()); (3)

                // You could also point the embedded instance to some pre-seeded directory (4)
                // registry.add(
                //         "org.neo4j.database-management-service.home-directory",
                //         () -> "/Users/msimons/tmp/preseededNeo4j"
                // );
        }

        @BeforeAll (5)
        static void prepareTestData(
                @Autowired DatabaseManagementService databaseManagementService
        ) {

                try (var tx = databaseManagementService.database("neo4j").beginTx()) {
                        tx.execute(
                                "CREATE (TheMatrix:Movie {title:'The Matrix', released:1999, tagline:'Welcome to the Real World'})\n"
                                        + "CREATE (TheMatrixReloaded:Movie {title:'The Matrix Reloaded', released:2003, tagline:'Free your mind'})\n"
                                        + "CREATE (TheMatrixRevolutions:Movie {title:'The Matrix Revolutions', released:2003, tagline:'Everything that has a beginning has an end'})\n");
                        tx.commit();
                }
        }

        @Test
        void shouldRetrieveMovieTitles(@Autowired MoviesService moviesService) { (6)

                assertThat(moviesService.getMovieTitles())
                        .hasSize(3)
                        .contains("The Matrix");
        }
}

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.neo4j.test</groupId>
            <artifactId>neo4j-harness</artifactId>
            <version>4.3.6</version>
        </dependency>
    </dependencies>
</dependencyManagement>