buzzardo / gs-accessing-data-neo4j Goto Github PK

You will use Neo4j’s NoSQL graph-based data store to build an embedded Neo4j server, store entities and relationships, and develop queries.

https://raw.githubusercontent.com/spring-guides/getting-started-macros/master/prereq_editor_jdk_buildtools.adoc

https://raw.githubusercontent.com/spring-guides/getting-started-macros/master/how_to_complete_this_guide.adoc

For all Spring applications, you should start with the Spring Initializr. The Initializr offers a fast way to pull in all the dependencies you need for an application and does a lot of the set up for you. This example only needs the Spring Data Neo4j starter. The following image shows the Initializr set up for this sample project:

You can follow this link to create the project skeleton.

The following listing shows the pom.xml file created when you choose Maven:

The following listing shows the build.gradle file created when you choose Gradle:

Before you can build this application, you need to set up a Neo4j server.

Neo4j has an open source server you can install for free.

On a Mac that has Homebrew installed, run the following command:

For other options, visit https://neo4j.com/download/community-edition/.

Once installed, launch it with its default settings by running the following command:

You should see output similar to the following:

By default, Neo4j has a username and password of neo4j and neo4j. However, it requires that the new account password be changed. To do so, run the following command:

This changes the password from neo4j to secret — something to NOT do in production! With that step completed, you should be ready to run the rest of this guide.

Neo4j captures entities and their relationships, with both aspects being of equal importance. Imagine you are modeling a system where you store a record for each person. However, you also want to track a person’s co-workers (teammates in this example). With Spring Data Neo4j, you can capture all that with some simple annotations, as the following listing (in src/main/java/com/example/accessingdataneo4j/Person.java) shows:

Here you have a Person class that has only one attribute: name.

The Person class is annotated with @NodeEntity. When Neo4j stores it, a new node is created. This class also has an id marked @GraphId. Neo4j uses @GraphId internally to track the data.

The next important piece is the set of teammates. It is a simple Set<Person> but is marked as @Relationship. This means that every member of this set is expected to also exist as a separate Person node. Note how the direction is set to UNDIRECTED. This means that when you query the TEAMMATE relationship, Spring Data Neo4j ignores the direction of the relationship.

With the worksWith() method, you can easily link people together.

Finally, you have a convenient toString() method to print out the person’s name and that person’s co-workers.

Spring Data Neo4j is focused on storing data in Neo4j. But it inherits functionality from the Spring Data Commons project, including the ability to derive queries. Essentially, you need not learn the query language of Neo4j. Instead, you can write a handful of methods and let the queries be written for you.

To see how this works, create an interface that queries Person nodes. The following listing (in src/main/java/com/example/accessingdataneo4j/PersonRepository.java) shows such a query:

PersonRepository extends the CrudRepository interface and plugs in the type on which it operates: Person. This interface comes with many operations, including standard CRUD (create, read, update, and delete) operations.

But you can define other queries by declaring their method signatures. In this case, you added findByName, which seeks nodes of type Person and finds the one that matches on name. You also have findByTeammatesName, which looks for a Person node, drills into each entry of the teammates field, and matches based on the teammate’s name.

Neo4j Community Edition requires credentials to access it. You can configure these credential by setting a couple of properties (in src/main/resources/application.properties), as the following listing shows:

This includes the default username (neo4j) and the newly set password we picked earlier (secret).

With this in place, you can wire this up and see what it looks like!

Spring Initializr creates a simple class for the application. The following listing shows the class that Initializr created for this example (in src/main/java/com/example/accessingdataneo4j/AccessingDataNeo4jApplication.java):

https://raw.githubusercontent.com/spring-guides/getting-started-macros/master/spring-boot-application-new-path.adoc

Spring Boot automatically handles those repositories as long as they are included in the same package (or a sub-package) of your @SpringBootApplication class. For more control over the registration process, you can use the @EnableNeo4jRepositories annotation.

Logging output is displayed. The service should be up and running within a few seconds.

Now autowire the instance of PersonRepository that you defined earlier. Spring Data Neo4j dynamically implements that interface and plugs in the needed query code to meet the interface’s obligations.

The main method uses Spring Boot’s SpringApplication.run() to launch the application and invoke the CommandLineRunner that builds the relationships.

In this case, you create three local Person instances: Greg, Roy, and Craig. Initially, they only exist in memory. Note that no one is a teammate of anyone (yet).

At first, you find Greg, indicate that he works with Roy and Craig, and then persist him again. Remember, the teammate relationship was marked as UNDIRECTED (that is, bidirectional). That means that Roy and Craig have been updated as well.

That is why when you need to update Roy. It is critical that you fetch that record from Neo4j first. You need the latest status on Roy’s teammates before adding Craig to the list.

Why is there no code that fetches Craig and adds any relationships? Because you already have it! Greg earlier tagged Craig as a teammate, and so did Roy. That means there is no need to update Craig’s relationships again. You can see it as you iterate over each team member and print their information to the console.

Finally, check out that other query where you look backwards, answering the question of "Who works with whom?"

The following listing shows the finished AccessingDataNeo4jApplication class (at src/main/java/com/example/accessingdataneo4j/AccessingDataNeo4jApplication.java):

https://raw.githubusercontent.com/spring-guides/getting-started-macros/master/build_an_executable_jar_mainhead.adoc https://raw.githubusercontent.com/spring-guides/getting-started-macros/master/build_an_executable_jar_with_both.adoc

You should see something similar to the following listing (with other stuff, such as queries, as well):

You can see from the output that (initially) no one is connected by any relationship. Then, after you add people, they are tied together. Finally, you can see the handy query that looks up people based on teammate.

Congratulations! You just set up an embedded Neo4j server, stored some simple related entities, and developed some quick queries.

The following guides may also be helpful:

• Accessing Neo4j Data with REST

• Accessing Data with MySQL

• Accessing Data with JPA

• Accessing Data with MongoDB

• Accessing data with Gemfire

https://raw.githubusercontent.com/spring-guides/getting-started-macros/master/footer.adoc