neo4j图数据库安装(mac)+neo4j集成springboot实现基础的增删改查

空の鱼

已于 2022-07-14 19:44:35 修改

阅读量1.5k

点赞数 2

分类专栏：记录积累文章标签： spring boot 数据库 java neo4j

于 2022-06-20 19:43:08 首次发布

本文链接：https://blog.csdn.net/xinghen1993/article/details/125378330

版权

记录积累专栏收录该内容

25 篇文章 0 订阅

订阅专栏

第一部分 mac安装neo4j

第二部分 neo4j集成springboot实现基础的增删改查

第一部分 mac安装图数据库NEO4J

1、官网下载：Neo4j Download Center - Neo4j Graph Data Platform

注意：neo4j需要和java版本相对应，jdk1.8.x的应对应Neo4j3.x

2、cd到安装目录下：tar -zxvf neo4j-community-3.5.34-unix.tar.gz

3、cd到解压的文件夹的bin目录下，输入neo4j start，如下就是启动成功了

4、进入浏览器，输入http://localhost:7474/

5、如果想要退出，cd到解压的文件夹的bin目录下，输入neo4j stop即可

6、想要在其他目录下也可启动数据库，配置环境变量

vim ~/.bash_profile

source ~/.bash_profile

第二部分 neo4j集成springboot实现基础的增删改查

一、图数据库相关配置

1、pom.xml

注意：这里使用的springboot2.3.2.RELEASE，jdk1.8，Neo4j Server version：3.5.28，不同版本可能存在冲突问题，导致程序起不来

 <!--这里使用的springboot2.3.2.RELEASE，jdk1.8，Neo4j Server version：3.5.28，不同版本可能存在冲突问题，导致程序起不来-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>



    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</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>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>


        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
            <scope>provided</scope>
        </dependency>

        <!--图数据库相关-->
        <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.16</version>
        </dependency>

2、application.yml（本地的neo4j数据库）

server:
  port: 8888
  servlet:
    context-path: /
spring:
  data:
    neo4j:
      uri: bolt://localhost:7687
      username: neo4j
      password: 123456

3、目录结构

二、业务逻辑

实体类

1、neo4j中节点的实体类——UserNode节点

package com.study.neo.entity;

import lombok.Data;
import org.neo4j.ogm.annotation.*;
import java.util.HashSet;
import java.util.Set;


@NodeEntity(label = "User")
@Data
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方法，这样关系才会同时被添加到图
    数据库中。如果想实现两个已有节点之间增加关系，需要单独实现，即controller中的addKnows方法*/
    @Relationship(type = "know" ,direction = Relationship.OUTGOING)
    private Set<UserNode> knows = new HashSet<>();

    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() {}

}

2、neo4j中关系的实体类——Know关系

package com.study.neo.entity;

import lombok.Data;
import org.neo4j.ogm.annotation.*;

@RelationshipEntity(type = "know")
@Data
public class Know {

    @Id
    @GeneratedValue
    private Long id;

    @StartNode
    private UserNode from;

    @EndNode
    private UserNode to;

    @Override
    public String toString() {
        return "Know{" +
                "id=" + id +
                ", from=" + from +
                ", to=" + to +
                '}';
    }

    public Know(UserNode from, UserNode to) {
        this.from = from;
        this.to = to;
    }

}

持久层

持久层继承Neo4jRepository<pojo类型, 主键类型>即实现基础的增删改查，当然也可以自己写sql，方式与mybatis框架大同小异。

UserRepository

package com.study.neo.dao;

import com.study.neo.entity.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);

}

KnowRepository

package com.study.neo.dao;

import com.study.neo.entity.Know;
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 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);

}

业务层

UserService

package com.study.neo.service;

import com.study.neo.entity.Know;
import com.study.neo.entity.UserNode;

import java.util.List;
import java.util.Optional;

public interface UserService {

    /**
     * @Description 添加user节点
     **/
    UserNode create(UserNode userNode);

    /**
     * @Description 根据id删除
     **/
    void deleteById(Long id);

    /**
     * @Description 根据id查询
     **/
    Optional<UserNode> findById(long id);

    /**
     * @Description 获取所有User节点
     **/
    List<UserNode> findAll();

    /**
     * @Description 增加“知道”关系
     **/
    Know addIKnows(UserNode fromNode, UserNode toNode);

    /**
     * @Description 修改单个节点
     **/
    UserNode updateByNode(UserNode userNode);

    /**
     * @Description 删除两个节点的关系
     **/
    void deleteKnowByNodeId(long fromId,long toId);

}

UserServiceImpl

package com.study.neo.service.impl;

import com.study.neo.service.UserService;
import com.study.neo.dao.KnowRepository;
import com.study.neo.dao.UserRepository;
import com.study.neo.entity.Know;
import com.study.neo.entity.UserNode;
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

package com.study.neo.controller;

import com.study.neo.entity.Know;
import com.study.neo.entity.UserNode;
import com.study.neo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Optional;

@RestController
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * @Description 添加节点
     **/
    @RequestMapping(path = "/add", method = RequestMethod.POST)
    public UserNode addUserNode(@RequestBody UserNode userNode) {
        return userService.create(userNode);
    }

    /**
     * @Description 根据id删除
     **/
    @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更新
     **/
    @RequestMapping(path = "/update", method = RequestMethod.POST)
    public UserNode updateUserNodeByNode(@RequestBody UserNode userNode) {
        return userService.updateByNode(userNode);
    }

    /**
     * @Description 根据id查询单个节点
     **/
    @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 查找所有节点
     **/
    @RequestMapping(path = "/list", method = RequestMethod.GET)
    public List<UserNode> getUserNodeList() {
        return userService.findAll();
    }

    /**
     * @Description 给已有的两个节点建立联系
     **/
    @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;
        }
    }

    /**
     * @Author keke
     * @Description 删除两个节点之间的关系
     * @Date 2021/6/7
     * @Param [fromId, toId]
     * @Return java.lang.String
     **/
    @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";
        }
    }

}

启动类

package com.study.neo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.neo4j.repository.config.EnableNeo4jRepositories;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@SpringBootApplication
@EnableNeo4jRepositories(basePackages = "com.study.neo.dao")
@EnableTransactionManagement // 激活SDN隐式事务
public class NeoDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(NeoDemoApplication.class, args);
    }

}

三、测试

通过controller层接口对数据库进行增删改查

附录：

想在浏览器里打开本地图数据库，输入：http://localhost:7474/ 然后，输入数据库的账号密码

如果连接远程数据库，浏览器输入：http://<服务器ip地址>:7474/browser/

空の鱼

关注

2
点赞
踩
8

收藏

觉得还不错? 一键收藏
4
评论
neo4j图数据库安装(mac)+neo4j集成springboot实现基础的增删改查

neo4j图数据库集成springboot实现基础的增删改查2、application.yml（本地的neo4j数据库）3、目录结构1、neo4j中节点的实体类——UserNode节点2、neo4j中关系的实体类——Know关系持久层持久层继承Neo4jRepository即实现基础的增删改查，当然也可以自己写sql，方式..................
复制链接

扫一扫