Java 批量导入CSV文件到Neo4j创建知识图谱（附测试数据）

已于 2022-03-18 09:45:15 修改
阅读量3.1k 收藏 26
点赞数 3
分类专栏： Java 常见工具类，常见错误解决方法 neo4j 文章标签： 知识图谱 neo4j
于 2019-12-31 18:16:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010797364/article/details/103787362
版权

测试类

注意jdk的安装版本，最好使用jdk1.7以上的版本。

package com.clinicalresearch.core.utils.Neo4jUtils;

import com.clinicalresearch.core.utils.Collections.CreateFileUtil;
import com.csvreader.CsvReader;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.ObjectMapper;
import net.sf.json.JSONObject;
import org.neo4j.driver.v1.*;
import org.neo4j.driver.v1.types.Node;

import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;

import static org.neo4j.driver.v1.Values.parameters;

/**
 * Created by liangguannan on 2019/12/24.
 */
public class Neo4jSessionTest {

    public final static ObjectMapper mapper = new ObjectMapper();

    public static Session session=null;

    public static Driver driver=null;

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

        driver = GraphDatabase.driver( "bolt://10.10.202.118:7687", AuthTokens.basic( "neo4j", "123456" ) );
        session = driver.session();
    }

    public static void createNodeAndRelation() throws Exception {

        /**
         * 建立一个爸爸与儿子的关系
         */

        // 1.首先创建爸爸节点
        RNode rDad = new RNode();
        rDad.setUuid(1110);
        rDad.setLabel("爸爸");
        // 2.其次为爸爸节点添加属性 == Property Keys
        rDad.addProperty("uuid", 1110);
        rDad.addProperty("name", "李大明");
        rDad.addProperty("age", 45);
        rDad.addProperty("height", "182.5cm");
        // 3.添加关系
        REdge edge = new REdge();
        edge.addProperty("relationID", 521);
        edge.addProperty("time", "1997-05-12");
        edge.setRelationID(521);
        edge.setName("父亲");
        // 4.为关系节点添加指向节点 == 创建儿子节点
        RNode rSon = new RNode();
        rSon.setUuid(2220);
        rSon.setLabel("儿子");
        // 5.为儿子节点添加属性 == Property Keys
        rSon.addProperty("uuid", 2220);
        rSon.addProperty("name", "李小明");
        rSon.addProperty("age", 20);
        rSon.addProperty("height", "185cm");
        // 6.给爸爸节点添加关系
        rDad.setEdge(edge);

        createNode(rDad);
        createNode(rSon);
        createRelation(rDad,rSon);
        System.err.println("创建成功");

    }

    /**
     * 创建节点
     * @param rNode
     * @throws Exception
     */
    public static void createNode(RNode rNode) throws Exception{
        RNode srcNode = queryNode(rNode);
        //查node是否已經存在了，不存在則創建
        if(srcNode == null){
            String propertiesString = mapper.writeValueAsString(rNode.getProperties());
            String cypherSql = String.format("create (:%s%s)", rNode.getLabel(), propertiesString);
            System.out.println(cypherSql);
            session.run(cypherSql);
            System.err.println("创建节点："+rNode.getLabel()+"成功！");
        }else{
            System.err.println("节点已存在，跳过创建");
        }
    }

    /**
     * 创建关系
     * @param srcNode
     * @param tarNode
     * @throws Exception
     */
    public static void createRelation(RNode srcNode,RNode tarNode) throws Exception{
        REdge edge = queryRelation(srcNode,tarNode);
        if(edge == null){
            edge = srcNode.getEdge();
            String propertiesString = mapper.writeValueAsString(edge.getProperties());
            String cypherSql = String.format("match(a),(b) where a.uuid=%d and b.uuid=%d create (a)-[r:%s %s]->(b)",
                    srcNode.getUuid(),tarNode.getUuid(),
                    edge.getName(), propertiesString);
            System.out.println(cypherSql);
            session.run(cypherSql);
            System.err.println("创建关系："+edge.getName()+"成功！");
        }else{
            System.err.println("关系已存在，跳过创建");
        }
    }


    /**
     * 查询节点
     *
     * @param rNode
     * @return
     */
    public static RNode queryNode(RNode rNode) {
        RNode node = null;
        REdge redge=rNode.getEdge();

        String cypherSql = String.format("match(n:%s) where n.%s = %d return n",redge.getLabel(), redge.getNodeIdName(), rNode.getUuid());
        StatementResult result = session.run(cypherSql);
        if (result.hasNext()) {
            Record record = result.next();
            for (Value value : record.values()) {
                /**
                 * 结果里面只要类型为节点的值
                 */
                if (value.type().name().equals("NODE")) {
                    Node noe4jNode = value.asNode();
                    node = new RNode();
                    node.setLabel(rNode.getLabel());
                    node.setProperties(noe4jNode.asMap());

                }
            }
        }
        return node;
    }


    /**
     * 查询关系
     * @param srcNode
     * @param tarNode
     * @return
     */
    public static REdge queryRelation(RNode srcNode,RNode tarNode){
        REdge edge = srcNode.getEdge();
        String cypherSql =String.format("match(n)-[r:%s]-(b) where n.%s = %d and b.%s = %d return r",
                edge.getName(),srcNode.getNodeIdName(),srcNode.getUuid(),srcNode.getNodeIdName(),tarNode.getUuid());
        StatementResult result = session.run(cypherSql);
        if(result.hasNext()){
            return edge;
        }
        return null;
    }

    /**
     * 读取CSV文件
     * @param diseaseName
     * @param filePath :全路径名
     * @param type
     * @param nodeIdName
     */
    public static List<String[]> readCSV(String diseaseName, String filePath, String type, String nodeIdName) throws Exception {
        CsvReader reader = null;
        List<String[]> dataList = new ArrayList<String[]>();

        char separator = ',';

        try {
            //如果生产文件乱码，windows下用gbk，linux用UTF-8
            reader = new CsvReader(filePath, separator, Charset.forName("UTF-8"));

            // 读取表头
            reader.readHeaders();
            String[] headArray = reader.getHeaders();//获取标题
            System.out.println(headArray[0] +"  " + headArray[1] + " " + headArray[2]);

            // 逐条读取记录，直至读完
            while (reader.readRecord()) {
                // 读一整行
                System.out.println("读一整行 "+reader.getRawRecord());
                // 读这行的第一列
                System.out.println("读这行的第一列: "+reader.get(0));//id
                // 读这行的第二列
                System.out.println("读这行的第二列: "+reader.get(1));//title

                System.out.println("读这行的第三列: "+reader.get(2));//level

                if ("Node".equals(type)){
                    createNodeTest(diseaseName,Integer.valueOf(reader.get(0)),reader.get(1),reader.get(2),reader.get(3),nodeIdName);
                }else {
                    createRelationTest(reader.get(2),Integer.valueOf(reader.get(0)),Integer.valueOf(reader.get(1)),nodeIdName);
                }

            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (null != reader) {
                reader.close();
            }
        }

        return dataList;
    }

    /**
     * 数据 创建节点
     * @param diseaseName
     * @param srcNodeUuid
     * @param title
     * @param level
     * @param describe
     * @param nodeIdName
     * @throws Exception
     */
    public static void createNodeTest(String diseaseName, int srcNodeUuid, String title, String level, String describe, String nodeIdName) throws Exception{
        REdge edge1 = new REdge();
        edge1.setLabel(diseaseName);
        edge1.setTitle(title);
        edge1.setNodeIdName(nodeIdName);

        RNode rNode= new RNode();
        rNode.setUuid(srcNodeUuid);
        rNode.setEdge(edge1);

        RNode srcNode = queryNode(rNode);
        //查node是否已經存在了，不存在則創建
        if(srcNode == null){
            String cypherSql =String.format("CREATE (n:%s {%s: {%s}, title: {title}, level: {level}, describe: {describe}})",
                    diseaseName,nodeIdName,nodeIdName);//一个总的根节点

            session.run(cypherSql,
                    parameters( nodeIdName, srcNodeUuid, "title", title,"level", level,"describe",describe) );

            System.err.println("创建节点："+edge1.getLabel()+"成功！");
        }else{
            System.err.println("节点已存在，跳过创建");
        }
    }

    /**
     * excel 数据 创建节点关系
     * @param srcNodeUuid
     * @param tarNodeUuid
     * @param nodeIdName
     * @throws Exception
     */
    public static void createRelationTest(String name, int srcNodeUuid, int tarNodeUuid, String nodeIdName) throws Exception{
        REdge edge1 = new REdge();
        edge1.setName(name);

        RNode srcNode= new RNode();
        srcNode.setUuid(srcNodeUuid);
        srcNode.setEdge(edge1);
        srcNode.setNodeIdName(nodeIdName);

        RNode tarNode= new RNode();
        tarNode.setUuid(tarNodeUuid);

        REdge edge = queryRelation(srcNode,tarNode);
        if(edge == null){
            edge = srcNode.getEdge();
            String propertiesString = mapper.writeValueAsString(edge.getProperties());
            String cypherSql = String.format("match(a),(b) where a.%s=%d and b.%s=%d create (a)-[r:%s %s]->(b)",
                    nodeIdName,srcNode.getUuid(),nodeIdName,tarNode.getUuid(),
                    edge.getName(), propertiesString);
            System.out.println(cypherSql);
            session.run(cypherSql);
            System.err.println("创建关系："+edge.getName()+"成功！");
        }else{
            System.err.println("关系已存在，跳过创建");
        }
    }

    /**
     * 知识图谱 节点数据
     * @throws Exception
     * @param diseaseName
     */
    public static void createNodeByFile(String diseaseName) throws Exception{

        String type="Node";

        List<JSONObject> list=CreateFileUtil.readfile("C:\\Users\\liangguannan\\Desktop\\neo4j数据\\脑梗塞\\node");

        for (int i=0;i<list.size();i++){
            JSONObject jsonObject=list.get(i);

            String filePath=jsonObject.get("path").toString();

            String nodeIdName=diseaseName+"_nodeId";

            readCSV(diseaseName,filePath,type,nodeIdName);
        }
    }

    /**
     * 知识图谱 关系数据
     * @throws Exception
     * @param diseaseName
     */
    public static void createRelationByFile(String diseaseName) throws Exception{

        String type="Relation";

        List<JSONObject> list=CreateFileUtil.readfile("C:\\Users\\liangguannan\\Desktop\\neo4j数据\\脑梗塞\\relation");


        for (int i=0;i<list.size();i++){

            JSONObject jsonObject=list.get(i);

            String filePath=jsonObject.get("path").toString();

            String nodeId=diseaseName+"_nodeId";
            String name=null;

            readCSV(name,filePath,type,nodeId);
        }

    }

    public static void main(String[] args) {
        try {

            //createNodeAndRelation();

            String name="cerebralInfarction";

            createNodeByFile(name);//读取文件夹下的节点excel集合
            createRelationByFile(name);//读取文件夹下关系excel集合


            //createRelationTest(50001,7);

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            session.close();
            driver.close();
        }
    }
}

RNode 类

package com.clinicalresearch.core.utils.Neo4jUtils;


/**
 * Created by  on 2019/12/24.
 */
public class RNode extends RObject {

    /**
     * 节点的uuid == 对应其他数据库中的主键
     */
    private int uuid;

    /**
     * 节点里面是否包含有边 == 关系
     */
    private REdge edge;

    public Integer getUuid() {
        return uuid;
    }

    public void setUuid(Integer uuid) {
        this.uuid = uuid;
    }

    public REdge getEdge() {
        return edge;
    }

    public void setEdge(REdge edge) {
        this.edge = edge;
    }
}

REdge类

package com.clinicalresearch.core.utils.Neo4jUtils;

/**
 * 边 == 关系
 * Created by liangguannan on 2019/12/24.
 */
public class REdge extends RObject {

    /**
     * 关系的ID  ==  聚合、连接、属于、包括等，这些关系可能是枚举字典，因此记录关系ID是有必要的
     */
    private int relationID;

    /**
     * 关系名称
     */
    private String name;

    /**
     * 关系指向哪一个节点 == 可能这个节点还有关系【节点关系递增下去】
     */
    private RNode  rNode;

    public Integer getRelationID() {
        return relationID;
    }

    public void setRelationID(Integer relationID) {
        this.relationID = relationID;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public RNode getrNode() {
        return rNode;
    }

    public void setrNode(RNode rNode) {
        this.rNode = rNode;
    }
}

RObject 类

package com.clinicalresearch.core.utils.Neo4jUtils;

import java.util.HashMap;
import java.util.Map;

/**
 * 节点和关系对象的基类，含公共部分的id、标签label以及属性properties
 * Created by liangguannan on 2019/12/24.
 */
public class RObject {
    /**
     * 节点标签名称 == Node Labels
     */
    private String label;

    /**
     * 节点标题
     */
    private String title;

    /**
     * 节点id的名称
     */
    private String nodeIdName;
    /**
     * 节点属性键值对 == Property Keys
     */
    private Map<String, Object> properties;

    public String getTitle() {
        return title;
    }

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

    public String getNodeIdName() {
        return nodeIdName;
    }

    public void setNodeIdName(String nodeIdName) {
        this.nodeIdName = nodeIdName;
    }

    public RObject(){
        properties = new HashMap<>();
    }


    public String getLabel() {
        return label;
    }
    public void setLabel(String label) {
        this.label = label;
    }
    public Map<String, Object> getProperties() {
        return properties;
    }

    /**
     * 添加属性
     * @param key
     * @param value
     */
    public void addProperty(String key,Object value){
        properties.put(key, value);
    }

    /**
     * 拿到属性
     * @param key
     * @return
     */
    public Object getProperty(String key){
        return properties.get(key);
    }
    /**
     * 移除属性
     * @param key
     */
    public void removeProperty(String key){
        properties.remove(key);
    }

    public void setProperties(Map<String, Object> properties) {
        this.properties = properties;
    }
}

读取Excel文件夹下的所有文件

package com.clinicalresearch.core.utils.Collections;

/**
 * Created by liangguannan on 2018/5/4.
 */
import com.clinicalresearch.core.utils.JsonFormatTool;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.clinicalresearch.utils.HttpClientUtils;

import java.io.*;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class CreateFileUtil {

    /**
     * 生成.json格式文件
     */
    public static boolean createJsonFile(String jsonString, String filePath, String fileName) {
        // 标记文件生成是否成功
        boolean flag = true;

        // 拼接文件完整路径
        String fullPath = filePath + File.separator + fileName + ".json";

        // 生成json格式文件
        try {
            // 保证创建一个新文件
            File file = new File(fullPath);
            if (!file.getParentFile().exists()) { // 如果父目录不存在，创建父目录
                file.getParentFile().mkdirs();
            }
            if (file.exists()) { // 如果已存在,删除旧文件
                file.delete();
            }
            file.createNewFile();

            // 格式化json字符串
            jsonString = JsonFormatTool.formatJson(jsonString);

            // 将格式化后的字符串写入文件
            Writer write = new OutputStreamWriter(new FileOutputStream(file), "UTF-8");
            write.write(jsonString);
            write.flush();
            write.close();
        } catch (Exception e) {
            flag = false;
            e.printStackTrace();
        }

        // 返回是否成功的标记
        return flag;
    }

    /**
     * 通过本地文件访问json并读取
     * @param path：E:/svn/05.Hospital/templatedept_uuid.json
     * @return：json文件的内容
     */
    public static String ReadFile(String path){
        String laststr="";
        File file=new File(path);// 打开文件
        BufferedReader reader=null;
        try{
            FileInputStream in = new FileInputStream(file);
            reader=new BufferedReader(new InputStreamReader(in,"UTF-8"));// 读取文件
            String tempString=null;
            while((tempString=reader.readLine())!=null){
                laststr=laststr+tempString;
            }
            reader.close();
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            if(reader!=null){
                try{
                    reader.close();
                }catch(IOException el){
                }
            }
        }
        return laststr;
    }




    /**
     * 读取某个文件夹下的所有文件
     */
    public static List<JSONObject> readfile(String filepath) throws FileNotFoundException, IOException {
        List<JSONObject> list= new ArrayList();

        try {
            File file = new File(filepath);
            if (!file.isDirectory()) {
                System.out.println("文件");
                System.out.println("path=" + file.getPath());
                System.out.println("absolutepath=" + file.getAbsolutePath());
                System.out.println("name=" + file.getName());

            } else if (file.isDirectory()) {
                System.out.println("文件夹");
                String[] filelist = file.list();
                for (int i = 0; i < filelist.length; i++) {
                    File readfile = new File(filepath + "\\" + filelist[i]);
                    if (!readfile.isDirectory()) {
                        System.out.println("path=" + readfile.getPath()+"========="+readfile.getName());

                        JSONObject jsonObject = new JSONObject();
                        jsonObject.put("path",readfile.getPath());
                        jsonObject.put("name",readfile.getName());

                        //getAllItems(readfile.getPath(),readfile.getName());

                        list.add(jsonObject);

                    } else if (readfile.isDirectory()) {
                        readfile(filepath + "\\" + filelist[i]);
                    }
                }

            }

        } catch (FileNotFoundException e) {
            System.out.println("readfile()   Exception:" + e.getMessage());
        }
        return list;
    }



    public static void main(String[] args) {



    }
}

测试数据网盘地址：

https://share.weiyun.com/TfBlKS4t

访问neo4j数据库查看
在这里插入图片描述

抹香鲸之海
关注
专栏目录
【知识图谱】基于neo4j的数字逻辑课程知识图谱构建
知识靠谱的博客
05-17 1000
知识图谱覆盖了从基础的代数概念到复杂的电路设计，旨在帮助学习者全面理解数字逻辑的各方面。除了理论知识点，这份数据还包含了逻辑门的真值表、逻辑表达式的计算题以及逻辑电路的分析题，这些题目旨在加深学习者对数字逻辑应用的理解。此外，数据中还包含了实体之间的关系，如逻辑运算包括与运算、或运算等，以及逻辑门包括与门、或门等，这些关系有助于构建起知识点之间的联系，形成完整的知识结构。整体来看，这份数据为数字逻辑的学习者提供了一个结构化和系统化的学习资源，有助于从基础概念到复杂应用逐步建立起扎实的数字逻辑知识基础。
知识图谱大模型系列之 17 使用 Llamaindex、Neo4j 和 Llama 3 构建具有知识图谱的高级 RAG 聊天机器人(教程含源码)
最新发布
iCloudEnd的博客
07-05 5795
检索增强生成 (RAG) 是一种先进的技术，它将基于检索的模型与生成模型相结合，以提高生成的响应的质量和相关性。它对于问答等应用特别有用，因为系统需要提供详细且上下文准确的答案。知识图谱是以节点和边的形式对信息进行结构化表示。节点通常表示实体（例如人物、地点、概念或对象），边表示这些实体之间的关系。知识图谱可以对复杂的关系进行建模，并提供一种高效查询和检索互连信息的方法。知识图谱的一个典型场景是建模社交媒体关系，以在用户和他们的联系人之间形成链接。
Java读取CSV插入Neo4j并生成Echarts关系图
08-05
Java读取CSV插入Neo4j并生成Echarts关系图
Neo4j大量CSV数据导入测试数据
05-05
Neo4j大量CSV数据导入测试数据，包含运行测试批处理脚本
neo4j 测试数据
04-26
使用工具http://download.csdn.net/detail/shenshouer/4102126生成的数据，具体使用请参考http://blog.csdn.net/shenshouer/article/details/7515253
Neo4j性能测试
xuguangyuansh的博客
04-23 3047
测试环境         3台节点，每台cpu和内存都差不多 CPU [root@f1 import]# lscpu Architecture: x86_64 CPU op-mode(s): 32-bit, 64-bit Byte Order: Little Endian CPU(s): 40 On-line CPU(s) list: 0-3
Java读取CSV用Load命令插入Neo4j与JDBC读取Neo4j数库生成Echarts关系图
02-06
Java读取CSV用Load命令插入Neo4j与JDBC读取Neo4j数库生成Echarts关系图 需要注意的是 1.自己改jdbc用户名密码 2.插入数据时,csv需要放在你的数据库下的import文件夹 3.查询数据库生成Echarts关系图时自己下载Echarts3放在生成文件的同级目录js文件夹下
知识图谱基本工具Neo4j使用笔记 四 ：使用csv文件批量导入图谱数据
争渡的博客
08-12 4037
-database: 指定要导入的数据库名称。--mode: 指定导入模式，有两种可选值：csv 和 database。默认为 csv 模式，表示从 CSV 文件导入数据。--nodes: 指定包含节点数据的 CSV 文件路径。可以指定多个节点文件。: 指定包含关系数据的 CSV 文件路径。可以指定多个关系文件。: 指定 CSV 文件中字段之间的分隔符，默认为逗号 ,。: 指定 CSV 文件中数组类型字段中元素之间的分隔符，默认为;。: 如果关系中的节点不存在是否忽略，默认为 false。
在neo4j中导入csv文件并构建知识图谱
hmcxy123的博客
09-21 2775
从开源社区中下载下来的数据文件还是json，先用python把json文件转为csv文件。注：其他两个表attributes和relationships操作同理。本文csv文件数据来源于openKG中达观的开源知识图谱数据。把entity根据relationship连接起来。导入之后在neo4j中使用命令。使用已知节点创建带属性的关系。
【知识图谱】Neo4j的基本使用及思知1.4亿三元组数据构建知识图谱
热门推荐
Nieson2012的专栏
10-29 1万+
目录 0、前言 1、Neo4j的基本使用 1.1 下载和安装Neo4j 1.2 Neo4j配置 1.2.1 核心数据文件的位置 1.2.2 安全验证，默认是启用的 1.2.3 配置JAVA 堆内存的大小 1.3 网络连接配置 1.3.1 Neo4j支持三种网络协议（Protocol） 1.3.2 连接器的可选属性 1.3.3 设置默认的监听地址 1.3.4 分别设置各个网络...
Java开发基于知识图谱的航天数据可视化系统源码+项目使用说明.zip
08-21
Java开发基于知识图谱的航天数据可视化系统源码+项目使用说明.zip 1、该资源内项目代码都是经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、...
新冠肺炎国外测试数据-地点表.csv
08-14
新冠肺炎国外测试数据，专用与Neo4j导入使用的.csv文件 新冠肺炎国外测试数据，专用与Neo4j导入使用的.csv文件 新冠肺炎国外测试数据，专用与Neo4j导入使用的.csv文件 新冠肺炎国外测试数据，专用与Neo4j导入使用的....
NEO4J数据插入测试
aol_aog的网上家园
05-23 581
CPU: I3 2.4Ghz 4核,内存8G 方式一：采用其原生接口操作 JVM：-Xms1024m -Xmx1024m -Xmn512m-XX:PermSize=128m -XX:MaxPermSize=256m 4000节点（50个属性），4000关系：1秒,其间cpu使用率25%，761M 8000节点（50个属性），8000关系：2秒,其间cpu使用率25%，829M 16...
Neo4j：入门基础（四）之Java API
Puzzle的博客
09-17 3702
Neo4j Java API Neo4j 提供 JAVA API 以编程方式执行所有数据库操作。它支持两种类型的API： 1、Neo4j 原生的 Java API 2、Neo4j Cypher Java API Neo4j 原生 Java API 是一种低级别的纯 JAVA API，用于执行数据库操作。Neo4j Cypher Java API 是简单而强大的 JAVA API，用于执行所有CQL命令以执行数据库操作。 环境配置 Neo4j 3.5.3 ...
java导入数据 neo4j_使用java操作Neo4j数据库
weixin_35561837的博客
12-29 575
1.引言这里的Java操作Neo数据库使用的是嵌入式模式，Neo4j可分为嵌入式模式和服务端模式，两者的区别可以查看方案(https://blog.csdn.net/regan_hoo/article/details/78771888)也可以查看《Neo4j实战 》这本书的第10章，上面有详细讲解(需要电子版的可以找我)。我们构造一个案件的场景。比如一个案件中有多个嫌疑人，有的嫌疑人参与了多个案件...
“d3.js可视化neo4j图数据库”需要用到的测试数据
07-23
是“d3.js可视化neo4j图数据库”这个项目中需要用到的测试数据文件，如果对这个项目感兴趣的可以关注我的专栏：https://blog.csdn.net/column/details/23743.html
neo4j数据批量插入测试
weixin_44447809的博客
05-01 1351
和。: 内嵌模式下，数据库会作为你的应用程序的一个部分，与你的应用程序代码在同一个Java进程中运行。你的代码可以直接访问数据库，而无需通过网络进行通信，这使得读写操作的性能非常高。​ 此外，内嵌模式允许你的应用程序直接访问Neo4j的API，提供更底层的数据库操作。然而，内嵌模式的缺点是: 在独立服务器模式下，Neo4j数据库作为一个独立的服务器运行，你的应用程序通过网络与数据库服务器进行通信。这允许了多个应用程序可以同时连接到数据库服务器，有利于构建高并发、分布式的应用。
neo4j创建数据库及导入csv文件内容详解
fortune_mz的博客
03-30 1万+
详细讲解neo4j导入数据的结构及知识图谱展示
评论 26
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值