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

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

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

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("李白","唐","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已无

现在可以回到删除节点的那一部分去删除全部节点。

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 删除指定设备和其可用人的所有关系

相关文章