Neo4j

官网地址：https://neo4j.com/

下载地址：https://neo4j.com/download-center/#community

官方入门文档：https://neo4j.com/docs/getting-started

安装

Window安装

window下安装下载对应的安装包，然后配置环境变量即可。

增加系统环境变量NEO4J_HOME；

修改path环境变量增加%NEO4J_HOME%\bin

cmd 窗口执行 ：neo4j console 便可以启动数据库。

C:\Users\lich0>neo4j console

2021-02-24 07:24:33.778+0000 INFO  ======== Neo4j 3.5.26 ========

2021-02-24 07:24:33.795+0000 INFO  Starting...

2021-02-24 07:24:37.133+0000 INFO  Bolt enabled on 127.0.0.1:7687.

2021-02-24 07:24:38.110+0000 INFO  Started.

2021-02-24 07:24:38.840+0000 INFO  Remote interface available at http://localhost:7474/

Linux安装

下载安装包，解压后，简单修改配置文件就可以使用。云服务器的话需要放开对应的端口。

配置文件修改：

# 可以读写

dbms.read_only=false

# 可以远程访问

dbms.connectors.default_listen_address=0.0.0.0

启动服务

[root@VM-0-2-centos bin]# ./neo4j start

Active database: graph.db

Directories in use:

  home:         /opt/neo4j-community-3.5.26

  config:       /opt/neo4j-community-3.5.26/conf

  logs:         /opt/neo4j-community-3.5.26/logs

  plugins:      /opt/neo4j-community-3.5.26/plugins

  import:       /opt/neo4j-community-3.5.26/import

  data:         /opt/neo4j-community-3.5.26/data

  certificates: /opt/neo4j-community-3.5.26/certificates

  run:          /opt/neo4j-community-3.5.26/run

Starting Neo4j.

Started neo4j (pid 20669). It is available at http://localhost:7474/

There may be a short delay until the server is ready.

See /opt/neo4j-community-3.5.26/logs/neo4j.log for current status.

查看状态

[root@VM-0-2-centos bin]# ./neo4j status

Neo4j is running at pid 20669

关闭服务

[root@VM-0-2-centos bin]# ./neo4j stop

Stopping Neo4j.. stopped

访问服务即可：http://xxxxx:7474/browser/

Docker部署

拉取镜像，启动就行了呀

拉取镜像

[root@VM-0-2-centos ~]# docker pull neo4j:3.5.26

[root@VM-0-2-centos ~]# docker images

REPOSITORY                TAG                 IMAGE ID            CREATED             SIZE

docker.io/neo4j           3.5.26              27b84ff7b769        6 weeks ago         333 MB

启动容器，建议写个启动的脚本：neo4j_start.sh

这里需要注意脚本权限，映射的目录的访问权限

sudo docker run -it --name neo4j -e NEO4J_AUTH=neo4j/123456 -p 7474:7474 -p 7687:7687 \

-v /data/neo4j/data:/data \

-v /data/neo4j/neo4j/logs:/logs \

-v /data/neo4j/conf:/conf \

-v /data/neo4j/metrics:/metrics \

-v /data/neo4j/plugins:/plugins \

-v /data/neo4j/import:/import \

-d neo4j:3.5.26

查看启动的容器

[root@VM-0-2-centos neo4j]# docker ps -a

CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                                                      NAMES

b92f8beb7d82        neo4j:3.5.26        "/sbin/tini -g -- ..."   3 minutes ago       Up 3 minutes        0.0.0.0:7474->7474/tcp, 7473/tcp, 0.0.0.0:7687->7687/tcp   neo4j

访问服务即可：http://xxxxx:7474/browser/

基本概念

Node 节点

图的基本单位主要是节点和关系，节点和关系都可以包含多个k-v结构的属性。

Relationships 关系

关系的主要功能就是连接节点，一个关系连接两个节点，一个开始和一个结束节点，这种关系是有进出方向的。

Properties 属性

属性就可以理解为关系型数据库中表中的所有字段了，节点和关系都可以有多个属性，并且属性的key为字符串，值可以是其他类型例如数值，布尔

Lables 标签

标签和ES的别名是一样的作用，可以用来划分一类的节点，查询的时候可以通过标签来分类查询。

Travelsal 遍历

查询的时候往往都是遍历图谱，遍历的过程中会有一个开始节点，然后根据Cypher语句，遍历相关的节点和关系得到最终的结果

Paths 路径

路径是一个或者多个节点通过关系连接起来，例如通过Cypher查询得到的结果

Schema 模式

neo4j是类似ES一样的无模式图谱数据库，使用它无需要定义schema

Indexes 索引

和关系型数据库中的索引一样为了加快检索的速度，这里构建索引是一个异步的过程，只有创建成功后才会生效。如果创建失败可以删除后从新创建。

Constraints 约束

约束可以定义在某个字段上，限制字段值唯一，创建约束会自动创建索引

Cypher

语句cypher是neo4j官网提供的声明式查询语言，非常强大，用它可以完成任意的图谱里面的查询过滤。就好像关系型数据库中的SQL语句一样

创建节点

创建电影相关的节点

-- 创建一个节点：黑客帝国； 标签：电影；属性：标题-The Matrix，发布年份-1997

CREATE (matrix:Movie { title:"The Matrix",released:1997 })

-- 下面的同理

CREATE (cloudAtlas:Movie { title:"Cloud Atlas",released:2012 })

CREATE (forrestGump:Movie { title:"Forrest Gump",released:1994 })

创建演员相关的节点

CREATE (keanu:Person { name:"Keanu Reeves", born:1964 })

CREATE (robert:Person { name:"Robert Zemeckis", born:1951 })

CREATE (tom:Person { name:"Tom Hanks", born:1956 })

CREATE (jerry:Person { name:"Jerry", born:1986 })

创建关系

-- Tom Hanks在电影Forrest Gump中出演Forrest角色

CREATE (tom)-[:ACTED_IN { roles: ["Forrest"]}]->(forrestGump)

-- Tom Hanks在电影Forrest Gump中出演Forrest角色

CREATE (tom)-[:ACTED_IN { roles: ['Zachry']}]->(cloudAtlas)

-- jerry 在电影 The Matrix 出演 Jerry角色

CREATE (jerry)-[:ACTED_IN { roles: ["J"]}]->(matrix)

-- Robert Zemeckis指导电影Forrest Gump

CREATE (robert)-[:DIRECTED]->(forrestGump)

注意：上面创建节点，关系的语句需要同时执行后，节点才会有关联关系，如下所示：

如果你的创建节点和创建关系的语句是分开执行的话，会是如下的结果：因为创建的关系的时候没有指定节点是属性会被认为是新的节点

如果是分开创建的话，创建关系的语句应该是如下所示：

-- Tom Hanks在电影Forrest Gump中出演Forrest角色

MATCH (tom:Person{name:"Tom Hanks"}),(forrestGump:Movie{title:"Forrest Gump"}) CREATE (tom)-[:ACTED_IN { roles: ["Forrest"]}]->(forrestGump) 

-- Tom Hanks在电影Forrest Gump中出演Forrest角色

MATCH (tom:Person{name:"Tom Hanks"}),(cloudAtlas:Movie{title:"Cloud Atlas"}) CREATE (tom)-[:ACTED_IN { roles: ['Zachry']}]->(cloudAtlas) 

-- jerry 在电影 The Matrix 出演 Jerry角色

MATCH (jerry:Person{name:"Jerry"}),(matrix:Movie{title:"The Matrix"}) CREATE (jerry)-[:ACTED_IN { roles: ["J"]}]->(matrix)

-- Robert Zemeckis指导电影Forrest Gump

MATCH (robert:Person{name:"Robert Zemeckis"}),(forrestGump:Movie{title:"Forrest Gump"}) CREATE (robert)-[:DIRECTED]->(forrestGump)

过滤查询

查询所有节点

MATCH (nodes) return nodes

结果:

╒════════════════════════════════════════╕

│"nodes"                                 │

╞════════════════════════════════════════╡

│{"title":"The Matrix","released":1997}  │

├────────────────────────────────────────┤

│{"title":"Cloud Atlas","released":2012} │

├────────────────────────────────────────┤

│{"title":"Forrest Gump","released":1994}│

├────────────────────────────────────────┤

│{"name":"Keanu Reeves","born":1964}     │

├────────────────────────────────────────┤

│{"name":"Robert Zemeckis","born":1951}  │

├────────────────────────────────────────┤

│{"name":"Tom Hanks","born":1956}        │

└────────────────────────────────────────┘

查询标签是Movie的节点

MATCH (m:Movie) return m

结果：

╒════════════════════════════════════════╕

│"m"                                     │

╞════════════════════════════════════════╡

│{"title":"The Matrix","released":1997}  │

├────────────────────────────────────────┤

│{"title":"Cloud Atlas","released":2012} │

├────────────────────────────────────────┤

│{"title":"Forrest Gump","released":1994}│

└────────────────────────────────────────┘

根据标题查询

-- 查询标题是The Matrix的节点

MATCH (m:Movie) WHERE m.title = "The Matrix" RETURN m

结果：

╒══════════════════════════════════════╕

│"m"                                   │

╞══════════════════════════════════════╡

│{"title":"The Matrix","released":1997}│

└──────────────────────────────────────┘

多个条件查询

-- 条件查询 和SQL语句一样

MATCH (p:Person)-[r:ACTED_IN]->(m:Movie) WHERE p.name =~ "K.+" OR m.released > 2000 OR "Neo" IN r.roles RETURN p,r,m

结果：

╒═════════════════════════════════════════════════════════════════════════════════════════════╕

│"p"                             │"r"                 │"m"                                    │

╞═════════════════════════════════════════════════════════════════════════════════════════════╡

│{"name":"Tom Hanks","born":1956}│{"roles":["Zachry"]}│{"title":"Cloud Atlas","released":2012}│

└─────────────────────────────────────────────────────────────────────────────────────────────┘

删除

删除所有节点和所有关系

MATCH (r)

DETACH DELETE r

根据ID删除节点及所有关系

MATCH (r)

WHERE id(r) = 493

DETACH DELETE r

结果增加列

和sql语句一样，可以给返回结果增加列

MATCH (p:Person)

RETURN p, p.name AS name, toUpper(p.name), coalesce(p.nickname,"n/a") AS nickname,

  { name: p.name, label:head(labels(p))} AS person

JSON结果：

[

  {

    "p": {

      "identity": 65,

      "labels": [

        "Person"

      ],

      "properties": {

        "name": "Keanu Reeves",

        "born": 1964

      }

    },

    "name": "Keanu Reeves",

    "toUpper(p.name)": "KEANU REEVES",

    "nickname": "n/a",

    "person": {

      "name": "Keanu Reeves",

      "label": "Person"

    }

  },

  {

    "p": {

      "identity": 66,

      "labels": [

        "Person"

      ],

      "properties": {

        "name": "Robert Zemeckis",

        "born": 1951

      }

    },

    "name": "Robert Zemeckis",

    "toUpper(p.name)": "ROBERT ZEMECKIS",

    "nickname": "n/a",

    "person": {

      "name": "Robert Zemeckis",

      "label": "Person"

    }

  },

  {

    "p": {

      "identity": 67,

      "labels": [

        "Person"

      ],

      "properties": {

        "name": "Tom Hanks",

        "born": 1956

      }

    },

    "name": "Tom Hanks",

    "toUpper(p.name)": "TOM HANKS",

    "nickname": "n/a",

    "person": {

      "name": "Tom Hanks",

      "label": "Person"

    }

  }

]

排序分页

演员按照出演电影的数量排序取前10个

MATCH (a:Person)-[:ACTED_IN]->(m:Movie)

RETURN a, count(*) AS appearances

ORDER BY appearances DESC SKIP 0 LIMIT 10;

结果：

╒════════════════════════════════╤═════════════╕

│"a"                             │"appearances"│

╞════════════════════════════════╪═════════════╡

│{"name":"Tom Hanks","born":1956}│2            │

├────────────────────────────────┼─────────────┤

│{"name":"Jerry","born":1986}    │1            │

└────────────────────────────────┴─────────────┘

聚合统计查询

查看演员的总数量

MATCH (:Person)

RETURN count(*) AS people

结果：

╒════════╕

│"people"│

╞════════╡

│4       │

└────────┘

统计出演电影的演员

MATCH (m:Movie)<-[:ACTED_IN]-(a:Person)

RETURN m.title AS movie, collect(a.name) AS cast, count(*) AS actors

结果：

╒══════════════╤═════════════╤════════╕

│"movie"       │"cast"       │"actors"│

╞══════════════╪═════════════╪════════╡

│"The Matrix"  │["Jerry"]    │1       │

├──────────────┼─────────────┼────────┤

│"Cloud Atlas" │["Tom Hanks"]│1       │

├──────────────┼─────────────┼────────┤

│"Forrest Gump"│["Tom Hanks"]│1       │

└──────────────┴─────────────┴────────┘

UNION / WITH

union 用来组合查询的结果，查询电影的演职人员表

MATCH (actor:Person)-[r:ACTED_IN]->(movie:Movie)

RETURN actor.name AS name, type(r) AS type, movie.title AS title

UNION

MATCH (director:Person)-[r:DIRECTED]->(movie:Movie)

RETURN director.name AS name, type(r) AS type, movie.title AS title

结果：

╒═════════════════╤══════════╤══════════════╕

│"name"           │"type"    │"title"       │

╞═════════════════╪══════════╪══════════════╡

│"Jerry"          │"ACTED_IN"│"The Matrix"  │

├─────────────────┼──────────┼──────────────┤

│"Tom Hanks"      │"ACTED_IN"│"Cloud Atlas" │

├─────────────────┼──────────┼──────────────┤

│"Tom Hanks"      │"ACTED_IN"│"Forrest Gump"│

├─────────────────┼──────────┼──────────────┤

│"Robert Zemeckis"│"DIRECTED"│"Forrest Gump"│

└─────────────────┴──────────┴──────────────┘

或者和下面的查询是等价的

MATCH (actor:Person)-[r:ACTED_IN|DIRECTED]->(movie:Movie)

RETURN actor.name AS name, type(r) AS type, movie.title AS title

WITH 关键字可以看成是查询的语句的一个子条件，主要是用来过滤数据用的，比如

查询出演次数大于一次的演员和相关的电影

MATCH (person:Person)-[:ACTED_IN]->(m:Movie)

WITH person, count(*) AS appearances, collect(m.title) AS movies

WHERE appearances > 1

RETURN person.name, appearances, movies

结果：

╒═════════════╤═════════════╤══════════════════════════════╕

│"person.name"│"appearances"│"movies"                      │

╞═════════════╪═════════════╪══════════════════════════════╡

│"Tom Hanks"  │2            │["Cloud Atlas","Forrest Gump"]│

└─────────────┴─────────────┴──────────────────────────────┘

Springboot 集成

测试版本：2.0.3.RELEASE

引入依赖

<dependency>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-data-neo4j</artifactId>

</dependency>

配置文件application.yml

注意格式的正确

spring:

  data:

    neo4j:

      uri: bolt://localhost:7687

      username: neo4j

      password: 123456

定义节点、关系对象

（省略了Get/Set等方法）

/**

 * @author chenghao.li

 * @Description 电影节点

 */

@NodeEntity(label = "Movie")

public class MovieGraph implements Serializable {

    /**

     * 主键

     */

    @Id

    @GeneratedValue

    private Long id;

    /**

     * 电影标题

     */

    @Property(name = "title")

    private String title;

    /**

     * 发布年份

     */

    @Property(name = "released")

    private Integer released;

}


/**

 * @author chenghao.li

 * @Description 演员节点

 */

@NodeEntity(label = "People")

public class PeopleGraph implements Serializable {

    @Id

    @GeneratedValue

    private Long id;

    @Property(name = "name")

    private String name;

    @Property(name = "born")

    private Integer born;

}


/**

 * @author chenghao.li

 * @Description 出演关系

 */

@RelationshipEntity(type = "ACTED_IN")

public class ActedInRelationShip implements Serializable {

    @Id

    @GeneratedValue

    private Long id;

    @StartNode

    private PeopleGraph startNode;

    @EndNode

    private MovieGraph endNode;

    @Property(name = "roles")

    private String roles;

}


/**

 * @author chenghao.li

 * @Description 指导关系

 */

@RelationshipEntity(type = "DIRECTED")

public class DirectedRelationShip implements Serializable {

    @Id

    @GeneratedValue

    private Long id;

    @StartNode

    private PeopleGraph startNode;

    @EndNode

    private MovieGraph endNode;

}

涉及到的一些注解说明：

@NodeEntity(label = "People") 表示图中的一个节点

@Id 主键ID,使用Long类型

@GeneratedValue 自动生成主键ID的值

@Property(name = "name") 表示图中节点的一个属性

@RelationshipEntity(type = "ACTED_IN") 表示图中连线的关系

定义Repository

以演员为例，继承Neo4jRepository 即可实现增删改查分页排序等操作；其他的都是如此

/**

 * @author chenghao.li

 */

@Repository

public interface PeopleRepository extends Neo4jRepository<PeopleGraph, Long> {

    /**

     * 根据姓名查找

     *

     * @param name 姓名

     * @return PeopleGraph

     */

    @Query("MATCH (p:People) where p.name={0} return p")

    PeopleGraph findByName(String name);

}

单元测试

@SpringBootTest

@RunWith(SpringRunner.class)

@FixMethodOrder(MethodSorters.NAME_ASCENDING)

public class Neo4jApplicationTests {

    @Autowired

    private PeopleRepository peopleRepository;

    @Autowired

    private MovieRepository movieRepository;

    @Autowired

    private ActedInRelationShipRepository actedInRelationShipRepository;

    @Autowired

    private DirectedRelationShipRepository directedRelationShipRepository;

    /**

     * 添加演员节点

     */

    @Test

    public void t1() {

        PeopleGraph peopleGraph1 = new PeopleGraph();

        peopleGraph1.setName("Keanu Reeves");

        peopleGraph1.setBorn(1964);

        PeopleGraph peopleGraph2 = new PeopleGraph();

        peopleGraph2.setName("Robert Zemeckis");

        peopleGraph2.setBorn(1951);

        PeopleGraph peopleGraph3 = new PeopleGraph();

        peopleGraph3.setName("Tom Hanks");

        peopleGraph3.setBorn(1956);

        PeopleGraph peopleGraph4 = new PeopleGraph();

        peopleGraph4.setName("Jerry");

        peopleGraph4.setBorn(1986);

        List<PeopleGraph> peopleGraphList = new ArrayList<>();

        peopleGraphList.add(peopleGraph1);

        peopleGraphList.add(peopleGraph2);

        peopleGraphList.add(peopleGraph3);

        peopleGraphList.add(peopleGraph4);

        Iterable<PeopleGraph> peopleGraphs = peopleRepository.saveAll(peopleGraphList);

        Assert.assertNotNull(peopleGraphs);

    }

    /**

     * 添加电影节点

     */

    @Test

    public void t2() {

        MovieGraph movieGraph1 = new MovieGraph();

        movieGraph1.setTitle("The Matrix");

        movieGraph1.setReleased(1997);

        MovieGraph movieGraph2 = new MovieGraph();

        movieGraph2.setTitle("Cloud Atlas");

        movieGraph2.setReleased(2012);

        MovieGraph movieGraph3 = new MovieGraph();

        movieGraph3.setTitle("Forrest Gump");

        movieGraph3.setReleased(1994);

        List<MovieGraph> movieGraphs = new ArrayList<>();

        movieGraphs.add(movieGraph1);

        movieGraphs.add(movieGraph2);

        movieGraphs.add(movieGraph3);

        Iterable<MovieGraph> movieGraphIterable = movieRepository.saveAll(movieGraphs);

        Assert.assertNotNull(movieGraphIterable);

    }

    /**

     * 添加关系

     */

    @Test

    public void t3() {

        // Tom Hanks在电影Forrest Gump中出演Forrest角色

        PeopleGraph tom_hanks = peopleRepository.findByName("Tom Hanks");

        MovieGraph forrest_gump = movieRepository.findByTitle("Forrest Gump");

        ActedInRelationShip tom_ActedIn_relationShip_forrest = new ActedInRelationShip();

        tom_ActedIn_relationShip_forrest.setStartNode(tom_hanks);

        tom_ActedIn_relationShip_forrest.setEndNode(forrest_gump);

        tom_ActedIn_relationShip_forrest.setRoles("Forrest");

        ActedInRelationShip save = actedInRelationShipRepository.save(tom_ActedIn_relationShip_forrest);

        Assert.assertNotNull(save);

        // Tom Hanks在电影Forrest Gump中出演Forrest角色

        MovieGraph cloud = movieRepository.findByTitle("Cloud Atlas");

        ActedInRelationShip tom_ActedIn_relationShip_Cloud = new ActedInRelationShip();

        tom_ActedIn_relationShip_Cloud.setStartNode(tom_hanks);

        tom_ActedIn_relationShip_Cloud.setEndNode(cloud);

        tom_ActedIn_relationShip_Cloud.setRoles("Zachry");

        ActedInRelationShip save1 = actedInRelationShipRepository.save(tom_ActedIn_relationShip_Cloud);

        Assert.assertNotNull(save1);

        // Robert Zemeckis指导电影Forrest Gump

        PeopleGraph robert_zemeckis = peopleRepository.findByName("Robert Zemeckis");

        DirectedRelationShip directedRelationShip = new DirectedRelationShip();

        directedRelationShip.setStartNode(robert_zemeckis);

        directedRelationShip.setEndNode(forrest_gump);

        DirectedRelationShip save2 = directedRelationShipRepository.save(directedRelationShip);

        Assert.assertNotNull(save2);

        // jerry 在电影 The Matrix 出演 J 角色

        PeopleGraph jerry = peopleRepository.findByName("Jerry");

        MovieGraph the_matrix = movieRepository.findByTitle("The Matrix");

        ActedInRelationShip jerry_ActedIn_relationShip_matrix = new ActedInRelationShip();

        jerry_ActedIn_relationShip_matrix.setStartNode(jerry);

        jerry_ActedIn_relationShip_matrix.setEndNode(the_matrix);

        jerry_ActedIn_relationShip_matrix.setRoles("J");

        actedInRelationShipRepository.save(jerry_ActedIn_relationShip_matrix);

    }

}

附报错信息

报错：检查下配置文件application.yml 是不是有多余的空格等格式问题

org.springframework.transaction.CannotCreateTransactionException: Could not open Neo4j Session for transaction; nested exception is org.neo4j.driver.v1.exceptions.AuthenticationException: Unsupported authentication token, scheme 'none' is only allowed when auth is disabled.

最新文章

  1. ASP.NET Aries 入门开发教程7：DataGrid的行操作（主键操作区）
  2. app开发外包注意事项，2017最新资讯
  3. php上传文件类型
  4. Java基础知识强化65：基本类型包装类之Integer的构造方法
  5. jquery+ajax分页
  6. 关闭ubuntu apport
  7. semaphore实现浏览器的读写原理
  8. 数据处理包dplyr的函数
  9. Python 一个奇特的引用设定
  10. D. Bicolorings
  11. count函数详细介绍
  12. Haskell语言学习笔记（82）Extensible effects
  13. 解决 ORA-27102: out of memory
  14. apache web服务器安全配置
  15. MT【174】凹凸无妨
  16. Codeforces 1028E Restore Array 构造
  17. Atitit &#160;404错误的排查流程总结&#160;v3 qaf
  18. jade——创建第一个jade模板
  19. testng日志和报告
  20. django rest_framework 框架的使用03

热门文章

  1. Inject-APC（Ring0）
  2. 你知道 JavaScript 中的 Arguments 对象都有哪些用途吗？
  3. NVidia Jetson Ubuntu 18.04 安装ROS过程中运行sudo rosdep init指令出错
  4. Java的Class类及static块的执行时机
  5. Spring依赖注入的四种方式
  6. Charles-模拟弱网环境
  7. HZ游记
  8. QT开发实战一：图片显示
  9. WEB漏洞——文件上传
  10. appnium显式等待机制