Gestión de datos de aplicaciones mobilees

Mi pregunta rodea a un único punto: la gestión de datos en la aplicación mobile . He creado una aplicación mobile donde los datos provienen del server. Los datos incluyen text e imágenes. Los siguientes son los pasos que estoy haciendo para esto:

Primer lanzamiento:
1. Obtenga datos del server.
2. Guarde los datos del server en la database Sqlite.
3. Mostrar datos de Sqlite.

Próximos lanzamientos:
1. Mostrar datos de Sqlite.
2. Obtenga los datos del server en segundo plano.
3. Eliminar los datos anteriores de SQLite.
4. Guarde los nuevos datos del server en la database Sqlite.
5. Mostrar datos de Sqlite.

Tengo un par de preguntas sobre estos pasos:
1. ¿Es este el enfoque correcto? Otra forma podría mostrar datos cada vez desde el server, pero eso no mostraría los datos en pantalla inmediatamente (dependiendo de la velocidad de internet).
2. También pensé en comparar los datos de Sqlite con los nuevos datos del server. Pero se enfrentó a un gran desafío. Los nuevos datos del server pueden tener loggings nuevos o loggings eliminados. Además, no pude encontrar un enfoque apropiado para comparar cada campo de la database con los datos de JSON .
Entonces, ¿ cuál es el mejor enfoque para comparar los datos locales de Sqlite con los nuevos datos del server?
3. Cada vez que borro los datos de Sqlite e inserto nuevos datos y luego actualizo la pantalla (que tiene una UITableView ), parpadea por un segundo que es obvio. ¿Cómo evitar este problema si se siguen los pasos 3, 4, 5?
4. ¿Cómo debo proceder con la actualización de datos en caso de que vuelva a aparecer en la pantalla cada vez o cuando la aplicación se active? Estoy muy al tanto de NSOperationQueues o el uso de GCD para ese asunto. Pero qué pasa si estoy loco y voy y vuelvo a mirar una y otra vez. Habrá varias NSOperations en la queue.

Es un desafío sincronizar los datos del server, lo he hecho antes, y si puedes dedicar time a eso, diría que es la mejor solución.

Es posible que necesite dates de creación y modificación tanto en el server como en los objects locales, para compararlos, esto le permitirá decidir qué objects agregar, actualizar y eliminar. Si el server le envía solo los objects actualizados recientemente, puede ahorrar mucho tráfico y mejorar el performance (pero los objects eliminados serán más difíciles de detectar).

Si los datos solo se modifican en el server, es más fácil, cuando la aplicación puede cambiar los datos también se vuelve más complicado (pero parece que no es su caso). También depende de cuán compleja es la database, por supuesto.

Si no desea invertir algo de time al hacer esto, solo trae todos los datos cada vez que funciona, ¡incluso si no es lo ideal! En lugar de mostrar los datos anteriores y parpadear, puede hacer que el usuario espere 2-3 segundos al ingresar, mientras obtiene los nuevos datos. O, en su lugar, puede get los datos solo al iniciar la aplicación, por lo que cuando llegue al controller de vista ya estará listo.

Es un problema complejo que todos enfrentan en algún momento, así que tengo curiosidad por ver lo que otras personas sugerirán 🙂

Esta es una buena pregunta.

Personalmente creo que download datos, almacenarlos localmente y luego intentar sincronizarlos es un escenario peligroso. Fácil de introducir errores, dominar <-> problemas de esclavo (qué datos deberían ser maestros, si se usaran múltiples dispositivos, etc.)

Creo que algo como esto podría ser un enfoque de trabajo:

1. Trataría de ver las posibilidades de cargar perezoso los datos del server a pedido. Es cuando un usuario tiene una Vista que debería mostrar datos, cargue esa información específica con la creación de esa Vista específica. Esto garantiza que los datos siempre estén sincronizados.

2. Hacer frente a la necesidad de volver a cargar los datos del server desde todas las vistas, podría hacerse simplemente almacenando los datos descargados como objects en la memory (no utilizando SqlLite). La vista tratará de cargar los datos necesarios a través de su administrador de caching, y lo servirá desde la memory, si está disponible. Si no está en la memory, simplemente obtenga los datos de su server y agréguelo a su memory caching. El caching de memory podría ser un gestor de datos hecho en casa que envuelve un Dictionary almacenado en su AppDelegate , o un "Singelton" global para envolver la gestión / almacenamiento de caching y la carga de datos.

3. Con datos cargados perezosos y caching de memory, deberá asegurarse de que las actualizaciones (cambios, loggings nuevos, loggings eliminados) actualicen su model de datos de memory, así como empujar estos cambios al server lo antes posible. Dependiendo del tamaño de los datos, etc., podría obligar al usuario a esperar, o hacerlo directamente como process en segundo plano.

4. Para garantizar que los datos estén sincronizados, debe asegurarse de invalidar periódicamente (eliminar) los loggings de la memory local en el caching y forzar así las actualizaciones de datos del server. El mejor enfoque sería tener una última timestamp actualizada para cada logging en el caching de memory. Por lo tanto, el invalidador periódico solo eliminaría "loggings antiguos" de la memory caching (una vez más, no del server).

Para save el server de la carga de datos innecesaria, los datos aún deben cargarse a pedido cuando el usuario lo necesite en una vista y no como parte de la "invalidation de caching".

5. Dependiendo del tamaño de los datos, es posible que necesite mirar "invalidation de caching". Podría ser tan simple como cuando se almacenan los loggings xx, comience a eliminar objects antiguos de la caching de memory (no del server, solo localmente en el dispositivo).

6. Si la synchronization de datos es absolutamente crítica, es posible que desee ver la actualización de la caching de memory para un logging, justo antes de permitir que el usuario cambie los datos. Por ejemplo, cuando el usuario toca "Editar" o similar, toma los últimos datos del server para ese logging. Esto es solo para asegurarse de que el usuario no va a actualizar un logging con datos obsoletos y, por lo tanto, anula accidentalmente cualquier cambio realizado a distancia, o en otro dispositivo, etc.

Mi opinión sobre eso No creo que haya una "forma perfecta perfecta" para hacer esto. Pero esto sería lo que intentaría hacer.

Espero que esto ayude con algunas ideas e inspiración.

introduzca la descripción de la imagen aquí

Qué tal esto:

  1. Si existen datos en SqlLite, cargue en la copy "en memory" y muéstralo
  2. En segundo plano, carga nuevos datos de server.
  3. borre los antiguos datos sqlite si existe (tenga en count que la copy en memory permanece)
  4. save nuevos datos de server en sqlite
  5. cargue nuevos datos sqlite en la copy "en memory" y muéstrela.

Si no se encontraron datos en el paso 1, muestre una pantalla de "carga" al usuario durante el paso 2.

Estoy asumiendo que los datos de SqlLite son lo suficientemente pequeños como para mantener una copy en la memory para mostrar en tu vista UITable (La vista UITable siempre mostraría los datos de la memory).

Puede ser posible combinar los pasos 4 y 5 si los datos son lo suficientemente pequeños como para contener dos copys en la memory al mismo time (creará una nueva copy en memory e intercambiará con la copy visible cuando se complete).

Nota: No hablo sobre el event handling errores aquí, pero sugiero que no elimines los datos sqlite hasta que tengas nuevos datos para replacelo.

Este enfoque también elimina la necesidad de determinar si este es el primer lanzamiento o no. La lógica siempre sigue siendo la misma que debería hacer que sea un poco más fácil de implementar.

Espero que esto sea útil.

Puede hacer las mismas cosas de manera más eficiente mediante MultiVersion Concurrency Control (MVCC), que utiliza un contador (una especie de "sello de time" muy simple) para cada logging de datos, que se actualiza cada vez que se cambia el logging, significa que necesita get esos datos que se actualiza después de la última llamada de synchronization que networkinguce muchos datos networkingundantes y ancho de banda.

Fuente: control de concurrency MultiVersion

Intereting Posts