Menu Docs
Página inicial do Docs
/ /
Atlas Device SDKs
/ /

sincronização baseada em partição - Java SDK

Nesta página

  • Valor da partição
  • Abrir um realm sincronizado
  • Abrir um Realm sincronizado enquanto estiver online
  • Abrir um Realm sincronizado enquanto estiver offline
  • Migrar da sincronização baseada em partição para a Flexible Sync
  • Atualizando o código do cliente após a migração

A sincronização baseada em partição é um modo mais antigo de usar o Atlas Device Sync com o Realm Java SDK. Recomendamos usar o Flexible Sync para novos aplicativos. As informações nesta página são para usuários que ainda estão usando a sincronização baseada em partições.

Dica

O Realm Java SDK v10.16.0 e mais recente suporta a capacidade de migrar da sincronização baseada em partição para a Flexible Sync. Para obter mais informações, consulte: Migrar da sincronização baseada em partição para a Flexible Sync.

Para obter mais informações sobre sincronização baseada em partição e como configurá-la no Atlas App Services, consulte sincronização baseada em partição na documentação do App Services.

Quando você seleciona sincronização baseada em partição para a configuração do aplicativo de backend, a implementação do cliente deve incluir um valor da partição}. Esse é o valor do campo da chave da partição que você seleciona ao configurar a sincronização baseada em partição.

O valor da partição determina quais dados o aplicativo cliente pode acessar.

Você passa no valor da partição quando abre um Realm sincronizado.

Para definir as configurações de um realm, crie uma SyncConfiguration com um SyncConfiguration.Builder.

O exemplo a seguir configura um Realm sincronizado com:

  • Sincronização baseada em partição

  • leituras síncronas explicitamente permitidas na thread da interface do usuário

  • gravações síncronas explicitamente permitidas no thread da interface do usuário

  • espera explícita para que todas as alterações de backend sincronizem com o dispositivo antes de retornar um Realm aberto

  • compactação automática ao iniciar o realm para economizar espaço no arquivo

Aviso

Os aplicativos de produção devem lidar com as redefinições do cliente

A aplicação usada em ambientes de produção deve lidar com erros de reinício do cliente. Para saber mais, consulte Redefinir um Realm do Cliente.

SyncConfiguration config = new SyncConfiguration.Builder(app.currentUser(), PARTITION)
.allowQueriesOnUiThread(true)
.allowWritesOnUiThread(true)
.waitForInitialRemoteData(500, TimeUnit.MILLISECONDS)
.compactOnLaunch()
.build();
Realm.getInstanceAsync(config, new Realm.Callback() {
@Override
public void onSuccess(Realm realm) {
Log.v("EXAMPLE", "Successfully opened a realm.");
}
});
val config =
SyncConfiguration.Builder(app.currentUser(), PARTITION)
.allowQueriesOnUiThread(true)
.allowWritesOnUiThread(true)
.waitForInitialRemoteData(500, TimeUnit.MILLISECONDS)
.compactOnLaunch()
.build()
Realm.getInstanceAsync(config, object : Realm.Callback() {
override fun onSuccess(realm: Realm) {
Log.v("EXAMPLE", "Successfully opened a realm.")
}
})

Importante

Leituras e gravações síncronas na thread da interface do usuário

Por padrão, você só pode ler ou escrever em um Realm no thread da UI da sua aplicação usando transação assíncronas. Ou seja, você só pode usar métodos Realm cujo nome termina com a palavra Async no thread principal do seu aplicativo Android, a menos que você permita explicitamente o uso de métodos síncronos.

Essa restrição existe para o benefício dos usuários do aplicativo: executar operações de leitura e escrita no thread da interface do usuário pode levar a interações de interface do usuário não responsivas ou lentas, portanto, geralmente é melhor lidar com essas operações de forma assíncrona ou em um thread de fundo. No entanto, se o seu aplicativo exigir o uso de leituras ou gravações síncronas de realm no thread da interface do usuário, você poderá permitir explicitamente o uso de métodos síncronos com as seguintes opções SyncConfiguration:

SyncConfiguration config = new SyncConfiguration.Builder(app.currentUser(), PARTITION)
.allowQueriesOnUiThread(true)
.allowWritesOnUiThread(true)
.build();
Realm.getInstanceAsync(config, new Realm.Callback() {
@Override
public void onSuccess(Realm realm) {
Log.v(
"EXAMPLE",
"Successfully opened a realm with reads and writes allowed on the UI thread."
);
}
});
val config = SyncConfiguration.Builder(app.currentUser(), PARTITION)
.allowQueriesOnUiThread(true)
.allowWritesOnUiThread(true)
.build()
Realm.getInstanceAsync(config, object : Realm.Callback() {
override fun onSuccess(realm: Realm) {
Log.v("EXAMPLE", "Successfully opened a realm with reads and writes allowed on the UI thread.")
}
})

Para abrir um Realm sincronizado, chame getInstanceAsync(), passando um objeto SyncConfiguration . O código a seguir demonstra como criar um Realm com configurações de sincronização específicas criadas usando um objeto SyncConfiguration :

SyncConfiguration config = new SyncConfiguration.Builder(app.currentUser(), PARTITION)
.allowQueriesOnUiThread(true)
.allowWritesOnUiThread(true)
.build();
Realm.getInstanceAsync(config, new Realm.Callback() {
@Override
public void onSuccess(Realm realm) {
Log.v(
"EXAMPLE",
"Successfully opened a realm with reads and writes allowed on the UI thread."
);
}
});
val config = SyncConfiguration.Builder(app.currentUser(), PARTITION)
.allowQueriesOnUiThread(true)
.allowWritesOnUiThread(true)
.build()
Realm.getInstanceAsync(config, object : Realm.Callback() {
override fun onSuccess(realm: Realm) {
Log.v("EXAMPLE", "Successfully opened a realm with reads and writes allowed on the UI thread.")
}
})

O código acima mostra como abrir o domínio de forma assíncrona usando getInstanceAsync(). Você também pode abrir um domínio de forma síncrona usando getInstance(), que retorna um domínio aberto antes de sincronizar todos os dados do backend. No entanto, isso pode levar a inconsistências temporárias de dados durante o download dos dados remotos e geralmente não é recomendado. Você pode usar a opção de configuração waitForInitialRemoteData() para forçar o SDK a buscar dados remotos antes de abrir o domínio para evitar essas inconsistências.

O valor da partição especifica qual subconjunto dos seus dados sincronizar. Normalmente, esse é um ID de usuário, ID de projeto, ID de loja ou algum outro identificador de categoria em seu aplicativo que tenha relevância específica para o usuário atual.

Você pode abrir um Realm sincronizado quando estiver off-line com a mesma sintaxe usada para abrir um Realm sincronizado enquanto estiver on-line. Nem todos os SDKs seguem esse padrão, portanto, os desenvolvedores de várias plataformas devem consultar a documentação de cada SDK para saber mais.

Você pode migrar seu Realm Mobile Sync do App Services da sincronização baseada em partição para a Flexible Sync. A migração é um processo automático que não exige alterações no código do aplicativo. A migração automática requer o Realm Java SDK versão 10,16,0 ou mais recente.

A migração permite que você mantenha os usuários existentes do App Services e a configuração de autenticação. O Flexible Sync fornece opções de configuração de permissões mais versáteis e sincronização de dados mais granular.

Para obter mais informações sobre como migrar seu aplicativo do App Services App da Partition-Based Sync para o Flexible Sync, consulte Migrar modos de Device Sync .

A migração automática da sincronização baseada em partição para a Flexible Sync não exige nenhuma alteração no código do cliente. No entanto, para suportar essa funcionalidade, o Realm lida automaticamente com as diferenças entre os dois modos de sincronização por:

  • Criando automaticamente assinaturas de Flexible Sync para cada Tipo de objeto de Realm em que partitionKey == partitionValue.

  • Injetando um campo partitionKey em cada objeto, se ainda não existir um. Isso é necessário para a assinatura automática do Flexible Sync.

Se você precisar fazer atualizações no código do cliente após a migração, considere atualizar a base de código do cliente para remover a funcionalidade de migração oculta. Talvez você queira atualizar a base de código do cliente quando:

  • Você adiciona um novo modelo ou altera um modelo na base de código do cliente

  • Você adiciona ou altera funcionalidades que envolvem a leitura ou escrita de Objeto de Realm

  • Você deseja implementar um controle mais refinado sobre quais dados você sincroniza

Faça essas alterações para converter seu código de cliente de sincronização baseada em partição para usar o Flexible Sync:

  • Atualize seu SyncConfiguration.Builder para usar o Flexible Sync. Isso envolve remover o partitionValue e adicionar um conjunto de assinaturas iniciais, se necessário.

  • Adicione propriedades relevantes aos seus modelos de objetos para usar em suas assinaturas do Flexible Sync. Por exemplo, você pode adicionar uma propriedade ownerId para permitir que um usuário sincronize somente seus próprios dados.

  • Remova assinaturas automáticas do Flexible Sync. Se você não adicionou assinaturas iniciais em SyncConfiguration.Builder, crie manualmente as assinaturas relevantes.

Para obter exemplos de estratégias de permissões de Flexible Sync , incluindo exemplos de como modelar dados para essas estratégias, consulte o Guia de permissões de Device Sync .

Quando você migra da sincronização baseada em partição para o Flexible Sync, o Realm cria automaticamente assinaturas ocultas do Flexible Sync para seu aplicativo. Da próxima vez que adicionar ou alterar subscrições, recomendamos que você:

  1. Remova as assinaturas geradas automaticamente.

  2. Adicione manualmente as assinaturas relevantes na base de código do cliente.

Isso permite que você veja toda a sua lógica de assinatura junto em sua base de código para futura iteração e depuração.

Para obter mais informações sobre as assinaturas Flexible Sync geradas automaticamente, consulte Migrar aplicativo cliente para Flexible Sync.

Voltar

Sincronização em segundo plano