Las bases de datos y los cachés van de la mano y han estado en estrecha asociación durante mucho tiempo. Los cachés como nivel medio reducen la presión sobre sus bases de datos al mantener sus datos en el caché para un procesamiento más rápido. NCache es una solución de almacenamiento en caché distribuido en memoria para sus aplicaciones .NET y Java. Durante años, NCache ha estado proporcionando alto rendimiento y escalabilidad al reducir la carga en las bases de datos. También garantiza un tiempo de respuesta más rápido para sus aplicaciones de misión crítica.
JSON ha sido uno de los formatos de intercambio de datos más famosos entre las aplicaciones modernas. Es un lenguaje independiente de la plataforma, liviano y muy legible y comprensible debido a su naturaleza modelada. Es extremadamente rápido y puede ser utilizado por lenguajes de programación modernos y es compatible con todos los principales marcos de JavaScript.
Hablar de las dos cosas mencionadas anteriormente por separado nos lleva a nuestro tema de discusión aquí, que es el soporte de JSON en NCache. NCache al ser extremadamente escalable y distribuido, admite el almacenamiento de datos JSON en la memoria caché junto con la serialización JSON de sus datos. Puede almacenar un documento JSON en la memoria caché para una manipulación rápida y sencilla. NCache proporciona sus propias clases para el almacenamiento de datos JSON, derivadas de una clase abstracta JsonValueBase basada en sus propiedades. Estas clases son:
- ValorJson
- JsonObjeto
- jsonmatriz
- JsonNulo
NCache Detalles Operaciones de caché en NCache
Ejemplo rápido de JSON entre .NET y Java
Para empezar, veamos un ejemplo rápido que muestra el uso de datos JSON en NCache. Puede agregar un documento JSON en su caché utilizando una aplicación .NET y una aplicación Java puede recuperar estos datos, ya que JSON es independiente de la plataforma.
El ejemplo que se muestra a continuación muestra la adición de un documento JSON en su caché como un JsonObject usando .NET.
1 2 3 4 5 6 7 8 9 10 |
// Pre-Condition: Cache is JSON serialized // The data provided in the string is a jsonObject string jsonString = "{ 'ProductID' : 1001, 'ProductName' : 'Chai', 'Category': 'Beverages', 'UnitPrice' : 500, 'UnitsInStock' : 2000 }"; // Populate an instance of the JsonObject by passing the string var jsonProduct = new JsonObject(jsonString); // Insert the jsonObject in the cache with a key string key = “Product:ProductID:1001”; cache.Insert(key, jsonProduct); |
El documento JSON agregado anteriormente se puede recuperar usando una aplicación Java. El código que se proporciona a continuación muestra la recuperación de los mismos documentos JSON a través de Java. Además, elimina los atributos del JsonObject y luego vuelve a insertar el JsonObject en el caché.
1 2 3 4 5 6 7 |
JsonObject jsonProduct = cache.get(key, JsonObject.class); // Remove the attribute UnitPrice from the JsonObject boolean result = jsonProduct2.removeAttribute("UnitPrice"); // Re-insert the item in the cache with the removed attribute cache.insert(key, jsonProduct); |
Soporte JSON en NCache
NCache es la solución principal de almacenamiento en caché que permite agregar datos personalizados en su caché y recuperarlos en formato JSON. De manera similar, puede agregar datos JSON en caché y recuperarlos como un objeto de datos personalizado.
Como se mencionó anteriormente, NCache proporciona sus propias clases derivadas de JsonValueBase y estas clases luego se usan para agregar diferentes formatos de datos JSON en el caché. Echaremos un vistazo más de cerca a estas clases una por una:
1. ValorJson
ValorJson representa los tipos de datos primitivos en las convenciones de JSON. Puede agregar valor de cualquier tipo primitivo, incluidos otros como cadena, fecha y hora o decimal en .NET como JsonValue en la memoria caché.
1 2 3 4 5 |
string keyInt = $"Product:{product.ProductID}"; JsonValue jsonValue = 1001; // Insert a JsonValue in the cache with the key cache.Insert(keyInt,jsonValue); |
2. ObjetoJson
JsonObjeto es un contenedor para pares de nombre/valor no ordenados donde el nombre o la clave es el nombre del atributo y el valor puede ser cualquiera de los tipos de datos primitivos. Puede analizar una cadena completa que contenga los datos JSON y completar un JsonObject a partir de ella. De manera similar, un objeto personalizado también se puede recuperar como un JsonObject y viceversa. El siguiente ejemplo muestra la creación de un JsonObject con atributos y sus valores y luego lo agrega al caché. Luego muestra más operaciones en JsonObject, como eliminar un atributo en particular.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
string key = "jsonKey"; // Create a new JsonObject with the attributes and insert in the cache JsonObject jsonProduct = new JsonObject(); jsonProduct.AddAttribute("ProductID", 1001); jsonProduct.AddAttribute("ProductName", (JsonValue)"Chai"); cache.Insert(key, jsonProduct); // Retrieve the jsonObject previously added the attribute from jsonObject var jsonProduct2 = cache.Get<JsonObject>(key); // Remove the attribute from jsonObject without changing the entire object bool result = jsonProduct2.RemoveAttribute("UnitPrice"); cache.Insert(key, jsonProduct2); |
3. MatrizJson
jsonmatriz es una colección de elementos y representa JArray en NCachedominio de . Al igual que JsonObject, puede especificar cualquier valor u objeto derivado de JsonValueBase. Puede agregar, recuperar o incluso eliminar valores de un JsonArray en cualquier índice especificado.
1 2 3 4 |
string jsonProductIds = " ['ProductIDs', { 'ProductID' : 1001 }, { 'ProductID' : 1002 }, { 'ProductID' : 1003 } ]"; // Create a JsonArray with from the JSON document provided var jsonArray = new JsonArray(jsonProductIds); |
4. Json Nulo
Esta clase representa un valor nulo en los estándares JSON. El ejemplo dado muestra un valor nulo para un atributo de JsonObject. Al recuperar más el atributo con el valor nulo, genera una excepción.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
// Create a new JsonObject with attributes and insert in the cache var jsonProduct = new JsonObject(); jsonProduct.AddAttribute("ProductID", product.ProductID); jsonProduct.AddAttribute("ProductName", (JsonValue)product.ProductName); jsonObject.AddAttribute("Category", null); cache.Insert(key, jsonProduct); // Retrieve the same jsonObject previously created var jsonProduct2 = cache.Get<JsonObject>(key); var productCategory = jsonObject.GetAttributeValue("Cateogry"); // Check if the attribute value is null if(category.DataType == Runtime.Enum.JsonDataType.Null) { // Throw category null Exception } |
NCache Detalles Caché de datos como documentos JSON Serialización JSON
Indexación de documentos JSON en NCache
Si su caché es una tienda JSON, puede indexar sus datos utilizando cualquiera de los siguientes:
- Grupos: Los elementos en un caché que tienen una relación entre ellos o que pertenecen a una categoría similar se pueden agrupar en NCache usando NCache Función "Grupos". Utilizando Grupos, puede particionar lógicamente sus datos para una mayor eficiencia.
- Etiquetas: Las etiquetas son identificadores basados en cadenas, asociados con sus datos. Utilizando Etiquetas, puede asociar palabras clave con sus elementos de caché que luego son útiles para realizar varias operaciones de caché en sus datos usando esas palabras clave.
- Etiquetas con nombre: Etiquetas con nombre es una característica proporcionada por NCache que es una forma mejorada de Etiquetas. Asocian información particular con los elementos en forma de par clave-valor en tiempo de ejecución.
Los documentos JSON se agregan en el caché con estos identificadores y NCache indexa los datos en función de estos identificadores. Posteriormente puede utilizar las consultas proporcionadas por NCache para realizar operaciones en él. El siguiente ejemplo muestra cómo agregar un documento JSON en el caché con etiquetas con nombre asociadas.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
string jsonString = "{'ProductID' : 1001, 'ProductName' : 'Chai', 'Category': 'Beverages', 'UnitPrice' : 500, 'UnitsInStock' : 2000 }"; // Populate an instance of the JsonObject by passing the string var jsonProduct = new JsonObject(jsonString); string key = $"Products:{product.ProductID}"; var item = new CacheItem(jsonProduct); var productNamedTag = new NamedTagsDictionary(); // Add NamedTag 'Discount' to the dictionary with the value productNamedTag.Add("Discount", 0.5); item.NamedTags = productNamedTag; // Add CacheItem with the NamedTag associated cache.Insert(key, item); |
Búsqueda de documentos JSON con SQL en NCache
NCache proporciona consultas similares a SQL para recuperar datos y eliminarlos. Puede utilizar consultas sobre los datos indexados para obtener los datos JSON en cualquiera de los formatos proporcionados por NCache.
El ejemplo dado muestra la consulta de los datos indexados en el ejemplo anterior, que es un documento JSON agregado con etiquetas con nombre. La consulta recupera todos los JsonObjects de la memoria caché con el valor de descuento de 0.5.
1 2 3 4 5 6 7 |
// Create a query for fetching item with NamedTag string query = "Select * FROM Alachisoft.NCache.Runtime.JSON.JsonArray WHERE Discount = ?"; QueryCommand queryCommand = new QueryCommand(query); queryCommand.Parameters.Add("Discount", 0.5); var queryResult = cache.SearchService.ExecuteReader(queryCommand); // QueryResult contains all the keys and metadata of result |
Documentos JSON persistentes
NCache tiene una serie de características del lado del servidor para realizar operaciones directas en su fuente de datos maestra. Estas funciones brindan la flexibilidad de leer o escribir datos desde y hacia la fuente de datos maestra, así como también precargar los datos en la memoria caché. Una de estas funciones denominada Fuente de respaldo le proporciona la facilidad de:
- Leer de parte a parte: Leer de parte a parte obtiene datos de la fuente de datos en caso de que no esté presente en el almacén de caché.
- Escriba por medio de:Escriba por medio de actualiza la fuente de datos (cualquier operación de escritura) después de actualizar el almacenamiento en caché.
NCache llama a un proveedor escrito por usted, con su lógica personalizada para cargar datos desde la fuente de datos maestra o escribir datos en su fuente de datos maestra. Los proveedores son entonces desplegado usando NCache Web Manager para usar lectura simultánea/escritura simultánea.
Para las fuentes de datos maestras basadas en JSON, como Cosmos DB, existe un beneficio adicional de usar datos JSON en la memoria caché. A diferencia de .NET, para JSON puede escribir un proveedor genérico para todas sus aplicaciones en JSON que se implementará en su caché para cargar datos directamente desde la base de datos. Puede lograr una mayor persistencia utilizando estos proveedores genéricos, ya que JSON es independiente de la plataforma. .NET requiere que escriba un proveedor diferente para cada una de sus aplicaciones, ya que los datos deben serializarse y luego deserializarse. Cuando su caché y su base de datos son almacenes JSON, estas funciones le brindan una persistencia de muy alto nivel que aumenta el rendimiento de su aplicación. A continuación se muestra un código que muestra cómo funciona la escritura simultánea con JSON.
1 2 3 4 5 6 7 8 9 10 11 12 |
string jsonString = "{ 'ProductID' : 1001, 'ProductName' : 'Chai', 'Category': 'Beverages', 'UnitPrice' : 500, 'UnitsInStock' : 2000 }"; // Populate an instance of the JsonObject by passing the string var jsonProduct = new JsonObject(jsonString); string key = $"Products:{product.ProductID}"; // Enable write through for the cacheItem created var writeThruOptions = new WriteThruOptions(); writeThruOptions.Mode = WriteMode.WriteThru; // Add the item in the cache with WriteThru enabled CacheItemVersion itemVersion = cache.Insert(key, cacheItem, writeThruOptions); |
Puede obtener una guía completa para NCachecaracterísticas del lado del servidor.
Serialización JSON de objetos .NET y Java
In NCache, todos los datos agregados en el caché se serializan. La serialización puede ser binaria o JSON. Es un lenguaje independiente de la plataforma y tiene mucha ventaja por ser ampliamente compatible. Casi todos los lenguajes de programación admiten la serialización y deserialización de JSON en sus bibliotecas estándar. NCache toma su objeto personalizado, JSON lo serializa convirtiéndolo en JSON y luego lo deserializa de nuevo al objeto personalizado.
serialización JSON sus datos en NCache le permite mucha flexibilidad ya que usa JSON.NET, por lo que es extremadamente portátil con múltiples idiomas y deserializa los datos de acuerdo con los requisitos del usuario. No requiere ningún cambio de código y le proporciona una facilidad para especificar los atributos no serializables.
Mire el ejemplo a continuación para ver los datos en .NET y es el equivalente de JSON.
.NET | JSON |
Product product = new Product(); |
{ |
El intercambio de datos es uno de los beneficios centrales de JSON que serializa sus datos. JSON, que es bastante fácil, comprensible y no tiene bibliotecas complejas, le permite proporcionar el tipo en el que se deben deserializar los datos. Tiene un esquema muy flexible para la serialización dado que los atributos son los mismos al deserializar. No solo eso, incluso te permite mapear dos versiones diferentes de la misma clase serializadas con JSON. Puede JSON serializar sus datos desde una clase .NET y una aplicación Java puede acceder a los datos serializados con los atributos de nombre. La figura 1 ilustra cómo se comparten los datos entre las aplicaciones .NET y Java mediante la serialización JSON en la memoria caché.
Conclusión
Esto nos lleva al final de nuestro blog, que muestra la importancia de NCache como una tienda JSON. NCache es un caché distribuido en memoria que le permite usar documentos JSON en el caché. Le permite mantener los datos persistentes en el caché con beneficios adicionales de serialización JSON y uso compartido de datos entre .NET y la aplicación Java.