{"id":5528,"date":"2018-07-26T07:00:06","date_gmt":"2018-07-26T14:00:06","guid":{"rendered":"https:\/\/www.couchbase.com\/blog\/?p=5528"},"modified":"2023-09-11T00:09:32","modified_gmt":"2023-09-11T07:09:32","slug":"processing-graphql-queries-with-java-spring-boot-and-nosql","status":"publish","type":"post","link":"https:\/\/www.couchbase.com\/blog\/es\/processing-graphql-queries-with-java-spring-boot-and-nosql\/","title":{"rendered":"Procesamiento de consultas GraphQL con Java, Spring Boot y NoSQL"},"content":{"rendered":"

Durante los \u00faltimos meses he estado aprendiendo sobre GraphQL y c\u00f3mo utilizarlo como alternativa al desarrollo de API RESTful. Hasta ahora me hab\u00eda centrado en GraphQL y Golang<\/a> as\u00ed como GraphQL y Node.js<\/a>. Puede que haya exprimido todo lo que he podido esos dos lenguajes de desarrollo, as\u00ed que he decidido cambiar de marcha y probar suerte con algo de Java.<\/p>\n

En este tutorial, vamos a ver c\u00f3mo poner r\u00e1pidamente en marcha GraphQL utilizando Java y el popular framework Spring Boot.<\/p>\n

<\/p>\n

Antes de entrar en materia, quiero dar cr\u00e9dito a quien lo merece. Prithviraj Pawar escribi\u00f3 un gran art\u00edculo titulado,\u00a0C\u00f3mo poner en marcha su servidor GraphQL Java en un abrir y cerrar de ojos<\/a>, que me dio muchas ideas aunque hab\u00eda cosas que desear, como una base de datos en lugar de datos simulados. Os animo a leer su art\u00edculo despu\u00e9s de leer a trav\u00e9s de la m\u00eda.<\/p>\n

Requisitos<\/h2>\n

Hay algunos requisitos previos que deben cumplirse antes de saltar a la GraphQL y el lado de desarrollo de las cosas.<\/p>\n

Vamos a asumir que ya tienes Couchbase instalado, configurado y funcionando. Cualquier cosa despu\u00e9s de Couchbase Server 5.0 servir\u00e1 porque s\u00f3lo vamos a utilizar las caracter\u00edsticas b\u00e1sicas.<\/p>\n

Tambi\u00e9n vamos a suponer que has descargado un proyecto base de Spring Boot. La p\u00e1gina Sitio web de Spring Boot<\/a> tiene un gran generador que te permite definir las dependencias. Si quieres mantener la coherencia con mi gu\u00eda, tendr\u00e1s que crear un proyecto Gradle en lugar de Maven.<\/p>\n

Definici\u00f3n de las dependencias del proyecto Gradle<\/h2>\n

Cuando tengas una plantilla de Spring Boot a mano, probablemente estar\u00e1 muy desnuda. Necesitamos incluir las dependencias que planeamos usar en nuestra configuraci\u00f3n de Gradle.<\/p>\n

Abra el archivo\u00a0build.gradle<\/strong> e incluya lo siguiente:<\/p>\n

dependencias {\r\n    compilar('org.springframework.boot:spring-boot-starter-web')\r\n    compilar('com.couchbase.client:java-client')\r\n    compilar('com.graphql-java:graphql-java:9.0')\r\n    testCompile('org.springframework.boot:spring-boot-starter-test')\r\n}<\/pre>\n
Usaremos Spring Boot para servir nuestro endpoint GraphQL, el SDK Java de Couchbase para interactuar con nuestra base de datos, y el plugin GraphQL para procesar nuestras consultas.<\/p>\n
Bootstrapping de la API Java con RESTful Endpoints<\/h2>\n
Con las dependencias en su lugar, podemos empezar a desarrollar nuestra API. A pesar de que estamos utilizando GraphQL como un reemplazo a todas las cosas comunes API RESTful, esto no significa que REST est\u00e1 completamente fuera de la ecuaci\u00f3n. Todav\u00eda necesitamos un punto final para enviar nuestras consultas GraphQL a.<\/p>\n
Dependiendo de c\u00f3mo haya llamado a su proyecto, paquete, etc., abra el archivo que contiene su principal<\/code> e incluyen lo siguiente:<\/p>\n
paquete com.couchbase.graphql;\r\n\r\nimport com.couchbase.client.java.Bucket;\r\nimport com.couchbase.client.java.Cluster;\r\nimport com.couchbase.client.java.CouchbaseCluster;\r\nimport com.couchbase.client.java.document.json.JsonObject;\r\nimport graphql.schema.DataFetcher;\r\nimport org.springframework.beans.factory.annotation.Autowired;\r\nimport org.springframework.beans.factory.annotation.Value;\r\nimport org.springframework.boot.SpringApplication;\r\nimport org.springframework.boot.autoconfigure.SpringBootApplication;\r\nimport org.springframework.context.annotation.Bean;\r\nimport org.springframework.http.HttpStatus;\r\nimport org.springframework.http.ResponseEntity;\r\nimport org.springframework.web.bind.annotation.RequestBody;\r\nimport org.springframework.web.bind.annotation.RequestMapping;\r\nimport org.springframework.web.bind.annotation.RequestMethod;\r\nimport org.springframework.web.bind.annotation.RestController;\r\nimport graphql.ExecutionInput;\r\nimport graphql.ExecutionResult;\r\nimport graphql.GraphQL;\r\nimport graphql.schema.GraphQLSchema;\r\nimport graphql.schema.StaticDataFetcher;\r\nimport graphql.schema.idl.RuntimeWiring;\r\nimport graphql.schema.idl.SchemaGenerator;\r\nimport graphql.schema.idl.SchemaParser;\r\nimport graphql.schema.idl.TypeDefinitionRegistry;\r\n\r\nimportar javax.annotation.PostConstruct;\r\n\r\nimport static graphql.schema.idl.RuntimeWiring.newRuntimeWiring;\r\n\r\nimport java.io.File;\r\nimport java.nio.file.Files;\r\nimport java.nio.file.Paths;\r\nimport java.util.HashMap;\r\nimport java.util.Map;\r\n\r\n@SpringBootApplication\r\n@RestController\r\npublic class GraphqlApplication {\r\n\r\n\tpublic static void main(String[] args) {\r\n\t\tSpringApplication.run(GraphqlApplication.class, args);\r\n\t}\r\n\r\n\t@RequestMapping(value=\"\/\", method= RequestMethod.GET)\r\n\tpublic Object rootEndpoint() {\r\n        Map response = new HashMap();\r\n        response.put(\"mensaje\", \"Hola Mundo\");\r\n        return respuesta;\r\n\t}\r\n\r\n    @RequestMapping(value=\"\/graphql\", method= RequestMethod.POST)\r\n    public Object graphql(@RequestBody String request) {\r\n        JsonObject jsonRequest = JsonObject.fromJson(request);\r\n        return jsonRequest;\r\n    }\r\n}<\/pre>\n
Recuerde que su paquete y nombre de clase pueden no coincidir con los m\u00edos. Rellene los huecos donde corresponda.<\/p>\n
Usted notar\u00e1 que tenemos dos puntos finales, donde uno es completamente opcional. He creado el rootEndpoint<\/code> para comprobar que mi API RESTful funcionaba. El sitio graphql<\/code> es donde vamos a pasar nuestro tiempo. Espera una petici\u00f3n POST as\u00ed como un cuerpo de petici\u00f3n. El cuerpo de la solicitud con el tiempo ser\u00e1 una consulta GraphQL real, pero por ahora podemos dejarlo como est\u00e1.<\/p>\n
Dise\u00f1o de un documento de esquema GraphQL<\/h2>\n
Hasta ahora s\u00f3lo hemos hecho un trabajo b\u00e1sico de preparaci\u00f3n de Spring Boot y nada realmente relacionado con GraphQL. Para que GraphQL sea posible, necesitamos conocer un esquema definido que explique las consultas que est\u00e1n disponibles as\u00ed como los tipos de datos con los que estamos trabajando. Hay numerosas maneras de hacer esto, pero vamos a centrarnos en un documento de esquema.<\/p>\n
Dentro del recursos<\/strong> de su proyecto, incluya un archivo\u00a0esquema.graphql<\/strong> que contiene lo siguiente:<\/p>\n
tipo Query{\r\n    pokemons [Pokemon]\r\n    juegos: [Juego]\r\n    juego(id: String): Juego\r\n}\r\ntype Juego {\r\n    id: Cadena\r\n    nombre: Cadena\r\n}\r\ntype Pokemon {\r\n    id: Cadena\r\n    juego: Juego\r\n    nombre: String\r\n    altura: Int\r\n    peso: Int\r\n}<\/pre>\n
Por si no es obvio, vamos a trabajar con datos de Pokemon. En el archivo anterior hemos definido las consultas que est\u00e1n disponibles y los dos tipos de datos que est\u00e1n disponibles.<\/p>\n
Hay una gran variedad de juegos Pokemon en el mercado y hay diferentes Pokemon en cada uno de los juegos, de ah\u00ed la relaci\u00f3n que hemos definido. Si eres un verdadero fan de Pokemon sabr\u00e1s que hay un poco m\u00e1s que esto, pero para este ejemplo es suficiente.<\/p>\n
Desarrollo de la l\u00f3gica de obtenci\u00f3n para la base de datos NoSQL Couchbase<\/h2>\n
Con el esquema definido, tenemos que idear la l\u00f3gica de base de datos que se ejecutar\u00e1 cuando se ejecute una consulta y esa l\u00f3gica de base de datos debe devolver resultados que coincidan con cada uno de los dos tipos de datos.<\/p>\n
Para hacer nuestra vida un poco m\u00e1s f\u00e1cil cuando se trata de mantenimiento del proyecto, vamos a crear un archivo separado para la gesti\u00f3n de la base de datos. Dentro de tu paquete, crea un archivo\u00a0Base de datos.java<\/strong> que contiene lo siguiente:<\/p>\n
paquete com.couchbase.graphql;\r\n\r\nimport com.couchbase.client.java.Bucket;\r\nimport com.couchbase.client.java.document.JsonDocument;\r\nimport com.couchbase.client.java.document.json.JsonObject;\r\nimport com.couchbase.client.java.query.N1qlQuery;\r\nimport com.couchbase.client.java.query.N1qlQueryResult;\r\nimport com.couchbase.client.java.query.N1qlQueryRow;\r\nimport graphql.schema.DataFetcher;\r\n\r\nimport java.util.ArrayList;\r\nimport java.util.HashMap;\r\nimport java.util.List\r\nimport java.util.Map;\r\n\r\npublic class Base de datos {\r\n\r\n    public static DataFetcher getPokemonData(Bucket bucket) { }\r\n\r\n    public static DataFetcher getGameData(Bucket bucket) { }\r\n\r\n    public static DataFetcher getGamesData(Bucket bucket) { }\r\n\r\n    private static List<Map> extractResultOrThrow(N1qlQueryResult result) { }\r\n\r\n}<\/pre>\n
En su mayor parte, el conjunto anterior de funciones debe parecer familiar porque los hemos definido de alguna manera para que coincida con lo que ten\u00edamos en nuestro archivo de esquema GraphQL.<\/p>\n
Antes de empezar a rellenar cada una de las funciones, hay que tener en cuenta algunas cosas:<\/p>\n
    \n
  1. El cubo se definir\u00e1 en nuestro archivo de proyecto principal poco despu\u00e9s de definir nuestra l\u00f3gica.<\/li>\n
  2. GraphQL espera un determinado tipo de respuesta, de ah\u00ed la etiqueta extractResultOrThrow<\/code> que hemos creado.<\/li>\n<\/ol>\n
    Dicho esto, empecemos por crear la funci\u00f3n envoltorio. El extractResultOrThrow<\/code> se utilizar\u00e1 s\u00f3lo en las consultas N1QL y tiene el siguiente aspecto:<\/p>\n
    private static List<Map> extractResultOrThrow(N1qlQueryResult result) {\r\n    List<Map> contenido = new ArrayList<Map>();\r\n    for (N1qlQueryRow fila : resultado) {\r\n        content.add(fila.valor().toMap());\r\n    }\r\n    return contenido;\r\n}<\/pre>\n
    B\u00e1sicamente, estamos recorriendo un conjunto de resultados de N1QL y creando un archivo Lista<\/code> de Mapa<\/code> de \u00e9l.<\/p>\n
    Suponiendo que tenemos los datos del juego en nuestra base de datos, podemos consultarlos en la funci\u00f3n getGamesData<\/code> funci\u00f3n:<\/p>\n
    public static DataFetcher getGamesData(Bucket bucket) {\r\n    return entorno -> {\r\n        System.out.println(\"OBTENIENDO DATOS DE JUEGOS...\");\r\n        String statement = \"SELECT ejemplo.* \"\r\n                + \"FROM ejemplo \"\r\n                + \"WHERE type = 'game'\";\r\n        N1qlQueryResult queryResult = bucket.query(N1qlQuery.simple(statement));\r\n        return extractResultOrThrow(queryResult);\r\n    };\r\n}<\/pre>\n
    Con N1QL podemos buscar documentos que coincidan con los criterios tipo<\/code> de juego<\/code> y procesar los resultados con nuestra funci\u00f3n envoltorio. Si realmente quieres ser estricto, en lugar de utilizar un asterisco comod\u00edn, podr\u00edas definir las propiedades que coincidan con tu esquema.<\/p>\n
    La siguiente funci\u00f3n, getPokemonData<\/code>nos permitir\u00e1 consultar nuestros datos Pokemon de forma similar a como lo hicimos con los datos de los juegos.<\/p>\n
    public static DataFetcher getPokemonData(Bucket bucket) {\r\n    return entorno -> {\r\n        System.out.println(\"OBTENIENDO DATOS POKEMON...\");\r\n        String statement = \"SELECT ejemplo.* \"\r\n                         + \"FROM ejemplo \"\r\n                         + \"WHERE type = 'pokemon'\";\r\n        N1qlQueryResult queryResult = bucket.query(N1qlQuery.simple(statement));\r\n        return extractResultOrThrow(queryResult);\r\n    };\r\n}<\/pre>\n
    Observar\u00e1 que no hemos hecho nada nuevo m\u00e1s all\u00e1 de cambiar el tipo<\/code> propiedad. Aqu\u00ed es donde las cosas pueden ponerse interesantes. Tenemos una relaci\u00f3n de datos para Pokemon con respecto a los datos del juego. Podr\u00edamos recuperarla en nuestra consulta actual o dividirla para que sea m\u00e1s modular y potencialmente m\u00e1s ligera. Vamos a optar por la opci\u00f3n modular y ligera.<\/p>\n
    Esto nos lleva a nuestro getGameData<\/code> funci\u00f3n:<\/p>\n
    public static DataFetcher getGameData(Bucket bucket) {\r\n    return entorno -> {\r\n        HashMap parent = environment.getSource();\r\n        documento JsonDocument;\r\n        if(parent != null) {\r\n            System.out.println(\"BUSCANDO DATOS DEL JUEGO PARA \" + (String)parent.get(\"juego\") + \"...\");\r\n            document = bucket.get((String) parent.get(\"juego\"));\r\n        } else {\r\n            System.out.println(\"FETCHING GAME DATA FOR \" + (String)environment.getArgument(\"id\") + \"...\");\r\n            document = bucket.get((String)environment.getArgument(\"id\"));\r\n        }\r\n        return document.content().toMap();\r\n    };\r\n}<\/pre>\n
    En la funci\u00f3n anterior ocurren dos cosas, ninguna de las cuales utiliza N1QL.<\/p>\n
    En nuestro esquema hemos definido una consulta basada en argumentos para los datos del juego, as\u00ed como una relaci\u00f3n de datos en los datos de Pokemon. Vamos a acomodar ambos escenarios en la misma funci\u00f3n.<\/p>\n
    Utilizaci\u00f3n de la environment.getSource()<\/code> podemos ver si hay alg\u00fan dato padre que acompa\u00f1e a la petici\u00f3n. Un ejemplo de estos datos padre podr\u00eda ser cuando consultamos datos de Pokemon. El juego<\/code> se refiere al campo getGameData<\/code> mientras que los dem\u00e1s datos, como el nombre, el peso u otros, se refieren a los datos principales. En la base de datos, la informaci\u00f3n del juego se almacena como un id, por lo que despu\u00e9s de extraerlo de los datos de los padres, podemos hacer una b\u00fasqueda de datos del juego.<\/p>\n
    El otro escenario es si pasamos un argumento que representa un id de juego.<\/p>\n
    Ambos son v\u00e1lidos y ambos hacen cosas diferentes. Al final, s\u00f3lo queremos un \u00fanico resultado en lugar de una matriz de resultados.<\/p>\n
    Cableado de la aplicaci\u00f3n para un procesamiento GraphQL satisfactorio<\/h2>\n
    Estamos en la recta final. Tenemos nuestra API y nuestra l\u00f3gica de base de datos en su lugar. El \u00faltimo paso es conectar el esquema GraphQL a la l\u00f3gica de la base de datos y ver los resultados en todo su esplendor.<\/p>\n
    \u00bfRecuerdas que en el paso anterior mencion\u00e9 la configuraci\u00f3n de la informaci\u00f3n de nuestro cubo? Vamos a ocuparnos de eso primero. Abra el proyecto\u00a0aplicaci\u00f3n.propiedades<\/strong> que se encuentra en el archivo\u00a0recursos<\/strong> directorio. Incluya lo siguiente:<\/p>\n
    hostname=127.0.0.1\r\nbucket=ejemplo\r\nnombre de usuario=ejemplo\r\ncontrase\u00f1a=123456<\/pre>\n
    La informaci\u00f3n de mi base de datos es s\u00f3lo un ejemplo. Aseg\u00farese de reemplazarla con la informaci\u00f3n que est\u00e1 utilizando para su instancia de Couchbase.<\/p>\n
    De vuelta en el archivo principal del proyecto, podemos asignar los valores y conectarnos a nuestra instancia:<\/p>\n
    paquete com.couchbase.graphql;\r\n\r\nimport com.couchbase.client.java.Bucket;\r\nimport com.couchbase.client.java.Cluster;\r\nimport com.couchbase.client.java.CouchbaseCluster;\r\nimport com.couchbase.client.java.document.json.JsonObject;\r\nimport graphql.schema.DataFetcher;\r\nimport org.springframework.beans.factory.annotation.Autowired;\r\nimport org.springframework.beans.factory.annotation.Value;\r\nimport org.springframework.boot.SpringApplication;\r\nimport org.springframework.boot.autoconfigure.SpringBootApplication;\r\nimport org.springframework.context.annotation.Bean;\r\nimport org.springframework.http.HttpStatus;\r\nimport org.springframework.http.ResponseEntity;\r\nimport org.springframework.web.bind.annotation.RequestBody;\r\nimport org.springframework.web.bind.annotation.RequestMapping;\r\nimport org.springframework.web.bind.annotation.RequestMethod;\r\nimport org.springframework.web.bind.annotation.RestController;\r\nimport graphql.ExecutionInput;\r\nimport graphql.ExecutionResult;\r\nimport graphql.GraphQL;\r\nimport graphql.schema.GraphQLSchema;\r\nimport graphql.schema.StaticDataFetcher;\r\nimport graphql.schema.idl.RuntimeWiring;\r\nimport graphql.schema.idl.SchemaGenerator;\r\nimport graphql.schema.idl.SchemaParser;\r\nimport graphql.schema.idl.TypeDefinitionRegistry;\r\n\r\nimportar javax.annotation.PostConstruct;\r\n\r\nimport static graphql.schema.idl.RuntimeWiring.newRuntimeWiring;\r\n\r\nimport java.io.File;\r\nimport java.nio.file.Files;\r\nimport java.nio.file.Paths;\r\nimport java.util.HashMap;\r\nimport java.util.Map;\r\n\r\n@SpringBootApplication\r\n@RestController\r\npublic class GraphqlApplication {\r\n\r\n    @Value(\"${nombre de host}\")\r\n    private String hostname;\r\n\r\n    @Valor(\"${cubo}\")\r\n    private String bucket;\r\n\r\n    @Valor(\"${nombredeusuario}\")\r\n    private String nombredeusuario;\r\n\r\n    @Valor(\"${contrase\u00f1a}\")\r\n    private String contrase\u00f1a;\r\n\r\n    public @Bean\r\n    Cluster cluster() {\r\n        Cluster cluster = CouchbaseCluster.create(this.hostname);\r\n        cluster.authenticate(this.username, this.password);\r\n        return cluster;\r\n    }\r\n\r\n    public @Bean\r\n    Bucket bucket() {\r\n        return cluster().openBucket(this.bucket);\r\n    }\r\n\r\n    private GraphQL build;\r\n\r\n\tpublic static void main(String[] args) {\r\n\t\tSpringApplication.run(GraphqlApplication.class, args);\r\n\t}\r\n\r\n\t@RequestMapping(value=\"\/\", method= RequestMethod.GET)\r\n\tpublic Object rootEndpoint() { }\r\n\r\n    @RequestMapping(value=\"\/graphql\", method= RequestMethod.POST)\r\n    public Object graphql(@RequestBody String request) { }\r\n}<\/pre>\n
    Observa que hemos creado dos Jud\u00eda<\/code> y usamos la informaci\u00f3n de nuestro archivo de propiedades. As\u00ed de f\u00e1cil estamos conectados a Couchbase.<\/p>\n
    El siguiente paso es inicializar nuestro esquema GraphQL. Hay numerosas maneras de hacer esto, pero me pareci\u00f3 m\u00e1s f\u00e1cil usando la anotaci\u00f3n de Spring Boot para cuando se inicia la aplicaci\u00f3n:<\/p>\n
    @PostConstruir()\r\npublic void init() {\r\n    ClassLoader classLoader = getClass().getClassLoader();\r\n    File schemaFile = new File(classLoader.getResource(\"schema.graphql\").getFile());\r\n    SchemaParser schemaParser = new SchemaParser();\r\n    TypeDefinitionRegistry typeDefinitionRegistry = schemaParser.parse(schemaFile);\r\n    RuntimeWiring runtimeWiring = RuntimeWiring.newRuntimeWiring()\r\n            .type(\"Query\",typeWiring -> typeWiring\r\n                    .dataFetcher(\"pokemons\",Database.getPokemonData(bucket()))\r\n            )\r\n            .type(\"Query\",typeWiring -> typeWiring\r\n                    .dataFetcher(\"juegos\",Database.getGamesData(bucket()))\r\n            )\r\n            .type(\"Query\",typeWiring -> typeWiring\r\n                    .dataFetcher(\"juego\",Database.getGameData(bucket()))\r\n            )\r\n            .type(\"Pokemon\",typeWiring -> typeWiring\r\n                    .dataFetcher(\"juego\",Database.getGameData(bucket()))\r\n            ).build();\r\n\r\n    SchemaGenerator schemaGenerator = new SchemaGenerator();\r\n    GraphQLSchema graphQLSchema = schemaGenerator.makeExecutableSchema(typeDefinitionRegistry, runtimeWiring);\r\n    this.build = GraphQL.newGraphQL(graphQLSchema).build();\r\n}<\/pre>\n
    En init<\/code> ser\u00e1 llamada cuando se inicie la aplicaci\u00f3n. Cargar\u00e1 nuestro archivo de esquema desde el directorio\u00a0recursos<\/strong> y definir el cableado. Por ejemplo, sabemos que pokemons<\/code>, juegos<\/code>y game(id: cadena)<\/code> son todos tipos de consultas. Cada una se mapea a la funci\u00f3n apropiada de la base de datos y se pasa el cubo abierto. Entonces establecemos un mapeo de juego<\/code> a la Pokemon<\/code> tipo. Estamos definiendo m\u00e1s o menos c\u00f3mo se vinculan los campos y las consultas a la interacci\u00f3n con la base de datos.<\/p>\n
    Una vez construido el esquema podemos vincularlo a nuestra variable de clase. Con el esquema construido, podemos finalizar nuestro punto final GraphQL RESTful:<\/p>\n
    @RequestMapping(value=\"\/graphql\", method= RequestMethod.POST)\r\npublic Object graphql(@RequestBody String request) {\r\n    JsonObject jsonRequest = JsonObject.fromJson(request);\r\n    ExecutionInput executionInput = ExecutionInput.newExecutionInput().query(jsonRequest.getString(\"query\")).build();\r\n    ExecutionResult executionResult = this.build.execute(executionInput);\r\n    return executionResult.toSpecification();\r\n}<\/pre>\n
    En nuestro endpoint tomamos la cadena de consulta que se pas\u00f3 con la petici\u00f3n y la ejecutamos con nuestro esquema construido. El resultado ser\u00e1 lo que el cliente haya solicitado en la consulta.<\/p>\n
    \u00bfQu\u00e9 aspecto tiene una consulta? Tomemos el siguiente ejemplo:<\/p>\n
    {\r\n  pokemons {\r\n    nombre\r\n    peso\r\n    juego {\r\n      nombre\r\n    }\r\n  }\r\n  juegos {\r\n    nombre\r\n  }\r\n  juego(id: \"juego-2\") {\r\n    nombre\r\n  }\r\n}<\/pre>\n
    La consulta anterior probablemente no sea algo que nadie necesite ejecutar nunca, pero podr\u00edas hacerlo si quisieras. En el ejemplo anterior estamos consultando todos los datos de Pokemon y el juego del que forman parte. Tambi\u00e9n estamos consultando todos los juegos, as\u00ed como un juego espec\u00edfico. Las tres partes de la consulta no est\u00e1n relacionadas, pero existen en la misma consulta.<\/p>\n
    Como dato curioso, en el pokemons<\/code> si elegimos no consultar los datos del juego, la funci\u00f3n de la base de datos nunca ser\u00e1 llamada. GraphQL s\u00f3lo ejecutar\u00e1 las funciones cuando sean necesarias.<\/p>\n
    Conclusi\u00f3n<\/h2>\n
    Acabas de ver c\u00f3mo construir una aplicaci\u00f3n GraphQL usando Spring Boot, Java y Couchbase Server como base de datos NoSQL. Como has visto en mi consulta de ejemplo, hemos sido capaces de consultar muchas piezas diferentes de datos no relacionados en una sola solicitud, algo que habr\u00eda requerido varias en una API RESTful.<\/p>\n
    Para obtener m\u00e1s informaci\u00f3n sobre el uso del SDK de Java con Couchbase, consulte la p\u00e1gina Portal para desarrolladores de Couchbase<\/a>.<\/p>","protected":false},"excerpt":{"rendered":"
    Over the span of the past few months I’ve been learning about GraphQL and how to use it as an alternative to RESTful API development. The focus thus far had been around GraphQL and Golang as well as GraphQL and […]<\/p>","protected":false},"author":63,"featured_media":5529,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[1814,1816,1818,1812],"tags":[1393,2210],"ppma_author":[9032],"class_list":["post-5528","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-application-design","category-couchbase-server","category-java","category-n1ql-query","tag-api","tag-graphql"],"acf":[],"yoast_head":"\nGraphQL Queries: Convert + Build w\/ Java, Spring Boot, NoSQL<\/title>\n<meta name=\"description\" content=\"In this Couchbase tutorial, we\u2019re going to see how to quickly get up and running with GraphQL queries using Java, Spring Boot, and NoSQL frameworks.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.couchbase.com\/blog\/es\/processing-graphql-queries-with-java-spring-boot-and-nosql\/\" \/>\n<meta property=\"og:locale\" content=\"es_MX\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Processing GraphQL Queries with Java, Spring Boot, and NoSQL\" \/>\n<meta property=\"og:description\" content=\"In this Couchbase tutorial, we\u2019re going to see how to quickly get up and running with GraphQL queries using Java, Spring Boot, and NoSQL frameworks.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.couchbase.com\/blog\/es\/processing-graphql-queries-with-java-spring-boot-and-nosql\/\" \/>\n<meta property=\"og:site_name\" content=\"The Couchbase Blog\" \/>\n<meta property=\"article:author\" content=\"https:\/\/www.facebook.com\/thepolyglotdeveloper\" \/>\n<meta property=\"article:published_time\" content=\"2018-07-26T14:00:06+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-09-11T07:09:32+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/2018\/07\/coffee-1580595_1920.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1920\" \/>\n\t<meta property=\"og:image:height\" content=\"1024\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Nic Raboy, Developer Advocate, Couchbase\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@nraboy\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Nic Raboy, Developer Advocate, Couchbase\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"8 minutos\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/\"},\"author\":{\"name\":\"Nic Raboy, Developer Advocate, Couchbase\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/#\/schema\/person\/bb545ebe83bb2d12f91095811d0a72e1\"},\"headline\":\"Processing GraphQL Queries with Java, Spring Boot, and NoSQL\",\"datePublished\":\"2018-07-26T14:00:06+00:00\",\"dateModified\":\"2023-09-11T07:09:32+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/\"},\"wordCount\":1690,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/#organization\"},\"image\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2018\/07\/coffee-1580595_1920.jpg\",\"keywords\":[\"API\",\"graphql\"],\"articleSection\":[\"Application Design\",\"Couchbase Server\",\"Java\",\"SQL++ \/ N1QL Query\"],\"inLanguage\":\"es\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/\",\"url\":\"https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/\",\"name\":\"GraphQL Queries: Convert + Build w\/ Java, Spring Boot, NoSQL\",\"isPartOf\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2018\/07\/coffee-1580595_1920.jpg\",\"datePublished\":\"2018-07-26T14:00:06+00:00\",\"dateModified\":\"2023-09-11T07:09:32+00:00\",\"description\":\"In this Couchbase tutorial, we\u2019re going to see how to quickly get up and running with GraphQL queries using Java, Spring Boot, and NoSQL frameworks.\",\"breadcrumb\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/#breadcrumb\"},\"inLanguage\":\"es\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"es\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/#primaryimage\",\"url\":\"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2018\/07\/coffee-1580595_1920.jpg\",\"contentUrl\":\"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2018\/07\/coffee-1580595_1920.jpg\",\"width\":1920,\"height\":1024},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/www.couchbase.com\/blog\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Processing GraphQL Queries with Java, Spring Boot, and NoSQL\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/#website\",\"url\":\"https:\/\/www.couchbase.com\/blog\/\",\"name\":\"The Couchbase Blog\",\"description\":\"Couchbase, the NoSQL Database\",\"publisher\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/www.couchbase.com\/blog\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"es\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/#organization\",\"name\":\"The Couchbase Blog\",\"url\":\"https:\/\/www.couchbase.com\/blog\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"es\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/2023\/04\/admin-logo.png\",\"contentUrl\":\"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/2023\/04\/admin-logo.png\",\"width\":218,\"height\":34,\"caption\":\"The Couchbase Blog\"},\"image\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/#\/schema\/logo\/image\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/#\/schema\/person\/bb545ebe83bb2d12f91095811d0a72e1\",\"name\":\"Nic Raboy, Developer Advocate, Couchbase\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"es\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/#\/schema\/person\/image\/8863514d8bed0cf6080f23db40e00354\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/bedeb68368d4681aca4c74fe5f697f0c423b80d498ec50fd915ba018b72c101f?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/bedeb68368d4681aca4c74fe5f697f0c423b80d498ec50fd915ba018b72c101f?s=96&d=mm&r=g\",\"caption\":\"Nic Raboy, Developer Advocate, Couchbase\"},\"description\":\"Nic Raboy is an advocate of modern web and mobile development technologies. He has experience in Java, JavaScript, Golang and a variety of frameworks such as Angular, NativeScript, and Apache Cordova. Nic writes about his development experiences related to making web and mobile development easier to understand.\",\"sameAs\":[\"https:\/\/www.thepolyglotdeveloper.com\",\"https:\/\/www.facebook.com\/thepolyglotdeveloper\",\"https:\/\/x.com\/nraboy\"],\"url\":\"https:\/\/www.couchbase.com\/blog\/es\/author\/nic-raboy-2\/\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"GraphQL Queries: Convert + Build w\/ Java, Spring Boot, NoSQL","description":"En este tutorial de Couchbase, vamos a ver c\u00f3mo poner r\u00e1pidamente en marcha consultas GraphQL usando Java, Spring Boot y frameworks NoSQL.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.couchbase.com\/blog\/es\/processing-graphql-queries-with-java-spring-boot-and-nosql\/","og_locale":"es_MX","og_type":"article","og_title":"Processing GraphQL Queries with Java, Spring Boot, and NoSQL","og_description":"In this Couchbase tutorial, we\u2019re going to see how to quickly get up and running with GraphQL queries using Java, Spring Boot, and NoSQL frameworks.","og_url":"https:\/\/www.couchbase.com\/blog\/es\/processing-graphql-queries-with-java-spring-boot-and-nosql\/","og_site_name":"The Couchbase Blog","article_author":"https:\/\/www.facebook.com\/thepolyglotdeveloper","article_published_time":"2018-07-26T14:00:06+00:00","article_modified_time":"2023-09-11T07:09:32+00:00","og_image":[{"width":1920,"height":1024,"url":"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/2018\/07\/coffee-1580595_1920.jpg","type":"image\/jpeg"}],"author":"Nic Raboy, Developer Advocate, Couchbase","twitter_card":"summary_large_image","twitter_creator":"@nraboy","twitter_misc":{"Written by":"Nic Raboy, Developer Advocate, Couchbase","Est. reading time":"8 minutos"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/#article","isPartOf":{"@id":"https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/"},"author":{"name":"Nic Raboy, Developer Advocate, Couchbase","@id":"https:\/\/www.couchbase.com\/blog\/#\/schema\/person\/bb545ebe83bb2d12f91095811d0a72e1"},"headline":"Processing GraphQL Queries with Java, Spring Boot, and NoSQL","datePublished":"2018-07-26T14:00:06+00:00","dateModified":"2023-09-11T07:09:32+00:00","mainEntityOfPage":{"@id":"https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/"},"wordCount":1690,"commentCount":0,"publisher":{"@id":"https:\/\/www.couchbase.com\/blog\/#organization"},"image":{"@id":"https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/#primaryimage"},"thumbnailUrl":"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2018\/07\/coffee-1580595_1920.jpg","keywords":["API","graphql"],"articleSection":["Application Design","Couchbase Server","Java","SQL++ \/ N1QL Query"],"inLanguage":"es","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/","url":"https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/","name":"GraphQL Queries: Convert + Build w\/ Java, Spring Boot, NoSQL","isPartOf":{"@id":"https:\/\/www.couchbase.com\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/#primaryimage"},"image":{"@id":"https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/#primaryimage"},"thumbnailUrl":"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2018\/07\/coffee-1580595_1920.jpg","datePublished":"2018-07-26T14:00:06+00:00","dateModified":"2023-09-11T07:09:32+00:00","description":"En este tutorial de Couchbase, vamos a ver c\u00f3mo poner r\u00e1pidamente en marcha consultas GraphQL usando Java, Spring Boot y frameworks NoSQL.","breadcrumb":{"@id":"https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/#breadcrumb"},"inLanguage":"es","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/"]}]},{"@type":"ImageObject","inLanguage":"es","@id":"https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/#primaryimage","url":"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2018\/07\/coffee-1580595_1920.jpg","contentUrl":"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2018\/07\/coffee-1580595_1920.jpg","width":1920,"height":1024},{"@type":"BreadcrumbList","@id":"https:\/\/www.couchbase.com\/blog\/processing-graphql-queries-with-java-spring-boot-and-nosql\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.couchbase.com\/blog\/"},{"@type":"ListItem","position":2,"name":"Processing GraphQL Queries with Java, Spring Boot, and NoSQL"}]},{"@type":"WebSite","@id":"https:\/\/www.couchbase.com\/blog\/#website","url":"https:\/\/www.couchbase.com\/blog\/","name":"El blog de Couchbase","description":"Couchbase, la base de datos NoSQL","publisher":{"@id":"https:\/\/www.couchbase.com\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.couchbase.com\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"es"},{"@type":"Organization","@id":"https:\/\/www.couchbase.com\/blog\/#organization","name":"El blog de Couchbase","url":"https:\/\/www.couchbase.com\/blog\/","logo":{"@type":"ImageObject","inLanguage":"es","@id":"https:\/\/www.couchbase.com\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/2023\/04\/admin-logo.png","contentUrl":"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/2023\/04\/admin-logo.png","width":218,"height":34,"caption":"The Couchbase Blog"},"image":{"@id":"https:\/\/www.couchbase.com\/blog\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/www.couchbase.com\/blog\/#\/schema\/person\/bb545ebe83bb2d12f91095811d0a72e1","name":"Nic Raboy, Defensor del Desarrollador, Couchbase","image":{"@type":"ImageObject","inLanguage":"es","@id":"https:\/\/www.couchbase.com\/blog\/#\/schema\/person\/image\/8863514d8bed0cf6080f23db40e00354","url":"https:\/\/secure.gravatar.com\/avatar\/bedeb68368d4681aca4c74fe5f697f0c423b80d498ec50fd915ba018b72c101f?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/bedeb68368d4681aca4c74fe5f697f0c423b80d498ec50fd915ba018b72c101f?s=96&d=mm&r=g","caption":"Nic Raboy, Developer Advocate, Couchbase"},"description":"Nic Raboy es un defensor de las tecnolog\u00edas modernas de desarrollo web y m\u00f3vil. Tiene experiencia en Java, JavaScript, Golang y una variedad de frameworks como Angular, NativeScript y Apache Cordova. Nic escribe sobre sus experiencias de desarrollo relacionadas con hacer el desarrollo web y m\u00f3vil m\u00e1s f\u00e1cil de entender.","sameAs":["https:\/\/www.thepolyglotdeveloper.com","https:\/\/www.facebook.com\/thepolyglotdeveloper","https:\/\/x.com\/nraboy"],"url":"https:\/\/www.couchbase.com\/blog\/es\/author\/nic-raboy-2\/"}]}},"authors":[{"term_id":9032,"user_id":63,"is_guest":0,"slug":"nic-raboy-2","display_name":"Nic Raboy, Developer Advocate, Couchbase","avatar_url":"https:\/\/secure.gravatar.com\/avatar\/bedeb68368d4681aca4c74fe5f697f0c423b80d498ec50fd915ba018b72c101f?s=96&d=mm&r=g","author_category":"","last_name":"Raboy","first_name":"Nic","job_title":"","user_url":"https:\/\/www.thepolyglotdeveloper.com","description":"Nic Raboy es un defensor de las tecnolog\u00edas modernas de desarrollo web y m\u00f3vil. Tiene experiencia en Java, JavaScript, Golang y una variedad de frameworks como Angular, NativeScript y Apache Cordova. Nic escribe sobre sus experiencias de desarrollo relacionadas con hacer el desarrollo web y m\u00f3vil m\u00e1s f\u00e1cil de entender."}],"_links":{"self":[{"href":"https:\/\/www.couchbase.com\/blog\/es\/wp-json\/wp\/v2\/posts\/5528","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.couchbase.com\/blog\/es\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.couchbase.com\/blog\/es\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.couchbase.com\/blog\/es\/wp-json\/wp\/v2\/users\/63"}],"replies":[{"embeddable":true,"href":"https:\/\/www.couchbase.com\/blog\/es\/wp-json\/wp\/v2\/comments?post=5528"}],"version-history":[{"count":0,"href":"https:\/\/www.couchbase.com\/blog\/es\/wp-json\/wp\/v2\/posts\/5528\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.couchbase.com\/blog\/es\/wp-json\/wp\/v2\/media\/5529"}],"wp:attachment":[{"href":"https:\/\/www.couchbase.com\/blog\/es\/wp-json\/wp\/v2\/media?parent=5528"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.couchbase.com\/blog\/es\/wp-json\/wp\/v2\/categories?post=5528"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.couchbase.com\/blog\/es\/wp-json\/wp\/v2\/tags?post=5528"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.couchbase.com\/blog\/es\/wp-json\/wp\/v2\/ppma_author?post=5528"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}