📌 第一部分：Neo4j 概览与定位

1.1 定义与全称

Neo4j 是由 Neo4j Inc. 于 2007 年创建的图数据库管理系统，是图数据库领域的领导者。Neo4j 将数据存储为 节点（Node）、关系（Relationship）和属性（Property），通过 Cypher 查询语言实现高效的关系遍历和分析。

1.2 核心定位

Neo4j 的核心定位是 关系数据的高效存储和查询。它提供了：

• 图数据模型（节点 + 关系 + 属性）
• Cypher 查询语言（声明式图查询）
• 高效的图遍历算法
• ACID 事务支持
• 嵌入式部署（Java）
• 高可用集群
• 与 Spring Boot 集成
• 可视化工具（Neo4j Browser）

1.3 主要应用领域

• 社交网络： 好友关系、推荐
• 推荐系统： 商品推荐、内容推荐
• 欺诈检测： 资金流追踪、异常检测
• 知识图谱： 实体关系存储
• 网络分析： 网络拓扑分析
• 身份识别： 权限管理、访问控制
• 供应链管理： 供应链追踪

1.4 知名案例

• eBay： 使用 Neo4j 构建推荐系统
• Uber： 使用 Neo4j 分析出行数据
• Airbnb： 使用 Neo4j 进行信任和安全分析
• 思科： 使用 Neo4j 进行网络分析
• NASA： 使用 Neo4j 管理知识图谱

---

⚙️ 第二部分：核心概念

2.1 图数据模型

• Node（节点）： 实体（用户、商品、电影）
• Relationship（关系）： 节点间的连接（朋友、购买、评论）
• Property（属性）： 键值对（姓名、年龄、价格）
• Label（标签）： 节点分类（Person、Product）

2.2 Cypher 查询语言

// 创建节点
CREATE (u:User {name: "Alice", age: 30})
CREATE (p:Product {name: "Laptop", price: 999})

// 创建关系
MATCH (u:User {name: "Alice"})
MATCH (p:Product {name: "Laptop"})
CREATE (u)-[:PURCHASED {date: "2024-01-15"}]->(p)

// 查询好友关系
MATCH (u:User {name: "Alice"})-[:FRIEND]->(friend)
RETURN friend.name

// 查询多级关系（好友的朋友）
MATCH (u:User {name: "Alice"})-[:FRIEND*2]->(friend_of_friend)
RETURN friend_of_friend.name

// 查询最短路径
MATCH p = shortestPath(
    (a:User {name: "Alice"})-[:FRIEND*]-(b:User {name: "Bob"})
)
RETURN p

// 查询购买推荐
MATCH (u:User {name: "Alice"})-[:PURCHASED]->(p:Product)<-[:PURCHASED]-(other:User)
MATCH (other)-[:PURCHASED]->(recommend:Product)
WHERE NOT (u)-[:PURCHASED]->(recommend)
RETURN recommend.name, COUNT(*) AS score
ORDER BY score DESC
LIMIT 10

2.3 高级查询

// 聚合查询
MATCH (u:User)-[:PURCHASED]->(p:Product)
RETURN u.name, COUNT(p) AS purchase_count
ORDER BY purchase_count DESC

// 路径查询
MATCH path = (start:User {name: "Alice"})-[:FRIEND*1..5]-(end:User)
WHERE end.name = "Bob"
RETURN path

// 条件过滤
MATCH (u:User)
WHERE u.age > 25 AND u.city = "Beijing"
RETURN u.name

// 创建多条关系
MATCH (u1:User {name: "Alice"}), (u2:User {name: "Bob"})
CREATE (u1)-[:FRIEND]->(u2)

// 更新节点
MATCH (u:User {name: "Alice"})
SET u.age = 31
RETURN u

// 删除关系
MATCH (u:User {name: "Alice"})-[r:PURCHASED]->(p:Product {name: "Laptop"})
DELETE r

// 删除节点
MATCH (u:User {name: "Alice"})
DETACH DELETE u

2.4 索引和约束

// 创建索引（加速查询）
CREATE INDEX ON :User(name)
CREATE INDEX ON :Product(name)

// 创建唯一约束
CREATE CONSTRAINT ON (u:User) ASSERT u.id IS UNIQUE
CREATE CONSTRAINT ON (p:Product) ASSERT p.sku IS UNIQUE

2.5 Python 示例

# 使用 neo4j 驱动
from neo4j import GraphDatabase

class Neo4jClient:
    def __init__(self, uri, user, password):
        self.driver = GraphDatabase.driver(uri, auth=(user, password))

    def close(self):
        self.driver.close()

    def create_user(self, name, age):
        with self.driver.session() as session:
            result = session.run(
                "CREATE (u:User {name: $name, age: $age}) RETURN u",
                name=name, age=age
            )
            return result.single()[0]

    def find_friends(self, name):
        with self.driver.session() as session:
            result = session.run(
                "MATCH (u:User {name: $name})-[:FRIEND]->(friend) RETURN friend.name",
                name=name
            )
            return [record["friend.name"] for record in result]

# 使用
client = Neo4jClient("bolt://localhost:7687", "neo4j", "password")
client.create_user("Alice", 30)
friends = client.find_friends("Alice")
client.close()

2.6 Java Spring Boot 集成

// Spring Data Neo4j 实体
@Node
public class User {
    @Id
    @GeneratedValue
    private Long id;

    private String name;
    private int age;

    @Relationship(type = "FRIEND")
    private Set friends = new HashSet<>();
}

// Repository
@Repository
public interface UserRepository extends Neo4jRepository {
    @Query("MATCH (u:User {name: $name})-[:FRIEND]->(friend) RETURN friend")
    List findFriends(@Param("name") String name);

    @Query("MATCH (u:User {name: $name}) SET u.age = $age RETURN u")
    User updateAge(@Param("name") String name, @Param("age") int age);
}

// Service
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public User createUser(String name, int age) {
        User user = new User();
        user.setName(name);
        user.setAge(age);
        return userRepository.save(user);
    }

    public List getFriends(String name) {
        return userRepository.findFriends(name);
    }
}

2.7 图算法

// 社区检测（Louvain 算法）
CALL gds.louvain.stream('my-graph')
YIELD nodeId, communityId
RETURN gds.util.asNode(nodeId).name AS name, communityId
ORDER BY communityId

// 中心度分析（PageRank）
CALL gds.pageRank.stream('my-graph')
YIELD nodeId, score
RETURN gds.util.asNode(nodeId).name AS name, score
ORDER BY score DESC
LIMIT 10

// 最短路径（Dijkstra）
CALL gds.shortestPath.astar.stream({
  nodeProjection: 'User',
  relationshipProjection: {
    FRIEND: {
      type: 'FRIEND',
      properties: 'distance',
      orientation: 'UNDIRECTED'
    }
  },
  startNode: {id: 1},
  endNode: {id: 10}
})
YIELD path
RETURN path

---

⚖️ 第三部分：Neo4j vs 其他数据库

对比项	Neo4j	MySQL	MongoDB
数据模型	图	关系型（表）	文档型
关系查询	极快（原生）	慢（JOIN）	慢（聚合）
深度遍历	极快	极慢	极慢
事务支持	✅ ACID	✅ ACID	✅
查询语言	Cypher	SQL	MQL
适用场景	关系分析	OLTP	文档存储

---

🧠 第四部分：学习建议

推荐学习资源

• Neo4j 官方文档： neo4j.com/docs
• 《Neo4j 实战》—— 全面入门
• Cypher 手册： neo4j.com/cypher
• Neo4j 沙箱： sandbox.neo4j.com

---

🎯 总结升华