史上最全面的Neo4j使用指南 - 薛师兄的博客

link管理
链接快照平台
输入网页链接，自动生成快照
标签化管理网页链接
第一章：介绍

Neo4j是什么

Neo4j 是一个高性能的,NOSQL图形数据库，它将结构化数据存储在网络上而不是表中。它是一个嵌入式的、基于磁盘的、具备完全的事务特性的Java持久化引擎，但是它将结构化数据存储在网络(从数学角度叫做图)上而不是表中。Neo4j也可以被看作是一个高性能的图引擎，该引擎具有成熟数据库的所有特性。程序员工作在一个面向对象的、灵活的网络结构下而不是严格、静态的表中——但是他们可以享受到具备完全的事务特性、企业级的数据库的所有好处。
Neo4j的特点

SQL就像简单的查询语言Neo4j CQL
它遵循属性图数据模型
它通过使用Apache Lucence支持索引
它支持UNIQUE约束
它它包含一个用于执行CQL命令的UI：Neo4j数据浏览器
它支持完整的ACID（原子性，一致性，隔离性和持久性）规则
它采用原生图形库与本地GPE（图形处理引擎）
它支持查询的数据导出到JSON和XLS格式
它提供了REST API，可以被任何编程语言（如Java，Spring，Scala等）访问
它提供了可以通过任何UI MVC框架（如Node JS）访问的Java脚本
它支持两种Java API：Cypher API和Native Java API来开发Java应用程序
Neo4j的优点

它很容易表示连接的数据
检索/遍历/导航更多的连接数据是非常容易和快速的
它非常容易地表示半结构化数据
Neo4j CQL查询语言命令是人性化的可读格式，非常容易学习
它使用简单而强大的数据模型
它不需要复杂的连接来检索连接的/相关的数据，因为它很容易检索它的相邻节点或关系细节没有连接或索引
第二章：安装

Centos 7.4
neo4j-community-3.4.1.tar.gz
下载地址 https://neo4j.com/download/other-releases/
wget https://neo4j.com/artifact.php?name=neo4j-community-3.4.1-unix.tar.gz
tar -zxvf neo4j-community-3.4.1.tar.gz
3.开启远程访问
一、对于3.0以前的版本
在安装目录的 $NEO4J_HOME/conf/neo4j.conf 文件内，找到下面一行，将注释#号去掉就可以了 #dbms.connector.https.address=localhost:7473 改为 dbms.connector.https.address=0.0.0.0:7473 这样，远程其他电脑可以用本机的IP或者域名后面跟上7474 端口就能打开web界面了 如： https://:7473
当然，你的操作系统的防火墙也要确保开放了7474端口才行，防火墙怎样开放请自行针对自己的操作系统查找文档
二、对于3.1及以后的版本
在安装目录的 $NEO4J_HOME/conf/neo4j.conf 文件内，找到下面一行，将注释#号去掉就可以了 dbms.connectors.default_listen_address=0.0.0.0
  Neo4j CQL 已命令来执行数据库操作。
  Neo4j CQL 支持多个子句像在哪里，顺序等，以非常简单的方式编写非常复杂的查询。
  NNeo4j CQL 支持一些功能，如字符串，Aggregation.In 加入他们，它还支持一些关系功能。
2.Neo4j CQL命令/条款
常用的Neo4j CQL命令/条款如下：
Neo.ClientError.Statement.SyntaxError: 
Query cannot conclude with MATCH 
(must be RETURN or an update clause) (line 1, column 1 (offset: 0))
如果你观察到错误消息，它告诉我们，我们可以使用MATCH命令与RETURN子句或UPDATA子句。
3.RETURN返回
Neo4j CQL RETURN子句用于 -
  检索节点的某些属性
  检索节点的所有属性
  检索节点和关联关系的某些属性
  检索节点和关联关系的所有属性
RETURN命令语法：
RETURN 
   <node-name>.<property1-name>,
   ........
   <node-name>.<propertyn-name>
MATCH (e:Employee) RETURN e
MATCH (dept: Dept)
RETURN dept.deptno,dept.dname,dept.location
4.关系基础
Neo4j图数据库遵循属性图模型来存储和管理其数据。
根据属性图模型，关系应该是定向的。 否则，Neo4j将抛出一个错误消息。
基于方向性，Neo4j关系被分为两种主要类型。
使用新节点创建关系
CREATE (e:Employee)-[r:DemoRelation]->(c:Employee)
这句会创建节点e，节点c，以及e -> c的关系r，这里需要注意方向，比如双向是
CREATE (e:Employee)<-[r:DemoRelation]->(c:Employee)
使用已知节点创建带属性的关系：
MATCH (<node1-label-name>:<node1-name>),(<node2-label-name>:<node2-name>)
CREATE  
    (<node1-label-name>)-[<relationship-label-name>:<relationship-name>
    {<define-properties-list>}]->(<node2-label-name>)
RETURN <relationship-label-name>
  还是一系列键值对
MATCH (cust:Customer),(cc:CreditCard) 
CREATE (cust)-[r:DO_SHOPPING_WITH{shopdate:"12/12/2014",price:55000}]->(cc) 
RETURN r
检索关系节点的详细信息：
MATCH 
(<node1-label-name>)-[<relationship-label-name>:<relationship-name>]->(<node2-label-name>)
RETURN <relationship-label-name>
MATCH (cust)-[r:DO_SHOPPING_WITH]->(cc) 
RETURN cust,cc
5.WHERE子句
像SQL一样，Neo4j CQL在CQL MATCH命令中提供了WHERE子句来过滤MATCH查询的结果。
简单WHERE子句语法
WHERE <property-name> <comparison-operator> <value>
语法说明：
MATCH (emp:Employee) 
WHERE emp.name = 'Abc' OR emp.name = 'Xyz'
RETURN emp
利用WHERE创建指定关系节点：
MATCH (cust:Customer),(cc:CreditCard) 
WHERE cust.id = "1001" AND cc.id= "5001" 
CREATE (cust)-[r:DO_SHOPPING_WITH{shopdate:"12/12/2014",price:55000}]->(cc) 
RETURN r
有必要补充一下，可以不使用WHERE达到WHERE的一些效果，比如
MATCH p=(m:Bot{id:123})<-[:BotRelation]->(:Bot)  RETURN p
6.DELETE删除
Neo4j使用CQL DELETE子句
  删除节点。
  删除节点及相关节点和关系。
DELETE节点子句语法
DELETE <node-name-list>
MATCH (e: Employee) DELETE e
DELETE节点和关系子句语法
DELETE <node1-name>,<node2-name>,<relationship-name>
MATCH (cc: CreditCard)-[rel]-(c:Customer) 
DELETE cc,c,rel
7.REMOVE删除
有时基于我们的客户端要求，我们需要向现有节点或关系添加或删除属性。
我们使用Neo4j CQL SET子句向现有节点或关系添加新属性。
我们使用Neo4j CQL REMOVE子句来删除节点或关系的现有属性。
Neo4j CQL REMOVE命令用于
  删除节点或关系的标签
  删除节点或关系的属性
Neo4j CQL DELETE和REMOVE命令之间的主要区别 -
  DELETE操作用于删除节点和关联关系。
  REMOVE操作用于删除标签和属性。
Neo4j CQL DELETE和REMOVE命令之间的相似性 -
  这两个命令不应单独使用。
  两个命令都应该与MATCH命令一起使用。
1.REMOVE属性子句语法
REMOVE <node-name>.<property1-name>,<node-name>.<property2-name>
语法说明：
SET子句语法
SET  <node-label-name>.<property1-name>,...<node-laben-name>.<propertyn-name>
语法说明：
MATCH (emp:Employee)
RETURN emp.empid,emp.name,emp.salary,emp.deptno
ORDER BY emp.name
10.UNION子句
与SQL一样，Neo4j CQL有两个子句，将两个不同的结果合并成一组结果
  UNION
  UNION ALL
UNION子句
它将两组结果中的公共行组合并返回到一组结果中。 它不从两个节点返回重复的行。
结果列类型和来自两组结果的名称必须匹配，这意味着列名称应该相同，列的数据类型应该相同。
UNION子句语法
<MATCH Command1>
   UNION
<MATCH Command2>
MATCH (cc:CreditCard) RETURN cc.id,cc.number
UNION
MATCH (dc:DebitCard) RETURN dc.id,dc.number
UNION ALL子句
它结合并返回两个结果集的所有行成一个单一的结果集。它还返回由两个节点重复行。
结果列类型，并从两个结果集的名字必须匹配，这意味着列名称应该是相同的，列的数据类型应该是相同的。
UNION ALL子句语法
<MATCH Command1>
UNION ALL
<MATCH Command2>
MATCH (cc:CreditCard) RETURN cc.id,cc.number
UNION ALL
MATCH (dc:DebitCard) RETURN dc.id,dc.number
11.LIMIT和SKIP子句
Neo4j CQL已提供LIMIT子句和SKIP来过滤或限制查询返回的行数。
简单来说：LIMIT返回前几行，SKIP返回后几行。
LIMIT 示例
MATCH (emp:Employee) 
RETURN emp
LIMIT 2
它只返回Top的两个结果，因为我们定义了limit = 2。这意味着前两行。
SKIP示例
MATCH (emp:Employee) 
RETURN emp
SKIP 2
它只返回来自Bottom的两个结果，因为我们定义了skip = 2。这意味着最后两行。
12.MERGE命令
Neo4j使用CQL MERGE命令 -
  创建节点，关系和属性
  为从数据库检索数据
MERGE命令是CREATE命令和MATCH命令的组合。
MERGE = CREATE + MATCH
Neo4j CQL MERGE命令在图中搜索给定模式，如果存在，则返回结果
如果它不存在于图中，则它创建新的节点/关系并返回结果。
Neo4j CQL MERGE语法
MERGE (<node-name




    
>:<label-name>
   <key>:<1-Value>
   .....
   <n-key>:<n-Value>
**注意 **
Neo4j CQL MERGE命令语法与CQL CREATE命令类似。
我们将使用这两个命令执行以下操作 -
  创建具有一个属性的配置文件节点：Id，名称
  创建具有相同属性的同一个Profile节点：Id，Name
  检索所有Profile节点详细信息并观察结果
我们将使用CREATE命令执行这些操作：
MERGE (gp2:GoogleProfile2{ Id: 201402,Name:"Nokia"})
MERGE (gp2:GoogleProfile2{ Id: 201402,Name:"Nokia"})
MATCH  (gp1:GoogleProfile1) 
RETURN gp1.Id,gp1.Name
如果我们观察上面的查询结果，它只显示一行，因为CQL MERGE命令检查该节点在数据库中是否可用。 如果它不存在，它创建新节点。 否则，它不创建新的。
通过观察这些结果，我们可以说，CQL MERGE命令将新的节点添加到数据库，只有当它不存在。
13.NULL值
Neo4j CQL将空值视为对节点或关系的属性的缺失值或未定义值。
当我们创建一个具有现有节点标签名称但未指定其属性值的节点时，它将创建一个具有NULL属性值的新节点。
让我们用一个例子来看这个。
MATCH (e:Employee) 
WHERE e.id IS NOT NULL
RETURN e.id,e.name,e.sal,e.deptno
提供了一个WHERE子句来过滤该行，即Id属性不应该包含NULL值。
MATCH (e:Employee) 
WHERE e.id IS NULL
RETURN e.id,e.name,e.sal,e.deptno
这里我们使用IS操作符来仅返回NULL行。
14.IN操作符
与SQL一样，Neo4j CQL提供了一个IN运算符，以便为CQL命令提供值的集合。
IN操作符语法
IN[<Collection-of-values>]
它是由逗号运算符分隔的值的集合。
MATCH (e:Employee) 
WHERE e.id IN [123,124]
RETURN e.id,e.name,e.sal,e.deptno
15.INDEX索引
Neo4j SQL支持节点或关系属性上的索引，以提高应用程序的性能。
我们可以为具有相同标签名称的所有节点的属性创建索引。
我们可以在MATCH或WHERE或IN运算符上使用这些索引列来改进CQL Command的执行。
Neo4J索引操作
  Create Index 创建索引
  Drop Index 丢弃索引
我们将在本章中用示例来讨论这些操作。
创建索引的语法：
CREATE INDEX ON :<label_name> (<property_name>)
冒号（:)运算符用于引用节点或关系标签名称。
上述语法描述它在节点或关系的的上创建一个新索引。
CREATE INDEX ON :Customer (name)
删除索引的语法：
DROP INDEX ON :<label_name> (<property_name>)
DROP INDEX ON :Customer (name)
16.UNIQUE约束
在Neo4j数据库中，CQL CREATE命令始终创建新的节点或关系，这意味着即使您使用相同的值，它也会插入一个新行。 根据我们对某些节点或关系的应用需求，我们必须避免这种重复。 然后我们不能直接得到这个。 我们应该使用一些数据库约束来创建节点或关系的一个或多个属性的规则。
像SQL一样，Neo4j数据库也支持对NODE或Relationship的属性的UNIQUE约束
UNIQUE约束的优点
  避免重复记录。
  强制执行数据完整性规则
创建唯一约束语法
CREATE CONSTRAINT ON (<label_name>)
ASSERT <property_name> IS UNIQUE
语法说明：
在Neo4j中，“Id”是节点和关系的默认内部属性。 这意味着，当我们创建一个新的节点或关系时，Neo4j数据库服务器将为内部使用分配一个数字。 它会自动递增。
我们从一个例子去看：
新增一个节点
CREATE (tweet:Tweet{message:"Hello"})
查看该节点
MATCH (n:Tweet) RETURN n 
3.SUBSTRING
它接受一个字符串作为输入和两个索引：一个是索引的开始，另一个是索引的结束，并返回从StartInded到EndIndex-1的子字符串。 所有CQL函数应使用“（）”括号。
函数的语法
SUBSTRING(<input-string>,<startIndex> ,<endIndex>)
在Neo4J CQL中，如果一个字符串包含n个字母，则它的长度为n，索引从0开始，到n-1结束。
是SUBSTRING函数的索引值。
是可选的。 如果我们省略它，那么它返回给定字符串的子串从startIndex到字符串的结尾。
MATCH (e:Employee) 
RETURN e.id,SUBSTRING(e.name,0,2),e.sal,e.deptno
2.AGGREGATION聚合
和SQL一样，Neo4j CQL提供了一些在RETURN子句中使用的聚合函数。 它类似于SQL中的GROUP BY子句。
我们可以使用MATCH命令中的RETURN +聚合函数来处理一组节点并返回一些聚合值。
聚合函数列表
数据导入：
./neo4j-admin load --from=/home/2018.dump --database=graph.db --force
重启服务：
./neo4j start
第八章：Spring Data Neo4j
1.简单介绍
Neo4j提供JAVA API以编程方式执行所有数据库操作。
具体Neo4j如何在原生Java程序编程，以及与Spring的集成，本章暂不讨论。
Spring数据模块的优点：
  消除DAO层中的boiler plate代码
  DAO层中的工件少
  易于开发和维护
  改进开发过程
Spring数据模块功能：
  支持基于XML的实体映射
  支持基于注释的实体映射
  更少的DAO层工件 - 实现存储库
Spring DATA Neo4j模块具有与上述相同的优点和特点。
接下来，我们将基于Spring Boot在IDEA上开发Neo4j应用程序，需要注意的是Springboot的版本
2.新建项目
我们选择web和Neo4j两个依赖即可，这里有必要说一下，如果你是使用Spring boot2.0以上，在你创建项目完成后，启动程序会报错：
Caused by: java.lang.ClassNotFoundException: org.neo4j.ogm.drivers.http.driver.HttpDriver
    at java.net.URLClassLoader.findClass(URLClassLoader.java:381) ~[na:1.8.0_111]
    at java.lang.ClassLoader.loadClass(ClassLoader.java:424) ~[na:1.8.0_111]
    at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:331) ~[na:1.8.0_111]
    at java.lang.ClassLoader.loadClass(ClassLoader.java:357) ~[na:1.8.0_111]
    at java.lang.Class.forName0(Native Method) ~[na:1.8.0_111]
    at java.lang.Class.forName(Class.java:264) ~[na:1.8.0_111]
    at org.neo4j.ogm.session.SessionFactory.newDriverInstance(SessionFactory.java:92) ~[neo4j-ogm-core-3.1.0.jar:3.1.0]
    ... 45 common frames omitted
原因是缺少依赖，解决方法是导入缺少的依赖：
<dependency>
    <groupId>org.neo4j</groupId>
    <artifactId>neo4j-ogm-http-driver</artifactId>
</dependency>
如果你的Spring boot版本为1.5.x，那么你只需要spring-data-neo4j即可：
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-neo4j</artifactId>
</dependency>
3.节点与关系
新建节点类，id的属性为Long而不能为long，还需要注意的是在Spring boot1.5中修饰id属性的注释为@GraphId，org.neo4j.ogm.annotation.Id不存在，效果一样，都是Neo4j数据库自动创建的ID值。
@NodeEntity(




    
label = "Bot")
public class BotNode {
    @GeneratedValue
    private Long id; //id
    @Property(name = "name")
    private String name;//名
    @Property(name = "kind")
    private String kind;//类
    @Property(name = "weight")
    private long weight;//权重
    public BotNode() {
    public BotNode(Long id, String name, String kind, long weight) {
        this.id = id;
        this.name = name;
        this.kind = kind;
        this.weight = weight;
    public Long getId() {
        return id;
    public void setId(Long id) {
        this.id = id;
    public String getName() {
        return name;
    public void setName(String name) {
        this.name = name;
    public String getKind() {
        return kind;
    public void setKind(String kind) {
        this.kind = kind;
    public long getWeight() {
        return weight;
    public void setWeight(long weight) {
        this.weight = weight;
    @Override
    public String toString() {
        return "BotNode{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", kind='" + kind + '\'' +
                ", weight=" + weight +
                '}';
新建节点关系类
有必要说明一下， @StartNode 和@EndNode注释的类可以不是同一个类。
@RelationshipEntity(type = "BotRelation")
public class BotRelation {
    @GeneratedValue
    private Long id;
    @StartNode
    private BotNode startNode;
    @EndNode
    private BotNode endNode;
    @Property
    private String relation;
    public BotRelation() {
    public BotRelation(Long id, BotNode startNode, BotNode endNode, String relation) {
        this.id = id;
        this.startNode = startNode;
        this.endNode = endNode;
        this.relation = relation;
    public String getRelation() {
        return relation;
    public void setRelation(String relation) {
        this.relation = relation;
    public Long getId() {
        return id;
    public void setId(Long id) {
        this.id = id;
    public BotNode getStartNode() {
        return startNode;
    public void setStartNode(BotNode startNode) {
        this.startNode = startNode;
    public BotNode getEndNode() {
        return endNode;
    public void setEndNode(BotNode endNode) {
        this.endNode = endNode;
    @Override
    public String toString() {
        return "BotRelation{" +
                "id=" + id +
                ", startNode=" + startNode +
                ", endNode=" + endNode +
                ", relation='" + relation + '\'' +
                '}';
4.Repository
我们只需要使接口继承Neo4jRepository就可以使用该接口提供的一些基础的增删改查方法。
@Repository
public interface BotRepository extends Neo4jRepository<BotNode,Long> {
    BotNode findAllByName(String name);
对于复杂的查询我们可以参照上面讲到的CQL语句执行。
@Repository
public interface BotRelationRepository extends Neo4jRepository<BotRelation,Long> {
    //返回节点n以及n指向的所有节点与关系
    @Query("MATCH p=(n:Bot)-[r:BotRelation]->(m:Bot) WHERE id(n)={0} RETURN p")
    List<BotRelation> findAllByBotNode(BotNode botNode);
    //返回节点n以及n指向或指向n的所有节点与关系
    @Query("MATCH p=(n:Bot)<-[r:BotRelation]->(m:Bot) WHERE m.name={name} RETURN p")
    List<BotRelation> findAllBySymptom(@Param("name") String name);
    //返回节点n以及n指向或指向n的所有节点以及这些节点间的所有关系
    @Query("MATCH p=(n:Bot)<-[r:BotRelation]->(m:Bot)<-[:BotRelation]->(:Bot)<-[:BotRelation]->(n:Bot) WHERE n.name={name} RETURN p")
    List<BotRelation> findAllByStartNode(@Param("name") String name);
5.单元测试
@RunWith(SpringRunner.class)
@SpringBootTest
public class Neo4jApplicationTests {
    @Autowired
    MovieRepository movieRepository;
    @Test
    public void contextLoads() {
        movieRepository.save(new Movie("《奥特曼》"));
        System.out.println(movieRepository.findAll());
查看打印：
[Movie{id=8183, name='《奥特曼》'}]
保存成功！
如果想保存关系的话
MedicalNode node = new MedicalNode(-1l,"节点","测试");
medicalNodeRepository.save(node);
MedicalNode node1 = new MedicalNode(-1l,"节点","测试");
medicalNodeRepository.save(node1);
medicalRelationRepository.save(new MedicalRelation(-1l,node,node1,"关系"));
public void updata(){
   Movie movie = movieRepository.findAllById(8183l);
   movie.setName("《迪迦》");
   movieRepository.save(movie);
   System.out.println(movieRepository.findAll());
执行程序，报错：
java.lang.NullPointerException
我们看到程序执行的CQL语句为：
MATCH (n:`Movie`) WHERE n.`id` = { `id_0` } WITH n RETURN n, ID(n)
然后我们在Neo4j浏览器控制台执行查询语句：
这是为什么呢？在Neo4j中，根据Id查询节点的语句为：
MATCH (n:Movie) where id(n)=8183  RETURN n
我们修改Repository层的查询方法：
@Repository
public interface MovieRepository extends Neo4jRepository<Movie, Long> {
    @Query("MATCH (n:Movie) where id(n)={id}  RETURN n")
    Movie findAllById(@Param("id") Long id);
再次执行更新程序，结果为：
[Movie{id=8183, name='《迪迦》'}]
更新成功！
  换句话说，只要掌握了CQL语句，就基本啥都会了~！
  还有，本书并不代表全部的Neo4j知识。
附录 neo4j.conf汉化释义版
# For more details and a complete list of settings, please see https://neo4j.com/docs/operations-manual/current/reference/configuration-settings/
# 如果想自定义neo4j数据库数据的存储路径，要同时修改dbms.active_database 和 dbms.directories.data 两项配置，
# 修改配置后，数据会存放在${dbms.directories.data}/databases/${dbms.active_database} 目录下
# 安装的数据库的名称，默认使用${NEO4J_HOME}/data/databases/graph.db目录
# The name of the database to mount  
#dbms.active_database=graph.db
# 安装Neo4j数据库的各个配置路径，默认使用$NEO4J_HOME下的路径
# Paths of directories in the installation. 
# 数据路径
#dbms.directories.data=data  
# 插件路径
#dbms.directories.plugins=plugins  
#dbms.directories.certificates=certificates  证书路径
#dbms.directories.logs=logs 日志路径
#dbms.directories.lib=lib jar包路径
#dbms.directories.run=run 运行路径
# 默认情况下想load csv文件，只能把csv文件放到${NEO4J_HOME}/import目录下，把下面的#删除后，可以在load csv时使用绝对路径，这样可能不安全
# This setting constrains all `LOAD CSV` import files to be under the `import` directory. Remove or comment it out to allow files to be loaded from anywhere in the filesystem; this introduces possible security problems. See the `LOAD CSV` section of the manual for details.  
# 此设置将所有“LOAD CSV”导入文件限制在`import`目录下。删除注释允许从文件系统的任何地方加载文件;这引入了可能的安全问题。
dbms.directories.import=import
# 把下面这行的#删掉后，连接neo4j数据库时就不用输密码了
# Whether requests to Neo4j are authenticated. 是否对Neo4j的请求进行了身份验证。
# To disable authentication, uncomment this line 要禁用身份验证，请取消注释此行。
#dbms.security.auth_enabled=false
# Enable this to be able to upgrade a store from an older version. 是否兼容以前版本的数据
dbms.allow_format_migration=true
# Java Heap Size: by default the Java heap size is dynamically calculated based on available system resources. Java堆大小：默认情况下，Java堆大小是动态地根据可用的系统资源计算。
# Uncomment these lines to set specific initial and maximum heap size. 取消注释这些行以设置特定的初始值和最大值
#dbms.memory.heap.initial_size=512m
#dbms.memory.heap.max_size=512m
# The amount of memory to use for mapping the store files, in bytes (or kilobytes with the 'k' suffix, megabytes with 'm' and gigabytes with 'g'). 用于映射存储文件的内存量（以字节为单位）千字节带有'k'后缀，兆字节带有'm'，千兆字节带有'g'）。
# If Neo4j is running on a dedicated server, then it is generally recommended to leave about 2-4 gigabytes for the operating system, give the JVM enough heap to hold all your transaction state and query context, and then leave the rest for the page cache. 如果Neo4j在专用服务器上运行，那么通常建议为操作系统保留大约2-4千兆字节，为JVM提供足够的堆来保存所有的事务状态和查询上下文，然后保留其余的页面缓存 。
# The default page cache memory assumes the machine is dedicated to running Neo4j, and is heuristically set to 50% of RAM minus the max Java heap size.  默认页面缓存存储器假定机器专用于运行Neo4j，并且试探性地设置为RAM的50％减去最大Java堆大小。
#dbms.memory.pagecache.size=10g
### Network connector configuration
# With default configuration Neo4j only accepts local connections. Neo4j默认只接受本地连接(localhost)
# To accept non-local connections, uncomment this line:  要接受非本地连接，请取消注释此行
dbms.connectors.default_listen_address=0.0.0.0 (这是删除#后的配置，可以通过ip访问)
# You can also choose a specific network interface, and configure a non-default port for each connector, by setting their individual listen_address. 还可以选择特定的网络接口，并配置非默认值端口，设置它们各自的listen_address
# The address at which this server can be reached by its clients. This may be the server's IP address or DNS name, or it may be the address of a reverse proxy which sits in front of the server. This setting may be overridden for individual connectors below. 客户端可以访问此服务器的地址。这可以是服务器的IP地址或DNS名称，或者可以是位于服务器前面的反向代理的地址。此设置可能会覆盖以下各个连接器。
#dbms.connectors.default_advertised_address=localhost
# You can also choose a specific advertised hostname or IP address, and configure an advertised port for each connector, by setting their individual advertised_address. 您还可以选择特定广播主机名或IP地址，
为每个连接器配置通告的端口，通过设置它们独特的advertised_address。
# Bolt connector 使用Bolt协议
dbms.connector.bolt.enabled=true
dbms.connector.bolt.tls_level=OPTIONAL
dbms.connector.bolt.listen_address=:7687
# HTTP Connector. There must be exactly one HTTP connector. 使用http协议
dbms.connector.http.enabled=true
dbms.connector.http.listen_address=:7474
# HTTPS Connector. There can be zero or one HTTPS connectors. 使用https协议
dbms.connector.https.enabled=true
dbms.connector.https.listen_address=:7473
# Number of Neo4j worker threads. Neo4j线程数
#dbms.threads.worker_count=
# Logging configuration  日志配置
# To enable HTTP logging, uncomment this line  要启用HTTP日志记录，请取消注释此行
dbms.logs.http.enabled=true
# Number of HTTP logs to keep. 要保留的HTTP日志数
#dbms.logs.http.rotation.keep_number=5
# Size of each HTTP log that is kept. 每个HTTP日志文件的大小
dbms.logs.http.rotation.size=20m
# To enable GC Logging, uncomment this line 要启用GC日志记录，请取消注释此行
#dbms.logs.gc.enabled=true
# GC Logging Options see http://docs.oracle.com/cd/E19957-01/819-0084-10/pt_tuningjava.html#wp57013 for more information.  GC日志记录选项 有关详细信息，请参见http://docs.oracle.com/cd/E19957-01/819-0084-10/pt_tuningjava.html#wp57013
#dbms.logs.gc.options=-XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+PrintGCApplicationStoppedTime -XX:+PrintPromotionFailure -XX:+PrintTenuringDistribution
# Number of GC logs to keep. 要保留的GC日志数
#dbms.logs.gc.rotation.keep_number=5
# Size of each GC log that is kept. 保留的每个GC日志文件的大小
#dbms.logs.gc.rotation.size=20m
# Size threshold for rotation of the debug log. If set to zero then no rotation will occur. Accepts a binary suffix "k", "m" or "g".  调试日志旋转的大小阈值。如果设置为零，则不会发生滚动(达到指定大小后切割日志文件)。接受二进制后缀“k”，“m”或“g”。
#dbms.logs.debug.rotation.size=20m
# Maximum number of history files for the internal log. 最多保存几个日志文件
#dbms.logs.debug.rotation.keep_number=7
### Miscellaneous configuration  其他配置