Java实现neo4j数据库连接及增删改查
天行健，君子以自强不息；地势坤，君子以厚德载物。
每个人都有惰性，但不断学习是好好生活的根本，共勉！
文章均为学习整理笔记，分享记录为主，如有错误请指正，共同学习进步。
Java实现neo4j数据连接及增删改查
- 一、简单连接neo4j数据库
-
- 1. 依赖引入
- 2. 主方法
- 二、对neo4j数据库的增删改查
-
- 1. 项目包结构
- 2. 依赖引入
- 3. yml文件
- 4. 启动类
- 5. 参数文件
- 6. 配置类
- 7. 工具类
- 8. 请求类
- 9. postman测试
-
- 9.1 创建节点
-
- 9.1.1 浏览器查看全部节点
- 9.1.2 添加节点
- 9.1.3 postman截图
- 9.1.4 浏览器查看已创建的节点
- 9.1.5 删除全部节点
- 9.1.6 批量创建设备
- 9.1.7 批量创建用户
- 9.1.8 查看新建节点
- 9.2 查询节点
-
- 9.2.1 查询全部节点
- 9.2.2 查询指定标签的所有节点
- 9.2.3 查询单个设备节点
- 9.2.4 查询单个用户节点
- 9.3 修改节点
-
- 9.3.1 修改用户节点
- 9.3.2 修改设备节点
- 9.4 删除节点
-
- 9.4.1 删除用户节点
- 9.4.2 删除设备节点
- 9.4.3 删除全部节点
- 9.5 创建关系
-
- 9.5.1 创建两个节点之间的关系
- 9.5.2 创建单用户对多设备的关系
- 9.5.3 创建单设备对应多用户的关系
- 9.6 查询关系
-
- 9.6.1 查询用户名下的设备列表
- 9.6.2 查询设备对应的可使用人
- 9.7 修改关系
-
- 9.7.1 修改某个用户对某个设备的关系
- 9.7.2 修改指定用户与其名下所有设备的关系
- 9.7.3 修改指定设备与其所有使用人的关系
- 9.8 删除关系
-
- 9.8.1 删除指定用户指定设备的关系
- 9.8.2 删除指定用户和其名下所有设备的关系
- 9.8.3 删除指定设备和其可用人的所有关系
可参考文章：
neo4j数据库的介绍及基础语法
neo4j数据库语法实例演示
在增删改查之前我们先连接一下数据库并尝试执行命令。如下：
一、简单连接neo4j数据库
创建maven项目，在pom中引入依赖，编写主类运行执行cql语句进行数据库操作
1. 依赖引入
引入neo4j的依赖，pom只需添加此依赖即可
<dependency>
<groupId>org.neo4j.driver</groupId>
<artifactId>neo4j-java-driver</artifactId>
<version>4.4.9</version>
</dependency>
2. 主方法
在主方法中填入数据库相关参数连接，并执行cql语法命令操作
public static void main( final String[] args ) throws Exception{
//输入你的数据库IP地址和端口、账号和密码
Driver driver = GraphDatabase.driver("bolt://47.101.196.172:7687", AuthTokens.basic("neo4j", "password"));
Session session = driver.session();
//创建一个类为User的节点并赋值属性name，name值为李白
session.run("create(u:User {name:\"李白\"})");
session.close();
driver.close();
System.out.println("sssss");
}
我们知道如何连接并知道怎么去操作数据库，接下来就是完整的对数据库连接和增删改查操作。
首先是参数读取数据库的服务器地址账号密码等参数，然后将每个命令封装成一个函数来执行。
如下：
二、对neo4j数据库的增删改查
以下内容是以spring boot项目为基础来操作neo4j数据库，可参考spring boot搭建
1. 项目包结构
2. 依赖引入
因为需要用到一些工具所以这里除了neo4j外还需要加点别的
完整pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>neo4j</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<parent>
<artifactId>spring-boot-starter-parent</artifactId>
<groupId>org.springframework.boot</groupId>
<version>2.3.4.RELEASE</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>2.0.32</version>
</dependency>
<dependency>
<groupId>org.neo4j.driver</groupId>
<artifactId>neo4j-java-driver</artifactId>
<version>4.4.9</version>
</dependency>
</dependencies>
</project>
3. yml文件
application.yml
server:
prot: 8089
4. 启动类
Neo4jApplication.java
package com.neo4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* @ClassDescription:
* @Author：李白
* @Date：2023/8/1 14:40
*/
@SpringBootApplication
public class Neo4jApplication {
public static void main(String[] args) {
SpringApplication.run(Neo4jApplication.class,args);
}
}
5. 参数文件
neo4j.properties
neo4j.url=bolt://47.101.196.173:7687
neo4j.username=neo4j
neo4j.password=password
6. 配置类
此类就是用来读取数据路参数文件中的参数的
有关文件参数读取可参考properties文件参数读取（@ConfigurationProperties）
Neo4jConfig.java
package com.neo4j.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;
/**
* @ClassDescription: neo4j数据库参数配置类
* @Author：李白
* @Date：2023/7/31 15:57
*/
@Data
@Component
@PropertySource("neo4j.properties")
@ConfigurationProperties(prefix = "neo4j")
public class Neo4jConfig {
private String url;
private String username;
private String password;
}
7. 工具类
Neo4jUtils.java
package com.neo4j.utils;
import com.alibaba.fastjson.JSONObject;
import com.neo4j.config.Neo4jConfig;
import org.neo4j.driver.*;
import org.springframework.beans.factory.annotation.Autowired;
import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
* @ClassDescription:
* @Author：李白
* @Date：2023/8/3 14:45
*/
@Component
public class Neo4jUtils {
@Autowired
Neo4jConfig neo4jCfg;
private static Neo4jConfig neo4jConfig;
@PostConstruct
public void s(){
neo4jConfig = neo4jCfg;
}
/**
* 增删改接口调用（create/delete/set）
* @param cql
*/
public static void cds(String cql){
Driver d = GraphDatabase.driver(neo4jConfig.getUrl(), AuthTokens.basic(neo4jConfig.getUsername(), neo4jConfig.getPassword()));
Session s = d.session();
s.run(cql);
s.close();
d.close();
}
/**
* 查询接口调用(match)
* @param cql
* @return
*/
public static List m(String cql){
Driver d = GraphDatabase.driver(neo4jConfig.getUrl(), AuthTokens.basic(neo4jConfig.getUsername(), neo4jConfig.getPassword()));
Session s = d.session();
Result result = s.run(cql);
List list = new ArrayList();
//获取每一个节点
while ( result.hasNext() )
{
Record record = result.next();
Map<String, Object> map = record.get("n").asMap();
Set<Entry<String, Object>> set = map.entrySet();
JSONObject nodeProperties = new JSONObject();
//遍历每个节点中的信息，都是key-value形式的
for(Map.Entry one : set){
nodeProperties.put(one.getKey().toString(),one.getValue());
System.out.print(one.getKey() + "=" + one.getValue() + ";");
}
System.out.println();
list.add(nodeProperties);
}
list.stream().sorted();
System.out.println(list);
s.close();
d.close();
return list;
}
}
8. 请求类
Neo4jController.java
package com.neo4j.controller;
import com.alibaba.fastjson.JSONObject;
import com.neo4j.entity.UserNode;
import com.neo4j.utils.Neo4jUtils;
import org.springframework.web.bind.annotation.*;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
/**
* @ClassDescription: 请求调用-neo4j数据操作
* @Author：李白
* @Date：2023/7/31 8:27
*/
@RestController
@RequestMapping("/neo4j-part")
public class Neo4jController {
/**
* 新增节点-用户----------------------问题：字符串直接使用需要用反斜杠转义，以变量形式填入则会报错。
*/
@PostMapping("/addNode")
public void add(@RequestParam("name")String name){
// String name = "libai666";
String cql = "create (u:User {name:\""+name+"\"})";
Neo4jUtils.cds(cql);
}
/**
* ----------------------------------------------------新增节点-------------------------------------------------------
*/
/**
* 新增设备
*/
@PostMapping("/addDevice")
public void addDevice(){
String deviceGroup = "internal";
//创建二十个设备
for (int i = 1; i < 21; i++) {
if (i<10){
String deviceIdPre = "NA000";
String cql = "create (d:Device {deviceId:"+"\""+deviceIdPre+i+"\""+", deviceGroup:"+"\""+deviceGroup+"\""+"})";
Neo4jUtils.cds(cql);
}else {
String deviceIdPre = "NA00";
String cql = "create (d:Device {deviceId:"+"\""+deviceIdPre+i+"\""+", deviceGroup:"+"\""+deviceGroup+"\""+"})";
Neo4jUtils.cds(cql);
}
}
}
/**
* 新增用户
*/
@PostMapping("/addUser")
public void addUser(){
//用户信息
UserNode un1 = new UserNode("李白","唐","[email protected]");
UserNode un2 = new UserNode("杜甫","唐","[email protected]");
UserNode un3 = new UserNode("李信","秦","[email protected]");
UserNode un4 = new UserNode("张飞","蜀","[email protected]");
UserNode un5 = new UserNode("黄忠","蜀","[email protected]");
UserNode un6 = new UserNode("刘备","蜀","[email protected]");
UserNode un7 = new UserNode("赵云","蜀","[email protected]");
UserNode un8 = new UserNode("马超","蜀","[email protected]");
UserNode un9 = new UserNode("关羽","蜀","[email protected]");
List<UserNode> list = new ArrayList();
list.add(un1);
list.add(un2);
list.add(un3);
list.add(un4);
list.add(un5);
list.add(un6);
list.add(un7);
list.add(un8);
list.add(un9);
//创建9个用户
for (int i = 0; i < list.size(); i++) {
UserNode u = list.get(i);
String cql = "create (u:User {name:\""+u.getUserName()+"\", userGroup:\""+u.getUserGroup()+"\",email:\""+u.getEmail()+"\"})";
Neo4jUtils.cds(cql);
}
}
/**
* ----------------------------------------------------查询节点-------------------------------------------------------
*/
/**
* 查询所有节点信息
* @return
*/
@GetMapping("/searchAll")
public JSONObject searchAll(){
String cql = "match (n) return n";
List m = Neo4jUtils.m(cql);
JSONObject listJson = new JSONObject();
listJson.put("allNodes",m);
return listJson;
}
/**
* 查询指定标签的所有节点信息
* @param label 标签
* @return
*/
@GetMapping("/searchLabelNodes")
public JSONObject searchLabelNodes(@RequestParam("label")String label){
String cql = "match (n:"+label+") return n";
List m = Neo4jUtils.m(cql);
JSONObject listJson = new JSONObject();
listJson.put("labelNodes",m);
return listJson;
}
/**
* 查询具体的一个节点信息--查询设备具体节点
* @param deviceId 设备号
* @return
*/
@GetMapping("/searchOneDevice")
public JSONObject searchOneDevice(@RequestParam("deviceId")String deviceId){
String cql = "match (n:Device{deviceId:\""+deviceId+"\"}) return n";
List m = Neo4jUtils.m(cql);
JSONObject listJson = new JSONObject();
listJson.put("device",m);
return listJson;
}
/**
* 查询具体的一个节点信息--查询设备具体节点
* @param name 用户名
* @return
*/
@GetMapping("/searchOneUser")
public JSONObject searchOneUser(@RequestParam("name")String name){
String cql = "match (n:User{name:\""+name+"\"}) return n";
List m = Neo4jUtils.m(cql);
JSONObject listJson = new JSONObject();
listJson.put("user",m);
return listJson;
}
/**
* ----------------------------------------------------删除节点-------------------------------------------------------
*/
/**
* 删除全部节点
*/
@DeleteMapping("/deleteAllNodes")
public void deleteAllNodes(){
String cql = "match(n) delete n";
Neo4jUtils.cds(cql);
}
/**
* 删除同一标签的全部节点
* @param label 标签
*/
@DeleteMapping("/deleteLabelAllNodes")
public void deleteLabelAllNodes(@RequestParam("label")String label){
String cql = "match(n:"+label+") delete n";
Neo4jUtils.cds(cql);
}
/**
* 删除指定的节点
* @param name 用户名
*/
@DeleteMapping("/deleteOneUser")
public void deleteOneUser(@RequestParam("name")String name){
String cql = "match(n:User{name:\""+name+"\"}) delete n";
Neo4jUtils.cds(cql);
}
/**
* 删除指定的节点
* @param deviceId 设备号
*/
@DeleteMapping("/deleteOneDevice")
public void deleteOneDevice(@RequestParam("deviceId")String deviceId){
String cql = "match(n:Device{deviceId:\""+deviceId+"\"}) delete n";
Neo4jUtils.cds(cql);
}
/**
* ----------------------------------------------------修改节点-------------------------------------------------------
*/
/**
* 根据用户名修改用户组和用户邮箱
* @param name 用户名
* @param userGroup 用户组
* @param email 用户邮箱
*/
@PutMapping("/updateUser")
public void updateUser(@RequestParam("name")String name,
@RequestParam("userGroup")String userGroup,
@RequestParam("email")String email){
String cql = "match(n:User{name:\""+name+"\"}) set n.userGroup=\""+userGroup+"\",n.email=\""+email+"\"";
Neo4jUtils.cds(cql);
}
/**
* 根据deviceId修改设备组
* @param deviceId 设备号
* @param deviceGroup 设备组
*/
@PutMapping("/updateDevice")
public void updateDevice(@RequestParam("deviceId")String deviceId,
@RequestParam("deviceGroup")String deviceGroup){
String cql = "match(n:Device{deviceId:\""+deviceId+"\"}) set n.deviceGroup=\""+deviceGroup+"\"";
Neo4jUtils.cds(cql);
}
/**
* ----------------------------------------------------创建关系-------------------------------------------------------
*/
/**
* 创建用户和设备之间的关系
* @param name 用户名
* @param deviceId 设备号
*/
@PostMapping("/createR")
public void createR(@RequestParam("name")String name,
@RequestParam("deviceId")String deviceId){
Date date = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd hhmmss");
String dateStr = sdf.format(date);
String cql1 = "match(u:User{name:\""+name+"\"}),(d:Device{deviceId:\""+deviceId+"\"})create (u)-[r:Borrow{date:\""+dateStr+"\"}]->(d)";
Neo4jUtils.cds(cql1);
String cql2 = "match(u:User{name:\""+name+"\"}),(d:Device{deviceId:\""+deviceId+"\"})create (u)<-[r:Belong{date:\""+dateStr+"\"}]-(d)";
Neo4jUtils.cds(cql2);
}
/**
* ----------------------------------------------------查询关系-------------------------------------------------------
*/
/**
* 查询指定用户名下的借用设备
* @param name 用户名
* @return
*/
@GetMapping("/searchU2D")
public JSONObject searchU2D(@RequestParam("name")String name){
JSONObject u2dJson = new JSONObject();
String cql = "match(u:User{name:\""+name+"\"})-[r:Borrow]->(n) return n";
List m = Neo4jUtils.m(cql);
u2dJson.put("u2dList",m);
return u2dJson;
}
/**
* 查询指定设备的使用用户列表
* @param deviceId 设备号
* @return
*/
@GetMapping("/searchD2U")
public JSONObject searchD2U(@RequestParam("deviceId")String deviceId){
JSONObject d2uJson = new JSONObject();
String cql = "match(d:Device{deviceId:\""+deviceId+"\"})-[r:Belong]->(n) return n";
List m = Neo4jUtils.m(cql);
d2uJson.put("d2uList",m);
return d2uJson;
}
/**
* ----------------------------------------------------删除关系-------------------------------------------------------
*/
/**
* 删除指定用户与指定设备的关系
* @param name 用户名
* @param deviceId 设备号
*/
@DeleteMapping("/deleteU2DR")
public void deleteU2DR(@RequestParam("name")String name,
@RequestParam("deviceId")String deviceId){
String cql1 = "match(u:User{name:\""+name+"\"})-[r:Borrow]->(d:Device{deviceId:\""+deviceId+"\"}) delete r";
String cql2 = "match(u:User{name:\""+name+"\"})<-[r:Belong]-(d:Device{deviceId:\""+deviceId+"\"}) delete r";
Neo4jUtils.cds(cql1);
Neo4jUtils.cds(cql2);
}
/**
* 删除指定用户与所有设备的关系
* @param name 用户名
*/
@DeleteMapping("/deleteU2AllDR")
public void deleteU2AllDR(@RequestParam("name")String name){
String cql1 = "match(u:User{name:\""+name+"\"})-[r:Borrow]->(d:Device) delete r";
String cql2 = "match(u:User{name:\""+name+"\"})<-[r:Belong]-(d:Device) delete r";
Neo4jUtils.cds(cql1);
Neo4jUtils.cds(cql2);
}
/**
* 删除指定设备与所有用户的关系
* @param deviceId 设备号
*/
@DeleteMapping("/deleteD2AllUR")
public void deleteD2AllUR(@RequestParam("deviceId")String deviceId){
String cql1 = "match(u:User)-[r:Borrow]->(d:Device{deviceId:\""+deviceId+"\"}) delete r";
String cql2 = "match(u:User)<-[r:Belong]-(d:Device{deviceId:\""+deviceId+"\"}) delete r";
Neo4jUtils.cds(cql1);
Neo4jUtils.cds(cql2);
}
/**
* ----------------------------------------------------修改关系-------------------------------------------------------
*/
/**
* 修改指定用户与指定设备的关系
* @param name 用户名
* @param deviceId 设备号
* @param expire 设备借用时间
*/
@PutMapping("/updateU2DR")
public void updateU2DR(@RequestParam("name")String name,
@RequestParam("deviceId")String deviceId,
@RequestParam("expire")String expire){
String cql1 = "match(u:User{name:\""+name+"\"})-[r:Borrow]->(d:Device{deviceId:\""+deviceId+"\"}) set r.date=\""+expire+"\"";
String cql2 = "match(u:User{name:\""+name+"\"})<-[r:Belong]-(d:Device{deviceId:\""+deviceId+"\"}) set r.date=\""+expire+"\"";
Neo4jUtils.cds(cql1);
Neo4jUtils.cds(cql2);
}
/**
* 修改指定用户与所有设备的关系
* @param name 用户名
* @param expire 设备借用时间
*/
@PutMapping("/updateU2AllDR")
public void updateU2AllDR(@RequestParam("name")String name,
@RequestParam("expire")String expire){
String cql1 = "match(u:User{name:\""+name+"\"})-[r:Borrow]->(d) set r.date=\""+expire+"\"";
String cql2 = "match(u:User{name:\""+name+"\"})<-[r:Belong]-(d) set r.date=\""+expire+"\"";
Neo4jUtils.cds(cql1);
Neo4jUtils.cds(cql2);
}
/**
* 修改指定设备与所有用户的关系
* @param deviceId 设备号
* @param expire 设备借用时间
*/
@PutMapping("/updateD2AllUR")
public void updateD2AllUR(@RequestParam("deviceId")String deviceId,
@RequestParam("expire")String expire){
String cql1 = "match(u)-[r:Borrow]->(d:Device{deviceId:\""+deviceId+"\"}) set r.date=\""+expire+"\"";
String cql2 = "match(u)<-[r:Belong]-(d:Device{deviceId:\""+deviceId+"\"}) set r.date=\""+expire+"\"";
Neo4jUtils.cds(cql1);
Neo4jUtils.cds(cql2);
}
}
9. postman测试
启动项目，通过postman请求测试，然后可以到neo4j的浏览器中查看
neo4j浏览器访问地址就是ip加端口号再加browser，如下：
http://47.101.196.173:7474/browser/
这里的端口号和连接数据库时的不同，这个是neo4j浏览器的端口。
9.1 创建节点
9.1.1 浏览器查看全部节点
先去浏览器中查看一下，查看全部节点的命令，如下：
match(n) return n
如图，数据库中节点为空
9.1.2 添加节点
127.0.0.1:8089/neo4j-part/addNode
9.1.3 postman截图
9.1.4 浏览器查看已创建的节点
此时去浏览器查看数据库中的节点
9.1.5 删除全部节点
删除李白节点，执行以下命令，可删除全部节点
match(n) delete n
接下来我们直接批量创建用户节点和设备节点
9.1.6 批量创建设备
127.0.0.1:8089/neo4j-part/addDevice
无参数的请求
9.1.7 批量创建用户
127.0.0.1:8089/neo4j-part/addUser
无参数的请求
9.1.8 查看新建节点
到浏览器界面查看
9.2 查询节点
9.2.1 查询全部节点
127.0.0.1:8089/neo4j-part/searchAll
9.2.2 查询指定标签的所有节点
127.0.0.1:8089/neo4j-part/searchLabelNodes
需要传参label=User如图
9.2.3 查询单个设备节点
127.0.0.1:8089/neo4j-part/searchOneDevice
9.2.4 查询单个用户节点
127.0.0.1:8089/neo4j-part/searchOneUser
9.3 修改节点
9.3.1 修改用户节点
127.0.0.1:8089/neo4j-part/updateUser
先在浏览器查看李白节点信息
postman发送修改请求
浏览器查看
9.3.2 修改设备节点
127.0.0.1:8089/neo4j-part/updateDevice
先在浏览器查看设备NA0001节点的信息
postman发送请求
浏览器查看
9.4 删除节点
9.4.1 删除用户节点
127.0.0.1:8089/neo4j-part/deleteOneUser
然后浏览器查看李白节点已经无了
9.4.2 删除设备节点
127.0.0.1:8089/neo4j-part/deleteOneDevice
删除全部节点，这个请求我们最后再执行，删了后面还得创建，我们先把后续的请求都试一遍再删。
9.4.3 删除全部节点
127.0.0.1:8089/neo4j-part/deleteAllNodes
先查看节点
match(n) return n
执行请求删除
浏览器查看节点已无
9.5 创建关系
9.5.1 创建两个节点之间的关系
127.0.0.1:8089/neo4j-part/createR
有参数传递，设置参数
创建赵云与设备NA0008之间的关系
此时去浏览器查看所有有关系的节点，使用命令如下：
match(u)-[r]->(d) return u,r,d
为了后续的操作我们这里多创建几个关系
9.5.2 创建单用户对多设备的关系
首先在赵云名下多建立几个设备的关系，name不变，修改参数deviceId即可，分别与设备NA0009,NA0010,NA0011,NA0012建立关系，创建后浏览器查看关系
9.5.3 创建单设备对应多用户的关系
将NA0008与多个用户建立关系，deviceId为NA0008不变，修改name，分别与用户黄忠、张飞、刘备、关羽创建关系，创建后浏览器查看
9.6 查询关系
9.6.1 查询用户名下的设备列表
127.0.0.1:8089/neo4j-part/searchU2D
查询用户赵云名下的设备列表
9.6.2 查询设备对应的可使用人
即单设备对用多用户的用户列表
127.0.0.1:8089/neo4j-part/searchD2U
查询设备NA0008对应的用户
9.7 修改关系
9.7.1 修改某个用户对某个设备的关系
127.0.0.1:8089/neo4j-part/updateU2DR
先查看用户赵云与设备NA0010的关系信息
将date信息修改为20230801 120000，注意，因为代码里请求参数的key是expire而不是date所以在postman中的key为expire
然后去浏览器查看修改后的关系
9.7.2 修改指定用户与其名下所有设备的关系
127.0.0.1:8089/neo4j-part/updateU2AllDR
将赵云名下的设备关系建立日期时间修改为20230707 070707
我们发现赵云对应的所有设备关系date全部修改
9.7.3 修改指定设备与其所有使用人的关系
127.0.0.1:8089/neo4j-part/updateD2AllUR
将设备NA0008对应的用户关系创建日期修改为20230808 080808
9.8 删除关系
9.8.1 删除指定用户指定设备的关系
127.0.0.1:8089/neo4j-part/deleteU2DR
删除设备NA0008与用户黄忠的关系
到浏览器查看，已无黄忠的关系
9.8.2 删除指定用户和其名下所有设备的关系
127.0.0.1:8089/neo4j-part/deleteU2AllDR
删除赵云和其名下所有设备的关系
浏览器查看赵云已无
9.8.3 删除指定设备和其可用人的所有关系
127.0.0.1:8089/neo4j-part/deleteD2AllUR
删除设备NA0008与所有用户的关系
浏览器查看关系设备NA0008已无
现在可以回到删除节点的那一部分去删除全部节点。