Gremlin Java实现教程求助：AWS Neptune CRUD及实体映射

Hey there! Since you’ve already got your AWS Neptune connection up and running, let’s jump right into building those CRUD operations with Gremlin in Java—including mapping query results to your Person entity class. I’ll walk you through each step with concrete code examples.

Before we start querying, let’s create a simple Person class to map Gremlin vertex results to. Manual mapping is straightforward for basic cases (you can use libraries like Jackson for more complex scenarios later):

public class Person {
    private String id;
    private String name;
    private int age;

    // Constructor, getters, setters, and toString()
    public Person(String id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    // Add standard getters and setters here
    @Override
    public String toString() {
        return "Person{id='" + id + "', name='" + name + "', age=" + age + "}";
    }
}

I’ll assume you already have a GraphTraversalSource instance (let’s call it g) connected to your Neptune cluster. Let’s dive into each operation:

2.1 Create: Add Persons, Attributes, and Relationships #

Here’s how to create two Person vertices, add their properties, and create a knows relationship between them. Use iterate() for write operations where you don’t need returned data (it’s more efficient):

// Create first person: Alice, 30
Vertex alice = g.addV("Person")
        .property("name", "Alice")
        .property("age", 30)
        .next(); // next() returns the created vertex if you need to reference it

// Create second person: Bob, 28
Vertex bob = g.addV("Person")
        .property("name", "Bob")
        .property("age", 28)
        .next();

// Add "knows" relationship from Alice to Bob
g.V(alice.id())
        .addE("knows")
        .to(V(bob.id()))
        .iterate();

System.out.println("Created Alice, Bob, and their 'knows' relationship successfully!");

Note: If you don’t need to reference the created vertices right away, replace next() with iterate() for all create steps to save resources.

2.2 Read: Fetch and Map Persons to Your Entity #

Now let’s query the Person vertices, map results to our Person class, and output them:

// Query all Person vertices
ResultSet results = g.V().hasLabel("Person").toList();

// Map results to Person objects
List<Person> persons = new ArrayList<>();
for (Result result : results) {
    Vertex vertex = result.getVertex();
    String id = vertex.id().toString();
    String name = vertex.property("name").value().toString();
    int age = Integer.parseInt(vertex.property("age").value().toString());
    
    persons.add(new Person(id, name, age));
}

// Output the results
System.out.println("Fetched Persons:");
for (Person person : persons) {
    System.out.println(person);
}

Mapping Breakdown: #

• Each Result can be cast to a Vertex with getVertex().
• Use vertex.property("<property-name>").value() to pull attribute values from the vertex.
• Convert values to match your Person class types (like parsing age to an integer).

2.3 Update: Modify a Person’s Attribute #

Let’s update Alice’s age to 31. We’ll target her by name and overwrite the existing age property:

// Update Alice's age to 31
g.V().hasLabel("Person")
        .has("name", "Alice")
        .property(Cardinality.single, "age", 31) // Overwrites existing value (critical for single-value attributes)
        .iterate();

// Verify the update
Person updatedAlice = g.V().hasLabel("Person").has("name", "Alice")
        .map(v -> new Person(v.id().toString(), v.property("name").value().toString(), Integer.parseInt(v.property("age").value().toString())))
        .next();

System.out.println("Updated Alice: " + updatedAlice);

Note: Neptune supports multi-valued properties by default, so Cardinality.single ensures we replace the existing value instead of adding a new one.

2.4 Delete: Remove a Person and Their Relationships #

Neptune won’t let you delete a vertex with active edges, so we first remove all connected edges, then delete the vertex itself:

// First, delete all edges connected to Bob
g.V().hasLabel("Person").has("name", "Bob")
        .bothE() // Gets all incoming and outgoing edges
        .drop()
        .iterate();

// Now delete Bob's vertex
g.V().hasLabel("Person").has("name", "Bob")
        .drop()
        .iterate();

// Verify deletion
long remainingPersons = g.V().hasLabel("Person").count().next();
System.out.println("Remaining persons after deletion: " + remainingPersons); // Should be 1 (only Alice left)

• next(): Use when expecting a single result (e.g., fetching one person by ID). Throws NoSuchElementException if no results exist.
• toList(): Use to get all results as a ResultSet (ideal for bulk reads).
• iterate(): Best for write operations (create/update/delete) where you don’t need returned data—it’s more efficient than next() or toList().
• Advanced Mapping: For complex entities, use Gremlin’s map() step to handle mapping inline (like we did in the update verification) or create a custom mapper class to keep your code clean.

Hope this gives you a solid, practical foundation for working with Gremlin Java and AWS Neptune! If you hit any snags with edge cases or query performance, feel free to dig into specific details.

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