Update Neo4j extension to use Spring Data Neo4j.

Author: meistermeier

spring-batch-neo4j/README.md

@@ -7,25 +7,100 @@ This extension contains an `ItemReader` and `ItemWriter` implementations for [Ne
 The `Neo4jItemReader` can be configured as follows:
 
 ```java
-SessionFactory sessionFactory = ...
-Neo4jItemReader<String> itemReader = new Neo4jItemReaderBuilder<String>()
-        .sessionFactory(sessionFactory)
-        .name("itemReader")
-        .targetType(String.class)
-        .startStatement("n=node(*)")
-        .orderByStatement("n.age")
-        .matchStatement("n -- m")
-        .whereStatement("has(n.name)")
-        .returnStatement("m")
+Neo4jItemReader<User> reader = new Neo4jItemReaderBuilder<User>()
+        .neo4jTemplate(neo4jTemplate)
+        .name("userReader")
+        .statement(Cypher.match(userNode).returning(userNode))
+        .targetType(User.class)
         .pageSize(50)
         .build();
 ```
 
 The `Neo4jItemWriter` can be configured as follows:
 
 ```java
-SessionFactory sessionFactory = ...
-Neo4jItemWriter<String> writer = new Neo4jItemWriterBuilder<String>()
-        .sessionFactory(sessionFactory)
+Neo4jItemWriter<User> writer = new Neo4jItemWriterBuilder<User>()
+        .neo4jTemplate(neo4jTemplate)
+        .neo4jDriver(driver)
+        .neo4jMappingContext(mappingContext)
         .build();
+```
+
+## Minimal Spring Boot example
+
+With a Spring Boot application containing the additional dependencies `spring-boot-starter-neo4j` and `spring-batch-neo4j`,
+the following _build.gradle_ dependency definition is the minimal needed. 
+Please note the exclusion for Spring JDBC from the `spring-boot-starter-batch` to avoid any need for JDBC-based connections.
+
+```groovy
+dependencies {
+    implementation ('org.springframework.boot:spring-boot-starter-batch') {
+        exclude group: 'org.springframework', module: 'spring-jdbc'
+        exclude group: 'org.springframework.boot', module: 'spring-boot-starter-jdbc'
+    }
+    // current development version 0.2.0-SNAPSHOT
+    implementation 'org.springframework.batch.extensions:spring-batch-neo4j'
+    implementation 'org.springframework.boot:spring-boot-starter-data-neo4j'
+    testImplementation 'org.springframework.boot:spring-boot-starter-test'
+    testImplementation 'org.springframework.batch:spring-batch-test'
+}
+```
+
+```java
+@SpringBootApplication
+public class TestSpringBatchApplication implements CommandLineRunner {
+    // those dependencies are created by Spring Boot's
+    // spring-data-neo4j autoconfiguration
+    @Autowired
+    private Driver driver;
+    @Autowired
+    private Neo4jMappingContext mappingContext;
+    @Autowired
+    private Neo4jTemplate neo4jTemplate;
+  
+    public static void main(String[] args) {
+      SpringApplication.run(TestSpringBatchApplication.class, args);
+    }
+  
+    @Override
+    public void run(String... args) {
+      // writing
+      Neo4jItemWriter<User> writer = new Neo4jItemWriterBuilder<User>()
+        .neo4jTemplate(neo4jTemplate)
+        .neo4jDriver(driver)
+        .neo4jMappingContext(mappingContext)
+        .build();
+      writer.write(Chunk.of(new User("id1", "ab"), new User("id2", "bb")));
+      
+      // reading
+      org.neo4j.cypherdsl.core.Node userNode = Cypher.node("User");
+      Neo4jItemReader<User> reader = new Neo4jItemReaderBuilder<User>()
+        .neo4jTemplate(neo4jTemplate)
+        .name("userReader")
+        .statement(Cypher.match(userNode).returning(userNode))
+        .targetType(User.class)
+        .build();
+      List<User> allUsers = new ArrayList<>();
+      User user = null;
+      while ((user = reader.read()) != null) {
+        System.out.printf("Found user: %s%n", user.name);
+        allUsers.add(user);
+      }
+      
+      // deleting
+      writer.setDelete(true);
+      writer.write(Chunk.of(allUsers.toArray(new User[]{})));
+    }
+  
+    @Node("User")
+    public static class User {
+      @Id public final String id;
+      public final String name;
+      
+      public User(String id, String name) {
+        this.id = id;
+        this.name = name;
+      }
+    }
+}
 ```

spring-batch-neo4j/pom.xml

@@ -54,16 +54,16 @@
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
-        <java.version>1.8</java.version>
+        <java.version>17</java.version>
 
         <!-- Production dependencies-->
-        <spring.batch.version>4.3.3</spring.batch.version>
-        <neo4j-ogm-core.version>3.2.21</neo4j-ogm-core.version>
+        <spring.batch.version>5.1.0</spring.batch.version>
+        <spring-data-neo4j.version>7.2.1</spring-data-neo4j.version>
 
         <!-- Test Dependencies -->
         <assertj.version>3.18.1</assertj.version>
-        <junit.version>4.13.2</junit.version>
-        <mockito.version>3.6.0</mockito.version>
+        <junit.version>5.10.1</junit.version>
+        <mockito.version>5.8.0</mockito.version>
 
         <!-- Maven plugins -->
         <maven-compiler-plugin.version>3.8.1</maven-compiler-plugin.version>
@@ -83,15 +83,15 @@
             <version>${spring.batch.version}</version>
         </dependency>
         <dependency>
-            <groupId>org.neo4j</groupId>
-            <artifactId>neo4j-ogm-core</artifactId>
-            <version>${neo4j-ogm-core.version}</version>
+            <groupId>org.springframework.data</groupId>
+            <artifactId>spring-data-neo4j</artifactId>
+            <version>${spring-data-neo4j.version}</version>
         </dependency>
 
         <!-- Test Dependencies -->
         <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
             <version>${junit.version}</version>
             <scope>test</scope>
         </dependency>

spring-batch-neo4j/src/main/java/org/springframework/batch/extensions/neo4j/Neo4jItemReader.java

@@ -16,20 +16,19 @@
 
 package org.springframework.batch.extensions.neo4j;
 
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.Map;
-
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
-import org.neo4j.ogm.session.Session;
-import org.neo4j.ogm.session.SessionFactory;
-
+import org.neo4j.cypherdsl.core.Statement;
+import org.neo4j.cypherdsl.core.StatementBuilder;
+import org.neo4j.cypherdsl.core.renderer.Renderer;
 import org.springframework.batch.item.ItemReader;
 import org.springframework.batch.item.data.AbstractPaginatedDataItemReader;
 import org.springframework.beans.factory.InitializingBean;
+import org.springframework.data.neo4j.core.Neo4jTemplate;
 import org.springframework.util.Assert;
-import org.springframework.util.StringUtils;
+
+import java.util.Iterator;
+import java.util.Map;
 
 /**
  * <p>
@@ -38,15 +37,15 @@
  * </p>
  *
  * <p>
- * It executes cypher queries built from the statement fragments provided to
+ * It executes cypher queries built from the statement provided to
  * retrieve the requested data.  The query is executed using paged requests of
  * a size specified in {@link #setPageSize(int)}.  Additional pages are requested
  * as needed when the {@link #read()} method is called.  On restart, the reader
  * will begin again at the same number item it left off at.
  * </p>
  *
  * <p>
- * Performance is dependent on your Neo4J configuration (embedded or remote) as
+ * Performance is dependent on your Neo4j configuration as
  * well as page size.  Setting a fairly large page size and using a commit
  * interval that matches the page size should provide better performance.
  * </p>
@@ -58,20 +57,19 @@
  * environment (no restart available).
  * </p>
  *
+ * @param <T> type of entity to load
+ *
  * @author Michael Minella
  * @author Mahmoud Ben Hassine
+ * @author Gerrit Meier
  */
 public class Neo4jItemReader<T> extends AbstractPaginatedDataItemReader<T> implements InitializingBean {
 
-	protected Log logger = LogFactory.getLog(getClass());
+	private final Log logger = LogFactory.getLog(getClass());
 
-	private SessionFactory sessionFactory;
+	private Neo4jTemplate neo4jTemplate;
 
-	private String startStatement;
-	private String returnStatement;
-	private String matchStatement;
-	private String whereStatement;
-	private String orderByStatement;
+	private StatementBuilder.OngoingReadingAndReturn statement;
 
 	private Class<T> targetType;
 
@@ -86,76 +84,23 @@ public void setParameterValues(Map<String, Object> parameterValues) {
 		this.parameterValues = parameterValues;
 	}
 
-	protected final Map<String, Object> getParameterValues() {
-		return this.parameterValues;
-	}
-
-	/**
-	 * The start segment of the cypher query.  START is prepended
-	 * to the statement provided and should <em>not</em> be
-	 * included.
-	 *
-	 * @param startStatement the start fragment of the cypher query.
-	 */
-	public void setStartStatement(String startStatement) {
-		this.startStatement = startStatement;
-	}
-
-	/**
-	 * The return statement of the cypher query.  RETURN is prepended
-	 * to the statement provided and should <em>not</em> be
-	 * included
-	 *
-	 * @param returnStatement the return fragment of the cypher query.
-	 */
-	public void setReturnStatement(String returnStatement) {
-		this.returnStatement = returnStatement;
-	}
-
 	/**
-	 * An optional match fragment of the cypher query.  MATCH is
-	 * prepended to the statement provided and should <em>not</em>
-	 * be included.
+	 * Cypher-DSL's {@link org.neo4j.cypherdsl.core.StatementBuilder.OngoingReadingAndReturn} statement
+	 * without skip and limit segments. Those will get added by the pagination mechanism later.
 	 *
-	 * @param matchStatement the match fragment of the cypher query
+	 * @param statement the Cypher-DSL statement-in-construction.
 	 */
-	public void setMatchStatement(String matchStatement) {
-		this.matchStatement = matchStatement;
+	public void setStatement(StatementBuilder.OngoingReadingAndReturn statement) {
+		this.statement = statement;
 	}
 
 	/**
-	 * An optional where fragment of the cypher query.  WHERE is
-	 * prepended to the statement provided and should <em>not</em>
-	 * be included.
+	 * Establish the Neo4jTemplate for the reader.
 	 *
-	 * @param whereStatement where fragment of the cypher query
+	 * @param neo4jTemplate the template to use for the reader.
 	 */
-	public void setWhereStatement(String whereStatement) {
-		this.whereStatement = whereStatement;
-	}
-
-	/**
-	 * A list of properties to order the results by.  This is
-	 * required so that subsequent page requests pull back the
-	 * segment of results correctly.  ORDER BY is prepended to
-	 * the statement provided and should <em>not</em> be included.
-	 *
-	 * @param orderByStatement order by fragment of the cypher query.
-	 */
-	public void setOrderByStatement(String orderByStatement) {
-		this.orderByStatement = orderByStatement;
-	}
-
-	protected SessionFactory getSessionFactory() {
-		return sessionFactory;
-	}
-
-	/**
-	 * Establish the session factory for the reader.
-	 * @param sessionFactory the factory to use for the reader.
-	 */
-	public void setSessionFactory(SessionFactory sessionFactory) {
-		this.sessionFactory = sessionFactory;
+	public void setNeo4jTemplate(Neo4jTemplate neo4jTemplate) {
+		this.neo4jTemplate = neo4jTemplate;
 	}
 
 	/**
@@ -167,28 +112,16 @@ public void setTargetType(Class<T> targetType) {
 		this.targetType = targetType;
 	}
 
-	protected final Class<T> getTargetType() {
-		return this.targetType;
-	}
-
-	protected String generateLimitCypherQuery() {
-		StringBuilder query = new StringBuilder(128);
-
-		query.append("START ").append(startStatement);
-		query.append(matchStatement != null ? " MATCH " + matchStatement : "");
-		query.append(whereStatement != null ? " WHERE " + whereStatement : "");
-		query.append(" RETURN ").append(returnStatement);
-		query.append(" ORDER BY ").append(orderByStatement);
-		query.append(" SKIP " + (pageSize * page));
-		query.append(" LIMIT " + pageSize);
-
-		String resultingQuery = query.toString();
-
+	private Statement generateStatement() {
+		Statement builtStatement = statement
+				.skip(page * pageSize)
+				.limit(pageSize)
+				.build();
 		if (logger.isDebugEnabled()) {
-			logger.debug(resultingQuery);
+			logger.debug(Renderer.getDefaultRenderer().render(builtStatement));
 		}
 
-		return resultingQuery;
+		return builtStatement;
 	}
 
 	/**
@@ -197,28 +130,15 @@ protected String generateLimitCypherQuery() {
 	 * @see InitializingBean#afterPropertiesSet()
 	 */
 	@Override
-	public void afterPropertiesSet() throws Exception {
-		Assert.state(sessionFactory != null,"A SessionFactory is required");
+	public void afterPropertiesSet() {
+		Assert.state(neo4jTemplate != null, "A Neo4jTemplate is required");
 		Assert.state(targetType != null, "The type to be returned is required");
-		Assert.state(StringUtils.hasText(startStatement), "A START statement is required");
-		Assert.state(StringUtils.hasText(returnStatement), "A RETURN statement is required");
-		Assert.state(StringUtils.hasText(orderByStatement), "A ORDER BY statement is required");
+		Assert.state(statement != null, "A statement is required");
 	}
 
 	@SuppressWarnings("unchecked")
 	@Override
 	protected Iterator<T> doPageRead() {
-		Session session = getSessionFactory().openSession();
-
-		Iterable<T> queryResults = session.query(getTargetType(),
-				generateLimitCypherQuery(),
-				getParameterValues());
-
-		if(queryResults != null) {
-			return queryResults.iterator();
-		}
-		else {
-			return new ArrayList<T>().iterator();
-		}
+		return neo4jTemplate.findAll(generateStatement(), parameterValues, targetType).iterator();
 	}
 }