Mecanismos de Persistencia en Android

Mecanismos de
Persistencia en
Android
Javier Muñoz Ferrara
jmunoz@grupogimeno.com
http://twitter.com/jmunozf
http://www.linkedin.com/in/javiermf

Febrero 2014

La empresa

§  Holding familiar. 3ª Generación
§  Más de 30 empresas.
§  Con 2.500 empleados.
§  Presente en 9 Comunidades.
§  Dando servicio a más de 1 millón de
personas.

2

La empresa
DEPARTAMENTO DE T.I.C.
28 personas

Área Software
Desarrollos a medidas en entornos
VB y Java
Proyectos de movilidad
Android
Web Responsive

Desarrollos Web:
Intranets corporativas
Extranets
Portales webs

Gestión Documental
Sist. de información Geográfica
(GIS)
SAP R3 – BI/BO

Área DataCenter y
Comunic.
Administración de servidores y
BBDD.
Virtualización de servidores
Gestión de comunicaciones y
radioenlaces/WIFI
Cloud privado - CPD propio (Tier
III)

Área de Microinf.

Mantenimiento integral
microinformático.
Asistencia remota
Soporte online

Auditorias del parque tecnológico.
Soporte de Helpdesk
Externalización de equipos de
impresión.
Venta de material informático

4

Índice

¿Qué es persistencia?
Retos de la persistencia en móviles
¿Cómo diseñar la persistencia de datos?
Mecanismos de persistencia de datos en Android
SQLite
ORMLite
Parse
Servicios REST

Conceptos básicos

¿Qué es la persistencia?

Almacenar los datos de la aplicación
para que estén disponibles al reiniciar
el software

Conceptos básicos

¿Por qué es necesaria?

Las aplicaciones se reinician
La RAM es limitada

Conceptos básicos

¿Es importante?

La persistencia suele ser imprescindible
para el correcto funcionamiento de las
aplicaciones

Conceptos básicos

¿Es LO MÁS importante?

NO. Lo más importante son las reglas
de negocio de los usuarios/clientes

¿Entonces por qué muchas veces empezamos
diseñando e implementando la base de datos?

Conceptos básicos

¿Cómo persistir los datos?

Al usuario/cliente probablemente no le interese

BBDD Relacionales

Archivos Binarios

CSV
Servicios Web

Almacenamiento Cloud

BBDD NoSQL

XML

Conceptos básicos

¿Cómo persistir los datos?

¿Cómo podemos persistir en Android?
§  Preferencias
§ 

Parejas: clave -> valor

§ 

Configuraciones, recordar acciones, etc.

§  Almacenamiento de archivos
§ 

Almacenamiento interno o externo

§ 

Archivos arbitrarios (imágenes, json, xml, texto, binarios, etc.)

§  Datos estructurados
§ 

Base de datos SQL

§ 

Colecciones de datos estructurados y relacionados

Tipo de Persistencia

¿Cómo realizar la persistencia en móvil?

1.- Local
§  Almacenamiento en el propio móvil
§  Especio limitado. Acceso rápido. Alto coste consultas complejas



2.- Remota en un servidor
§  El móvil sólo muestra datos, que lee de un servidor
§  Cada acceso a datos requiere un consulta
§  Alta latencia. Muy sensible a desconexiones



3.- Mix (Cacheo/Hoarding)
§  Copia local de alguna información del servidor
§  Comunicación con el servidor para sincronizar
§  Funcional (más o menos) desconectado. Latencia según acierto.

Retos

Espacio limitado

Almacenamiento local
§  Memoria interna/Memoria externa
§  Varios GB (no está mal)

Seleccionar datos a persistir

Retos

Computación y memoria limitada

Consultas complejas lentas
§  Mejor preprocesar datos en el servidor
§  Desnormalizar BBDD si es posible

Alto consumo de batería

Retos

Restricciones de comunicación

Dificultad para sincronizar
§  Minimizar número de conexiones
§  Sólo datos relevantes para la aplicación
§  Sólo modificaciones a los datos
§  Preprocesar datos

Retos

Desconexiones habituales

Modo off-line. ¿Qué ocurre?
§  No funciona nada
§  Funcionamiento limitado (sólo lectura)
§  Funcionamiento completo (conflictos)

Recuperación conexión
§  Sincronización de datos
§  Resolución de conflictos

Diseño de la persistencia
El camino sin reflexionar
Diseñar y crear la BBDD
Escribir SQL donde haga falta leer o modificar datos
Utilizar cursores para recorrer los resultados

Con el paso del tiempo
¿Y si cambio el nombre o tipo de una columna?
¿Y si añado una tabla nueva?
¿Y si cambio BBDD local por servicios web externos?

Patron DAO

Data Access Object

Originario del ámbito J2EE
Aplicable a cualquier tipo de software OO

Patrón DAO

¿Qué es?

Interfaz con métodos de persistencia para Bussiness Objects
Independiente del mecanismo de persistencia (BBDD, XML, Servicios
Web, etc.)

Sólo entran y salen Bussiness Objects y tipos primitivos
Excepciones independientes de la persistencia

Patrón DAO

¿Qué es?

Entran y salen objetos, pero la lógica de la aplicación no
sabe cómo se guardan

Patrón DAO

Beneficios e Inconvenientes
Beneficios
Separación lógica aplicación y gestión persistencia
Evolución/Migración persistencia sin cambiar lógica aplicación
Centralización de las tareas de persistencia (mejor mantenimiento)

Inconvenientes
Capa extra quizá innecesaria en aplicaciones pequeñas
Mueve objetos enteros -> Sobrecarga (si no se diseña bien)
Dificulta integración con frameworks ActiveRecord u ORM

Patrón DAO

Estructura habitual

Un objeto DAO por Bussiness Object/Tabla
Métodos habituales en el interfaz
List<BO> getAll() / findAll()

BO getById(Long id) / findById(Long id)
insert(BO theObject)

delete(BO theObject)
update(BO theObject)

Y todos los que hagan falta….

Patrón DAO

Métodos Genéricos vs Métodos Específicos

Ejemplo: Aplicación tipo Google Calendar (vista calendario + vista detalle)
Métodos genéricos
List<Event> getAllEvents()

Event insertEvent(Event e)
Event updateEvent(Event e)

Métodos genéricos
List<Event> getAllEventsWithScheduleInfo()
updateScheduleInfo(long eventId, Date start, Date end)

Event insertEvent(String title, Date start, Date end)
Event getEventWithDetailnfo()
Event updateEvent(Event e)

¿Cómo cambiar de persistencia?

DAO permite varias persistencias. ¿Para qué?
Conectado vs Desconectado
Desarrollo vs Producción
Lite vs Premium
Conexión rápida vs Conexión lenta

¿Cómo cambiar entre persistencias?
UsuariosDAO usuariosDAO = new UsuariosSQliteDAO();

UsuariosDAO usuariosDAO = new UsuariosRESTDAO();

¡Disperso por toda la aplicación!

Patrón DAO

Abstract Factory Pattern

Factoría -> encargado de crear objetos
Agrupar y encapsular factorías individuales (una por DAO)
DAOFactory
getUsersDAO()
getProducsDAO()
<implementa>

SqliteDAOFactory
UserSqliteDAO
ProductsSqliteDAO

RestDAOFactory

getUsersDAO()
getProducsDAO()

getUsersDAO()
getProducsDAO()

UserRestDAO
ProductsRestDAO

Patrón DAO

Abstract Factory Pattern
DAOFactory
getUsersDAO()
getProducsDAO()
<implementa>

SqliteDAOFactory

RestDAOFactory

getUsersDAO()
getProducsDAO()

getUsersDAO()
getProducsDAO()

<delega en>

MyAppDAOFactory
getUsersDAO()
getProducsDAO()

<delega en>

Android Annotations

¿Por qué utilizarlo?

Facilitar la legibilidad del código
Evitar escribir código boilerplate
Centrarse en la lógica de la aplicación

Ocultar la complejidad técnica

Android Annotations

¿Qué funcionalidad simplifica?

Inyección de dependencias
§ 

Obtener referencias a vistas, recursos, extras, etc.

Gestión de threads
§ 

UI vs Background

Listeners de eventos
§ 

No más clases anónimas

Cliente REST
§ 

Interacción con servicios WEB

Android Annotations

¿Cómo funciona?

Anotaciones Java
Generación automática de código boilerplate
Clases que extienden las de la aplicación

Necesario referencias las clases generadas

SQLite en Android

Conceptos básicos

Incluida en por defecto
Open Source → Utilizada en otros muchos proyectos
Ligera y embebida
BDs privadas de cada aplicación
Se almacenan en “/data/data/<package-name>/databases”

A tener en cuenta
No mantiene integridad de datos
No mantiene integridad referencial (foreign keys)
Se puede simular con triggers

Por defecto no tiene soporte completo a Unicode
No proporciona interfaz gráfica de administración

SQLite en Android

Implementación

Crear clase para administración:
Heredar de android.database.sqlite.SQLiteOpenHelper
Parámetros del constructor:
Contexto
Nombre de la DB
CursorFactory (null para utilizar el por defecto)
Versión del esquema de BBD (para tener en cuenta en migraciones)

Implementar métodos de construcción
public void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE TABLE "+tableName+" (_id INTEGER PRIMARY KEY , "+
colDeptName+ " TEXT)");
// More stuff including initial data
}

SQLite en Android

Implementación

Implementar método de migración
Parámetros del constructor:
oldVersion: versión de la bbdd en el dispositivo
newVersion: versión que se quiere alcanzar
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// do stuff
}

Desde la Actividad:
Crear instancia del DBOpenHelper
Conseguir DB
db.getWritableDatabase();

SQLite en Android

Interactuando con la BBDD

Consultas (Queries)
Modo “raw”:
SQLiteDatabase db=this.getReadableDatabase();
Cursor cur=db.rawQuery("SELECT "+colDeptID+" as _id,"+colDeptName+" from
"+deptTable,new String [] {});

Modo “sencillo” (API)
SQLiteDatabase db=this.getReadableDatabase();
String [] columns=new String[]{"_id",colName,colAge,colDeptName};
Cursor c=db.query(viewEmps, columns, colDeptName+"=?",
new String[]{Dept}, null, null, null);
§ 
§ 
§ 

Nombre tabla
Columnas
Condición WHERE

§ 
§ 
§ 

Argumentos del WHERE
Cláusula GROUP BY
Clásula HAVING

§ 

Clásulula ORDER BY

SQLite en Android

Interactuando con la BBDD

Insertar fila
SQLiteDatabase db=this.getWritableDatabase();
ContentValues cv=new ContentValues();
cv.put(“colDeptID”, 1);
cv.put(“colDeptName”, "Sales");
db.insert(deptTable, “colDeptID”, cv);
cv.put(“colDeptID”, 2);
cv.put(“colDeptName”, "IT");
db.insert(“tablename”, null, cv);
db.close();

SQLite en Android

Operaciones con Vectores

Puntero a un conjunto de datos
Resultado de una interacción con una BBDD

Operaciones de gestión:
close()
deactivate()
requery()

Operaciones de consulta:
getInt(int column_index)
getString(int column_index)
Etc.
getColumnIndex(String
ColumnName)

Operaciones de posición:
moveToNext()
moveToFirst()
moveToPosition(int pos)
moveToLast()
isFirst()
isLast()
isBeforeFirst()
isAfterLast()

Object-Relational Mapping

¿Qué es un ORM?

Una técnica de programación para
convertir datos entre un sistema OO y un
sistema Relacional


Impedancia Objeto-Relacional

Relacional
Tablas

Orientación a Objetos
Grafos

Frameworks ORM

Gestionan la impedancia OO-Relacional
Aplican patrones estándar de correspondencia
OK para el 90% de la funcionalidad necesaria

Algunas Recomendaciones

Loggea y lee las SQL que genera el ORM
Utiliza profiling para encontrar queries lentas
Añade los selects para recuperar sólo columnas necesarias
Utiliza raw SQL cuando el ORM complica las cosas

OrmLite
¿Qué es?

http://ormlite.com/
ORM básico para aplicaciones Java
Se integra con MySQL, PostgreSQL, SQL Server, SQLite…
Mapping por anotaciones
Generación dinámicas de DAOs básicos

OrmLite
Definició de las correspondiencias
@DatabaseTable(tableName = "samples")
public class SampleRow {
[…]
@DatabaseField(columnName = COLUMN_ID, id = true)
String id;
@DatabaseField(foreign = true, columnName = COLUMN_ROUTEPLANED)
RouteRow routeRowPlannedSample;
@DatabaseField(foreign = true, foreignAutoRefresh = true)
UserRow madeByRow;
@DatabaseField(foreign = true, foreignAutoRefresh = true)
UserRow takenByRow;
@DatabaseField(columnName = COLUMN_KIND)
SampleKind kind;
@DatabaseField(columnName = COLUMN_CITYNAME)
String cityName;
@DatabaseField(columnName = COLUMN_COMMENTSFORANALYST)
String comment;

@ForeignCollectionField(eager = false)
public ForeignCollection<SampleParameterRow> samplesParameters;
[…]
}

OrmLite
Manipular la BBDD

Instanciar el OpenHelper
Obtener un DAO para un tipo de objeto

@RootContext
Context ctxt;
Dao<SampleRow, Long> dbDAO;
@AfterInject
void initDbHelper() {
DatabaseHelper dbHelper = OpenHelperManager.getHelper(ctxt, DatabaseHelper.class);
try {
dbDAO = dbHelper.getDao(SampleRow.class);
}
catch (SQLException e) {
dbDAO = null;
}
}

OrmLite
Manipular la BBDD
Crear un objeto
SampleRow sampleRow = new SampleRow();
sampleRow.setCityName(“Zaragoza”);
[…]
dbDAO.create(sampleRow);

Actualizar un objeto
sampleRow.setCityName(“Huesca”);
dbDAO.update(sampleRow);

//debe tener id

Eliminar un objeto
dbDAO.delete(sampleRow);
// o también dbDAO.deleteById(sampleRow.getId());

Persistencia Cloud

¿Qué es?

Servicios de persistencia de manera remota
a través de Internet

Servicios Cloud
Ventajas e Inconvenientes

Ventajas
Evitar infraestructura sobredimensionada
Evitar costes de administración y mantenimiento
Distribuir costes en el tiempo
Soportar picos de necesidad

Inconvenientes
Problemas de privacidad y seguridad
Imposible adaptación/personalización
Difícil respuesta a fallos de servicio
Falta de estándares (vendor lock-in)

Persistencia Cloud
Ecosistema de Servicios

Acceso por SDK o API REST
Firebase Data (REST + SDK)

Parse Data (REST + SDK)
MongoDB (REST)

SimpleDB (REST + SDK)
Oracle (custom REST)
CouchDB (SDK)

NoSQL

¿Qué es?

Sistemas de almacenamiento de información que
no cumplen con el esquema entidad-relación

No hay consultas con SQL
No hay estructura fija
No hay JOINs
No garantizan ACID
(atomicidad, coherencia, aislamiento y durabilidad)

NoSQL
¿Por qué surge?

Aplicaciones Web Globales
- Grandes volúmenes
- Datos heterogéneos
- Rápida evolución de la estructura
- Acceso escalable

Nueva Infraestructura
- Grandes clústers
- Almacenamiento y computación cloud

NoSQL
¿Por qué surge?

Problemas de BBDD Relacionales
- No escalan bien en horizontal (distribución)
- Dificultan las evolución del esquema

Persistencia “Políglota”
- Distintas necesidades -> Distinto tipo de persistencia
- Encapsular para independizar

Datos muy estructurados
Volumen reducido
Acceso ocasional

Datos poco estructurados
Volumen muy grande
Acceso constante

Características NoSQL

Schema-less
Facilidades distribución
Consistencia ocasional

Características NoSQL
Principales tipos de BBDD NoSQL
Clave->Valor
- Como un map enorme
- Particionado sencillo por clave

Document Store
- Mapas anidados con listas
- Permiten “consultas” del contenido

Big Table
- Filas y columnas
- “Familias” de columnas dinámicas

BBDD Grafos
- Nodos, propiedades y aristas
- Permiten consultas complejas

NoSQL
Ventajas e Inconvenientes

Ventajas
Estructura adecuada para algunos datos
Mejor escalabilidad
Más flexibilidad de la estructura de datos

Inconvenientes
Aplicaciones más complejas
Falta de estandarización/formación
Integración estrategias persistencia

Parse
Conceptos Básicos

Parse Data
- Parte de suite de servicios para desarrollo de apps
- Notificaciones PUSH, Identificación, Analíticas…

Instalación
1.- Descargar JAR e incluir
2.- Inicializar librería

Parse.initialize(this, APP_CODE, API_KEY);!

Parse
Manipular datos

Guardar datos
ParseObject parseObject = new ParseObject("Note");!
parseObject.put("title",note.getTitle());!
parseObject.put("text",note.getText());!
parseObject.put("category",ParseObject.createWithoutData("Category",note.getCategory().getId()));!

!

Consultas
ParseQuery<ParseObject> query = ParseQuery.getQuery("Note"); !
for (ParseObject parseObject : query.find()) { …. }!
!

ParseObject parseObject = query.get(noteToEditId);!

REST

¿Qué es?

El Representational State Transfer (REST)
es un estilo arquitectónico para sistemas
software distribuidos basado en
RECURSOS

REST
¿Qué es?

Cliente <- Recurso -> Servidor

RECURSO
API
REST

BBDD

Aplicación
Software

REST

Recursos

Cualquier concepto con significado en la
aplicación que puede ser nombrado

FACTURA
CLIENTE
LUGAR

COMENTARIO
TIENDA

REST
Nombrado

Basado en URLs (Human readable)
http://example.com/customers/1234
http://example.com/orders/2007/10/776654/products
http://example.com/bills/4554/lines/6
recurso

Recomendaciones:
- No utilizar nombres de acción
-  Evitar parámetros (si es posible)
-  Denominación en plural

subrecurso

REST
Acciones

Acciones estándar definidas en HTTP
Comando
HTTP

Acción

Código
respuesta

Contenido respuesta

GET

Lectura

Código 200
(OK)

El recurso/s
consultado/s

POST

Creación

Código 201
(Created)

El recurso creado

PUT

Modificación

Código 200
(OK)

El recurso
modificado

DELETE

Eliminación

Código 204
(No content)

Nada

REST
Representación

Representación en texto del recurso (human-readable)
- JSON, XML, HTML, YAML, RSS, ATOM

JSON

XML

REST

Conexión HTTP manual
q  Leer un stream
String getURL = “http://nombredelservidor.com/services/clientes/”+clienteId;
URL url = new URL(myurl);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setReadTimeout(10000 /* milliseconds */);
conn.setConnectTimeout(15000 /* milliseconds */);
conn.setRequestMethod("GET");
conn.setDoInput(true);
// Starts the query
conn.connect();
int response = conn.getResponseCode();
is = conn.getInputStream();
JSONObject clienteJsonObject = new JSONObject(is.toString());
ObjectMapper mapper = new ObjectMapper();
return mapper.readValue(clienteJsonObject, Cliente.class);

REST

Con Android Annotations
q  Definir una interfaz
@Rest(rootUrl = "http://nombredelservidor.com/services/",converters =
{ MappingJacksonHttpMessageConverter.class })
public interface ClientesClient {
@Get(”clientes/{clientId}")
Client getClienteById(String clientId);
}

Mecanismos de Persistencia en Android

Conclusiones

La persistencia es un detalle (importante)
Varias opciones/tecnologías de implementación
Elija una, pero no hipoteques tu futuro

Mecanismos de Persistencia en Android

Javier Muñoz Ferrara
jmunoz@grupogimeno.com
http://twitter.com/jmunozf
http://www.linkedin.com/in/javiermf

Mecanismos de Persistencia en Android

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (20)

Similar a Mecanismos de Persistencia en Android

Similar a Mecanismos de Persistencia en Android (20)

Más de Javier Muñoz

Más de Javier Muñoz (6)

Último

Último (20)

Mecanismos de Persistencia en Android