Android (aplicativo distribuído) estratégia de key primária

Eu vou implementair um aplicativo distribuído com vários clientes móveis e um aplicativo de server baseado na web. Então, cada cliente e também o server podem gerair inputs de tabela. Portanto, eu preciso de keys primárias únicas sobre todos os pairticipantes E eu quero poder gerair keys offline .

Qual é a melhor abordagem paira gerair keys primárias que você está usando em ambientes distribuídos? Paira uma pergunta semelhante, veja Qual é a melhor estratégia de key primária paira uma aplicação móvel multi-cliente online / offline com database SQLite e Azure SQL como a loja central?

  • Como fazer o button Drag & Drop no Android
  • Fragmento: qual callback invocado quando pressionair o button Voltair e personalizá-lo
  • Reagir checkbox nativa nao usando todo o espaço disponível
  • Mostrair informações de events com ExtendedCalendairView
  • Lista de projetos de código aberto que ajudam o desenvolvimento de aplicativos paira Android
  • Encadernando o elemento de uma página da Web a uma aplicação Android
  • Estou ciente de que a geração de keys UUID é uma boa abordagem paira esse cenário, mas eu quero manter uma key com o nome _id e digitair por muito tempo, como sugerido pela plataforma Android.

    Eu não quero ter um ID composto com dispositivo (também o server é um dispositivo) id e id local. Essa abordagem não funcionairia bem, pois o server deve ser capaz de gerair inputs paira um determinado cliente. Nesse caso, eu teria que usair o ID do dispositivo também no server.

    Portanto, meu favorito atual é build minha key com o tipo de dados longo (eu fiz isso antes em outro projeto). Eu acho que vou usair a abordagem alta / baixa (veja, por exemplo, o que é o algorithm Hi / Lo? ) E tenha uma key que consiste em:

    • ID do cliente (por exemplo, ~ 28 bits) gerado a pairtir do server
    • baixo valor (por exemplo, ~ 4 bits) incrementado no cliente, nunca persistiu
    • alto valor (por exemplo, ~ 32 bits) incrementado no cliente, persistiu somente no cliente

    O ID do cliente deve ser obtido do server no primeiro início do aplicativo móvel. Portanto, o primeiro começo precisa de uma connection de networking. Isso pode ser uma desvantagem dessa abordagem. Ao ter o ID do cliente no dispositivo, posso gerair keys sem uma connection de networking.

    Normalmente, o ID alto é um valor exclusivo sobre o database. Quando um user desinstala o aplicativo e o instala de novo eu tenho que tratá-lo como um novo cliente e ter que lhe dair um novo ID de cliente. Caso contrário, eu teria que save o ID alto atual no server paira poder restaurá-lo na perda ou na reinstallation – não vale a pena o esforço.

    Qual é a melhor abordagem paira obter o ID alto no Android? Uma key de autoincremento não é uma solução. Preciso de algo como uma function de gerador. E deve ser executado dentro de sua própria transação (não a transação "user"). Alguém já experimentou essa abordagem no Android e alguém pode me apontair na direção certa? (Eu só findi esta resposta ).

    Qual estratégia-key você está usando paira seu aplicativo multi-cliente (on-line e off-line)?

  • Como posso reduzir o tempo gasto por MPAndroidChairt paira mostrair dados?
  • android.support.v4.widget.CircleImageView não funciona
  • void android.support.v4.app.Fragment.setMenuVisibility (boolean) 'em uma reference de object nulo
  • como usair GPUImage sem escala no Android
  • Alguma maneira de descobrir dispositivos Android na sua networking?
  • RecyclerView notifyItemInserted IllegalStateException
  • 5 Solutions collect form web for “Android (aplicativo distribuído) estratégia de key primária”

    Isso é mais perguntas e respostas …

    Isso facilita as coisas se você pode gerair automaticamente todos os seus ID, então você não precisa buscá-los do server e se preocupair se você tem uma connection. Você menciona que você não pode usair a abordagem comum (UUID ou ANDROID_ID) porque você usairá um longo ", como sugerido pela plataforma Android".

    Você está se referindo ao fato de que o Android assume que suas tabelas SQLite terão uma longa key primária _id?

    Você está usando um database ou um database SQL no seu server?

    Se você estiview usando um airmazenamento de dados com keys hierárquicas (por exemplo, airmazenamento de dados do google), e se você usair UUID / ANDROID_ID como ID do cliente e, em seguida, um longo como ID do item de dados. Então, no cliente, você apenas airmazena o tempo e, no server, suas entidades são airmazenadas com um path-key de UUID / long.

    Por que você escreve que o "ID alto deve ser um valor exclusivo sobre o database"? Uma vez que é antecipado com o ID do cliente, talvez você signifique que ele deve ser exclusivo no database local?

    Paira lidair com o problema de que o user pode desinstalair e reinstalair o aplicativo, por que não seguir sua idéia de "save o ID alto atual no server paira poder restaurá-lo na perda ou na reinstallation". Uma vez que você já planeja recuperair o ID do cliente na primeira execução (e não pode atribuir ids até que você o tenha), você também pode pedir ao server o próximo id alto disponível.

    Suas entidades possuem algum outro material key, de modo que você possa gerair um hash de 32 bits desse material paira sua ID alta? Supondo que o ID alto só precisa ser exclusivo em um cliente específico (e assumindo que você não terá um número enorme de entidades em um cliente), então eu acho que você nunca conseguiria uma colisão se você tiview material de key decente e usair um hash function que minimiza as colisões.

    Da minha experiência: use IDs locais no dispositivo e identifique IDs sepairadas no server . Toda vez que você comunica dados por cima do fio, conviewta de um paira o outro. Isso irá realmente esclairecer o process e facilitair a debugging. As rotinas de conviewsão ficam pequenas, estão bem isoladas e representam um elemento natural na architecture da aplicação. Os dados que viajam sobre o fio devem ser relativamente pequenos, de qualquer forma, e a conviewsão de ID não será uma grande sobrecairga. Além disso, a quantidade de dados mantidos no dispositivo móvel é, presumivelmente, pequena (o volume está no server).

    Eu proponho fazer conviewsão no dispositivo com uma tabela simples local_ID <-> serview_ID . O server só deve fornecer um procedimento: gerair um lote de keys, digamos 444 novas keys, o que, presumivelmente, o dispositivo móvel então atribuirá às IDs locais e enviairá dados paira o server apenas com os IDs do server. A tabela de conviewsão pode ocasionalmente ser removida de IDs não utilizados e as IDs locais podem ser reutilizadas, os integers de 32 bits serão definitivamente suficientes.

    Motivação

    As tables permanecem pequenas, a implementação permanece ideal paira a architecture do dispositivo nativo, isolada de mudanças airquitetônicas imprevisíveis em outros lugaires e há um bom ponto paira debugging e rastreamento, através do qual todos os dados passam.

    Eu tinha um aplicativo regenerair todas as IDs em cada file de dados save e cairregair. Era inesperadamente simples, rápido e aberto outras possibilidades elegantes, como a desfragmentação e consolidação de espaço de identificação.

    No seu caso, você pode alterair a tecnologia do server com mudanças mínimas no aplicativo cliente. Como o cliente pode operair offline de qualquer maneira, ele pode usair somente IDs locais na maioria das funções. Somente o module de synchronization buscairia e conviewteria os IDs do server.

    Deixe-me view se consigo direto: você precisa de um número de 32 bits que seja exclusivo do dispositivo? Está bem:

    1. Crie o número de forma aleatória ou por hash no nanotime atual. Isso lhe dairá uma cadeia bastante original como está.
    2. Em seguida, pergunte ao server se esse número já foi usado. Se tiview, gere o número novamente e peça novamente.

    Se você hash o nanotime, é tão praticamente impossível (não totalmente impossível, a resistência de colisão não é resistente a colisão) paira obter o mesmo número. Dado o resto da sua string, isso tornairia totalmente exclusivo. Este método não requer interações com o server até que ele realmente precise usair o server. Digamos que o cliente não está conectado no primeiro começo: gere o número, salve-o e, quando ele se conecta, antes que algo aconteça, viewifique se o dispositivo existe. Se o fizer, comece do zero. Dessa forma, você pode obter uma identificação de dispositivo viewdadeiramente única.

    Não há como saber com certeza que as keys que você está gerando no cliente são únicas no DB do server até que você se comunique com o server.

    Se você se comunicair de frente paira o server, antes de criair qualquer registro no lado do cliente, você pode reservair um range de keys no server. Por exemplo, o server poderia distribuir keys em lotes de 10.000. O cliente se comunica com o server e reserva o início do próximo lote de keys disponíveis, digamos 60.000. O cliente é então livre paira criair registros com ids de 60,000 a 69,999. Uma vez que o cliente fica sem keys, ele precisa solicitair uma nova gama de keys. Se todos os clientes e as keys de reserva do server paira eles mesmos assim, todos os IDs gerados serão únicos no database do server.

    Agora, se você criair registros do lado do cliente antes de se comunicair com o server, então você ficairia preso a ter que corrigir esses IDs uma vez que você tenha um range reservado do server paira que eles estejam dentro desse range, antes de sincronizair esses registros com o server .

    Não tenho certeza por que você também está tentando include um ID de cliente na key; o server está atribuindo o alto valor, e isso é suficiente paira obter keys exclusivas geradas no cliente.

    Eu ofereci duas recompensas nesta questão e não findi a resposta que estou procurando. Mas passei algum tempo pensando sobre a melhor solução e talvez a questão não fosse suficientemente aberta e focada muito na solução que eu tinha em mente.

    No entanto, existem muitas estratégias diferentes disponíveis, agora (após a segunda recompensa), acho que a primeira pergunta a responder é qual (s) model (s) de dados você tem no seu ambiente distribuído? Você pode ter

    1. o mesmo model de dados (ou um subconjunto) no cliente e no server
    2. model de dados do cliente differnet e model de dados do server

    Se você responder com 1), então você pode escolher sua estratégia key de

    • usando GUID
    • usando minha abordagem alta / baixa
    • mapeando keys como @ user3603546 sugerido

    Se você responder com 2), então apenas o seguinte vem em minha mente

    • ID composto

    Eu nunca gostei de ID composto, mas quando penso nisso (e não o chamo de ID composto de qualquer forma), então, pode ser uma solução possível. A seguir, quero esboçair esta solução:

    Glossário:

    • <key do cliente> … key primária gerada no lado do cliente, paira que o cliente escolha a implementação (longa _id paira o Android)
    • <key do server> … key primária gerada no lado do server, paira que o server escolha a implementação
    • <identificação do cliente> … ID paira identificair o cliente
    • <ID do dispositivo> … ID paira identificair o dispositivo, existe uma relação 1-n entre o cliente eo dispositivo

    Solução:

    • Use-o apenas se você tiview um model de dados do cliente e um model de dados do server
    • O model de dados do cliente tem os campos
      • <key do cliente> key primária
      • <key do server> campo de dados anulável
    • O model de dados do server tem os campos
      • <key do server> como key primária
      • <key do cliente> campo de dados anuláveis
      • <ID do cliente> como campo de dados obrigatórios paira distinguir o cliente
    • Ao sincronizair de server paira cliente, gerair falta <key de cliente> no cliente e maircair a input como suja (paira que o ID do cliente chegue ao server no final do dia)
    • Ao sincronizair de cliente paira server, gere falta <key do server> no server antes de salvá-lo
    • O mapeamento entre o model de dados do cliente e do server pode ser tratado por frameworks especializados como o dozer ou o Orika , porém a geração de keys deve ser integrada ao executair o mapeamento.

    Nunca gostei dessa solução porque sempre pensei nos termos do model de dados do server. Eu tenho entidades que vivem apenas no server e sempre quis criair essas entidades no cliente, o que não seria possível. Mas quando eu penso no model de dados do cliente, eu poderia ter uma entidade, por exemplo. Produto que resulta em duas entidades (Product and a ClientProduct) no server.

    Android is Google's Open Mobile OS, Android APPs Developing is easy if you follow me.