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

  • 9
    点赞
  • 52
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
Spring Boot是一个用于开发Java应用程序的开源框架,它简化了Java应用程序的开发和部署过程。Neo4j是一个图数据库,它采用图结构来存储和处理数据,可以用于管理复杂的关系数据。 要在Spring Boot中整合Neo4j,首先需要添加相关的依赖库。在pom.xml文件中添加Neo4j的依赖项,以便在项目中使用Neo4j的功能。然后,创建一个配置类,使用@Configuration注解将其标记为配置类,并使用@EnableNeo4jRepositories注解启用Neo4j的存储库。 在配置类中,可以配置Neo4j的连接信息,例如服务器地址、用户名和密码等。可以使用@ConfigurationProperties注解来读取配置文件中的属性,并将其值注入到配置类中。 然后,创建实体类来映射Neo4j中的节点和关系。可以使用@NodeEntity注解将实体类标记为一个Neo4j节点,并使用@Id注解指定节点的唯一标识。可以使用@Relationship注解来定义节点之间的关系。 接下来,可以创建Neo4j的存储库接口,继承自Neo4jRepository或者Neo4jRepositoryImpl,并使用@Repository注解将其标记为存储库。可以在存储库接口中定义查询方法,通过方法的命名规则来定义查询条件,例如根据节点的属性进行查询。 最后,在应用程序的入口类中,使用@SpringBootApplication注解标记该类为Spring Boot应用程序的入口,并使用@ComponentScan注解指定要扫描的包。可以在入口类中使用@Autowired注解将配置类、存储库接口等注入到应用程序中,并使用它们来进行数据库操作。 通过上述步骤,就可以完成Spring Boot与Neo4j的整合。可以使用Spring Boot的自动化配置和依赖管理功能,简化了整合过程,让开发者可以更方便地使用Neo4j来处理图数据。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值