路线规划之Neo4j

cyt涛2024-08-25 9:13

1. Neo4j介绍

Neo4j 是一个领先的图数据库管理系统，以其高效处理和查询复杂关系数据的能力而闻名。它使用图结构存储数据，能够直观地表示实体及其之间的关系，非常适合处理社交网络分析、推荐系统、网络安全、供应链管理等场景中的复杂关系和连接数据。

1.1 图数据库概念

  • 图数据模型：图数据库的核心是图数据模型，它由节点（Nodes）和关系（Relationships）组成。

    • 节点（Node）：表示实体或对象，例如用户、产品、地点等。每个节点可以有一个或多个标签（Label），用来分类节点。
    • 关系（Relationship）：表示节点之间的连接或关联，通常是有方向的，具有类型和属性。比如"朋友"关系、"购买"关系等。
    • 属性（Properties）：节点和关系都可以附带属性，这些属性是键值对，用于存储具体的数据。

  • Cypher 查询语言：Neo4j 使用一种名为 Cypher 的声明性查询语言来操作图数据库。Cypher 类似于 SQL，但专门设计用于处理图结构数据。

1.2 Neo4j 的优势

  • 高效的关系查询：Neo4j 擅长处理具有复杂关系的数据集，能够在大量数据中快速查询节点和关系。
  • 灵活的数据模型：与传统的关系型数据库相比，图数据库不需要事先定义严格的模式，可以动态地添加和修改节点和关系。
  • 直观的数据表示：图模型能够直观地表达现实世界中的复杂关系，容易理解和可视化。
  • 强大的社区支持：Neo4j 拥有庞大的用户社区和丰富的生态系统，提供了许多工具、插件和文档支持。

1.3 Neo4j 的核心组件

  • Neo4j Database：核心数据库引擎，负责存储和查询图数据。
  • Neo4j Browser：图形化用户界面，用于可视化查询结果和管理数据库。
  • Neo4j Desktop：一个桌面应用，提供开发、测试和管理 Neo4j 数据库的工具。
  • Neo4j Aura：一个托管的云服务，提供 Neo4j 数据库的云端解决方案。

1.4 使用场景

  • 社交网络分析：建模和分析社交网络中的用户及其关系，例如朋友推荐、影响力分析等。
  • 推荐系统：基于用户行为和兴趣的推荐，例如电商产品推荐、电影推荐等。
  • 网络安全：检测复杂网络中的威胁模式和攻击路径。
  • 供应链管理：追踪产品从原材料到最终消费者的整个供应链过程。

1.5 Cypher 查询语言

Cypher 是 Neo4j 的查询语言，用于创建、读取、更新和删除图数据。以下是几个基本的 Cypher 查询示例：

  • 创建节点 ：

    CREATE (n:Person {name: 'Alice', age: 30})

  • 创建关系 ：

    MATCH (a:Person {name: 'Alice'}), (b:Person {name: 'Bob'})
CREATE (a)-[:FRIEND]->(b)

  • 查询节点和关系 ：

    MATCH (a:Person)-[:FRIEND]->(b:Person)
WHERE a.name = 'Alice'
RETURN b.name

  • 更新节点 ：

    MATCH (a:Person {name: 'Alice'})
SET a.age = 31

  • 删除节点和关系 ：

    MATCH (a:Person {name: 'Alice'})-[r:FRIEND]->(b:Person)
DELETE r, a

1.6 与传统关系型数据库的对比

  • 数据表示：关系型数据库使用表、行、列来存储数据，而图数据库使用节点、关系、属性来表示数据和连接。
  • 模式（Schema）：关系型数据库需要预定义的模式，而图数据库的模式更加灵活，可以动态变化。
  • 查询复杂度：在关系型数据库中，复杂的关系查询通常需要多表联结，性能可能会受到影响。而在图数据库中，关系查询更加自然和高效。

1.7 Neo4j 的集成与扩展

  • 语言支持：Neo4j 提供多种编程语言的驱动程序，包括 Java, Python, JavaScript, Go 等。
  • Spring Data Neo4j：对于 Java 和 Spring 开发者，可以使用 Spring Data Neo4j 轻松集成 Neo4j，并利用 Spring 提供的功能，如数据存取、事务管理等。
  • 插件与工具：Neo4j 支持各种扩展和插件，如 APOC 库（用于增强 Cypher 的功能），Graph Algorithms 库（用于图算法的实现）。

1.8 部署与运维

  • 单节点部署：适用于开发和测试环境。
  • 集群部署：在生产环境中，Neo4j 可以通过集群部署来提高可用性和扩展性，支持水平扩展和故障恢复。
  • 备份与恢复：Neo4j 提供了工具和 API，用于数据库的备份与恢复，确保数据的安全性和可恢复性。

1.9 总结

Neo4j 是一个功能强大的图数据库系统，专注于处理和查询复杂的关系数据。凭借其灵活的图数据模型、高效的关系查询能力以及丰富的生态系统，Neo4j 在许多领域中得到了广泛应用。它不仅适用于传统的数据库应用场景，还能够处理需要分析和查询复杂关系的现代应用程序。

2. 分层使用

在使用 Neo4j 作为图数据库时，通常会在项目的 `Controller`, `Service`, 和 `Repository` 层进行相应的集成和操作。

2.1 Repository 层

Repository 层负责与数据库直接交互，在使用 Neo4j 时，这一层会处理所有与数据库相关的操作，如查询、创建、更新和删除图数据。

2.1.1 定义 Repository 接口

首先，定义一个接口，这个接口通常继承自 Neo4jRepository，Neo4jRepository 提供了一些基本的 CRUD 操作。你也可以定义自己的查询方法。

java 复制代码 
@Repository
public interface OrganRepository extends Neo4jRepository<OrganEntity, Long> {
    // 自定义查询方法
    Optional<OrganEntity> findByBid(Long bid);

    // 使用 @Query 注解自定义 Cypher 查询
    @Query("MATCH (n:Organ) WHERE n.name CONTAINS $name RETURN n")
    List<OrganEntity> findByNameContaining(String name);
}
2.1.1.1 自动生成查询

在 Neo4j 中，除了使用 Neo4jRepository 提供的标准方法（如 findById、save 等），你也可以定义自己的查询方法。这些自定义方法在接口中声明，通过名称和参数的匹配，Spring Data 会根据方法名称自动生成查询。

findByBid(Long bid) 自定义查询方法：

java 复制代码 
Optional<OrganEntity> findByBid(Long bid);

这个方法的作用是根据 bid 字段查找 OrganEntity，并返回一个 Optional 类型的结果。这是 Spring Data 的一种自动查询功能，根据方法名生成相应的 Cypher 查询。

可以自动生成查询的自定义方法的命名规则：

|-------------------------|-------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 关键字 | 示例 | 自动生成的Cypher语句片断 |
| After | findByLaunchDateAfter(Date date) | n.launchDate > date |
| Before | findByLaunchDateBefore(Date date) | n.launchDate < date |
| Containing (String) | findByNameContaining(String namePart) | n.name CONTAINS namePart |
| Containing (Collection) | findByEmailAddressesContains(Collection addresses) findByEmailAddressesContains(String address) | ANY(collectionFields IN [addresses] WHERE collectionFields in n.emailAddresses) ANY(collectionFields IN address WHERE collectionFields in n.emailAddresses) |
| In | findByNameIn(Iterable names) | n.name IN names |
| Between | findByScoreBetween(double min, double max) findByScoreBetween(Range range) | n.score >= min AND n.score <= max Depending on the Range definition n.score >= min AND n.score <= max or n.score > min AND n.score < max |
| StartingWith | findByNameStartingWith(String nameStart) | n.name STARTS WITH nameStart |
| EndingWith | findByNameEndingWith(String nameEnd) | n.name ENDS WITH nameEnd |
| Exists | findByNameExists() | EXISTS(n.name) |
| True | findByActivatedIsTrue() | n.activated = true |
| False | findByActivatedIsFalse() | NOT(n.activated = true) |
| Is | findByNameIs(String name) | n.name = name |
| NotNull | findByNameNotNull() | NOT(n.name IS NULL) |
| Null | findByNameNull() | n.name IS NULL |
| GreaterThan | findByScoreGreaterThan(double score) | n.score > score |
| GreaterThanEqual | findByScoreGreaterThanEqual(double score) | n.score >= score |
| LessThan | findByScoreLessThan(double score) | n.score < score |
| LessThanEqual | findByScoreLessThanEqual(double score) | n.score <= score |
| Like | findByNameLike(String name) | n.name =~ name |
| NotLike | findByNameNotLike(String name) | NOT(n.name =~ name) |
| Near | findByLocationNear(Distance distance, Point point) | distance( point(n),point({latitude:lat, longitude:lon}) ) < distance |
| Regex | findByNameRegex(String regex) | n.name =~ regex |
| And | findByNameAndDescription(String name, String description) | n.name = name AND n.description = description |
| Or | findByNameOrDescription(String name, String description) | n.name = name OR n.description = description (Cannot be used to OR nested properties) |

2.1.2 自定义 Repository 实现

如果需要更复杂的查询逻辑，可以创建一个自定义的 Repository 实现类。

java 复制代码 
@Repository
public class OrganRepositoryImpl implements OrganRepositoryCustom {

    @Autowired
    private Neo4jClient neo4jClient;

    @Override
    public List<OrganDTO> findByCustomQuery(String query) {
        return neo4jClient.query(query)
                .fetchAs(OrganDTO.class)
                .mappedBy((typeSystem, record) -> {
                    Map<String, Object> map = record.get("n").asMap();
                    return BeanUtil.toBean(map, OrganDTO.class);
                }).all();
    }
}

2.2 Service 层

Service 层处理业务逻辑，它调用 Repository 层来获取或操作数据，并在此基础上进行业务处理。

2.2.1 定义 Service 接口

首先，定义一个接口，用于定义服务的业务方法。

java 复制代码 
public interface OrganService {
    OrganDTO findOrganByBid(Long bid);
    List<OrganDTO> searchOrgans(String name);
    void createOrgan(OrganDTO organDTO);
}

2.2.2 实现 Service

然后，创建一个实现类来实现这些业务方法。

java 复制代码 
@Service
public class OrganServiceImpl implements OrganService {

    @Autowired
    private OrganRepository organRepository;

    @Override
    public OrganDTO findOrganByBid(Long bid) {
        return organRepository.findByBid(bid).orElse(null);
    }

    @Override
    public List<OrganDTO> searchOrgans(String name) {
        return organRepository.findByNameContaining(name);
    }

    @Override
    public void createOrgan(OrganDTO organDTO) {
        OrganEntity organEntity = new OrganEntity();
        organEntity.setBid(organDTO.getBid());
        organEntity.setName(organDTO.getName());
        // ... 设置其他属性
        organRepository.save(organEntity);
    }
}

2.3 Controller 层

Controller 层是应用程序的入口，处理 HTTP 请求，调用 Service 层的业务逻辑，并返回响应。

2.3.1 定义 Controller

创建一个 Controller 类，映射 URL 路径到具体的业务方法。

java 复制代码 
@RestController
@RequestMapping("/organs")
public class OrganController {

    @Autowired
    private OrganService organService;

    @GetMapping("/{bid}")
    public OrganDTO getOrganByBid(@PathVariable Long bid) {
        return organService.findOrganByBid(bid);
    }

    @GetMapping("/search")
    public List<OrganDTO> searchOrgans(@RequestParam String name) {
        return organService.searchOrgans(name);
    }

    @PostMapping
    public void createOrgan(@RequestBody OrganDTO organDTO) {
        organService.createOrgan(organDTO);
    }
}

2.4 总结和工作流程

  • Repository 层 ：与 Neo4j 数据库直接交互。通过 Neo4jRepository 或自定义查询方法执行 Cypher 查询。
  • Service 层：处理业务逻辑，从 Repository 层获取数据并进行处理。
  • Controller 层：处理 HTTP 请求，将请求数据传递给 Service 层，并返回处理结果。

示例流程：

  1. 用户请求 ：用户通过浏览器访问 /organs/{bid} 获取某个组织的信息。
  2. Controller 处理请求 ：Controller 调用 OrganService.findOrganByBid。
  3. Service 处理业务逻辑 ：Service 层调用 OrganRepository.findByBid 查询数据库。
  4. Repository 执行查询：Repository 层执行查询并返回结果。
  5. 返回结果：Service 处理结果并将其传递回 Controller，Controller 返回 JSON 响应。

通过这种分层架构，你可以清晰地组织代码，使得业务逻辑、数据操作和请求处理各司其职。

3. 复杂查询详解

通过继承Neo4jRepository实现简单的查询是非常方便的，如果要实现复杂的查询就需要定义Cypher查询实现了，需要通过Neo4jClient进行查询操作。

在RepositoryImpl实现类中编写代码，实现查询：

java 复制代码 
@Component
public class RepositoryImpl implements Repository {

    @Autowired
    private Neo4jClient neo4jClient;

    public List<OrganDTO> findByBid(Long bid) {
        String cypherQuery = "MATCH (n) WHERE n.bid = $bid RETURN n";
        return executeQuery(cypherQuery, Collections.singletonMap("bid", bid));
    }

    private List<OrganDTO> executeQuery(String cypherQuery, Map<String, Object> parameters) {
        return neo4jClient.query(cypherQuery)
            .bindAll(parameters)  // 绑定参数
            .fetchAs(OrganDTO.class)  // 指定返回类型
            .mappedBy((typeSystem, record) -> {  // 自定义映射
                Map<String, Object> map = record.get("n").asMap();
                OrganDTO organDTO = new OrganDTO();
                organDTO.setBid((Long) map.get("bid"));
                organDTO.setName((String) map.get("name"));
                // 映射其他属性
                return organDTO;
            })
            .all();
    }
}
  • fetchAs(Class<T> resultType)：指定将结果映射为的目标类型。
  • mappedBy(BiFunction<TypeSystem, Record, T> mappingFunction) ：自定义映射函数，用于将 Record 转换为目标类型。
相关推荐
NY61 分钟前
mysql运维篇笔记——日志，主从复制，分库分表，读写分离
数据库·sql
向阳12182 分钟前
sentinel来源访问控制（黑白名单）
java·sentinel
Takumilove2 分钟前
MQTT入门：在Spring Boot中建立连接及测试
java·spring boot·后端
潜洋15 分钟前
Spring Boot 教程之三十六：实现身份验证
java·数据库·spring boot
科马25 分钟前
【Redis】缓存
数据库·redis·spring·缓存
TroubleMaker27 分钟前
OkHttp源码学习之retryOnConnectionFailure属性
android·java·okhttp
LuiChun40 分钟前
Django 模板分割及多语言支持案例【需求文档】--＞【实现方案】
数据库·django·sqlite
凡人的AI工具箱41 分钟前
每天40分玩转Django：Django管理界面
开发语言·数据库·后端·python·django
中科院提名者44 分钟前
Django连接mysql数据库报错ModuleNotFoundError: No module named ‘MySQLdb‘
数据库·mysql·django
cloud___fly1 小时前
Spring AOP入门
java·后端·spring
热门推荐
01SQL 主从数据库实时备份02YOLOv8训练好模型后，追加轮数继续训练、或者提前终止训练，缩减训练轮数03玄机平台应急响应—webshell查杀04VSCode插件 —— Cody AI （免费AI助手！）05HCIA-datacom数通题库和录播视频资料06Docker 夺命连环 15 问07组基轨迹建模 GBTM的介绍与实现（Stata 或 R）08校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10【华东南AWDP】第十七届全国大学生信息安全竞赛 CISCN 2024 创新实践能力赛区域赛 部分题解WP