Learn how to create and access nodes and relationships. For information on project setup, see Section 4.1, “Include Neo4j in your project”.
Remember, from Section 2.1, “What is a Graph Database?”, that a Neo4j graph consist of:
All relationships have a type.
For example, if the graph represents a social network, a relationship type could be KNOWS
.
If a relationship of the type KNOWS
connects two nodes, that probably represents two people that know each other.
A lot of the semantics (that is the meaning) of a graph is encoded in the relationship types of the application.
And although relationships are directed they are equally well traversed regardless of which direction they are traversed.
Tip | |
---|---|
The source code of this example is found here: EmbeddedNeo4j.java |
Relationship types can be created by using an enum
.
In this example we only need a single relationship type. This is how to
define it:
private static enum RelTypes implements RelationshipType { KNOWS }
We also prepare some variables to use:
GraphDatabaseService graphDb; Node firstNode; Node secondNode; Relationship relationship;
The next step is to start the database server. Note that if the directory given for the database doesn’t already exist, it will be created.
graphDb = new GraphDatabaseFactory().newEmbeddedDatabase( DB_PATH ); registerShutdownHook( graphDb );
Note that starting a database server is an expensive operation, so don’t start up a new instance every time you need to interact with the database! The instance can be shared by multiple threads. Transactions are thread confined.
As seen, we register a shutdown hook that will make sure the database shuts down when the JVM exits. Now it’s time to interact with the database.
All mutating transactions have to be performed in a transaction. This is a conscious design decision, since we believe transaction demarcation to be an important part of working with a real enterprise database. Now, transaction handling in Neo4j is very easy:
Transaction tx = graphDb.beginTx(); try { // Mutating operations go here tx.success(); } finally { tx.finish(); }
For more information on transactions, see Chapter 13, Transaction Management and Java API for Transaction.
Now, let’s create a few nodes. The API is very intuitive. Feel free to have a look at the JavaDocs at http://components.neo4j.org/neo4j/1.7/apidocs/. They’re included in the distribution, as well. Here’s how to create a small graph consisting of two nodes, connected with one relationship and some properties:
firstNode = graphDb.createNode(); firstNode.setProperty( "message", "Hello, " ); secondNode = graphDb.createNode(); secondNode.setProperty( "message", "World!" ); relationship = firstNode.createRelationshipTo( secondNode, RelTypes.KNOWS ); relationship.setProperty( "message", "brave Neo4j " );
We now have a graph that looks like this:
After we’ve created our graph, let’s read from it and print the result.
System.out.print( firstNode.getProperty( "message" ) ); System.out.print( relationship.getProperty( "message" ) ); System.out.print( secondNode.getProperty( "message" ) );
Which will output:
Hello, brave Neo4j World!
In this case we’ll remove the data before committing:
// let's remove the data firstNode.getSingleRelationship( RelTypes.KNOWS, Direction.OUTGOING ).delete(); firstNode.delete(); secondNode.delete();
Note that deleting a node which still has relationships when the transaction commits will fail. This is to make sure relationships always have a start node and an end node.
Copyright © 2012 Neo Technology