Mastering Neo4j with Java: Setup, Queries, Transactions, and Visualization

Neo4j is a powerful graph database that excels at managing highly connected data. When combined with Java, it provides a robust solution for building applications that require complex relationship modeling. This post will walk you through the basics of using Neo4j with Java, covering setup, querying, and best practices.

Setting Up Neo4j with Java

To get started, you’ll need to add the Neo4j Java driver to your project. If you’re using Maven, add the following dependency to your pom.xml:

<dependency>
    <groupId>org.neo4j.driver</groupId>
    <artifactId>neo4j-java-driver</artifactId>
    <version>5.2.0</version>
</dependency>

Connecting to Neo4j

Once you’ve added the dependency, you can establish a connection to your Neo4j database:

import org.neo4j.driver.*;
public class Neo4jBasicExample {
    public static void main(String[] args) {
        try (Driver driver = GraphDatabase.driver("bolt://localhost:7687", AuthTokens.basic("neo4j", "your_password"));
             Session session = driver.session()) {

Creating Nodes and Relationships

// Create nodes and a relationship
            String createQuery = "CREATE (a:Person {name: 'Alice'})-[:FRIENDS_WITH]->(b:Person {name: 'Bob'})";
            session.run(createQuery);
            System.out.println("Nodes and relationship created successfully.");
        }
    }
}

Querying Nodes and Relationships

import org.neo4j.driver.*;
public class Neo4jQueryExample {
    public static void main(String[] args) {
        try (Driver driver = GraphDatabase.driver("bolt://localhost:7687", AuthTokens.basic("neo4j", "your_password"));
             Session session = driver.session()) {
// Query nodes and relationships
String matchQuery = "MATCH (a:Person)-[r:FRIENDS_WITH]->(b:Person) RETURN a.name, b.name";
            Result result = session.run(matchQuery);
// Process the results
 while (result.hasNext()) {
                Record record = result.next();
                System.out.println(record.get("a.name").asString() + " is friends with " + record.get("b.name").asString());
            }
        }
    }
}

Using Transactions for Data Integrity

Transactions ensure that operations are completed successfully or rolled back if any issues arise. Here’s how you can use transactions with Neo4j and Java:

import org.neo4j.driver.*;
public class Neo4jTransactionExample {
    public static void main(String[] args) {
        try (Driver driver = GraphDatabase.driver("bolt://localhost:7687",AuthTokens.basic("neo4j", "your_password"));
             Session session = driver.session()) {
// Start a transaction
session.writeTransaction(tx -> {
   tx.run("CREATE (a:Person {name: 'Charlie'})-[:FRIENDS_WITH]->(b:Person {name: 'Diana'})");
    return null;
 });
// Verify the data
String matchQuery = "MATCH (a:Person)-[r:FRIENDS_WITH]->(b:Person) RETURN a.name, b.name";
            Result result = session.run(matchQuery);
// Process the results
 while (result.hasNext()) {
  Record record = result.next();
  System.out.println(record.get("a.name").asString() + " is friends with " + record.get("b.name").asString());
            }
        }
    }
}

When you run this code, it will:

Connect to a Neo4j database and create two nodes (Charlie and Diana) with a relationship between them.
Retrieve and print out the relationship between these nodes.
Ensure proper cleanup of resources.

Visualizing Graph Data with GraphStream

Visualizing graph data helps in understanding relationships better. Here’s how you can visualize data using the GraphStream library:

First, add GraphStream to your pom.xml:

<dependency>
    <groupId>org.graphstream</groupId>
    <artifactId>graphstream-core</artifactId>
    <version>2.0</version>
</dependency>

Visualization Code

import org.graphstream.graph.*;
import org.graphstream.graph.implementations.SingleGraph;
import org.neo4j.driver.*;

public class Neo4jGraphVisualization {
    public static void main(String[] args) {
// Initialize Neo4j driver
        try (Driver driver = GraphDatabase.driver("bolt://localhost:7687", AuthTokens.basic("neo4j", "your_password"));
             Session session = driver.session()) {
// Fetch nodes and relationships
  String cypherQuery = "MATCH (a)-[r]->(b) RETURN a, r, b";
            Result result = session.run(cypherQuery);
// Create a graph instance
Graph graph = new SingleGraph("Neo4j Graph");
// Process results and add to graph
 while (result.hasNext()) {
   Record record = result.next();
   Node nodeA = record.get("a").asNode();
   Node nodeB = record.get("b").asNode();
   Relationship relationship = record.get("r").asRelationship();
    graph.addNode(nodeA.id()).setAttribute("label", nodeA.get("name").asString());
  graph.addNode(nodeB.id()).setAttribute("label", nodeB.get("name").asString());
 graph.addEdge(relationship.id(), nodeA.id(), nodeB.id()).setAttribute("label", relationship.type());
            }
// Display the graph
graph.display();
        }
    }
}

When you run this code, it will:

The code connects to the Neo4j database using the specified Bolt protocol and credentials.
Nodes and relationships from the Neo4j database are retrieved according to the specified Cypher query.
A graph representation is created using GraphStream, with nodes and relationships added based on the retrieved data.
A visual window opens displaying the graph, allowing you to see the structure of nodes and their relationships.

Conclusion

Integrating Neo4j with Java offers a powerful platform for managing and analyzing graph data. By creating nodes and relationships, using transactions for data integrity, and visualizing data, you can leverage Neo4j’s capabilities to build sophisticated applications. Start exploring graph databases to unlock new insights and enhance your data-driven solutions.

Blog