RedisGraph中复杂字符串属性的持久化策略

GRAPH.QUERY movies "CREATE (:Actor {name:"Peter O'Toole", desc:"An "actors" actor", actor_id:1})"

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.core.json.JsonWriteFeature;

// 假设有一个Person类
class Person {
    public String firstname;
    public String lastname;
    public String desc;

    public Person(String firstname, String lastname) {
        this.firstname = firstname;
        this.lastname = lastname;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }
}

public class JsonFormatter {
    public static void main(String[] args) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();

        // (可选) 启用美观打印JSON
        objectMapper.enable(SerializationFeature.INDENT_OUTPUT);

        // 不为属性名添加双引号。例如 { firstname : "Peter" }
        objectMapper.configure(JsonWriteFeature.QUOTE_FIELD_NAMES.mappedFeature(), false);

        // 创建一个Person对象
        Person person = new Person("Peter", "O'Toole");
        // 设置包含转义双引号和单引号的描述
        person.setDesc("An "actor's" actor");

        // 将Person对象转换为JSON字符串
        String json = objectMapper.writeValueAsString(person);

        System.out.println(json);
    }
}

{
  firstname : "Peter",
  lastname : "O'Toole",
  desc : "An "actor's" actor"
}

String firstname = "Peter";
String lastname = "O'Toole";
String desc = "An "actor's" actor"; // Java字符串中，内部的"就是两个字符：反斜杠和双引号

String cmdStr = "CREATE (:Actor {firstname:"" + firstname + "", lastname: "" + lastname + "", desc:"" + desc + "", actor_id:1})";
// 简化为硬编码的示例：
// String cmdStr = "CREATE (:Actor {firstname:"Peter", lastname: "O'Toole", desc:"An \"actor's\" actor", actor_id:1})";
// 注意：如果desc变量已经包含"，那么在拼接时就不需要额外的\。
// 如果直接硬编码，则需要\"来表示Cypher中的"。

import io.vertx.core.Future;
import io.vertx.core.Vertx;
import io.vertx.redis.client.Command;
import io.vertx.redis.client.Redis;
import io.vertx.redis.client.Request;

public class RedisGraphClientExample {

    private final Redis redisClient;

    public RedisGraphClientExample(Vertx vertx) {
        this.redisClient = Redis.createClient(vertx);
    }

    public Future<String> createActor(String firstname, String lastname, String desc, int actorId) {
        // 构建Cypher查询字符串
        // 注意：这里的"是Java字符串的转义，表示Cypher中的一个双引号
        String cmdStr = String.format("CREATE (:Actor {firstname:"%s", lastname: "%s", desc:"%s", actor_id:%d})",
                                      firstname, lastname, desc.replace(""", "\""), actorId);

        // 如果desc变量本身就包含了正确的"，则不需要额外的replace
        // 例如，如果desc是 "An "actor's" actor"
        // String cmdStr = String.format("CREATE (:Actor {firstname:"%s", lastname: "%s", desc:"%s", actor_id:%d})",
        //                               firstname, lastname, desc, actorId);


        System.out.println("Executing Cypher: " + cmdStr);

        return redisClient.send(Request.cmd(Command.GRAPH_QUERY).arg("movies").arg(cmdStr))
            .compose(response -> {
                System.out.println("createRequest response=" + response.toString());
                return Future.succeededFuture("OK");
            })
            .onFailure(failure -> {
                System.err.println("createRequest failure=" + failure.toString());
            });
    }

    public static void main(String[] args) {
        Vertx vertx = Vertx.vertx();
        RedisGraphClientExample client = new RedisGraphClientExample(vertx);

        // 示例数据
        String firstname = "Peter";
        String lastname = "O'Toole";
        String desc = "An "actor's" actor"; // 原始Java字符串，内部已包含转义双引号

        client.createActor(firstname, lastname, desc, 1)
            .onComplete(res -> {
                if (res.succeeded()) {
                    System.out.println("Actor created successfully!");
                } else {
                    System.err.println("Failed to create actor: " + res.cause().getMessage());
                }
                vertx.close(); // 关闭Vertx实例
            });
    }
}