Prev |  | Next

## 4.2. Hello World

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:

- Nodes that are connected by
- Relationships, with
- Properties on both nodes and relationships.

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

### 4.2.1. Prepare the database

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.

### 4.2.2. Wrap writes in a transaction

All writes (creating, deleting and updating any data) 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
    {
        // Updating operations go here
        tx.success();
    }
    finally
    {
        tx.finish();
    }

For more information on transactions, see Chapter 12, Transaction Management and Java API for Transaction.

### 4.2.3. Create a small graph

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.8.2/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:

Figure 4.1. Hello World Graph

### 4.2.4. Print the result

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!

### 4.2.5. Remove the data

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.

### 4.2.6. Shut down the database server

Finally, shut down the database server when the application finishes:

    graphDb.shutdown();

Copyright © 2013 Neo Technology

Prev | Up | Next
| Home |