你知道图数据库-Neo4j是咋回事吗？来看看

比眉伴天荒 2023-10-14 20:57 23阅读 0赞

#### **一. 背景介绍** ####

最近有粉丝问我，百度百科中的明星关系效果是如何实现的呢？比如下图这种效果：

![图片][f962f0973ba07d023b7b445af5c8fc54.png]

这种功能可以用关系型数据库来实现吗？答案当然是肯定的！其实简单的关系维护，本就是关系型数据库擅长的事情，但如果关系维度过多且关联足够复杂，还适合用关系型数据库吗？

比如实际生活中，人与人之间可能存在多重关系与交集，且分别还有自己的社交圈，圈子与圈子之间又存在各种交集。另外除了人与人之间的关系，还牵连到人物本身的作品、成绩、历史事件的关系等等...... 想想是不是就挺复杂的了？且不说构建这么庞大且复杂的关系之后，查询性能是否可以保证，仅仅只是这些人物、作品、地点、成绩、事件、关系等表结构的设计，就够开发者喝一壶的了。

类似的场景实际上还有很多，比如天眼查里的企业、法人、股东、投资者、事件等之间的关系；再比如商城项目中，商铺、买家、商品、订单、渠道之间的关系等。对于类似这种功能，如果仅仅只是依靠关系型数据库，一旦碰到深度关联的需求，那就等着系统重构吧。

那该**怎么解决****呢****？**当然就是今天的主角 - **图数据库****Neo4j**来搞定咯！

![图片][dccf2c397b8e6e8bdc776f360aef1ed3.png]

这是一张Neo4j官方提供的电影、导演、演员、主角的关系数据，怎么样？看着是不是就很高端大气上档次？既然如此，那我就带大家认识一下Neo4j吧！

#### **二. 图数据库概述** ####

##### 2.1 什么是图数据库？ #####

图数据库(Graph Database)是基于图论实现的一种NoSQL数据库。在图论中，图的基本元素为节点和边，在图数据库中对应的就是节点和关系。

在图数据库中，数据与数据之间的关系通过节点和关系构成一个图结构，并在此结构上实现数据库的所有特性(CRUD)，还有事务处理等能力。

##### 2.2 图数据库 vs 关系型数据库 #####

**关系型数据库****的弊端**

关系型数据库将高度结构化的数据存储在二维表格中，并且通过外键约束来实现表与表之间的关联关系。关系数据库通过外键去主表中寻找匹配的主键记录进行搜索匹配，这种操作是计算密集型和内存密集型的，并且操作次数是表中记录的指数级别，当数据量巨大，或者关系特别复杂(关联表特别多)时，查询成本将会变的巨大。

**图数据库的优势**

图数据库中，**关系**是最重要的元素。每个**节点**都直接包含一个关系列表，关系列表存放此节点与其他节点的关系记录。关系记录类型和方向组织起来，并且保存附加属性，当进行连接Join时，图数据库都将使用关系列表直接放行连接的节点，无须进行记录搜索匹配的操作。

这种预先保存关系列表的方式，使得图数据库能够提供比关系型数据库高几个数量级的性能，特别对于复杂连接的查询，Neo4j可以实现毫秒级的响应。

##### 2.3 图数据库的运用场景 #####

学习一个技术，我觉得最重要的就是这个技术能解决什么问题？Neo4j的运用场景很多，以下就是给大家列举的几个场景的运用场景：

>  *  朋友圈关系维护，好友推荐，可能认识的人
>  *  金融圈行为管理，防电话欺诈
>  *  电商项目中商品多维度智能推荐
>  *  短视频搜索联想
>  *  .......

#### **三. Neo4j基础** ####

##### 3.1 概述 #####

**官网：****https://neo4j.com/**

Neo4j是由Java实现的开源NoSQL图数据库。2003年研发，2007年正式发布第一版。Neo4j实现了专业数据库级别的图数据库模型的存储，与普通的图处理不同，Neo4j提供了完整的数据库特性，包括ACID事务、集群支持、备份、故障转移等，使其适用于企业级生产环境下的各种应用。

废话不多说，咱们直接开整吧！！！！！！

##### 3.2 Neo4j安装 #####

这里我们选择比较简单的docker-compose的安装方法，如果没有学过docker-compose的小伙伴，你要先学习下这块内容哦。

**1****).** **编写docker-compose.yml**

neo4j:
      image: neo4j:5.5.0-community
      container_name: neo4j
      ports:
        - 7474:7474
        - 7687:7687
      environment:
        NEO4J_AUTH: neo4j/neo4j123456
      volumes:
        - ./neo4j/data:/data
        - ./neo4j/logs:/logs
        - ./neo4j/conf:/var/lib/neo4j/conf
        - ./neo4j/import:/var/lib/neo4j/import
      restart: always

**2).** **运行容器**

docker-compose up -d neo4j

**3).** **访问****Neo4j****管理平台**

http://ip:7474/

![图片][2922a6e03f8d0a02acabc9c7ebc2cd7f.png]

##### 3.3 Neo4j的基本元素 #####

>  *  节点
>  *  关系

###### 3.3.1 节点 ######

节点(Node)是图数据库中的一个基本元素，用以表示一个实体记录，就像关系型数据库中的一条记录一样。每个实体可以有0到多个属性(Property)，这些属性以key-value形式存在。同时每个节点还具有相应的标签(Label)，用来区分不同类型的节点。

###### 3.3.2 关系 ######

关系(Relationship)也是图数据库中的基本元素。关系用来连接两个节点，有起始节点和终止节点，另外，与节点一样，关系可以包含多个属性，但是只能有一个类型(Type)。

![图片][b59852051c9bd4ed29120b45bf27e670.png]

![图片][c9c9bb7390deb44e855edb7185941448.png]

**注意：**

>  *  在图遍历时，可以**指定关系遍历的方向**或者**指定为无方向**，故在创建关系时，**不用**给两个节点**创建双向关系****；**
>  *  一个节点可以存在**指向自己的关系****。**

###### 3.3.3 属性 ######

节点和关系都可以拥有多个属性，属性由键值对组成，属性值可以是基本的数据类型，也可以由基本数据类型组成的数组。

注意：

>  *  属性没有null的概念；
>  *  属性不需要时，可以直接将整个键值对都移除，可以使用is null判断属性是否存在。

<table> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>说明</td> 
   <td>备注</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>布尔值</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>byte</td> 
   <td>8位整数</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>16位整数</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>32位整数</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>64位整数</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>32位浮点数</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>64位浮点数</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>16位无符号整数代表的字符</td> 
   <td>u0000 to uffff</td> 
  </tr> 
  <tr> 
   <td>string</td> 
   <td>Unicode字符序列</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

###### 3.3.4 路径 ######

使用节点和关系创建一个图后，图中任意两个节点间，都是可能存在路径的。路径有长度的概念，也就是路径中关系的条数。简单来说，如果两个节点之间只有一个关系，那路径的长度就是1

![图片][d9f3351db765774c00959724a2ea1c4a.png]

#### 四. Cypher语句(CQL语句) ####

##### 4.1 Cypher概述 #####

Cypher是一种声明书图数据库查询语言，能高效的查询和更新图数据。有点类似关系型数据库中的SQL语言。

###### 4.1.1 节点语法 ######

Cypher采用一对括号表示节点，比如()、(person)

> **()**：表示一个匿名节点；**(n)**：表示一个(一批)的节点，并且用一个变量n代表这个(这批)节点；**(:Label)**：表示一个(一批)标签为Label的节点；**(n:Label)**：表示一个(一批)标签为Label的节点，并且用一个变量n代表这个(这批)节点；**(n:Label \{key:"value"\})**：表示一个(一批)标签为Label，属性key的值为value的节点，并且用一个变量n代表这个(这批)节点。

###### 4.1.2 关系语法 ######

Cypher使用 -- 表示一个关系，有方向的关系加上一个箭头即可。反括号\[...\]用于添加详情，里面可以包括变量、属性和类型信息。

> **--**：无方向的关系，只表示关系的存在性；**-->**：向右方向的关系；**<--**：向左方向的关系；**-\[r\]->**：表示一个(一批)关系，并且用一个变量r表示这个(这批)关系；**-\[:Type\]->**：表示一个(一批)类型为Type的关系；**-\[r:Type\]->**：表示一个(一批)类型为Type的关系，并且用一个变量r表示这个(这批)关系；**-\[r:Type \{key: \["value"\]\}\]->**：表示一个(一批)类型为Type、属性key的值为数组\["Neo"\]的关系，并且用一个变量r表示这个(这批)关系。

##### 4.2 基本语法 #####

<table> 
 <tbody> 
  <tr> 
   <td>CQL命令</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>create</td> 
   <td>创建节点、关系和属性</td> 
  </tr> 
  <tr> 
   <td>match</td> 
   <td>查询节点、关系和属性</td> 
  </tr> 
  <tr> 
   <td>return</td> 
   <td>返回查询结果</td> 
  </tr> 
  <tr> 
   <td>where</td> 
   <td>过滤查询数据</td> 
  </tr> 
  <tr> 
   <td>delete</td> 
   <td>删除节点和关系</td> 
  </tr> 
  <tr> 
   <td>remove</td> 
   <td>删除节点/关系的属性</td> 
  </tr> 
  <tr> 
   <td>order by</td> 
   <td>排序查询数据</td> 
  </tr> 
  <tr> 
   <td>set</td> 
   <td>添加或更新标签</td> 
  </tr> 
 </tbody> 
</table>

###### 4.2.1 准备测试数据 ######

**查看****Neo4j****数据库**

![图片][90003715823fb593dac0b91aaccc516e.png]

**创建测试数据**

![图片][4363d17ea8d3042ce6305ba01326a8c3.png]

![图片][3fb55c08134d4c419fc40759cca09db4.png]

###### 4.2.2 match语句 ######

使用指定的模式检索数据库，通常与WHERE语句一起使用。

**查找所有节点**

match (n)
    return n

**查询带有某个标签的所有节点**

//返回所有<电影>节点
     match (n:Movie)
     return n
    
     //返回所有<电影>节点的<标题>属性值以及节点的所有<标签>
     match (n:Movie)
     return n.title, labels(n)

**查询关联节点**

//返回Tom Hanks有关系的所有节点
     match (n {name: 'Tom Hanks'}) -- (m)
     return m
    
     //返回Tom Hanks有参与的所有电影节点
     match (n {name: 'Tom Hanks'}) -- (m:Movie)
     return m
    
     //返回Tom Hanks导演（:DIRECTED）的所有电影节点
     match (n {name: 'Tom Hanks'}) -[:DIRECTED]- (m:Movie)
     return n,m //同时返回两种节点
    
     //返回所有和电影《A Few Good Men》有关的人物节点
     match (m:Movie {title:"A Few Good Men"}) <-[r]- (n:Person)
     return n,m
    
     //同上，关系方向相反
     match (n:Person) -[r]-> (m:Movie {title:"A Few Good Men"})
     return n,m
    
     //返回所有和电影《A Few Good Men》有关的人物的关系类型
     match (m:Movie {title:"A Few Good Men"}) <-[r]- (n:Person)
     return type[r]
    
     //返回电影《Something's Gotta Give》参与（:ACTED_IN）或者编写（:WROTE）人物节点
     match (m {title:"Something's Gotta Give"}) <-[:WROTE|:ACTED_IN]- (n:Person)
     return n,m
    
     //查询电影和人物之间的关系 包含属性roles，并且值为["Jane"]的相关数据
     match p = (m:Movie) -[* {roles:["Jane"]}]- (n:Person)
     return p

**查询多个关系**

//查询人物Susan Sarandon参与的电影（:movie）,以及这些电影的导演节点（:DIRECTED）
     match (n:Person {name:"Susan Sarandon"}) -[:ACTED_IN]-> (m:Movie) <-[:DIRECTED]-(x:Person)
     return m,x

**查询多级关系**

孤驻一郑[电影] 
        https://mr.baidu.com/14mMKrYDLQ4

**查询最短路径**

//查找电影《Ninja Assassin》和电影《Speed Racer》之间最短的关系路径
     //shortestPath()函数 - 找到两个节点之间的最短路径
     match 
        (m1:Movie {title:"Ninja Assassin"}),
        (m2:Movie {title:"Speed Racer"}),
        p = shortestPath((m1)-[*0..5]-(m2))
     return p
    
     //查找所有最短路径
     //allshortestPaths()函数 - 找到两个节点之间所有的最短路径
     match 
        (m1:Movie {title:"Ninja Assassin"}),
        (m2:Movie {title:"Speed Racer"}),
      p = allshortestPaths((m1)-[*0..5]-(m2))
     return p
    
     //查找电影《Ninja Assassin》和电影《Speed Racer》之间最短的所有关系路径，但是要排除掉id为174的关系路径
     //relationships(p)函数 - 获取变量p中代表的所有关系
     match 
        (m1:Movie {title:"Ninja Assassin"}),
        (m2:Movie {title:"Speed Racer"}),
        p = allshortestPaths((m1)-[r*0..5]-(m2))
     where none(r in relationships(p) where id(r) = 174)
     return p

**根据id查询**

//查询id为127的节点
     match (n)
        where id(n) = 127
     return n
    
     //查询关系id为117的关系以及连接节点
     match p = ()-[r]-()
      where id(r) = 177
     return p
    
     //多id查询
     match p = ()-[r]-()
      where id(r) in [177,17]
     return p

**4.2.3 where 语句**

**where不能单独使用**，只能作为**match、optinal match、start和with的一部分**。和with和start配合使用时，where用于过滤结果。对于match、optinal match，where用于增加约束，这时不能看成匹配完成后过滤结果。

**基本使用**

//返回所有电影节点 等同于match(n:Movie) return n
     match (n) 
     where n:Movie return n
    
     //返回所有发行时间（released）小于1995年的电影
     match (n:Movie) 
     where n.released < 1995 return n
    
     //返回所有影评（REVIEWED）中，评分（rating）小于50分的相关数据
     match p = () -[r:REVIEWED]- () 
     where r.rating < 50 return p
    
     //返回所有不存在released属性的节点
     match (n) 
     where n.released is null return n
    
     //返回所有存在released属性的节点
     match (n) 
     where n.released is not null return n

属性过滤中，**n.属性名称** 等价于 **n\["属性名称"\]**

**布尔运算**

可以在where中使用布尔运算符：

>  *  and
>  *  or
>  *  not

//返回电影2012年之前发行（released），并且编剧（WROTE）的出生年月（born）不低于1960年的电影与编剧关系
     match p = (n:Movie) -[r:WROTE]- (m:Person) 
     where n.released <= 2012 and not m.born <= 1960  return p

**字符串匹配**

//返回所有以C开头的电影节点，类似于sql中的like 'C%'
     match (n)
     where n.title starts with 'C' 
     return n
    
     //返回所有以c结尾的电影节点，类似于sql中的like '%c'
     match (n)
     where n.title ends with 'c' 
     return n
    
     //返回所有包含c的电影节点，类似于sql中的like '%c%'
     match (n)
     where n.title contains 'c'
     return n

**注意：**

>  *  **字符串匹配方式，是大小写敏感的****；**
>  *  **如果要反向匹配，只需要在前面加上not即可，比如 not n.title contains 'c'****。**

**路径匹配**

//返回Jim Cash编剧的所有电影节点
     match (n:Person),(m)
     where n.name = 'Jim Cash' and (n)-[:WROTE]->(m)
     return n,m
    
     //返回Jim Cash编剧的所有电影节点
     match (n:Person),(m)
     where n.name = 'Jim Cash' and (n)-[:WROTE]->(m)
     return n,m
    
     //返回Meg Ryan没有参演的所有电影节点
     match (n:Person),(m)
     where n.name = 'Meg Ryan' and m:Movie and not (n)-[:ACTED_IN]->(m)
     return n,m
    
     //返回参演过RescueDawn电影的所有人员节点
     match(n) 
     where (n)-[:ACTED_IN]->(:Movie{title: "RescueDawn"})
     return n

**列表**

//返回姓名为Zach Grenier和Christian Bale的人员节点
     match(n) 
     where n.name in ["Zach Grenier", "Christian Bale"]
     return n

**注意：in后面是用的\[\]，和sql不一样**

###### 4.2.4 create语句 ######

create语句用于创建图元素：节点和关系

**创建节点**

//创建单个节点
     create (n)
     //创建多个节点
     create (n),(m)
     //创建带标签的节点
     create (m:Movie)
     //创建带多个标签的节点
     create (n:Person:Docter)
     //创建带标签并且带属性的节点
     create(n:Person {name:"张三",age:18})

**注意：**

>  *  **创建的节点标签可以完全自定义****；**
>  *  **创建的节点属性可以完全自定义****。**

**创建关系**

//创建<张三>和<王五>之间的<朋友>关系
     match(n1:Person {name:"张三"}),(n2:Person {name:"王五"})
     create (n1)-[r:Friend]->(n2)
     return r

**注意：**

>  *  **创建节点关系时，必须携带关系的方向****；**
>  *  **这种创建关系的方式，必须保证节点已经存在****。**

//创建<张三>和<王五>之间的<朋友>关系，并且附带了相识的时间和关系的类型
     match(n1:Person {name:"张三"}),(n2:Person {name:"王五"})
     create (n1)-[r:Friend {date: "2012-12-01", type:"同窗"}]->(n2)
     return r
    
    //创建3个节点的并创建他们的关系
     create p=(n:People {name:"关羽"})-[r:Borther {type:"二弟"}]
     ->(m:People {name: "刘备"})
     <-[r2:Borther {type:"三弟"}]-(k:People {name:"张飞"})
     -[r3:Borther {type:"三弟"}]->(n)
     return p

### **五. SpringBoot操作Neo4j** ###

这里大家注意一点哦，带大家用的是最新的Neo4j5.5，最低只支持JDK17，还在用JDK8的小伙伴，给了你们一个升级JDK的理由，嘿嘿。

##### 5.1 基本步骤 #####

**1****).** **添加依赖**

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.5.5</version>
            <scope>import</scope>
            <type>pom</type>
        </dependency>
     </dependencies>
    
     <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-neo4j</artifactId>
     </dependency>

**注意：**

>  *  **Neo4j** **5.x最低支持JDK17****；**
>  *  **SpringBoot最低要求2.5.5的版本****。**

**2****).** **配置文件**

spring:
      neo4j:
        uri: bolt://ip:7687
        authentication:
          username: neo4j
          password: neo4j

**3).** **准备节点实体**

package com.qf.neo4j.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.util.ArrayList;
     import java.util.HashSet;
     import java.util.Set;
    
     @Data
     @Node(primaryLabel = "student", labels = {"person"})
     public class Student {
        @Id
        private Long id;
        private String name;
        private Integer age;
        private String sex;
    
        @Relationship(type = "select", direction = Relationship.Direction.OUTGOING)
        private Set<StuCourRelations> stuCourRelations = new HashSet<>();
    
        public void addStuCourRelations(StuCourRelations stuCourRelations) {
            this.stuCourRelations.add(stuCourRelations);
        }
     }
    
    package com.qf.neo4j.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.math.BigDecimal;
    
     /**
     * 课程
     */
     @Data
     @Node(primaryLabel = "course")
     public class Course {
        @Id
        private Long id;
        private String courseName;
        private BigDecimal price;
     }
    
    package com.qf.neo4j.entity;
    
     import lombok.Data;
     import org.springframework.data.neo4j.core.schema.*;
     import java.util.Date;
    
     @Data
     @RelationshipProperties
     public class StuCourRelations {
        @Id
        @GeneratedValue
        private Long id;
    
        /**
         * 选课的时间
         */
        private Date time;
        @TargetNode
        private Course course;
     }

**4****).** **操作****Neo4j**

/**
     * spring提供的操作对象
     */
     @Autowired
     private Neo4jTemplate neo4jTemplate;
    
     /**
     * 原生操作对象，获取Session进行原生操作
     */
     @Autowired
     private Driver driver;

##### 5.2 相关操作 #####

**保存完整关系**

/**
     * 添加节点
     */
     @Test
     public void insert(){
        //准备一个学生节点
        Student student = new Student();
        student.setId(5L);
        student.setName("小明");
        student.setAge(18);
        student.setSex("男");
    
        //准备两个课程节点
        Course course1 = new Course();
        course1.setId(100L);
        course1.setCourseName("Java高级开发");
        course1.setPrice(BigDecimal.valueOf(199.99));
    
        Course course2 = new Course();
        course2.setId(101L);
        course2.setCourseName("C语言基础");
        course2.setPrice(BigDecimal.valueOf(259.99));
    
        //创建学生和课程的关系
        StuCourRelations stuCourRelations = new StuCourRelations();
        stuCourRelations.setCourse(course1);
        stuCourRelations.setTime(new Date());
        student.addStuCourRelations(stuCourRelations);
    
        StuCourRelations stuCourRelations2 = new StuCourRelations();
        stuCourRelations2.setCourse(course2);
        stuCourRelations2.setTime(new Date());
        student.addStuCourRelations(stuCourRelations2);
    
        neo4jTemplate.save(student);
     }

**追加关系**

/**
     * 追加节点
     */
     @Test
     public void append(){
        //将学生和课程关联起来
        Course course = neo4jTemplate.findById(156L, Course.class).get();
        Student student = neo4jTemplate.findById(5L, Student.class).get();
        System.out.println(student);
    
        //创建关联关系
        StuCourRelations courRelations = new StuCourRelations();
        courRelations.setTime(new Date());
        courRelations.setCourse(course);
    
        student.addStuCourRelations(courRelations);
        //保存关系
        neo4jTemplate.save(student);
     }

**查询数据**

/**
     * 根据CQl查询
     */
     @Test
     public void query(){
        //查询id为5的学生1..2级相关的节点
        String cql = """
            match p = (n:student {id:5}) -[r*1..2]- (m)
            return p
            """;
        
        List<Course> result = neo4jTemplate.findAll(cql, Course.class);
        System.out.println("查询集合：" + result);
     }

#### **六. 结语** ####

感谢大家观看Neo4j 5.x的入门篇，因为篇幅所限，还有很多语法和使用技巧没办法写出来，感兴趣的小伙伴可以去官网学习下Neo4j更高级的用法，或者私信我获取更多学习资料。关注千锋官方博客，干货天天都不断哦！

[f962f0973ba07d023b7b445af5c8fc54.png]: https://img-blog.csdnimg.cn/img_convert/f962f0973ba07d023b7b445af5c8fc54.png
[dccf2c397b8e6e8bdc776f360aef1ed3.png]: https://img-blog.csdnimg.cn/img_convert/dccf2c397b8e6e8bdc776f360aef1ed3.png
[2922a6e03f8d0a02acabc9c7ebc2cd7f.png]: https://img-blog.csdnimg.cn/img_convert/2922a6e03f8d0a02acabc9c7ebc2cd7f.png
[b59852051c9bd4ed29120b45bf27e670.png]: https://img-blog.csdnimg.cn/img_convert/b59852051c9bd4ed29120b45bf27e670.png
[c9c9bb7390deb44e855edb7185941448.png]: https://img-blog.csdnimg.cn/img_convert/c9c9bb7390deb44e855edb7185941448.png
[d9f3351db765774c00959724a2ea1c4a.png]: https://img-blog.csdnimg.cn/img_convert/d9f3351db765774c00959724a2ea1c4a.png
[90003715823fb593dac0b91aaccc516e.png]: https://img-blog.csdnimg.cn/img_convert/90003715823fb593dac0b91aaccc516e.png
[4363d17ea8d3042ce6305ba01326a8c3.png]: https://img-blog.csdnimg.cn/img_convert/4363d17ea8d3042ce6305ba01326a8c3.png
[3fb55c08134d4c419fc40759cca09db4.png]: https://img-blog.csdnimg.cn/img_convert/3fb55c08134d4c419fc40759cca09db4.png