Java实现neo4j数据库连接及增删改查

天行健，君子以自强不息；地势坤，君子以厚德载物。

每个人都有惰性，但不断学习是好好生活的根本，共勉！

文章均为学习整理笔记，分享记录为主，如有错误请指正，共同学习进步。

可参考文章：
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:
  port: 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;
}

补：UserNode实体类

UserNode.java

package com.neo4j.entity;

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * @ClassDescription: 用户节点信息
 * @Author：李白
 * @Date：2023/8/1 8:43
 */
@Data
@AllArgsConstructor
public class UserNode {
    private String userName;
    private String userGroup;
    private String email;
}

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("李白","唐","libai@163.com");
        UserNode un2 = new UserNode("杜甫","唐","dufu@163.com");
        UserNode un3 = new UserNode("李信","秦","lixin@163.com");
        UserNode un4 = new UserNode("张飞","蜀","zhangfei@163.com");
        UserNode un5 = new UserNode("黄忠","蜀","huangzhong@163.com");
        UserNode un6 = new UserNode("刘备","蜀","liubei@163.com");
        UserNode un7 = new UserNode("赵云","蜀","zhaoyun@163.com");
        UserNode un8 = new UserNode("马超","蜀","machao@163.com");
        UserNode un9 = new UserNode("关羽","蜀","guanyu@163.com");
        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已无

现在可以回到删除节点的那一部分去删除全部节点。文章来源地址https://www.toymoban.com/news/detail-634573.html

到了这里，关于Java实现neo4j数据库连接及增删改查的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！