SpringBoot 集成neo4j

Java 文档 后端技术 spring
2024-06-21 07:39

Neo4j社区版和企业版

主要区别在如下几点：


1、容量：社区版最多支持 320 亿个节点、320 亿个关系和 640 亿个属性，而企业版没有这个限制；


2、并发：社区版只能部署成单实例，不能做集群。而企业版可以部署成高可用集群或因果集群，从而可以解决高并发量的问题；


3、容灾：由于企业版支持集群，部分实例出故障不会影响整个系统正常运行；


4、热备：社区版只支持冷备份，即需要停止服务后才能进行备份，而企业版支持热备，第一次是全量备份，后续是增量备份；


5、性能：社区版最多用到 4 个内核，而企业能用到全部内核，且对性能做了精心的优化；


6、支持：企业版客户能得到 5X10 电话支持（Neo4j 美国电话、邮件，微云数聚电话、微信、邮件）；


7、插件：还有企业版可以使用Bloom、ETL这些工具，社区版不支持


8、关于社区版与企业版的性能对比，企业版的性能是社区版的 2~4 倍


image-20230424144003665


备注：


Neo4j社区版的neo4j最大节点存储量2**35，大约二百多亿，企业版没限制。如果服务器容许挂载的硬盘最大容量很大，采用企业版产品，那么也还是可以满足要求。不要实时性的话，titan也可以做；预算不够的话，arangodb、orientdb都支持分片存储。另外别指望all in one，慎重进行物理模型设计，仔细考虑图数据库的定位（当个图结构的索引最合适）。

Neo4j安装和配置

https://yum.neo4j.com/?_gl=111chijh_gaNjQxNTk2NTk3LjE2ODIzMTc0NzA._ga_DL38Q8KGQC*MTY4MjMxNzQ2Ny4xLjEuMTY4MjMyMjY0My4xNS4wLjA.&_ga=2.13639728.648652099.1682318571-641596597.1682317470


Neo4j下载


https://neo4j.com/download-center/#community


查看支持的运行环境

image.png

image.png

Neo4j库

image.png

以Neo4j Community Edition 4.4为例


System requirements

image.png

OpenJDK 11 or Oracle Java 11


yum安装（适用于在线）

#卸载
查看
rpm -qa | grep java
rpm -qa | grep jdk
#批量卸载
rpm -qa | grep jdk | xargs rpm -e --nodeps
rpm -qa | grep java | xargs rpm -e --nodeps

# 可以不用执行，查找安装包
yum search java-11-openjdk
# 安装
yum install -y java-11-openjdk java-11-openjdk-devel

# 通过yum方式安装默认安装在/usr/lib/jvm文件下
# 修改JAVA_HOME为/usr/lib/jvm/java-11-openjdk-11.0.12.0.7-0.el7_9.x86_64
# 编辑/etc/profile文件
vi /etc/profile
 
# 按" i "键进行编辑，设置环境变量，ESC退出编辑，" :wq "保存内容
# Java Environment
export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-11.0.12.0.7-0.el7_9.x86_64
export JRE_HOME=$JAVA_HOME/jre
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/jre/lib/tools.jar:$JRE_HOME/lib:$CLASSPATH
export PATH=$JAVA_HOME/bin:$PATH
 
# 使环境变量生效
source /etc/profile

tar解压安装（适用于离线）

#切换到root用户，在/usr下创建java文件夹
    
su root
mkdir /usr/java
cd /usr/java/
#tar解压文件
tar -zxvf openjdk-11+28_linux-x64_bin.tar.gz

#配置环境变量
# 修改JAVA_HOME为/usr/java/jdk-11
# 编辑/etc/profile文件
vi /etc/profile
 
# 按" i "键进行编辑，设置环境变量，ESC退出编辑，" :wq "保存内容
# Java Environment
export JAVA_HOME=/usr/java/jdk-11
export JRE_HOME=$JAVA_HOME/jre
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib:$CLASSPATH
export PATH=$JAVA_HOME/bin:$PATH
 
# 使环境变量生效
source /etc/profile

windows安装

https://neo4j.com/docs/operations-manual/4.4/installation/windows/


配置环境变量，系统变量Path目录添加**D:\neo4j\neo4j-community-3.5.35\bin**


在命令窗口输入**neo4j.bat console**


打开浏览器输入**http://localhost:7474/**

  • 第一次登录，用户名为neo4j，默认密码为neo4j

注册NEO4J服务输入命令：neo4j install-service本地服务查看


开启NEO4J服务输入命令：neo4j start

bin\neo4j console

bin\neo4j are: help, start, stop, restart, status, install-service, uninstall-service, and update-service

bin\neo4j install-service

echo dbms.memory.heap.initial_size=8g >> conf\neo4j.conf
echo dbms.memory.heap.max_size=16g >> conf\neo4j.conf

bin\neo4j update-service

bin\neo4j restart

Centos7安装

https://neo4j.com/docs/operations-manual/4.4/installation/linux/

rpm --import https://debian.neo4j.com/neotechnology.gpg.key
cat <<EOF >  /etc/yum.repos.d/neo4j.repo
[neo4j]
name=Neo4j RPM Repository
baseurl=https://yum.neo4j.com/stable
enabled=1
gpgcheck=1
EOF
sudo yum install https://dist.neo4j.org/neo4j-java11-adapter.noarch.rpm

yum install neo4j-4.4.15

sudo yum install https://dist.neo4j.org/neo4j-java11-adapter.noarch.rpm
#To install Neo4j Community Edition as root:
yum install neo4j-4.4.15

#To install Neo4j Enterprise Edition as root:
yum install neo4j-enterprise-4.4.15

rpm -qa | grep neo

systemctl {start|stop|restart} neo4j

systemctl edit neo4j
###########################
[Service]
# The user and group which the service runs as.
User=neo4j
Group=neo4j
# If it takes longer than this then the shutdown is considered to have failed.
# This may need to be increased if the system serves long-running transactions.
TimeoutSec=120
###########################
systemctl cat neo4j

systemctl restart neo4j

journalctl -e -u neo4j

备注：

Neo4j 5
cat <<EOF>  /etc/yum.repos.d/neo4j.repo
[neo4j]
name=Neo4j Yum Repo
baseurl=https://yum.neo4j.com/stable/5
enabled=1
gpgcheck=1
EOF
Neo4j 4.4
cat <<EOF>  /etc/yum.repos.d/neo4j.repo
[neo4j]
name=Neo4j Yum Repo
baseurl=https://yum.neo4j.com/stable/4.4
enabled=1
gpgcheck=1
EOF
Neo4j 3.5
cat <<EOF>  /etc/yum.repos.d/neo4j.repo
[neo4j]
name=Neo4j Yum Repo
baseurl=https://yum.neo4j.com/stable/3.5
enabled=1
gpgcheck=1
EOF
# 第 22 行
# 限制 LOAD CSV 在导入文件时，只能从 `import` 目录下读取
# 将其注释之后，可以从文件系统的任意路径读取文件
dbms.directories.import=import

# 第 54 行
# 在默认设置下，只能从本地访问 neo4j
# 取消注释之后，可以从远程访问 neo4j
dbms.connectors.default_listen_address=0.0.0.0

# 第 69 行
# 是否允许 bolt 链接方式，默认是 true
dbms.connector.bolt.enabled=true

# 第 71 行
# bolt 的默认端口是 7687，也可以通过这行设置进行修改
dbms.connector.bolt.listen_address=:7687

# 第 74 行
# 是否允许 http 链接方式，默认是 true
dbms.connector.http.enabled=true

# 第 75 行
# http 的默认端口是 7474，也可以通过这行设置进行修改
dbms.connector.http.listen_address=:7474

# 第 78 行
# 是否允许 https 链接方式，默认是 true
dbms.connector.https.enabled=true

# 第 79 行
# https 的默认端口是 7473，也可以通过这行设置进行修改
dbms.connector.https.listen_address=:7473

# 第 245 行
# 是否允许 LOAD CSV 在导入文件时，可以从远程读取文件
dbms.security.allow_csv_import_from_file_urls=true

# 第 265 行
# neo4j 数据库是否只读
dbms.read_only=false

http://192.168.137.30:7474/browser/


默认 neo4j/neo4j

配置说明

https://neo4j.com/docs/operations-manual/4.4/configuration/file-locations/

neo4j使用手册

详见neo4j使用手册

springboot集成neo4j安装配置

步骤1


创建项目


步骤2


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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>cn.guangjun.spring.boot2</groupId>
        <artifactId>springboot2-parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <relativePath>../pom.xml</relativePath>
    </parent>
    <artifactId>springboot2-neo4j</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot2-neo4j</name>
    <description>springboot2-neo4j集成案例</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </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>
     
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.58</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

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

步骤3


application.yaml

server:
 servlet:
   context-path: /
 port: 9000
spring:
 data:
   neo4j:
     uri: bolt://192.168.137.30:7687
     username: neo4j
     password: hu@123#!

步骤4

package cn.guangjun.spring.boot2.neo4j.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import org.neo4j.ogm.annotation.GeneratedValue;
import org.neo4j.ogm.annotation.Id;
import org.neo4j.ogm.annotation.NodeEntity;
import org.neo4j.ogm.annotation.Relationship;

import java.util.Collections;
import java.util.HashSet;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * @BeongsPackage：cn.guangjun.spring.boot2.neo4j.pojo
 * @Author guangjunhu
 * @Date： 2023年04月25日 10:39:44
 * @Descripton：
 * @Version：
 **/
@NodeEntity
public class Person {
    @Id
    @GeneratedValue
    private Long id;
    private String name;
    private Person() {
        // Empty constructor required as of Neo4j API 2.0.5
    };

    public Person(String name) {
        this.name = name;
    }

    /**
     * Neo4j doesn't REALLY have bi-directional relationships. It just means when querying
     * to ignore the direction of the relationship.
     * https://dzone.com/articles/modelling-data-neo4j
     */
    @Relationship(type = "TEAMMATE", direction = Relationship.UNDIRECTED)
    public Set<Person> teammates;

    public void worksWith(Person person) {
        if (teammates == null) {
            teammates = new HashSet<>();
        }
        teammates.add(person);
    }

    public String toString() {

        return this.name + "'s teammates => "
                + Optional.ofNullable(this.teammates).orElse(
                        Collections.emptySet()).stream()
                .map(Person::getName)
                .collect(Collectors.toList());
    }

    public String getName() {
        return name;
    }

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

}

package cn.guangjun.spring.boot2.neo4j.repository;

import cn.guangjun.spring.boot2.neo4j.pojo.Person;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.neo4j.annotation.Query;
import org.springframework.data.neo4j.repository.Neo4jRepository;

import java.util.List;

/**
 * @BeongsPackage：cn.guangjun.spring.boot2.neo4j.repository
 * @Author guangjunhu
 * @Date： 2023年04月25日 10:39:22
 * @Descripton：
 * @Version：
 **/
public interface PersonRepository extends Neo4jRepository<Person, Long> {

    Person findByName(String name);

    List<Person> findByTeammatesName(String name);

    @Query(value = "match (Greg:Person) return Greg",
            countQuery= "match (Greg:Person) return count(Greg)")
    Page<Person> getActorsThatActInAmoviesFromTitle(Pageable pageable );

    @Query(value ="",countQuery = "")
    List<Person> getAllById();
}

package cn.guangjun.spring.boot2.neo4j;

import cn.guangjun.spring.boot2.neo4j.pojo.Person;
import cn.guangjun.spring.boot2.neo4j.repository.PersonRepository;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;

import java.util.Arrays;
import java.util.List;

@Slf4j
@SpringBootApplication
public class Springboot2Neo4jApplication {

    public static void main(String[] args) {
        SpringApplication.run(Springboot2Neo4jApplication.class, args);
    }
    @Bean
    CommandLineRunner demo(PersonRepository personRepository) {
        return args -> {

            personRepository.deleteAll();

            Person greg = new Person("Greg");
            Person roy = new Person("Roy");
            Person craig = new Person("Craig");

            List<Person> team = Arrays.asList(greg, roy, craig);

            log.info("Before linking up with Neo4j...");

            team.stream().forEach(person -> log.info("\t" + person.toString()));

            personRepository.save(greg);
            personRepository.save(roy);
            personRepository.save(craig);

            greg = personRepository.findByName(greg.getName());
            greg.worksWith(roy);
            greg.worksWith(craig);
            personRepository.save(greg);

            roy = personRepository.findByName(roy.getName());
            roy.worksWith(craig);
            // We already know that roy works with greg
            personRepository.save(roy);

            // We already know craig works with roy and greg

            log.info("Lookup each person by name...");
            team.stream().forEach(person -> log.info(
                    "\t" + personRepository.findByName(person.getName()).toString()));

            List<Person> teammates = personRepository.findByTeammatesName(greg.getName());
            log.info("The following have Greg as a teammate...");
            teammates.stream().forEach(person -> log.info("\t" + person.getName()));
            Page<Person> grag=personRepository.getActorsThatActInAmoviesFromTitle(PageRequest.of(0,5));
            log.info("\t" + grag);
        };
    }
}
相关新闻
热点
1
Flink容错检查点配置
2
需求评审流程规范
3
SpringCloud之Nacos集群和持久化配置
4
需求评审报告模板
5
SpringCloud体系思维导图
6
腾讯产品需求文档
7
软件项目管理全套文档
8
项目开发计划（GB856T——88）
9
软件项目配置管理计划案例
视频
投票
您从哪里知道本网站的
查看结果
Tags
后端技术 文档 Java 文库 spring Linux 运维 flink 数据库 mysql

站点地图 在线访客: 今日访问量: 昨日访问量: 总访问量:

© 2025 个人网站 版权所有

备案号：苏ICP备2024108837号

苏公网安备32011302322151号