Implementação de serialização compacta dinâmica
NCache armazena dados do aplicativo em formato serializado - eles são serializados no cliente de cache antes de serem adicionados ao cache. Portanto, os dados adicionados ao cache também devem ser marcados como serializáveis. Ele suporta serialização binária nativa e serialização JSON para NCache clientes e também possui sua própria estrutura de serialização chamada serialização compacta (que é rápida e compacta em comparação à serialização nativa). Na serialização nativa Java, todos os dados de um objeto junto com todos os tipos de informações são serializados. Dessa forma, o tamanho do objeto aumenta, enquanto na serialização compacta todo o tipo de informação não trafega na rede e o tamanho do objeto na rede é reduzido. À medida que o tamanho do objeto diminui, as viagens de rede tornam-se mais rápidas e, eventualmente, o custo diminui, aumentando assim o desempenho geral do aplicativo.
A serialização compacta também é uma serialização binária que tem os seguintes benefícios:
Tamanho de dados compacto
In NCache dados binários, o tamanho do objeto serializado é compacto. Em determinados cenários, o tamanho dos dados pode ser 10 vezes menor que o da serialização nativa. Objetos serializados menores levam menos tempo para viajar na rede, resultando em maior rendimento. Isso também ajuda a reduzir o consumo de memória no servidor de cache. Desta forma, NCache alcança melhor desempenho - reduzindo tempo e custo. O pequeno tamanho do objeto e o rápido tráfego de rede aumentam o desempenho do aplicativo.
Mais rápido que a serialização nativa
A serialização compacta é mais rápida que a serialização nativa, pois não depende tanto de reflexão quanto a serialização nativa. A serialização nativa usa reflexão para informações de atributos. Esta reflexão é evitada em NCacheserialização compacta. As informações de tipo para tipos compactos são carregadas apenas uma vez quando o cache é inicializado, o que reduz a sobrecarga enfrentada pelo uso da serialização nativa. Os benchmarks mostraram que, em certos casos de uso, é 5 a 10 vezes mais rápido que a serialização nativa.
Sem alteração de código
Não há nenhuma alteração de código necessária para tornar uma classe compacta serializável. O único passo necessário é configurar suas aulas através de ferramentas de gerenciamento (o NCache Management Center ou suas ferramentas de linha de comando).
Serialização Seletiva: NCache permite serialização seletiva; você pode selecionar membros de dados de uma classe que deseja marcar como não serializável. O atributo excluído de qualquer objeto armazenado em cache será nulo ou terá um valor padrão (se atribuído). Este recurso é útil em um cenário onde, para determinados atributos, não há necessidade de cache, por exemplo, objeto de conexões para banco de dados. Através desta serialização seletiva, o processo torna-se ainda mais eficiente e compacto.
Controle granular sobre serialização compacta: Para isso, você pode implementar
ICompactSerializable
. Essa interface oferece um controle mais refinado sobre a serialização compacta. Você pode controlar quais membros de dados serializar e quais excluir de acordo com suas necessidades de negócios.Suporte para serialização nativa: NCache suporta serialização binária nativa. Os dados são armazenados em formato serializado em cache, a serialização nativa do cliente é suportada para clientes .NET e Java de NCache.
Implementando serialização compacta para tipo de objeto
Para usar a serialização compacta, os tipos de objetos que serão serializados compactamente precisam ser configurados por meio do NCache Centro de Gerenciamento. NCache lida internamente com a serialização/desserialização de classes registradas e o usuário não precisa codificá-la explicitamente.
importante
Os atributos de classe precisam ser desserializados na mesma ordem em que foram serializados, caso contrário, o fluxo serializado não poderá ser desserializado.
O Mercado Pago não havia executado campanhas de Performance anteriormente nessas plataformas. Alcançar uma campanha de sucesso exigiria NCache também permite a implementação explícita do ICompactSerializable
interface.
Para implementar esta interface, a classe DemoObject precisa implementar Serialize
e Deserialize
métodos que serão chamados por NCache ao serializar/desserializar este objeto. Um exemplo de código para implementar esta interface é fornecido abaixo:
importante
Se você quiser marcar uma classe para serialização compacta que requer um construtor parametrizado, certifique-se de que a classe contenha um construtor padrão.
Pré-requisitos
- Para aprender sobre os pré-requisitos padrão necessários para trabalhar com todos os NCache recursos do lado do servidor, consulte a página fornecida em Pré-requisitos da API do lado do servidor.
- O cache deve estar em execução.
- A aplicação deve ser conectado ao cache antes de realizar a operação.
- Para detalhes da API, consulte: ICompactSerializável, Serialize, Desserializar, CheckIfSerializable, IGenericTypeProvider.
Criando DemoObject
public class DemoObject : ICompactSerializable
{
private string _attribute1;
private int _attribute2;
private bool _attribute3;
public DemoObject()
{ }
public DemoObject(string attrib1, int attrib2, bool attrib3)
{
_attribute1 = attrib1;
_attribute2 = attrib2;
_attribute3 = attrib3;
}
#region ICompactSerializable Members
public void Deserialize(CompactReader reader) {
_attribute1 = reader.ReadObject() as string;
_attribute2 = reader.ReadInt32();
_attribute3 = reader.ReadBoolean();
}
public void Serialize(CompactWriter writer){
writer.WriteObject(_attribute1);
writer.Write(_attribute2);
writer.Write(_attribute3);
}
#endregion
}
Implementando um manipulador de tipo genérico
NCache também permite registrar tipos genéricos na serialização compacta. Para isso, cada tipo precisa ser cadastrado através do NCache Centro de Gerenciamento. Existe outra maneira de registrar tipos compactos genéricos através do "Generic Type Handler". Com o Generic Type Handler, o usuário pode adicionar todos os tipos genéricos de uma vez, implementando o IGenericTypeProvider
interface. Isso economiza muito tempo e esforço caso o usuário queira cadastrar um grande número de tipos.
importante
Para utilizar a interface, inclua o seguinte namespace em seu aplicativo: Alachisoft.NCache.Runtime.GenericTypesProvider
Para implementar isso, o usuário precisa implementar o GetGenericTypes
método e retornar os tipos genéricos desejados no Type
variedade. Depois disso, implante este assembly de classe no NCache Centro de Gerenciamento. O NCache O Management Center registrará todos os tipos preenchidos no Type
variedade. Um exemplo de código é fornecido abaixo:
importante
Se você quiser marcar uma classe para serialização compacta que requer um construtor parametrizado, certifique-se de que a classe contenha um construtor padrão.
public class CustomGenericType<T, K, V>
{ }
public class SetGenerics : IGenericTypeProvider
{
Type[] types = new Type[6];
Type[] IGenericTypeProvider.GetGenericTypes()
{
types[0] = typeof(Dictionary<string, Customer>);
types[1] = typeof(List<int>);
types[2] = typeof(CustomGenericType<Employee, Product, Customer>);
types[3] = typeof(CustomGenericType<Employee, Product, int>);
types[4] = typeof(CustomGenericType<Employee, string, byte>);
types[5] = typeof(CustomGenericType<string, Customer, bool>);
return types;
}
public bool CheckIfSerializable(Type type, FieldInfo fieldInfo)
{
// Implement logic
}
}
guia de solução de problemas
Exceção de serialização compacta
Uma exceção de serialização pode ocorrer no nó onde os tipos Compact Serializáveis não estão registrados.
Solução
Registrar Serializável Compacto tipos em todos os nós do cluster.
Veja também
.INTERNET: Alachisoft.NCache.Tempo de execução espaço para nome.