Neo4j+SpringBoot实现节点以及关系的增删改查（Spring Data Neo4j）

最新推荐文章于 2024-07-27 16:08:44 发布
最新推荐文章于 2024-07-27 16:08:44 发布
阅读量9.1k 收藏 48
点赞数 10
分类专栏： SpingBoot 文章标签： neo4j spring boot
本文为博主原创文章，未经博主允许不得转载。---by chen
本文链接：https://blog.csdn.net/qq_33637730/article/details/107629950
版权

公司让学习一下Neo4j在SpringBoot框架下的使用，我知道有个Spring DATA Neo4J，在网上找了很多教程，有些地方让我困惑了很久，所以记下来希望能给后面学习的伙伴一些帮助。

先上效果图：

效果.png

一、开发环境

IDE：idea

JDK：1.8

先搭建一个普通的SpringBoot项目，然后导入依赖。

yml配置：


spring:

  data:

    neo4j:

      uri: bolt://localhost:7687

      username: neo4j

      password: cldev

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <parent>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-parent</artifactId>

        <version>2.3.2.RELEASE</version>

        <relativePath/> <!-- lookup parent from repository -->

    </parent>

    <groupId>com.example</groupId>

    <artifactId>neo4jdemo</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    <name>neo4jdemo</name>

    <description>Demo project for Spring Boot</description>

    <properties>

        <java.version>1.8</java.version>

    </properties>

    <dependencies>

        <!--Neo4j相关-->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-data-neo4j</artifactId>

        </dependency>

        <dependency>

            <groupId>org.neo4j</groupId>

            <artifactId>neo4j-ogm-core</artifactId>

            <version>3.2.14</version>

        </dependency>

        <dependency>

            <groupId>org.springframework.data</groupId>

            <artifactId>spring-data-neo4j</artifactId>

            <version>5.3.2.RELEASE</version>

        </dependency>

        <!--Json处理 @JsonIdentityInfo(generator= JSOGGenerator.class)用到-->

        <dependency>

            <groupId>com.voodoodyne.jackson.jsog</groupId>

            <artifactId>jackson-jsog</artifactId>

            <version>1.1</version>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-web</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-test</artifactId>

            <scope>test</scope>

            <exclusions>

                <exclusion>

                    <groupId>org.junit.vintage</groupId>

                    <artifactId>junit-vintage-engine</artifactId>

                </exclusion>

            </exclusions>

        </dependency>

    </dependencies>

    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>

</project>

项目目录结构

二、代码部分

为了简单，本项目节点只设置一种类型（User），实现的关系的某一个User知道另一User，关系（Know）。

首先编写User节点类（UserNode .java）：

package com.example.neo4jdemo.entity.node;

import com.fasterxml.jackson.annotation.JsonIdentityInfo;

import com.voodoodyne.jackson.jsog.JSOGGenerator;

import org.neo4j.ogm.annotation.*;

import java.util.HashSet;

import java.util.Set;

@JsonIdentityInfo(generator= JSOGGenerator.class)

@NodeEntity(label = "User")

public class UserNode {

    @Id

    @GeneratedValue

    private Long nodeId;

    @Property(name = "name")

    private String name;

    @Property(name = "age")

    private int age;

    @Property(name = "sex")

    private String sex;

    /*注意这个地方：并不是说加了这个注解，然后下面实现了addKnows这个方法在以后调用addKnows

    就可以实现关系的增加，这是不对的，我看了很多教程没有说明。这个addKnows方法，只有在节点未被

    添加之前，调用该方法添加关系，然后再调用UserService中的create方法，这样关系才会同时被添加到图

    数据库中。如果想实现两个已有节点之间增加关系，需要单独实现*/

    @Relationship(type = "know" ,direction = Relationship.OUTGOING)

    private Set<UserNode> knows = new HashSet<>();

    public Long getNodeId() {

        return nodeId;

    }

    public void setNodeId(Long nodeId) {

        this.nodeId = nodeId;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

    public String getSex() {

        return sex;

    }

    public void setSex(String sex) {

        this.sex = sex;

    }

    public Set<UserNode> getKnows() {

        return knows;

    }

    public void setKnows(Set<UserNode> knows) {

        this.knows = knows;

    }

    public Boolean addKnows(UserNode to){

        return this.knows.add(to);

    }

    @Override

    public String toString() {

        return "UserNode{" +

                "nodeId=" + nodeId +

                ", name='" + name + '\'' +

                ", age=" + age +

                ", sex='" + sex + '\'' +

                '}';

    }

    public UserNode() {}

}
关系类（Know.java）

package com.example.neo4jdemo.entity.relationship;

import com.example.neo4jdemo.entity.node.UserNode;

import com.fasterxml.jackson.annotation.JsonIdentityInfo;

import com.voodoodyne.jackson.jsog.JSOGGenerator;

import org.neo4j.ogm.annotation.*;

/**

* @program: neo4jdemo

* @description: 知道关系类

* @author: chen

* @create: 2020-07-27

**/

@JsonIdentityInfo(generator= JSOGGenerator.class)

@RelationshipEntity(type = "know")

public class Know  {

    @Id

    @GeneratedValue

    private Long id;

    @StartNode

    private UserNode from;

    @EndNode

    private UserNode to;

    public Long getId() {

        return id;

    }

    public void setId(Long id) {

        this.id = id;

    }

    public UserNode getFrom() {

        return from;

    }

    public void setFrom(UserNode from) {

        this.from = from;

    }

    public UserNode getTo() {

        return to;

    }

    public void setTo(UserNode to) {

        this.to = to;

    }

    public Know() {

    }

    public Know(UserNode from, UserNode to) {

        this.from = from;

        this.to = to;

    }

    @Override

    public String toString() {

        return "Know{" +

                "id=" + id +

                ", from=" + from +

                ", to=" + to +

                '}';

    }

}
KnowRepository.java

package com.example.neo4jdemo.repository;

import com.example.neo4jdemo.entity.relationship.Know;

import org.springframework.data.neo4j.annotation.Query;

import org.springframework.data.neo4j.repository.Neo4jRepository;

import org.springframework.data.repository.query.Param;

/**

* @program: neo4jdemo

* @description: 知道关系接口类

* @author: chen

* @create: 2020-07-27

**/

public interface KnowRepository extends Neo4jRepository<Know,Long> {

    @Query("MATCH (fromNode) WHERE id(fromNode) = {fromId} MATCH (toNode) WHERE id(toNode) = {toId} MATCH (fromNode)-[r]->(toNode) DELETE r")

    void deleteByNodeId(@Param(value = "fromId") long fromId,@Param(value = "toId") long toId);

}
UserRepository.java

基础的增删改查Spring Data Neo4j已经封装好在Neo4jRepository里面了。


package com.example.neo4jdemo.repository;

import com.example.neo4jdemo.entity.node.UserNode;

import org.springframework.data.neo4j.annotation.Query;

import org.springframework.data.neo4j.repository.Neo4jRepository;

import org.springframework.data.repository.query.Param;

import org.springframework.stereotype.Repository;

@Repository

public interface UserRepository extends Neo4jRepository<UserNode,Long> {

//    @Query("MATCH (n:User) RETURN n ")

//    List<UserNode> getUserNodeList();

//

//    @Query("create (n:User{name:{name},age:{age},sex:{sex}}) RETURN n ")

//    UserNode addUserNode(@Param("name") String name, @Param("age")int age, @Param("sex") String sex);

    @Query("MATCH (n) WHERE id(n) = :#{#userNode.nodeId} SET n.name = :#{#userNode.name},n.age = :#{#userNode.age},n.sex = :#{#userNode.sex} RETURN n")

    UserNode updateByNode(@Param("userNode") UserNode userNode);

}
UserService.java

package com.example.neo4jdemo.service;

import com.example.neo4jdemo.entity.node.UserNode;

import com.example.neo4jdemo.entity.relationship.Know;

import java.util.List;

import java.util.Optional;

public interface UserService {

    /**

    * @Description: 添加user节点

    * @Params: [UserNode]

    * @return: int

    * @Author: chen

    * @Date: 2020/7/27

    */

    UserNode create(UserNode userNode);

    /**

    * @Description: 删除

    * @Author: chen

    * @Date: 2020/7/27

    */

    void deleteById(Long id);

    /**

    * @Description: 查询

    * @Author: chen

    * @Date: 2020/7/27

    * @return

    */

    Optional<UserNode> findById(long id);

    /**

    * @Description: 获取所有User节点

    * @Params: null

    * @return: List

    * @Author: chen

    * @Date: 2020/7/27

    */

    List<UserNode> findAll();

    /**

    * @Description: 增加“知道”关系

    * @Author: chen

    * @Date: 2020/7/27

    */

    Know addIKnows(UserNode fromNode, UserNode toNode);

    UserNode updateByNode(UserNode userNode);

    void deleteKnowByNodeId(long fromId,long toId);

}
UserServiceImpl.java

package com.example.neo4jdemo.service.impl;

import com.example.neo4jdemo.entity.node.UserNode;

import com.example.neo4jdemo.entity.relationship.Know;

import com.example.neo4jdemo.repository.KnowRepository;

import com.example.neo4jdemo.repository.UserRepository;

import com.example.neo4jdemo.service.UserService;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import java.util.List;

import java.util.Optional;

@Service

public class UserServiceImpl implements UserService {

    @Autowired

    private UserRepository userRepository;

    @Autowired

    private KnowRepository knowRepository;

    @Override

    public UserNode create(UserNode userNode) {

        return userRepository.save(userNode);

    }

    @Override

    public void deleteById(Long id) {

        userRepository.deleteById(id);

    }

    @Override

    public Optional<UserNode> findById(long id) {

        return userRepository.findById(id);

    }

    @Override

    public List<UserNode> findAll() {

        return (List<UserNode>) userRepository.findAll();

    }

    @Override

    public Know addIKnows(UserNode fromNode, UserNode toNode) {

        Know newKnow = new Know(fromNode,toNode);

        return knowRepository.save(newKnow);

    }

    @Override

    public UserNode updateByNode(UserNode userNode) {

        return userRepository.updateByNode(userNode);

    }

    @Override

    public void deleteKnowByNodeId(long fromId, long toId) {

        knowRepository.deleteByNodeId(fromId,toId);

    }

}
UserController.java

package com.example.neo4jdemo.controller;

import com.example.neo4jdemo.entity.node.UserNode;

import com.example.neo4jdemo.entity.relationship.Know;

import com.example.neo4jdemo.service.UserService;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.*;

import java.util.List;

import java.util.Optional;

/**

* @program: neo4jdemo

* @description: 控制层

* @author: chen

* @create: 2020-07-27

**/

@RestController

public class UserController {

    @Autowired

    private UserService userService;

    /**

    * @Description: 添加节点

    * @Author: chen

    * @Date: 2020/7/27

    */

    @RequestMapping(path = "/add", method = RequestMethod.POST)

    public UserNode addUserNode(@RequestBody UserNode userNode) {

        return userService.create(userNode);

    }

    /**

    * @Description: 根据id删除

    * @Author: chen

    * @Date: 2020/7/27

    */

    @RequestMapping(path = "/delete", method = RequestMethod.POST)

    public int delUserNodeById(@RequestParam(value = "id") long id) {

        userService.deleteById(id);

        System.out.println(id);

        return 1;

    }

    /**

    * @Description: 根据id更新

    * @Author: chen

    * @Date: 2020/7/27

    */

    @RequestMapping(path = "/update", method = RequestMethod.POST)

    public UserNode updateUserNodeByNode(@RequestBody UserNode userNode) {

        return userService.updateByNode(userNode);

    }

    @RequestMapping(path = "/get", method = RequestMethod.GET)

    public UserNode getUserNodeById(@RequestParam(value = "id") long id) {

        Optional<UserNode> optionalUserNode =  userService.findById(id);

        if(optionalUserNode.isPresent()){

            return optionalUserNode.get();

        }else{

            return null;

        }

    }

    /**

    * @Description: 查找所有节点

    * @Author: chen

    * @Date: 2020/7/27

    */

    @RequestMapping(path = "/list", method = RequestMethod.GET)

    public List<UserNode> getUserNodeList() {

        return userService.findAll();

    }

    @RequestMapping(path = "/addKnows", method = RequestMethod.POST)

    public Know addKnowsById(@RequestParam(value = "from") long fromId, @RequestParam(value = "to") long toId) {

        Optional<UserNode> fromOpt =  userService.findById(fromId);

        Optional<UserNode> toOpt =  userService.findById(toId);

        if(fromOpt.isPresent()&&toOpt.isPresent()){

            return userService.addIKnows(fromOpt.get(),toOpt.get());

        }else{

            return null;

        }

    }

    @RequestMapping(path = "/delKnows", method = RequestMethod.POST)

    public String deleteKnowsByNodeId(@RequestParam(value = "from") long fromId, @RequestParam(value = "to") long toId) {

        Optional<UserNode> fromOpt =  userService.findById(fromId);

        Optional<UserNode> toOpt =  userService.findById(toId);

        if(fromOpt.isPresent()&&toOpt.isPresent()){

            userService.deleteKnowByNodeId(fromId,toId);

            return "ok";

        }else{

            return "false";

        }

    }

}
Neo4jConfig.java 我也不知道干啥的

package com.example.neo4jdemo.config;

import org.springframework.context.annotation.Configuration;

import org.springframework.data.neo4j.repository.config.EnableNeo4jRepositories;

import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration

@EnableNeo4jRepositories(basePackages = "com.example.neo4jdemo.repository")

@EnableTransactionManagement // 激活SDN隐式事务

public class Neo4jConfig {

}

重点就是User中的那段注释，是我困扰了很久的问题，希望大家能够避坑。有什么问题可以留言。

会飞的鱼__
关注
专栏目录
springBoot集成neo4j实现查询节点
chenfangsong的博客
06-04 5585
springBoot+neo4j的文件目录 导入pom.xml依赖 <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-neo4j</artifactId> &lt...
基于Neo4j+springboot+vue+d3.js知识图谱构建和可视化
05-09
在这个项目中，Spring Boot作为后端服务，负责处理前端的HTTP请求，与Neo4j数据库进行交互，执行增删改查等操作。通过Spring Data Neo4j模块，可以方便地集成Neo4j并编写对应的Repository接口，以图形化方式操作数据...
neo4j服务端开发示例，采用spring-boot开发，内含节点增删改查、关系增删改查、复杂关系的查询。
06-19
neo4j3.1.18 windows版安装文件，neo4j服务端开发示例，采用spring-boot开发，内含节点增删改查、关系增删改查、复杂关系的查询。
Spring-Boot+Neo4j+节点之间关系网的搭建和查询
Appleyk的专栏
01-19 2万+
接着上一篇讲       上一篇我们学习了如何创建节点，以及查询节点，但未涉及二者之间的关系relationship，本篇，我们将通过简单的案列来完整的走一遍整个节点--关系--节点的流程，为了降低复杂度，关系是（1...n）单向的，也就是默认关系是Out出去的。一、场景节点Nodes：1.创建一个Coder类型的节点，代表程序员，属性有id，name，sex，hobby（姓名，性别，爱好）2.创
neo4j 基本查询
最新发布
hellochenlian的专栏
07-27 699
每个子句的输入都是图的状态和由引用变量组成的中间结果表。第一个子句将查询前的图的状态和一个空的中间结果表作为输入。一个子句的输出是图的新状态和新的中间结果表，作为下一个子句的输入。，他尚未与这些演员合作过，但他的合作演员曾与这些演员合作过。然后，该查询根据匹配的合作演员与 Keanu Reeves 的合作演员之一合作的频率对结果进行排序。请注意，如果其中一个子句返回中间结果的空表，则没有任何内容可以传递给后续子句，从而结束查询。还可以查询图中的多个节点。节点的传出关系，并返回与该节点相关的关系和电影名称。
图数据库Neo4j——SpringBoot使用Neo4j & 简单增删改查 & 复杂查询初步
Arya的博客，专注后端领域
11-01 8098
Neo4j是用Java实现的开源NoSQL图数据库，本篇博客介绍如何在SpringBoot中使用Neo4j图数据库，如何进行简单的增删改查，以及如何进行复杂的查询。
Spring-Boot +Neo4j+实现节点的创建和关系的添加【玩转neo4j】
热门推荐
Appleyk的专栏
05-12 2万+
我们先来看下neo4j的三种连接方式打开neo4j的配置文件总过有三种连接方式常用的有两种，一种是http的连接方式【端口：7474】，一种是Bolt的连接方式【端口：7687】http的连接方式本篇不再讲了，本篇主要讲第二种连接方式，并结合neo4j提供的原生JavaAPI驱动进行节点的创建和关系的添加最终实现的效果是...
Spring Data Neo4j解除两个节点之间的关系
fxtxz2的专栏
04-01 1086
问题 需要解除两个Node之间的某种关系 思路 利用@Query注解，在其中运行Cypher的解除两个Node之间关系语句即可。 Repository @Query("MATCH (:MyNode{id:$startNodeId})-[r:MY_REL]->(:MyNode{id:$targetNodeId}) DELETE r") void detachForRel(@Param("startNodeId") String startNodeId,@Param("targetNodeId")
neo4j中设置关联关系，以及查询
weixin_43632687的博客
05-04 1038
neo4j 关联关系
Neo4j+springboot+vue+d3.js知识图谱构建和可视化
01-17
在知识图谱项目中，SpringBoot可以作为后端服务，处理HTTP请求，调用Neo4j的API进行数据的增删查改，并将结果返回给前端。 **3. Vue.js - 前端开发框架** Vue.js是一个轻量级的前端JavaScript框架，用于构建用户...
neo4j整合springboot添加节点关系.rar
05-08
在IT领域，尤其是在开发Web应用程序时，整合不同的技术框架能够极大地提高开发效率和系统的...通过遵循上述步骤，你可以轻松地在Spring Boot应用中管理Neo4j中的节点和关系，实现数据的增删改查以及更高级的图操作。
springboot整合neo4j完整demo
08-31
springboot集成neo4j图数据库，使用java语言连接数据库mysql和neo4j，实现将mysql数据插入neo4j中。 实现的功能有对neo4j数据进行统计分析、关系遍历增删改查等 。并且使用d3对查询结果数据进行页面展示！
毕设项目：基于springboot+neo4j的医疗系统知识图谱问答.zip
12-24
该项目是基于SpringBoot框架构建的，结合Neo4j数据库实现的一个医疗系统知识图谱问答系统。SpringBoot以其简化Spring应用初始搭建以及开发过程的特点，被广泛应用于现代Java Web开发。以下将详细介绍SpringBoot和...
neo4j查询某个节点的所有关系节点和与这些节点的关系（python之py2neo）
shadowkillerss的博客
04-14 2万+
废话不多说，直接上代码 from py2neo import Graph, Node, Relationship,NodeMatcher graph = Graph('http://localhost:7474',username='neo4j',password='123456') #这是提取柳枝这个节点 data1 = graph.run("MATCH(n:planet) WHERE n.name = '柳枝' RETURN n ").data() #返回和柳枝有同义词关系的其他节点和关系 a = gr
neo4j中修改关系属性
lixiaobai_boke的博客
09-28 1517
neo4j中修改关系属性
Spring-Boot+Neo4j☞节点关系的创建和查询
Appleyk的专栏
06-02 1万+
一、
neo4j修改节点(包括属性，关系）
11-14 6107
将 “傅式级数” 这个节点删除，并把 ”单位冲激序列的傅里叶变换“ 这个节点 指向 ”傅氏级数“ 这个节点 match (r) where id(r)=76247 detach delete r match (p:KnowledgeBlock{name:'单位冲激序列的傅里叶变换'}),(m:AlignmentObject{name:'傅氏级数'}) create (p)-[r:hasPartOf]->(m) ...
【Neo4j】Spring Data Neo4j APi阅读随笔
Junnix的博客
02-26 798
TargetNode: 应用在注解为 的类的某个字段上，@RelationshipProperties从另一端的角度来标记该关系的目标。@CompositeProperty：在字段级别应用于应作为复合读回的 Map 类型的属性。@RelationshipProperties：应用于类级别以指示此类作为关系属性的目标。@DynamicLabels：应用于字段级别以指定动态标签的来源。：用于实体映射，里面存放的是映射后的类名。：应用于字段级别以指定关系的详细信息。：用与实体类的属性，表示映射后为属性。
neo4j+springboot+vue+d3.js知识图谱构建和可视化运行
05-23
构建和可视化知识图谱可以分为两个阶段，首先是构建知识图谱的数据模型和存储，其次是将数据可视化成图形。 下面是一个neo4j+springboot+vue+d3.js知识图谱构建和可视化的基本流程： 1. 安装neo4j，并创建一个新的数据库 2. 使用springboot连接neo4j数据库，定义数据模型和业务逻辑 3. 使用vue.js作为前端框架，实现用户界面和交互 4. 使用d3.js作为可视化工具，将数据可视化为图形 具体步骤： 1. 安装neo4j 下载neo4j社区版并安装，创建一个新的数据库。可以使用neo4j的自带的web界面Neo4j Browser访问和管理数据库。 2. 使用springboot连接neo4j数据库 在springboot中使用neo4j的Java API连接数据库，定义数据模型和业务逻辑。可以使用spring-data-neo4j库来简化开发。 3. 使用vue.js作为前端框架 使用vue.js构建前端界面和交互。可以使用vue-router进行页面路由管理，使用axios进行异步请求和数据交互。 4. 使用d3.js进行可视化 使用d3.js将数据可视化为图形，可以使用d3-force布局算法展示节点之间的关系。也可以使用其他的d3.js插件来实现更复杂的可视化效果。 总结： 以上是neo4j+springboot+vue+d3.js知识图谱构建和可视化的基本流程。这个方案可以帮助构建复杂的知识图谱，同时也能够提供交互性强的用户界面。
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值