RedisGraph属性持久化：如何优雅处理包含单引号与转义双引号的数据

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

// 假设Person类已定义，包含firstName, lastName, desc属性
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 InitialAttempt {
    public static void main(String[] args) throws Exception {
        // 使用自定义JsonFactory，将引号字符替换为u007F
        JsonFactory builder = new JsonFactoryBuilder().quoteChar('u007F').build();
        ObjectMapper objectMapper = new ObjectMapper(builder);

        objectMapper.enable(SerializationFeature.INDENT_OUTPUT);
        // 不引用属性名
        objectMapper.configure(JsonWriteFeature.QUOTE_FIELD_NAMES.mappedFeature(), false);

        Person person = new Person("Peter", "O'Toole");
        // 设置包含转义双引号的描述
        person.setDesc("An "actors" actor");

        String json = objectMapper.writeValueAsString(person);
        // 将u007F替换为转义的双引号"
        String j2 = json.replaceAll("u007F", "\\"");

        System.out.println("初步尝试生成的JSON字符串:");
        System.out.println(j2);
        // 预期输出:
        // {
        //   firstName : "Peter",
        //   lastName : "O'Toole",
        //   desc : "An "actors" actor"
        // }
    }
}

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

// 假设Person类已定义，包含firstname, lastname, desc属性
class Person {
    public String firstname;
    public String lastname;
    public String desc;
    public int actor_id; // 示例新增

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

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

    public void setActorId(int actor_id) {
        this.actor_id = actor_id;
    }
}

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

        // (可选) 启用漂亮打印
        objectMapper.enable(SerializationFeature.INDENT_OUTPUT);

        // 不引用属性名，例如：{ firstname : "Peter" } 而不是 { "firstname" : "Peter" }
        objectMapper.configure(JsonWriteFeature.QUOTE_FIELD_NAMES.mappedFeature(), false);

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

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

        System.out.println("Jackson生成的属性JSON字符串:");
        System.out.println(jsonProperties);
        // 预期输出:
        // {
        //   firstname : "Peter",
        //   lastname : "O'Toole",
        //   desc : "An "actor's" actor",
        //   actor_id : 1
        // }
    }
}

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> createActorNode() {
        // 注意：这里需要根据Jackson输出的格式手动构造Cypher属性部分
        // 或者更推荐的做法是，直接从Java对象构建Cypher片段，而不是先转JSON再解析
        // 但为了演示与前一步Jackson输出的衔接，这里直接使用字面量。
        // 
        // 关键点：Java字符串字面量中的转义。
        // "Peter" -> "Peter"
        // "O'Toole" -> "O'Toole"
        // "An "actor's" actor" -> "An \"actor's\" actor" (Java中需要转义反斜杠)
        String firstname = "Peter";
        String lastname = "O'Toole";
        String desc = "An "actor's" actor"; // Java中表示 "An "actor's" actor"
        int actorId = 1;

        // 构建Cypher命令字符串
        String cmdStr = String.format(
            "CREATE (:Actor {firstname:"%s", lastname: "%s", desc:"%s", actor_id:%d})",
            firstname,
            lastname,
            // 注意：这里需要对desc中的内部双引号进行Cypher层面的转义
            // 如果desc是 "An "actor's" actor"，那么在Cypher字符串中，需要表示为 "An \"actor's\" actor"
            // 因此在Java的String.format中，需要将desc中的"再次转义为\"
            desc.replace(""", "\""), // 替换desc中的"为"，使其在Cypher字符串中成为转义双引号
            actorId
        );

        System.out.println("
将发送到RedisGraph的命令字符串:");
        System.out.println(cmdStr);
        // 预期输出:
        // CREATE (:Actor {firstname:"Peter", lastname: "O'Toole", desc:"An "actor's" actor", actor_id:1})

        return redisClient.send(Request.cmd(Command.GRAPH_QUERY).arg("movies").arg(cmdStr))
            .compose(response -> {
                System.out.println("RedisGraph响应: " + response.toString());
                return Future.succeededFuture("OK");
            })
            .onFailure(failure -> {
                System.err.println("RedisGraph请求失败: " + failure.toString());
            });
    }

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

        client.createActorNode().onComplete(ar -> {
            if (ar.succeeded()) {
                System.out.println("节点创建成功: " + ar.result());
            } else {
                System.err.println("节点创建失败");
            }
            vertx.close(); // 关闭Vert.x实例
        });
    }
}