Springboot连接Neo4j 完整版（提供代码)

先展示我的项目目录👇

application.properties

这个文件是一个全局的配置文件，如果你工程没有这个application.properties，那就在目录下新建一个。

application.properties代码

本地访问：

//这一段是连接本地neo4j的代码
spring.neo4j.url=bolt://localhost:7687
spring.neo4j.username=neo4j//！账号密码填写自己账号的密码，不确定可以去neo4j查询或重新设置
spring.neo4j.password=111111//错误则会访问失败

访问远程neo4j 的application.properties文件代码如下，远程neo4j具体如何配置参考我的主页另一篇博客：https://blog.csdn.net/weixin_44078713/article/details/106163409

//如果需要访问远程neo4j 
spring.data.neo4j.uri=bolt://对应ip:7687
spring.data.neo4j.username=neo4j
spring.data.neo4j.password=111111

pom.xml

pom.xml文件是Maven进行工作的主要配置文件。在这个文件中我们可以配置Maven项目的groupId、artifactId和version等Maven项目必须的元素；可以配置Maven项目需要使用的远程仓库；可以定义Maven项目的资源依赖关系等等。简单来说，你的项目必须包含这个文件，文件内容是你这个项目所必需的一些配置资源。
在连接Neo4j中，我的pom.xml文件代码如下↓
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>com.appleyk</groupId>
    <artifactId>Spring-Boot-Neo4jAPI</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <description>Spring-Boot 集成Neo4j-Karenmaxx</description>


    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>


<!--    <groupId>com.demo</groupId>-->
<!--    <artifactId>neo4j_demo</artifactId>-->
<!--    <version>0.0.1-SNAPSHOT</version>-->
<!--    <name>neo4j_demo</name>-->
<!--    <description>Demo project for Spring Boot</description>-->

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.neo4j.driver</groupId>
            <artifactId>neo4j-java-driver</artifactId>
            <version>1.6.3</version>
        </dependency>
        <dependency>
            <!-- 嵌入式开发需要的jar包 -->
            <groupId>org.neo4j</groupId>
            <artifactId>neo4j</artifactId>
            <version>3.3.4</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-neo4j</artifactId>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

entity节点类

节点类需要根据你的Neo4j数据库内的结点去定制，不可直接复制，需要修改。修改可以关注代码注释
展示Category代码

package com.mengxuegu.springboot;
import org.neo4j.ogm.annotation.GeneratedValue;
import org.neo4j.ogm.annotation.Id;
import org.neo4j.ogm.annotation.NodeEntity;
import org.neo4j.ogm.annotation.Property;

@NodeEntity(label = "Category")//对应修改结点标签
public class Category {

        @Id
        @GeneratedValue
        private Long id;
        @Property
        private String title;   //这一部分需要对应修改节点属性


        public Category() {

        }//较新版本都需要构造无参数函数

        public Category(String title) {
            this.title = title;//传参
        }
//以下getset函数对应自己修改
        public Long getCategoryId() {
            return id;
        }

        public void setCategoryId(Long id) {
            this.id = id;
        }

        public String getCategoryTitle() {
            return title;
        }

        public void setCategoryTitle(String title) {
            this.title = title;
        }

}

Repository

每个节点类文件都需要对应写一个Repository
展示CategoryRepository

package com.mengxuegu.springboot;

import org.springframework.data.neo4j.annotation.Query;
import org.springframework.data.neo4j.repository.Neo4jRepository;
import org.springframework.stereotype.Repository;
import java.util.List;

@Repository
public interface CategoryRepository extends Neo4jRepository<Category,Long> {
//Query标签后面的内容根据自己Neo4j数据库定义查询
//Neo4j里面也有一些固定的查询不用用到query标签，如findall之类，自己去了解一下
     @Query(value = "match (a:Category)  return a limit 5 ")
     List<Category>  findBytitle( );
}

JsonSimple

转换成Json格式输出
JsonSimple

package com.mengxuegu.springboot;

import java.io.IOException;
import java.util.Collection;
import java.util.Map;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.util.JSONPObject;

/*
 * 简单封装Jackson,提供一些操作json的静态方法
 */
public class JsonSimple {

  private static Logger logger = LoggerFactory.getLogger(JsonSimple.class);
  private static ObjectMapper mapper = null;

  static {
    mapper = new ObjectMapper();
    // 设置输出时包含属性的风格
    mapper.setSerializationInclusion(Include.NON_EMPTY);
    // 设置输入时忽略在JSON字符串中存在但Java对象实际没有的属性
    mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
  }

  /**
   * Object可以是POJO，也可以是Collection或数组。 如果对象为Null, 返回"null". 如果集合为空集合, 返回"[]".
   */
  public static String toJson(Object object) {

    try {
      return mapper.writeValueAsString(object);
    } catch (IOException e) {
      logger.warn("write to json string error:" + object, e);
      return null;
    }
  }

  /**
   * 默认返回Map<String,?>
   * #fromJson(String, JavaType)
   */
  @SuppressWarnings("rawtypes")
  public static Map fromJson(String jsonString) {
    return fromJson(jsonString, Map.class);
  }

  /**
   * 反序列化POJO或简单Collection如List<String>.或 List（默认返回Map）
   * 
   * 如果JSON字符串为Null或"null"字符串, 返回Null. 如果JSON字符串为"[]", 返回空集合.
   * 
   * 如需反序列化复杂Collection如List<MyBean>, 请使用fromJson(String, JavaType)
   #fromJson(String, JavaType)
   */
  public static <T> T fromJson(String jsonString, Class<T> clazz) {
    if (StringUtils.isEmpty(jsonString)) {
      return null;
    }

    try {
      return mapper.readValue(jsonString, clazz);
    } catch (IOException e) {
      logger.warn("parse json string error:" + jsonString, e);
      return null;
    }
  }

  /**
   * 反序列化复杂Collection如List<Bean>, 先使用createCollectionType()或contructMapType()构造类型, 然后调用本函数
   */
  @SuppressWarnings("unchecked")
  public static <T> T fromJson(String jsonString, JavaType javaType) {
    if (StringUtils.isEmpty(jsonString)) {
      return null;
    }

    try {
      return (T) mapper.readValue(jsonString, javaType);
    } catch (IOException e) {
      logger.warn("parse json string error:" + jsonString, e);
      return null;
    }
  }

  /**
   * 构造Collection类型.
   */
  public static JavaType contructCollectionType(
      @SuppressWarnings("rawtypes") Class<? extends Collection> collectionClass,
      Class<?> elementClass) {
    return mapper.getTypeFactory().constructCollectionType(collectionClass, elementClass);
  }
   //构造Map类型.
  public static JavaType contructMapType(
      @SuppressWarnings("rawtypes") Class<? extends Map> mapClass, Class<?> keyClass,
      Class<?> valueClass) {
    return mapper.getTypeFactory().constructMapType(mapClass, keyClass, valueClass);
  }


   //当JSON里只含有Bean的部分屬性時，更新一個已存在Bean，只覆蓋該部分的屬性.

  public static void update(String jsonString, Object object) {
    try {
      mapper.readerForUpdating(object).readValue(jsonString);
    } catch (JsonProcessingException e) {
      logger.warn("update json string:" + jsonString + " to object:" + object + " error.", e);
    } catch (IOException e) {
      logger.warn("update json string:" + jsonString + " to object:" + object + " error.", e);
    }
  }

  /**
   * 輸出JSONP格式數據.
   */
  public static String toJsonP(String functionName, Object object) {
    return toJson(new JSONPObject(functionName, object));
  }
}

test测试

testsave

package com.mengxuegu.springboot;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class testsave {
    @Autowired
    FileRepository fileRepo;
    @Autowired
    CategoryRepository categoryRepo;


    final static ObjectMapper mapper = new ObjectMapper();

    static {
        /**
         * 使用neo4j的session执行条件语句statement，一定要使用这个反序列化对象为json字符串
         * 下面的设置的作用是，比如对象属性字段name="李二明"，正常反序列化json为 == "name":"李二明"
         * 如果使用下面的设置后，反序列name就是 == name:"appleyk"
         * 而session执行语句create (:儿子{"name":"李二明","uuid":3330,"age":12,"height":"165cm"})会报错
         */

        mapper.configure(JsonGenerator.Feature.QUOTE_FIELD_NAMES, false);
    }
    
    @Test
    public void contextLoads() {}
    @Test
    public void testfindByFile() {
    
//通过转换的cypher语句查File类型
       List<File> f1 = fileRepo.findByFile();
        System.out.println(JsonSimple.toJson(f1));
        System.out.println("共查出来节点有："+f1.size()+"个");
    }

    @Test
    public void testfindByTitle() {
//通过转换的cypher语句查Category类型
        List<Category> f2 = categoryRepo.findBytitle();
        System.out.println(JsonSimple.toJson(f2));
        System.out.println("共查出来节点有："+f2.size()+"个");

    }
}

测试运行

返回的结果正是我们在CategoryRepository中查询的 match (a:Category) return a limit 5即返回五个标签为Category的结点，运行并查询成功！

动手试一试吧~如果对你有帮助的话点赞关注哟ヾ(≧▽≦*)o