前幾天阿粉給大家擴展了關于 Neo4J 圖譜數據庫的內容，今天阿粉教給大家如何使用 Java 來操作 Neo4j 數據庫。

使用 Java 操作 Neo4J

首先我們先使用原生的這種方式，導入 jar 包，然后：

1. public class TestController { 
2.     public static void main(String[] args) { 
3.         Driver driver = GraphDatabase.driver("bolt://localhost:7687", AuthTokens.basic("neo4j", "Yinlidong1995.")); 
4.         Session session = driver.session(); 
5.         session.run("CREATE (n:Part {name: {name},title: {title}})", 
6.                 parameters( "name", "Arthur001", "title", "King001" )); 
7.         StatementResult result = session.run( "MATCH (a:Part) WHERE a.name = {name} " + 
8.                         "RETURN a.name AS name, a.title AS title", 
9.                 parameters( "name", "Arthur001")); 
10.         while (result.hasNext()) { 
11.             Record record = result.next(); 
12.             System.out.println( record.get( "title" ).asString() + "" + record.get( "name" ).asString() ); 
13.         } 
14.         session.close(); 
15.         driver.close(); 
16.     } 
17. } 

這是一種比較古老的方式，來實現的，而且還是需要些 CQL 語句來進行實現。但是勝在非常好理解，這個時候，我們需要再來看看圖，看看在 Neo4J 中他是怎么展現的。

通過這個，我們至少證明我們成功連上了，并且創建也成功了。

這時候有細心的讀者就會問，為啥我之前在 GraphDatabase.driver 的地方，連接的是

bolt://localhost:7687.

這是因為，你啟動的Neo4J 是7474，也就是說，Neo4J 服務里面可不是這個來連接，

SpringBoot 整合 Neo4j

1.創建SpringBoot項目

常規的創建SpringBoot項目，

創建完成之后，習慣性的要改一下 SpringBoot 的版本號，最好別用最新的，因為阿粉親身經歷，使用最新版的，出現了錯誤你都不知道怎么出現的，就是這么神奇，你永遠都發現不了的bug。

我們把版本號改成2.1.0，這樣的話，我們在 pom 文件中加入依賴 jar

1. <dependency> 
2.  <groupId>org.springframework.boot</groupId> 
3.  <artifactId>spring-boot-starter-data-neo4j</artifactId> 
4. </dependency> 
5. <dependency> 
6.  <groupId>org.projectlombok</groupId> 
7.  <artifactId>lombok</artifactId> 
8.  <version>1.16.10</version> 
9. </dependency> 

2.增加配置

1. spring: 
2.   data: 
3.     neo4j: 
4.       url: bolt://localhost:7687 
5.       username: neo4j 
6.       password: Yinlidong1995. 
7.   main: 
8.     allow-bean-definition-overriding: true

3.Neo4JConfig

1. package com.example.neo4j.config; 
2.  
3. import org.neo4j.driver.v1.AuthTokens; 
4. import org.neo4j.driver.v1.Driver; 
5. import org.neo4j.driver.v1.GraphDatabase; 
6. import org.neo4j.driver.v1.Session; 
7. import org.springframework.beans.factory.annotation.Value; 
8. import org.springframework.context.annotation.Bean; 
9. import org.springframework.context.annotation.Configuration; 
10. import org.springframework.data.neo4j.repository.config.EnableNeo4jRepositories; 
11. import org.springframework.transaction.annotation.EnableTransactionManagement; 
12.  
13. @Configuration 
14. @EnableNeo4jRepositories("com.example.neo4j.repository") 
15. @EnableTransactionManagement 
16. public class Neo4jConfig { 
17.     @Value("${spring.data.neo4j.url}") 
18.     private String url; 
19.     @Value("${spring.data.neo4j.username}") 
20.     private String userName; 
21.     @Value("${spring.data.neo4j.password}") 
22.     private String password; 
23.  
24.     @Bean(name = "session") 
25.     public Session neo4jSession() { 
26.         Driver driver = GraphDatabase.driver(url, AuthTokens.basic(userName, password)); 
27.         return driver.session(); 
28.     } 
29. } 

4.編寫實體類

1. package com.example.neo4j.entry; 
2.  
3. import org.neo4j.ogm.annotation.*; 
4.  
5. import java.util.HashSet; 
6. import java.util.Set; 
7. @NodeEntity("group") 
8. @Data 
9. public class GroupNode { 
10.     @Id 
11.     @GeneratedValue 
12.     private Long id; 
13.  
14.     /** 
15.      * 班級名稱 
16.      */ 
17.     @Property(name = "name") 
18.     private String name; 
19.  
20.     /** 
21.      * 編號 
22.      */ 
23.     private String num; 
24.  
25.     @Relationship(type = "RelationEdge") 
26.     private Set<RelationEdge> sets = new HashSet<>(); 
27.  
28.     public void addRelation(StudentNode sonNode, String name) { 
29.         RelationEdge relationNode = new RelationEdge(this, sonNode, name); 
30.         sets.add(relationNode); 
31.         sonNode.getSets().add(relationNode); 
32.     } 
33. } 

學生實體類：

1. package com.example.neo4j.entry; 
2. import org.neo4j.ogm.annotation.GeneratedValue; 
3. import org.neo4j.ogm.annotation.Id; 
4. import org.neo4j.ogm.annotation.NodeEntity; 
5. import org.neo4j.ogm.annotation.Relationship; 
6.  
7. import java.util.HashSet; 
8. import java.util.Set; 
9.  
10. /** 
11.  * 有點類似于Mysql中的table 映射的對象類，mysql中叫做ORM，neo4j中叫做OGM [object graph mapping] 
12.  */ 
13. @NodeEntity("student") 
14. @Data 
15. public class StudentNode { 
16.     @Id 
17.     @GeneratedValue 
18.     private Long id; 
19.  
20.     /** 
21.      * 學生名稱 
22.      */ 
23.     private String name; 
24.  
25.     /** 
26.      * 性別 
27.      */ 
28.     private String sex; 
29.  
30.     @Relationship(type = "RelationEdge", direction = "INCOMING") 
31.     private Set<RelationEdge> sets = new HashSet<>(); 
32.     
33. } 

1. package com.example.neo4j.entry; 
2. import lombok.Data; 
3. import org.neo4j.ogm.annotation.*; 
4.  
5. @RelationshipEntity(type = "RelationEdge") 
6. @Data 
7. public class RelationEdge { 
8.     @Id 
9.     @GeneratedValue 
10.     private Long id; 
11.  
12.     // 關系名 
13.     private String name; 
14.  
15.     @StartNode 
16.     private GroupNode groupNode; 
17.  
18.     @EndNode 
19.     private StudentNode studentNode; 
20.  
21.     public RelationEdge(GroupNode parentNode, StudentNode sonNode, String name) { 
22.         this.groupNode = parentNode; 
23.         this.studentNode = sonNode; 
24.         this.name = name; 
25.     } 
26. } 

5.Repository接口

對應的學生接口：

1. package com.example.neo4j.repository; 
2.  
3. import com.example.neo4j.entry.StudentNode; 
4. import org.springframework.data.neo4j.repository.Neo4jRepository; 
5.  
6. public interface StudentRepository extends Neo4jRepository<StudentNode,Long> { 
7. } 

對應的班級接口

1. package com.example.neo4j.repository; 
2.  
3. import com.example.neo4j.entry.GroupNode; 
4. import org.springframework.data.neo4j.repository.Neo4jRepository; 
5.  
6. public interface GroupRepository extends Neo4jRepository<GroupNode,Long> { 
7. } 

最后完成編寫我們的 Controller

1. package com.example.neo4j.controller; 
2.  
3. import com.example.neo4j.entry.*; 
4. import com.example.neo4j.repository.GroupRepository; 
5. import com.example.neo4j.repository.StudentRepository; 
6. import lombok.extern.slf4j.Slf4j; 
7. import org.springframework.beans.factory.annotation.Autowired; 
8. import org.springframework.web.bind.annotation.GetMapping; 
9. import org.springframework.web.bind.annotation.RequestMapping; 
10. import org.springframework.web.bind.annotation.RestController; 
11.  
12.  
13. @RestController 
14. @RequestMapping("/node") 
15. @Slf4j 
16. public class GroupController { 
17.  
18.     @Autowired 
19.     private StudentRepository studentRepository; 
20.     @Autowired 
21.     private GroupRepository groupRepository; 
22.  
23.     @GetMapping(value = "/create") 
24.     public void createNodeRelation() { 
25.         StudentNode studentNode1 = new StudentNode(); 
26.         studentNode1.setName("Alen"); 
27.         studentNode1.setSex("男"); 
28.         StudentNode studentNode2 = new StudentNode(); 
29.         studentNode2.setName("Kai"); 
30.         studentNode2.setSex("女"); 
31.         studentRepository.save(studentNode1); 
32.         studentRepository.save(studentNode2); 
33.  
34.         GroupNode groupNode = new GroupNode(); 
35.         groupNode.setName("火箭班"); 
36.         groupNode.setNum("298"); 
37.         // 增加關系 
38.         groupNode.addRelation(studentNode1, "includes"); 
39.         groupNode.addRelation(studentNode2, "includes"); 
40.         groupRepository.save(groupNode); 
41.     } 
42. } 

啟動之后，訪問http://localhost:8080/node/create

我們再去圖譜數據庫看看。

怎么樣，使用Java 操作是不是也是非常簡單的呢?這樣的圖譜數據庫你會選擇么?

原文鏈接：https://mp.weixin.qq.com/s/OnZ21ecRd5OUdq-wo37LwQ