Sincronizando objetos entre dois sistemas diferentes, a melhor abordagem?

Question

Eu estou trabalhando em sincronizar dois objetos de negócios entre um iPhone e um site usando uma carga baseado em XML e gostaria de solicitar algumas idéias para uma rotina ideal.

A natureza desta questão é bastante genérico embora e eu posso ver que é aplicável a uma variedade de diferentes sistemas que precisam de negócios sincronização objetos entre uma entidade de web e um cliente (desktop, celular, etc.)

Os objetos de negócios podem ser editados, excluídos e atualizados em ambos os lados. Ambos os lados podem armazenar o objeto localmente, mas a sincronização só é iniciada no lado iPhone para visualização desconectado. Todos os objetos têm uma updated_at e timestamp created_at e são apoiados por um RDBMS em ambos os lados (SQLite no lado do iPhone e MySQL na web ... outra vez eu não acho que isso importa muito) eo telefone faz gravar a última vez que um sincronização foi tentada. Caso contrário, nenhum outro dado é armazenado (no momento).

O algoritmo que você usaria para minimizar vibração da rede entre os sistemas para sincronizar? Como você lidaria com exclusões se "soft-exclui" não são uma opção? O que muda modelo de dados que você adicionar à facilité isso?

Answer 1

A abordagem mais simples: ao sincronizar, transferir todos os registros where updated_at >= @last_sync_at. No lado: esta abordagem não tolera relógio inclinação muito bem em tudo

.

É provavelmente mais seguro para manter uma coluna de número de versão que é incrementado cada vez que uma linha é atualizada (para que bagunça no relógio não falta o seu processo de sincronização) e uma última sincronizados número de versão (para que as alterações potencialmente conflitantes pode ser identificado). Para fazer esta largura de banda eficiente, manter um cache em cada banco de dados da última versão enviada a cada um dos pares de replicação de modo que apenas linhas modificadas precisa de ser transmitida. Se isso vai ser uma topologia em estrela, as folhas podem usar um esquema simplificado onde a última versão sincronizada é armazenado em cada mesa.

Alguma forma de soft-exclusões são necessários para sincronização suporte de exclusões, porém este pode ser na forma de um registro de "lápide", que contém somente a chave da linha excluída. Lápides só pode ser excluído com segurança uma vez que você tem certeza de que todas as réplicas ter processado-los, caso contrário, é possível que uma réplica straggling para ressuscitar um registro que você pensou foi apagado.

Answer 2

Então eu acho que, em síntese, as suas questões dizem respeito à sincronização desconectado.

Então aqui é o que eu acho que deve acontecer:

Initial Sync recuperar os dados e todas as informações associadas a ele (versões de linha, somas de verificação de arquivos etc). é importante que você armazenar essas informações e deixá-la intocada até a próxima sincronização bem sucedida. As mudanças devem ser feitas em uma cópia desses dados.

Controlando alterações Se você está lidando com linhas de banco de dados, a idéia é, basicamente você tem que acompanhar de inserção, atualização e operações de exclusão. Se você está lidando com arquivos de texto como XML, então o seu um pouco mais complicado. Se é provável que vários usuários editar esse arquivo, ao mesmo tempo, então você teria que ter uma ferramenta de comparação, de modo que os conflitos podem ser detectados em um nível mais granular (em vez de todo o arquivo).

Verificando conflitos Novamente, se você está lidando apenas com fileiras de bancos de dados, os conflitos são fáceis de detectar. Você pode ter uma outra coluna que incrementos sempre que a linha é atualizada (eu acho que mssql tem esta embutido não tem certeza sobre mysql). Então, se a cópia que você tem tem um número diferente do que o que está no servidor, então você tem um conflito. Para arquivos ou cordas, uma soma de verificação irá fazer o trabalho. Eu suponho que você também pode usar data de modificação, mas certifique-se de que você tem uma medida muito precisa e exata para evitar acidentes. por exemplo: Vamos dizer que eu recuperar um arquivo e salvá-lo assim que o recuperou. Vamos dizer a diferença de tempo é de 1 milissegundo. Eu, então, fazer alterações em arquivo, então eu tentar salvá-lo. Se a hora da última modificação registrada é preciso apenas 10 milésimos de segundo, há uma boa chance de que o arquivo que eu recuperados terá a mesma data de modificação como o que você salvou para que o programa pensa que não há nenhuma conflito e substitui as alterações. Então, eu geralmente não utilizar este método apenas para estar no lado seguro. Por outro lado, as chances de uma colisão de checksum / hash de depois de uma pequena modificação está perto de nenhum deles.

resolver conflitos Agora esta é a parte complicada. Se este é um processo automatizado, então você teria que avaliar a situação e decidir se deseja substituir as alterações, perder as suas alterações ou recuperar os dados do servidor novamente e tentar refazer as alterações. Felizmente para você, parece que não haverá interação humana. Mas ainda muita dor ao código. Se você está lidando com linhas de banco de dados, você pode verificar cada coluna individual e compará-la com os dados no servidor e apresentá-lo para o usuário. A ideia é a conflitos presentes para o usuário de uma forma muito granular de modo a não sobrecarregar-los. A maioria dos conflitos tem diferenças muito pequenas em muitos lugares diferentes, para apresentá-lo ao usuário uma pequena diferença de cada vez. Assim, para arquivos de texto, é quase o mesmo, mas mais de uma centena de vezes mais complicado. Então, basicamente, você teria que criar ou usar uma ferramenta de comparação (comparação de texto é um assunto totalmente diferente e é muito ampla para mencionar aqui) que lhe permite saber das pequenas alterações no arquivo e onde eles estão em uma forma similar como em um banco de dados: em que o texto foi inserido, excluído ou editado. Em seguida, apresentar isso para o usuário da mesma maneira. Então, basicamente, para cada pequeno conflito, o usuário teria que escolher se deseja descartar suas alterações, Substituir as alterações no servidor ou executar uma edição manual antes de enviar para o servidor.

Então, se você tiver feito as coisas direito, o usuário deve ser dada uma lista de conflitos, se houver algum. Estes conflitos deve ser suficiente granular para o usuário a decidir rapidamente. Assim, por exemplo, o conflito é uma mudança de ortografia a partir, seria mais fácil para o usuário para escolher grafias de palavras em contraste com dando ao usuário o parágrafo inteiro e dizendo-lhe que houve uma mudança e que eles têm de decidir o que fazer , o usuário teria, então, a caça para este pequeno erro ortográfico.

Outras considerações: Validação de dados - mantenha em mente que você tem que executar a validação depois de resolver conflicts desde que os dados podem ter mudado Texto Comparação - como eu disse, este é um grande assunto. Então, o Google it! Disconnected Sincronização - Eu acho que existem alguns artigos lá fora

.

Fonte: https://softwareengineering.stackexchange.com/questions/94634 / sincronização-web-service-metodologias-ou-papers