如何基于AGE图数据库及其JDBC驱动实现Object-Graph Mapping(OGM)

1. 依赖准备 #

首先确保项目引入必要依赖：PostgreSQL JDBC驱动（AGE基于PostgreSQL）和Jackson用于JSON属性解析，Maven依赖示例如下：

<dependencies>
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <version>42.6.0</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.15.2</version>
    </dependency>
</dependencies>

2. 实体类定义 #

创建与AGE节点一一对应的Java类，同时在类中定义关联节点的引用，体现图关系：

Person类（对应:Person节点） #

public class Person {
    private Long id; // 对应AGE节点的唯一ID
    private String name;
    private Integer age;
    private City city; // 对应Person-[:LIVES_IN]->City的关系
    private Department department; // 对应Person-[:WORKS_IN]->Department的关系

    // 全参、无参构造器
    // Getter和Setter方法
}

City类（对应:City节点） #

public class City {
    private Long id;
    private String name;
    private String country;

    // 构造器、Getter、Setter
}

Department类（对应:Department节点） #

public class Department {
    private Long id;
    private String name;

    // 构造器、Getter、Setter
}

3. 核心映射工具实现 #

编写映射工具类，将AGE查询返回的ResultSet结果转换为Java实体对象，同时处理关联节点的引用赋值：

import java.sql.ResultSet;
import java.sql.SQLException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class NodeMapper {
    private static final ObjectMapper objectMapper = new ObjectMapper();

    // 映射Person及其关联的City、Department
    public static Person mapPerson(ResultSet rs) throws SQLException {
        // 解析Person节点的JSON属性
        String personJson = rs.getString("p");
        Person person = objectMapper.readValue(personJson, Person.class);
        person.setId(rs.getLong("p.id"));

        // 解析关联的City节点
        String cityJson = rs.getString("c");
        City city = objectMapper.readValue(cityJson, City.class);
        city.setId(rs.getLong("c.id"));
        person.setCity(city);

        // 解析关联的Department节点
        String deptJson = rs.getString("d");
        Department department = objectMapper.readValue(deptJson, Department.class);
        department.setId(rs.getLong("d.id"));
        person.setDepartment(department);

        return person;
    }

    // 同理可实现mapCity、mapDepartment方法，处理各自的关联关系
}

4. DAO层数据操作实现 #

通过JDBC执行Cypher语句，完成数据的CRUD操作，并调用映射工具转换对象：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class PersonDAO {
    // 数据库连接参数，根据实际配置修改
    private static final String DB_URL = "jdbc:postgresql://localhost:5432/your_database";
    private static final String DB_USER = "your_username";
    private static final String DB_PASS = "your_password";

    // 根据ID查询Person及其关联对象
    public Person getPersonById(Long id) throws SQLException {
        String cypher = "MATCH (p:Person)-[:LIVES_IN]->(c:City), (p)-[:WORKS_IN]->(d:Department) WHERE id(p) = ? RETURN p, c, d";
        try (Connection conn = DriverManager.getConnection(DB_URL, DB_USER, DB_PASS);
             PreparedStatement stmt = conn.prepareStatement(cypher)) {
            stmt.setLong(1, id);
            try (ResultSet rs = stmt.executeQuery()) {
                if (rs.next()) {
                    return NodeMapper.mapPerson(rs);
                }
            }
        }
        return null;
    }

    // 保存Person及其关联关系（自动创建不存在的关联节点）
    public void savePerson(Person person) throws SQLException {
        // 先确保关联的City和Department已存在
        saveCityIfNotExists(person.getCity());
        saveDepartmentIfNotExists(person.getDepartment());

        // 执行Cypher语句保存Person并建立关系
        String cypher = """
            MERGE (p:Person {name: ?, age: ?})
            MERGE (c:City {name: ?, country: ?})
            MERGE (d:Department {name: ?})
            MERGE (p)-[:LIVES_IN]->(c)
            MERGE (p)-[:WORKS_IN]->(d)
            RETURN id(p) as personId
            """;
        try (Connection conn = DriverManager.getConnection(DB_URL, DB_USER, DB_PASS);
             PreparedStatement stmt = conn.prepareStatement(cypher)) {
            stmt.setString(1, person.getName());
            stmt.setInt(2, person.getAge());
            stmt.setString(3, person.getCity().getName());
            stmt.setString(4, person.getCity().getCountry());
            stmt.setString(5, person.getDepartment().getName());
            try (ResultSet rs = stmt.executeQuery()) {
                if (rs.next()) {
                    person.setId(rs.getLong("personId"));
                }
            }
        }
    }

    // 辅助方法：保存City（不存在则创建）
    private void saveCityIfNotExists(City city) throws SQLException {
        String cypher = "MERGE (c:City {name: ?, country: ?}) RETURN id(c) as cityId";
        try (Connection conn = DriverManager.getConnection(DB_URL, DB_USER, DB_PASS);
             PreparedStatement stmt = conn.prepareStatement(cypher)) {
            stmt.setString(1, city.getName());
            stmt.setString(2, city.getCountry());
            try (ResultSet rs = stmt.executeQuery()) {
                if (rs.next()) {
                    city.setId(rs.getLong("cityId"));
                }
            }
        }
    }

    // 辅助方法：保存Department（不存在则创建）
    private void saveDepartmentIfNotExists(Department department) throws SQLException {
        String cypher = "MERGE (d:Department {name: ?}) RETURN id(d) as deptId";
        try (Connection conn = DriverManager.getConnection(DB_URL, DB_USER, DB_PASS);
             PreparedStatement stmt = conn.prepareStatement(cypher)) {
            stmt.setString(1, department.getName());
            try (ResultSet rs = stmt.executeQuery()) {
                if (rs.next()) {
                    department.setId(rs.getLong("deptId"));
                }
            }
        }
    }
}

5. 示例用法 #

public class Main {
    public static void main(String[] args) {
        try {
            PersonDAO personDAO = new PersonDAO();

            // 构造测试数据
            City newYork = new City();
            newYork.setName("New York");
            newYork.setCountry("USA");

            Department engineering = new Department();
            engineering.setName("Engineering");

            Person alice = new Person();
            alice.setName("Alice");
            alice.setAge(30);
            alice.setCity(newYork);
            alice.setDepartment(engineering);

            // 保存数据
            personDAO.savePerson(alice);
            System.out.println("保存的Person ID: " + alice.getId());

            // 查询并打印结果
            Person retrievedPerson = personDAO.getPersonById(alice.getId());
            System.out.println("查询到的Person: " + retrievedPerson.getName());
            System.out.println("居住城市: " + retrievedPerson.getCity().getName());
            System.out.println("所属部门: " + retrievedPerson.getDepartment().getName());

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

注意事项 #

• 延迟加载：如果关联节点数据量大，可实现延迟加载逻辑，比如在访问关联属性时再执行Cypher查询获取数据；
• 事务管理：在批量操作或多步操作时，使用conn.setAutoCommit(false)开启事务，操作完成后调用conn.commit()提交；
• 节点ID：AGE节点的ID由数据库自动生成，通过id(node)函数获取，映射时需注意赋值给实体类的id字段；
• 属性一致性：确保Java实体类的属性名与AGE节点的属性名一致，避免JSON解析失败。

内容的提问来源于stack exchange，提问作者Abdul Manan