Bancos de dados e caches andam de mãos dadas e estão em estreita associação há muito tempo. Caches como a camada intermediária reduzem a pressão em seus bancos de dados, mantendo seus dados no cache para um processamento mais rápido. NCache é uma solução de cache distribuído na memória para seus aplicativos .NET e Java. Por anos, NCache vem proporcionando alto desempenho e escalabilidade reduzindo a carga nos bancos de dados. Ele também garante um tempo de resposta mais rápido para seus aplicativos de missão crítica.
JSON tem sido um dos formatos de intercâmbio de dados mais famosos entre aplicativos modernos. É uma linguagem independente de plataforma, leve e muito legível e compreensível devido à sua natureza padronizada. É extremamente rápido e pode ser usado por linguagens de programação modernas e é suportado por todas as principais estruturas JavaScript.
Falar sobre as duas coisas acima mencionadas separadamente nos leva ao nosso tópico de discussão aqui que é o suporte do JSON em NCache. NCache ser extremamente escalável e distribuído oferece suporte ao armazenamento de dados JSON no cache junto com a serialização JSON de seus dados. Você pode armazenar um documento JSON no cache para manipulação rápida e fácil. NCache fornece suas próprias classes para armazenamento de dados JSON, derivadas de uma classe abstrata JsonValueBase com base em suas propriedades. Essas aulas são:
- JsonValor
- JsonObjectName
- JsonArrayName
- JsonNullGenericName
NCache Adicionar ao carrinho Operações de cache em NCache
Exemplo rápido de JSON entre .NET e Java
Para começar, vejamos um exemplo rápido mostrando o uso de dados JSON em NCache. Você pode adicionar um documento JSON em seu cache usando um aplicativo .NET e esses dados podem ser recuperados por um aplicativo Java, pois o JSON é independente de plataforma.
O exemplo abaixo mostra a adição de um documento JSON em seu cache como um 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); |
O documento JSON adicionado acima pode ser recuperado usando um aplicativo Java. O código abaixo mostra a recuperação dos mesmos documentos JSON por meio de Java. Ele remove ainda mais os atributos do JsonObject e, em seguida, reinsere o JsonObject no cache.
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); |
Suporte JSON em NCache
NCache é a principal solução de cache que permite adicionar dados personalizados em seu cache e recuperá-los no formato JSON. Da mesma forma, você pode adicionar dados JSON no cache e recuperá-los como um objeto de dados personalizado.
Como mencionado anteriormente, NCache fornece suas próprias classes derivadas de JsonValueBase e essas classes são usadas para adicionar diferentes formatos de dados JSON no cache. Vamos dar uma olhada mais de perto nessas classes, uma por uma:
1. Valor Json
JsonValor representa os tipos de dados primitivos nas convenções do JSON. Você pode adicionar valor de qualquer tipo primitivo incluindo outros como string, DateTime ou decimal em .NET como JsonValue no cache.
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. JsonObject
JsonObjectName é um contêiner para pares nome/valor não ordenados em que nome ou chave é o nome do atributo e valor pode ser qualquer um dos tipos de dados primitivos. Você pode analisar uma string inteira contendo os dados JSON e preencher um JsonObject a partir dela. Da mesma forma, um objeto personalizado também pode ser recuperado como um JsonObject e vice-versa. O exemplo abaixo mostra a criação de um JsonObject com atributos e seus valores e depois adicioná-lo ao cache. Em seguida, ele mostra outras operações no JsonObject, como remover um atributo específico.
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.JsonArray
JsonArrayName é uma coleção de itens e representa o JArray em NCachedomínio de. Assim como JsonObject, você pode especificar qualquer valor ou objeto derivado de JsonValueBase. Você pode adicionar, recuperar ou até mesmo remover valores de um JsonArray em qualquer í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. JsonNulo
Essa classe representa o valor nulo nos padrões JSON. O exemplo dado mostra o valor nulo para um atributo do JsonObject. Ao recuperar ainda mais o atributo com o valor nulo, ele lança uma exceção.
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 Adicionar ao carrinho Cache de dados como documentos JSON Serialização JSON
Indexando documentos JSON em NCache
Se seu cache for um armazenamento JSON, você poderá indexar seus dados usando um dos seguintes:
- Grupos: Os itens de uma cache que tenham uma relação entre eles ou que se enquadrem na categoria semelhante podem ser agrupados em NCache utilização NCache Função “Grupos”. Usando Grupos, você pode particionar logicamente seus dados para melhor eficiência.
- Tags: as tags são identificadores baseados em strings, associados aos seus dados. Usando Tags, você pode associar palavras-chave aos seus itens de cache, que são úteis para realizar várias operações de cache em seus dados usando essas palavras-chave.
- Etiquetas nomeadas: Tags nomeadas é um recurso fornecido por NCache que é uma forma aprimorada de Tags. Eles associam informações específicas aos itens na forma de par chave-valor em tempo de execução.
Os documentos JSON são adicionados ao cache com esses identificadores e NCache indexa os dados com base nesses identificadores. Mais tarde, você pode usar consultas fornecidas por NCache para realizar operações nele. O exemplo abaixo mostra a adição de um documento JSON no cache com tags nomeadas associadas a ele.
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); |
Pesquisando documentos JSON com SQL em NCache
NCache fornece consultas semelhantes a SQL para recuperar dados e removê-los. Você pode usar consultas nos dados indexados para buscar os dados JSON em qualquer um dos formatos fornecidos por NCache.
O exemplo dado mostra a consulta dos dados indexados no exemplo acima, que é um documento JSON adicionado com tags nomeadas. A consulta recupera todos os JsonObjects do cache com o valor de desconto 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 tem vários recursos do lado do servidor para realizar operações diretas em sua fonte de dados mestre. Esses recursos fornecem a flexibilidade de ler ou gravar dados de e para a fonte de dados mestre, bem como pré-carregar os dados no cache. Um desses recursos chamado Fonte de apoio oferece a facilidade de:
- Leia: Leia busca dados da fonte de dados caso não esteja presente no armazenamento em cache.
- Gravação:Gravação atualiza a fonte de dados (qualquer operação de gravação) após atualizar o armazenamento em cache.
NCache chama um provedor que é escrito por você, com sua lógica personalizada para carregar dados da fonte de dados mestre ou gravar dados em sua fonte de dados mestre. Os provedores são então implantado utilização NCache Web Manager para usar Read-Through/Write-Through.
Para as fontes de dados mestre baseadas em JSON, como Cosmos DB, há um benefício adicional de usar dados JSON no cache. Ao contrário do .NET, para JSON você pode escrever um provedor genérico para todos os seus aplicativos em JSON a serem implantados em seu cache para carregar dados diretamente do banco de dados. Você pode obter maior persistência usando esses provedores genéricos, pois o JSON é independente da plataforma. O .NET exige que você escreva um provedor diferente para cada aplicativo, pois os dados precisam ser serializados e, em seguida, desserializados. Quando seu cache e seu banco de dados são armazenamentos JSON, esses recursos fornecem uma persistência de nível muito alto, aumentando o desempenho do aplicativo. Abaixo está um código que mostra como o write-through funciona com 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); |
Você pode obter um guia completo para NCacherecursos do lado do servidor.
Serialização JSON de objetos .NET e Java
In NCache, todos os dados adicionados no cache são serializados. A serialização pode ser binária ou JSON. É uma linguagem independente de plataforma e tem muita vantagem por ser amplamente suportada. Quase todas as linguagens de programação oferecem suporte à serialização e desserialização de JSON em suas bibliotecas padrão. NCache pega seu objeto personalizado, o JSON o serializa convertendo-o em JSON e, em seguida, desserializa-o de volta para o objeto personalizado.
Serialização JSON seus dados em NCache permite muita flexibilidade, pois usa JSON.NET, por isso é extremamente portátil com vários idiomas e desserializa os dados de acordo com a necessidade do usuário. Ele não requer alteração de código e oferece facilidade para especificar os atributos não serializáveis.
Veja o exemplo abaixo para dados em .NET e é o equivalente do JSON.
. NET | JSON |
Product product = new Product(); |
{ |
O compartilhamento de dados é um dos principais benefícios do JSON serializando seus dados. JSON sendo bastante fácil, compreensível e sem bibliotecas complexas permite que você forneça o tipo em que os dados precisam ser desserializados. Possui um esquema muito flexível para serialização, pois os atributos são os mesmos ao desserializar. Não apenas isso, ele ainda permite mapear duas versões diferentes da mesma classe serializada com JSON. Você pode serializar seus dados em JSON de uma classe .NET e um aplicativo Java pode acessar os dados serializados com os atributos de nome. A Figura 1 ilustra como os dados são compartilhados entre aplicativos .NET e Java usando a serialização JSON no cache.
Conclusão
Isso nos leva ao final do nosso blog que mostra o significado de NCache como um armazenamento JSON. NCache é um cache distribuído na memória que permite usar documentos JSON no cache. Ele permite que você mantenha os dados persistentes no cache com benefícios adicionais de serialização JSON e compartilhamento de dados entre o .NET e o aplicativo Java.
NCache Adicionar ao carrinho Baixar NCache Comparação de edição