neo4j5.x使用教程简版

已于 2023-04-03 16:58:33 修改
阅读量821 收藏 4
点赞数
文章标签： neo4j
于 2023-03-30 15:03:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/devotemyself/article/details/129857815
版权

之前写过3.x版本的neo4j使用方法，最近又要用neo4j发现版本升级了好多，我使用的是4.4.5，5.x的都差不多，但是跟以前区别挺大
引入maven包，jdk本人使用的是17

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>3.0.5</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-neo4j</artifactId>
        <version>3.0.5</version>
    </dependency>
    <dependency>
         <groupId>org.neo4j.driver</groupId>
         <artifactId>neo4j-java-driver</artifactId>
         <version>5.6.0</version>
     </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.8</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
        <version>4.1.19</version>
    </dependency>
</dependencies>

配置文件

server.port=9004
spring.neo4j.uri=bolt://localhost:7687
spring.neo4j.authentication.username=neo4j
spring.neo4j.authentication.password=12345678
logging.level.org.springframework.data.neo4j=DEBUG
#spring.data.neo4j.database = my-database

基础类

package com.fy.entity;

import lombok.Data;
import org.springframework.data.neo4j.core.schema.GeneratedValue;
import org.springframework.data.neo4j.core.schema.Id;
import org.springframework.data.neo4j.core.schema.Node;

import java.io.Serializable;

/**
 * @ClassName CarEntity
 * @author: maliang
 * @Description 汽车
 * @date 2023/3/30 13:32
 * @Version 1.0版本
 */
@Data
@Node("car")
public class CarEntity implements Serializable {

    @Id
    @GeneratedValue
    private Long id;

    private String carName;

    private String carType;

    private String color;

}

package com.fy.entity;

import lombok.Data;
import org.springframework.data.neo4j.core.schema.GeneratedValue;
import org.springframework.data.neo4j.core.schema.Id;
import org.springframework.data.neo4j.core.schema.Node;

import java.io.Serializable;

/**
 * @ClassName NeoEntity
 * @author: maliang
 * @Description 通用类
 * @date 2023/3/29 11:15
 * @Version 1.0版本
 */
@Node("neo")
@Data
public class NeoEntity implements Serializable{

    @Id
    @GeneratedValue
    private Long id;

    private String name;

    private String num;

    private int age;

    private String local;
}

package com.fy.entity;

import lombok.Data;
import org.springframework.data.neo4j.core.schema.GeneratedValue;
import org.springframework.data.neo4j.core.schema.Id;
import org.springframework.data.neo4j.core.schema.Node;
import org.springframework.data.neo4j.core.schema.Relationship;

import java.io.Serializable;
import java.util.List;

import static org.springframework.data.neo4j.core.schema.Relationship.Direction.OUTGOING;

/**
 * @ClassName Person
 * @author: maliang
 * @Description 人员
 * @date 2023/3/30 13:28
 * @Version 1.0版本
 */
@Data
@Node("person")
public class Person implements Serializable {

    @Id
    @GeneratedValue
    private Long id;

    private String name;

    private String num;

    private int age;

    private String local;

    /**
     * 拥有的商品
     */
    @Relationship("have")
    private List<ProductEntity> productEntityList;

    /**
     * 亲戚
     */
    @Relationship("kinsfolk")
    private List<Person> kinsfolkShips;

    /**
     * 拥有的汽车
     */
    @Relationship(type = "have", direction = OUTGOING)
    private List<CarEntity> cars;

}


package com.fy.entity;

import lombok.Data;
import org.springframework.data.neo4j.core.schema.GeneratedValue;
import org.springframework.data.neo4j.core.schema.Id;
import org.springframework.data.neo4j.core.schema.Node;

import java.io.Serializable;

/**
 * @ClassName ProductEntity
 * @author: maliang
 * @Description 商品
 * @date 2023/3/30 13:29
 * @Version 1.0版本
 */
@Node("product")
@Data
public class ProductEntity implements Serializable {

    @Id
    @GeneratedValue
    private Long id;

    private String productName;

    private String param;

}


@Repository
public interface CarRespository extends Neo4jRepository<CarEntity, Long> {
}

@Repository
public interface NeoRepository extends Neo4jRepository<NeoEntity, Long> {
}

@Repository
public interface PersonRepository extends Neo4jRepository<Person, Long> {

    @Query(value = "MATCH(n:person) WHERE id(n) in $ids RETURN n",
            countQuery = "MATCH(n:person) WHERE id(n) in $ids RETURN count(*)")
    Page<Person> findByIds(@Param("ids") List<Long> ids, Pageable pageable);

    @Query(value = "MATCH(n:person) RETURN n",
            countQuery = "MATCH(n:person) RETURN count(*)")
    Page<Person> getAll(Pageable pageable);

    @Query(value = "MATCH(n:person) where id(n) = $id RETURN n")
    Person getById(@Param("id") Long id);

    @Query(value = "MATCH(n:person)-[:kinsfolk]->(m:person) where id(n) = $id RETURN m")
    List<Person> getKinsfolkById(@Param("id") Long id);
}



@Repository
public interface ProductRepository extends Neo4jRepository<ProductEntity, Long> {

    @Query("MATCH(n:product) RETURN n")
    List<ProductEntity> getAll();

    @Query("MATCH (p:person)-[:have]->(n:product) WHERE id(p) = $id RETURN n")
    List<ProductEntity> getByPersonId(@Param("id") Long id);
}


package com.fy.client;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import org.neo4j.driver.Record;
import org.neo4j.driver.*;
import org.neo4j.driver.types.Node;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;


/**
 * @ClassName Neo4jLink
 * @author: maliang
 * @Description 查询数据工具类
 * @date 2023/3/31 10:14
 * @Version 1.0版本
 */
@Component
public class Neo4jLink implements AutoCloseable {
    private final Driver driver;

    public Neo4jLink(@Value("${spring.neo4j.uri}") String uri, @Value("${spring.neo4j.authentication.username}") String user, @Value("${spring.neo4j.authentication.password}") String password) {
        driver = GraphDatabase.driver(uri, AuthTokens.basic(user, password));
    }

    @Override
    public void close() throws RuntimeException {
        driver.close();
    }

    public <T> T query(final String nql, Class<T> beanClass) {
        try (Session session = driver.session()) {
            return session.executeWrite(tx -> {
                Query query = new Query(nql);
                Result result = tx.run(query);
                while (result.hasNext()) {
                    Record next = result.next();
                    for (int i = 0; i < next.size(); i++) {
                        Node value = next.get(i).asNode();
                        Map<String, Object> map = value.asMap();
                        T t = BeanUtil.mapToBean(map, beanClass, new CopyOptions());
                        setId(t, value.elementId());
                    }
                }
                return null;
            });
        }
    }

    public <T> T query(final String nql, Map<String, Object> paramMap, Class<T> beanClass) {
        try (Session session = driver.session()) {
            return session.executeWrite(tx -> {
                Query query = new Query(nql, paramMap);
                Result result = tx.run(query);
                while (result.hasNext()) {
                    Record next = result.next();
                    for (int i = 0; i < next.size(); i++) {
                        Node value = next.get(i).asNode();
                        Map<String, Object> map = value.asMap();
                        T t = BeanUtil.mapToBean(map, beanClass, new CopyOptions());
                        setId(t, value.elementId());
                    }
                }
                return null;
            });
        }
    }

    public <T> List<T> queryList(final String nql, Class<T> beanClass) {
        try (Session session = driver.session()) {
            return session.executeWrite(tx -> {
                Query query = new Query(nql);
                Result result = tx.run(query);
                List<T> list = new ArrayList<>();
                while (result.hasNext()) {
                    Record next = result.next();
                    for (int i = 0; i < next.size(); i++) {
                        Node value = next.get(i).asNode();
                        Map<String, Object> map = value.asMap();
                        T t = BeanUtil.mapToBean(map, beanClass, new CopyOptions());
                        setId(t, value.elementId());
                        list.add(t);
                    }
                }
                return list;
            });
        }
    }

    public <T> List<T> queryList(final String nql, Map<String, Object> paramMap, Class<T> beanClass) {
        try (Session session = driver.session()) {
            return session.executeWrite(tx -> {
                Query query = new Query(nql, paramMap);
                Result result = tx.run(query);
                List<T> list = new ArrayList<>();
                while (result.hasNext()) {
                    Record next = result.next();
                    for (int i = 0; i < next.size(); i++) {
                        Node value = next.get(i).asNode();
                        Map<String, Object> map = value.asMap();
                        T t = BeanUtil.mapToBean(map, beanClass, new CopyOptions());
                        setId(t, value.elementId());
                        list.add(t);
                    }
                }
                return list;
            });
        }
    }

    public void write(final String nql) {
        try (Session session = driver.session()) {
            Transaction tx = session.beginTransaction();
            try {
                tx.run(nql);
                tx.commit();
            } catch (Exception e) {
                tx.rollback();
            }
        }
    }

    private <T> void setId(T t, String primaryKey) {
        Class<?> aClass = t.getClass();
        Method[] methods = aClass.getMethods();
        for (Method method : methods) {
            if (method.getName().contains("setId")) {
                try {
                    method.invoke(t, Long.parseLong(primaryKey));
                } catch (IllegalAccessException e) {
                    throw new RuntimeException(e);
                } catch (InvocationTargetException e) {
                    throw new RuntimeException(e);
                }
                break;
            }
        }
    }

}



package com.fy.controller;

import com.fy.dao.CarRespository;
import com.fy.entity.CarEntity;
import jakarta.annotation.Resource;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * @ClassName CarController
 * @author: maliang
 * @Description TODO
 * @date 2023/3/30 13:50
 * @Version 1.0版本
 */
@RestController
@RequestMapping("car")
public class CarController {

    @Resource
    private CarRespository respository;

    @PostMapping
    public String add(@RequestBody List<CarEntity> carEntityList) {
        respository.saveAll(carEntityList);
        return "success";
    }

}

package com.fy.controller;

import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.StrUtil;
import com.fy.client.Neo4jLink;
import com.fy.dao.CarRepository;
import com.fy.dao.PersonRepository;
import com.fy.dao.ProductRepository;
import com.fy.entity.CarEntity;
import com.fy.entity.Person;
import com.fy.entity.ProductEntity;
import jakarta.annotation.Resource;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

/**
 * @ClassName PersonController
 * @author: maliang
 * @Description TODO
 * @date 2023/3/30 13:50
 * @Version 1.0版本
 */
@RestController
@RequestMapping("person")
public class PersonController {

    @Resource
    private PersonRepository repository;

    @Resource
    private ProductRepository productRepository;

    @Resource
    private CarRepository carRespository;

    @Resource
    private Neo4jLink neo4jLink;

    @PostMapping
    public String add(@RequestBody List<Person> personList) {
        repository.saveAll(personList);
        return "success";
    }

    @PostMapping("addProduct")
    public String saveHave(Long personId, Long productId) {
        Optional<Person> person = repository.findById(personId);
        person.ifPresent(e -> {
            Optional<ProductEntity> product = productRepository.findById(productId);
            product.ifPresent(p -> {
                e.getProductEntityList().add(p);
                repository.save(e);
            });
        });
        return "success";
    }

    @DeleteMapping("removeProduct")
    public String removeProduct(Long personId, Long productId) {
        String dele = "MATCH (p:person)-[h:have]->(p1:product) where id(p) = $personId and id(p1) = $productId detach delete h";
        HashMap<String, Object> objectObjectHashMap = MapUtil.newHashMap();
        objectObjectHashMap.put("personId", personId);
        objectObjectHashMap.put("productId", productId);
        neo4jLink.write(dele, objectObjectHashMap);
        return "success";
    }


    @PostMapping("addCar")
    public String addCar(Long personId, Long carId) {
        Optional<Person> person = repository.findById(personId);
        person.ifPresent(e -> {
            Optional<CarEntity> car = carRespository.findById(carId);
            car.ifPresent(c -> {
                e.getCars().add(c);
                repository.save(e);
            });
        });
        return "success";
    }

    @DeleteMapping("remoteCar")
    public String remoteCar(Long personId, Long carId) {
        Optional<Person> person = repository.findById(personId);
        person.ifPresent(e -> {
            List<CarEntity> cars = e.getCars();
            List<CarEntity> collect = cars.stream().filter(c -> !c.getId().equals(carId)).collect(Collectors.toList());
            e.setCars(collect);
            repository.save(e);
        });
        return "success";
    }

    @PostMapping("addKinsfolk")
    public String addKinsfolk(Long personId, Long kinsfolkId) {
        Optional<Person> person = repository.findById(personId);
        person.ifPresent(e -> {
            Optional<Person> kinsfolk = repository.findById(kinsfolkId);
            kinsfolk.ifPresent(c -> {
                e.getKinsfolkShips().add(c);
                repository.save(e);
            });
        });
        return "success";
    }

    @GetMapping("findAll")
    public Page<Person> findAll(@RequestParam(defaultValue = "1") Integer page, @RequestParam(defaultValue = "10") Integer size) {
        Pageable pageable = PageRequest.of(page, size);
        Page<Person> all = repository.getAll(pageable);
        for (Person person : all) {
            Long id = person.getId();
            person.setProductEntityList(productRepository.getByPersonId(id));
            person.setCars(carRespository.getByPersonId(id));
            person.setKinsfolkShips(repository.getKinsfolkById(id));
        }
        return all;
    }

    @GetMapping("findById")
    public Person findById(Long id) {
        return repository.getById(id);
    }

    @GetMapping("findByIds")
    public Page<Person> findByIds(String ids, @RequestParam(defaultValue = "1") Integer page, @RequestParam(defaultValue = "10") Integer size) {
        List<Long> collect = StrUtil.split(ids, ',').stream().map(Long::parseLong).collect(Collectors.toList());
        Pageable pageable = PageRequest.of(page, size);
        Page<Person> all = repository.findByIds(collect, pageable);
        for (Person person : all) {
            Long id = person.getId();
            Map<String, Object> idMap = MapUtil.of("id", id);
            String cql = "MATCH (p:person)-[:have]->(n:product) WHERE p.id = $id RETURN n";
            List<ProductEntity> productEntity = neo4jLink.queryList(cql, idMap, ProductEntity.class);
            String cql2 = "MATCH (p:person)-[:have]->(n:car) WHERE id(p) = $id RETURN n";
            List<CarEntity> carEntityList = neo4jLink.queryList(cql2, idMap, CarEntity.class);
            String cql3 = "MATCH(n:person)-[:kinsfolk]->(m:person) where id(n) = $id RETURN m";
            List<Person> personList = neo4jLink.queryList(cql3, idMap, Person.class);
            person.setCars(carEntityList);
            person.setKinsfolkShips(personList);
            person.setProductEntityList(productEntity);
        }
        return all;
    }

}


package com.fy.controller;

import com.fy.dao.ProductRepository;
import com.fy.entity.ProductEntity;
import jakarta.annotation.Resource;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @ClassName ProductController
 * @author: maliang
 * @Description TODO
 * @date 2023/3/30 13:50
 * @Version 1.0版本
 */
@RestController
@RequestMapping("product")
public class ProductController {

    @Resource
    private ProductRepository repository;

    @PostMapping
    public String add(@RequestBody List<ProductEntity> productEntityList) {
        repository.saveAll(productEntityList);
        return "success";
    }

    @GetMapping("findAll")
    public List<ProductEntity> findAll() {
        return repository.getAll();
    }

}

增加人员
127.0.0.1:9004/person
[
    {
        "name": "包拯",
        "num": "001",
        "age": "25",
        "local": "保定"
    },
    {
        "name": "狄仁杰",
        "num": "002",
        "age": "38",
        "local": "凤阳"
    }
]

增加商品
127.0.0.1:9004/product
[
    {
        "productName": "西门子冰箱",
        "param": "size:10,long:200"
    },
    {
        "productName": "海尔冰箱",
        "param": "size:10,long:200"
    },
    {
        "productName": "小米手机",
        "param": "size:10,long:200"
    },
    {
        "productName": "跑步机",
        "param": "size:10,long:200"
    }
]

127.0.0.1:9004/person
[
    {
        "name": "包拯",
        "num": "001",
        "age": "25",
        "local": "保定"
    },
    {
        "name": "狄仁杰",
        "num": "002",
        "age": "38",
        "local": "凤阳"
    },
    {
        "name": "李昌钰",
        "num": "003",
        "age": "56",
        "local": "江苏"
    }
]
127.0.0.1:9004/product
[
    {
        "productName": "西门子冰箱",
        "param": "size:10,long:200"
    },
    {
        "productName": "海尔冰箱",
        "param": "size:10,long:200"
    },
    {
        "productName": "小米手机",
        "param": "size:10,long:200"
    },
    {
        "productName": "跑步机",
        "param": "size:10,long:200"
    }
]
127.0.0.1:9004/person/addProduct?personId=2&productId=6
127.0.0.1:9004/person/saveKinsfolk?personId=1&kinsfolkId=0
127.0.0.1:9004/car
[
    {
        "carName": "宝马",
        "carType": "宝马X5",
        "color": "红色"
    },
    {
        "carName": "奥迪",
        "carType": "奥迪a6",
        "color": "蓝色"
    },
    {
        "carName": "宝马",
        "carType": "宝马X5",
        "color": "红色"
    },
    {
        "carName": "奔驰",
        "carType": "奔驰350",
        "color": "黑色"
    },
    {
        "carName": "宝马",
        "carType": "宝马X5",
        "color": "红色"
    },
    {
        "carName": "五菱之光",
        "carType": "五菱mini",
        "color": "蓝色"
    }
]
127.0.0.1:9004/person/addCar?personId=1&carId=6
127.0.0.1:9004/person/findAll
127.0.0.1:9004/person/findById?id=0
127.0.0.1:9004/person/findByIds?ids=0,1,2

码云代码地址，给需要的人

devotemyself
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
Learning Neo4j 3.x(2nd)(英文原版) 免费
02-21
这是一本相对比较新的关于Neo4j的电子书，看不惯那些收费的资源，这个免费！
neo4j springboot 日志_Neo4j系列-整合SpringBoot（五）
weixin_39882948的博客
12-20 358
1. 开发环境Springboot 1.5.9.RELEASE(Springboot-parent2.0 版本里面接口变化较大，后期会出一个2.0版本的)jdk1.8springboot pom配置如下org.springframework.bootspring-boot-starter-parent1.5.9.RELEASEneo4j 相关配置如下UTF-8UTF-81.82.1.3org.sp...
neo4j 安装 apoc
颹蕭蕭
02-10 1068
把 docker 容器中 labs 中的 apoc jar包移动到 plugins 文件夹下，然后重启容器 docker restart container_name 统计apoc中函数个数 call dbms.functions() yield name where name starts with 'apoc.' return count(name) union call dbms.procedures() yield name where name starts with 'apoc.' retur
【Neo4j】Spring Boot操作Neo4j
LY_z_的博客
03-16 464
在 Spring Boot 中配置和操作 Neo4j 数据库
Neo4j批量导入大量csv数据
weixin_43342297的博客
07-22 2177
背景本人在建立知识图谱的过程中需要导入23w条节点之间的关系，把csv放到import下之后就开始导入，导了一晚上没导完，这里说一下如何导入大量的csv文件
安装并切换不同版本的Neo4j
weixin_44809084的博客
03-18 3891
根据研究或业务需求，有时需要在同一计算机上安装两个以上版本的Neo4j，具体操作如下： 检查Neo4j状态：neo4j status 停用Neo4j服务：neo4j stop 修改环境变量NEO4J_HOME，使Path中%NEO4J_HOME%/bin/指向需要切换的版本的路径 更新Neo4j服务: neo4j update-service 启动Neo4j服务: neo4j start 在输入Neo4j的地址前，需要先清空浏览器缓存才能正常访问新版本数据库。 ...
Neo4j框架学习之二语法命令
liushangzaibeijing的博客
01-11 508
本篇博文是作者有关neo4j学习的第二篇博文，主要介绍了neo4j的查询语句cypher语言，几乎涉猎了neo4j 增删改查的所有语法语句，是一篇不错的命令指导手册，读者不必全篇通读，只需要在使用的时候查询即可
【图数据库】Neo4j与Java调用
喵木木的博客
03-25 5695
参考资料： Neo4j官方教程
最新版本Neo4j的安装、配置和一丢丢使用要点（包括jdk配置），超详细教程
m0_66225353的博客
08-29 4047
●是根据各种文本和视频总结出来的蕴含本人血泪的经验教程●使用jgk17.0.8版本，与neo4j5.11.0版本●电脑为windows11点击右边蓝色链接即可下载①可以在电脑的C/D/E/F中选一个盘，先创建一个文件夹，用英文命名②双击安装③安装路径填写自定义文件夹路径（可以点击浏览，然后慢慢点到自己创建的文件夹，点击确定就OK啦），然后一路next，最后close即可。
Neo4j 5的自治图数据库集群
GraphWay的博客
11-25 926
本文介绍新近发布的Neo4j 版本5的自治集群（Autonomous Cluster）特性，以实际例子介绍其如何支持快速部署、可扩展、自容错等重要要求。
springboot2.6 整合neo4j 5.x 填坑
比尔·马云的博客
08-19 313
neo4j 5.x
linux安装neo4j5
一个有趣、有料、有内涵的地方!
11-15 1398
neo4j5.x 社区版下载地址： https://neo4j.com/download-center/#community ...
Neo4j 5.x 简体中文版指南.CHM
05-01
Neo4j 5.x 简体中文版指南.CHM
Learning Neo4j 3.x, 2nd Edition-Packt Publishing(2017).epub
03-21
Chapter 10, Security, covers authentication and authorization in Neo4j. Chapter 11, Visualizations for Neo4j, shows you how to display your data. Chapter 12, Data Refactoring with Neo4j, explains ...
Learning-Neo4j-3x-Second-Edition:学习Neo4j 3.x-第二版，由Packt发行
05-28
学习Neo4j 3.x-第二版 这是发布的的代码存储库。 它包含从头到尾完成本书所必需的所有支持项目文件。 关于这本书 Neo4j是一个图形数据库，可以轻松遍历大量数据。 本书旨在快速帮助您开始使用流行的图形数据库Neo4j...
Learning Neo4j 3.x(2nd) epub
11-29
Learning Neo4j 3.x(2nd) 英文epub 第2版 本资源转载自网络，如有侵权，请联系上传者或csdn删除 本资源转载自网络，如有侵权，请联系上传者或csdn删除
neo4j导出导入数据库
最新发布
weixin_43434136的博客
05-05 197
请注意，导出的数据文件通常包含在Neo4j的二进制格式中，因此如果您要将数据迁移到另一个Neo4j实例或将其导入到其他数据库系统中，您需要使用Neo4j提供的相应工具或方法来完成导入操作。导航到Neo4j数据库的安装目录。通常，Neo4j数据库安装在一个目录中，您可以在其中找到bin子目录。另外，请确保在执行导出操作之前，Neo4j数据库已停止，以避免数据不一致。要导出Neo4j数据库，您可以使用Neo4j提供的工具和方法之一。Neo4j将开始导出数据库。命令将数据加载到新的Neo4j实例中。
Neomodel 快速上手 构建neo4j 知识图谱
u010295555的博客
05-01 994
python 创建neo4j 数据通常使用py2neo，但是这个包 官方声明已经停止更新，根据neo4j网站推荐使用neomodelneomodel 使用起来很想django 中的orm，如果有django基础的上手很简单，而且neomodel 支持 neo4j 5.X版本更新维护的也较及时用于neo4j图形数据库的对象图形映射器 (OGM) ，基于很棒的构建如果您需要 neomodel 方面的帮助，请在https://github.com/neo4j-contrib/neomodel/
Neo4j v5 中 Cypher 的变化
u010295555的博客
05-01 1218
Neo4j 的新版本提供了更快的性能和更多的 Cypher 灵活性。然而，你可能需要重构一些现有的 Cypher 语句以适应 Neo4j v5。希望这篇博客文章能帮助你完成升级过程。
如何下载neo4j3.x版本2023
12-23
要下载Neo4j 3.x 版本 2023，可以按照以下步骤进行操作。 首先，打开您的网络浏览器，然后在搜索栏中键入“Neo4j 3.x 2023版本下载”。点击搜索按钮后，您会看到一系列与您搜索相关的结果。 接着，选择Neo4j官方网站的链接，该网站会列出所有最新和以前的Neo4j版本。在页面上找到3.x 版本 2023的下载链接，并点击它。 然后，根据您的操作系统选择合适的下载链接。如果您使用的是Windows，可以选择Windows平台的下载链接。如果您使用的是Mac，可以选择Mac平台的下载链接。下载完成后，您可以在系统中找到安装包并双击运行它。 接下来，按照安装向导的指示来完成Neo4j 3.x 版本 2023的安装。通常情况下，您需要选择安装路径、许可协议同意和其他选项。 最后，等待安装程序完成，并在安装完成后启动Neo4j数据库。您可以使用浏览器访问Neo4j数据库的管理界面，在那里您可以开始使用这个新版本的数据库。 需要注意的是，确保您的系统符合Neo4j 3.x 版本 2023的最低系统要求，并且在下载和安装过程中注意网络连接的稳定性，以确保安装过程顺利进行。祝您顺利下载和使用Neo4j 3.x 版本 2023！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值