In Part 1, we talked about setting up a connection to the Neo4j Server using the Java REST Binding. Let’s now go into some details about transactions, batching, and what the REST requests really look like.Make sure you turn on logging (set system property org.neo4j.rest.logging_filter to true) as described in Part 1.
We will change our code to execute these Neo4j API calls.
Example 1:
Transaction tx = graphDb.beginTx();
Map props=new HashMap();
props.put("id", 100);
props.put("name","firstNode");
Node node=graphDb.createNode(props);
props.put("id",200);
props.put("name","secondNode");
Node node2=graphDb.createNode(props);
node.createRelationshipTo(node2, DynamicRelationshipType.withName("KNOWS"));
tx.success();
tx.finish();
result=engine.query("start n=node(*) return count(n) as total", Collections.EMPTY_MAP);
Iterator iterator=result.iterator();
if(iterator.hasNext()) {
Map row= iterator.next();
out.print("Total nodes: " + row.get("total"));
}Check the logs (for me, they appeared by default on the Tomcat console) and look for the REST calls. The code above produced:
INFO: 1 * Client out-bound request
1 > POST http://localhost:7474/db/data/node
1 > Accept: application/json; stream=true
1 > X-Stream: true
1 > Content-Type: application/json
1 >
{"id":100,"name":"firstNode"}
INFO: 1 * Client in-bound response
1 < 201
1 < Access-Control-Allow-Origin: *
1 < Transfer-Encoding: chunked
1 < Content-Encoding: UTF-8
1 < Location: http://localhost:7474/db/data/node/1
1 < Content-Type: application/json; stream=true
1 < Server: Jetty(6.1.25)
1 <
{"extensions":{},"paged_traverse":"http://localhost:7474/db/data/node/1/paged/traverse/{returnType}{?pageSize,leaseTime}","outgoing_relationships":"http://localhost:7474/db/data/node/1/relationships/out","traverse":"http://localhost:7474/db/data/node/1/traverse/{returnType}","all_typed_relationships":"http://localhost:7474/db/data/node/1/relationships/all/{-list|&|types}","property":"http://localhost:7474/db/data/node/1/properties/{key}","all_relationships":"http://localhost:7474/db/data/node/1/relationships/all","self":"http://localhost:7474/db/data/node/1","properties":"http://localhost:7474/db/data/node/1/properties","outgoing_typed_relationships":"http://localhost:7474/db/data/node/1/relationships/out/{-list|&|types}","incoming_relationships":"http://localhost:7474/db/data/node/1/relationships/in","incoming_typed_relationships":"http://localhost:7474/db/data/node/1/relationships/in/{-list|&|types}","create_relationship":"http://localhost:7474/db/data/node/1/relationships","data":{"name":"firstNode","id":100}}
INFO: 2 * Client out-bound request
2 > POST http://localhost:7474/db/data/node
2 > Accept: application/json; stream=true
2 > X-Stream: true
2 > Content-Type: application/json
2 >
{"id":200,"name":"secondNode"}
INFO: 2 * Client in-bound response
2 < 201
2 < Access-Control-Allow-Origin: *
2 < Transfer-Encoding: chunked
2 < Content-Encoding: UTF-8
2 < Location: http://localhost:7474/db/data/node/2
2 < Content-Type: application/json; stream=true
2 < Server: Jetty(6.1.25)
2 <
{"extensions":{},"paged_traverse":"http://localhost:7474/db/data/node/2/paged/traverse/{returnType}{?pageSize,leaseTime}","outgoing_relationships":"http://localhost:7474/db/data/node/2/relationships/out","traverse":"http://localhost:7474/db/data/node/2/traverse/{returnType}","all_typed_relationships":"http://localhost:7474/db/data/node/2/relationships/all/{-list|&|types}","property":"http://localhost:7474/db/data/node/2/properties/{key}","all_relationships":"http://localhost:7474/db/data/node/2/relationships/all","self":"http://localhost:7474/db/data/node/2","properties":"http://localhost:7474/db/data/node/2/properties","outgoing_typed_relationships":"http://localhost:7474/db/data/node/2/relationships/out/{-list|&|types}","incoming_relationships":"http://localhost:7474/db/data/node/2/relationships/in","incoming_typed_relationships":"http://localhost:7474/db/data/node/2/relationships/in/{-list|&|types}","create_relationship":"http://localhost:7474/db/data/node/2/relationships","data":{"name":"secondNode","id":200}}
INFO: 3 * Client out-bound request
3 > POST http://localhost:7474/db/data/node/1/relationships
3 > Accept: application/json; stream=true
3 > X-Stream: true
3 > Content-Type: application/json
3 >
{"to":"http://localhost:7474/db/data/node/2","type":"KNOWS"}
INFO: 3 * Client in-bound response
3 < 201
3 < Access-Control-Allow-Origin: *
3 < Transfer-Encoding: chunked
3 < Content-Encoding: UTF-8
3 < Location: http://localhost:7474/db/data/relationship/0
3 < Content-Type: application/json; stream=true
3 < Server: Jetty(6.1.25)
3 <
{"extensions":{},"start":"http://localhost:7474/db/data/node/1","property":"http://localhost:7474/db/data/relationship/0/properties/{key}","self":"http://localhost:7474/db/data/relationship/0","properties":"http://localhost:7474/db/data/relationship/0/properties","type":"KNOWS","end":"http://localhost:7474/db/data/node/2","data":{}}
INFO: 4 * Client out-bound request
4 > POST http://localhost:7474/db/data/cypher
4 > Accept: application/json; stream=true
4 > X-Stream: true
4 > Content-Type: application/json
4 >
{"query":"start n=node(*) return count(n) as total","params":{}}
INFO: 4 * Client in-bound response
4 < 200
4 < Access-Control-Allow-Origin: *
4 < Transfer-Encoding: chunked
4 < Content-Encoding: UTF-8
4 < Content-Type: application/json; stream=true
4 < Server: Jetty(6.1.25)
4 <
{"columns":["total"],"data":[[3]]}A total of 4 REST calls over the wire for that tiny piece of code. You definitely want to avoid this as far as possible. Option 1 is to use Cypher as far as possible. We could convert the first three REST calls into one by not using the embedded style API and switching to Cypher.
Example 2:
Map<String,Object> props=new HashMap<String, Object>();
props.put("id", 100);
props.put("name","firstNode");
Map<String,Object> props2=new HashMap<String, Object>();
props2.put("id",200);
props2.put("name","secondNode");
Map<String,Object> params=new HashMap<String, Object>();
params.put("props1",props);
params.put("props2",props2);
engine.query("create (n1 {props1})-[:KNOWS]->(n2 {props2})", params);This produces:
1 > POST http://localhost:7474/db/data/cypher
{"query":"create (n1 {props1})-[:KNOWS]->(n2 {props2})","params":{"props1":{"id":100,"name":"firstNode"},"props2":{"id":100,"name":"firstNode"}}}
Jul 24, 2013 10:38:47 PM com.sun.jersey.api.client.filter.LoggingFilter log
INFO: 1 * Client in-bound response
1 < 200
1 < Access-Control-Allow-Origin: *
1 < Transfer-Encoding: chunked
1 < Content-Encoding: UTF-8
1 < Content-Type: application/json; stream=true
1 < Server: Jetty(6.1.25)
1 <
{"columns":[],"data":[]}
Batching all operations within a transaction
The documentation at https://github.com/neo4j/java-rest-binding states:
“In 1.8 it tries to collect all operations within a tx as a batch-operation which will then be executed on the server. This has the implication that the results retrieved within that “tx” are not immediately available but only after you called tx.success and tx.finish“
However, note that this is NOT the default behavior as you can see from Example 1. To turn this on, you need to set the following system property:org.neo4j.rest.batch_transaction=true
Once the system property is set and Example 1 is re-run, the REST calls look like(requests only):
INFO: 1 * Client out-bound request
1 > POST http://localhost:7474/db/data/batch
1 > Accept: application/json; stream=true
1 > X-Stream: true
1 > Content-Type: application/json
1 >
[{"id":1,"to":"node","body":{"id":200,"name":"secondNode"},"method":"POST"},{"id":2,"to":"node","body":{"id":200,"name":"secondNode"},"method":"POST"},{"id":3,"to":"{1}/relationships","body":{"to":"{2}","type":"KNOWS"},"method":"POST"}]
INFO: 2 * Client out-bound request
2 > POST http://localhost:7474/db/data/cypher
2 > Accept: application/json; stream=true
2 > X-Stream: true
2 > Content-Type: application/json
2 >
{"query":"start n=node(*) return count(n) as total","params":{}}You may also explicitly create batch operations like so:
List<Node> response =graphDb.executeBatch(new BatchCallback<List<Node>>() {
@Override
public List<Node> recordBatch(RestAPI batchRestApi) {
List<Node> nodes=new ArrayList<Node>();
Map props=new HashMap<String, Object>();
props.put("id",600);
nodes.add(batchRestApi.createNode(props));
Map props2=new HashMap<String, Object>();
props2.put("id",500);
nodes.add(batchRestApi.createNode(props2));
return nodes;
}
});
This translates into:
INFO: 1 * Client out-bound request
1 > POST http://localhost:7474/db/data/batch
1 > Accept: application/json; stream=true
1 > X-Stream: true
1 > Content-Type: application/json
1 >
[{"id":1,"to":"node","body":{"id":600},"method":"POST"},{"id":2,"to":"node","body":{"id":500},"method":"POST"}]
Any of the Cypher/Batching approaches are highly recommended over the finer grained Neo4j Java API. In the final post, we will take a look how transactions behave in the context of the REST binding.
Reference: Neo4j Java REST Binding – Part 2 (Batching) from our JCG partner Luanne Misquitta at the Thought Bytes blog.
