En este tutorial, aprenderá cómo crear una base de datos SQLite que le permita almacenar datos en la memoria interna de su dispositivo. Los dispositivos Android vienen con una base de datos SQLite integrada que tiene métodos para crear, actualizar, eliminar, ejecutar comandos SQL y realizar otras tareas comunes de administración de bases de datos. Crearemos una aplicación sencilla que permita a los usuarios crear, actualizar, eliminar y mostrar una lista de datos. Vamos a empezar…
Cree un nuevo proyecto en Eclipse File > New > Android Application Project. Complete los detalles y nombre su proyecto DatabaseTutorial .
Nombre de la aplicación: Tutorial de base de datos
Nombre del proyecto: Tutorial de base de datos
Nombre del paquete: com.androidbegin.databasetutorial
Abra su MainActivity .java y pegue el siguiente código.
Actividad principal .java
paquete com.androidbegin.databasetutorial;
importar android.os.AsyncTask;
importar android.os.Bundle;
importar android.app.ListActivity;
importar android.content.Intent;
importar android.database.Cursor;
importar android.view.Menú;
importar android.view.MenuItem;
importar android.view.View;
importar android.view.MenuItem.OnMenuItemClickListener;
importar android.widget.AdapterView;
importar android.widget.CursorAdapter;
importar android.widget.ListView;
importar android.widget.SimpleCursorAdapter;
importar android.widget.AdapterView.OnItemClickListener;
clase pública MainActivity extiende ListActivity {
// Declarar Variables
Cadena final estática pública ROW_ID = "row_id";
Cadena final estática privada TITLE = "título";
ListView privado noteListView;
adaptador de nota de CursorAdapter privado;
@Anular
public void onCreate (Paquete guardadoInstanceState) {
super.onCreate(estadoDeInstanciaGuardado);
// Localizar ListView
noteListView = getListView();
// Preparar elemento ListView Click Listener
noteListView.setOnItemClickListener(viewNoteListener);
// Asigne todos los títulos a ViewTitleNotes TextView
Cadena[] de = nueva Cadena[] { TÍTULO };
int[] to = new int[] { R.id.ViewTitleNotes };
// Crear un adaptador de cursor simple
noteAdapter = new SimpleCursorAdapter(MainActivity.this,
R.layout.list_note, null, from, to);
// Establecer el adaptador en SimpleCursorAdapter
setListAdapter(noteAdapter);
}
// Capturar clic en el elemento ListView
OnItemClickListener viewNoteListener = new OnItemClickListener() {
public void onItemClick(AdapterView<?> arg0, Ver arg1, int arg2,
argumento largo3) {
// Abrir la actividad ViewNote
Intent viewnote = new Intent(MainActivity.this, ViewNote.class);
// Pasar el ROW_ID a la actividad ViewNote
viewnote.putExtra(ROW_ID, arg3);
iniciarActividad(vernota);
}
};
@Anular
vacío protegido en el currículum () {
super.onReanudar();
// Ejecutar GetNotes Asynctask al regresar a MainActivity
nuevo GetNotes().ejecutar((Objeto[]) nulo);
}
@Anular
vacío protegido onStop() {
Cursor cursor = noteAdapter.getCursor();
// Desactiva el Cursor
si (cursor != nulo)
cursor.desactivar();
noteAdapter.cambiarCursor(nulo);
super.onStop();
}
// Crear un menú de barra de acción
@Anular
public boolean onCreateOptionsMenu(Menú menú) {
// Título del menú
menu.add("Agregar nuevas notas")
.setOnMenuItemClickListener(this.SaveButtonClickListener)
.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
volver super.onCreateOptionsMenu(menú);
}
// Hacer clic en el elemento del menú de captura
OnMenuItemClickListener SaveButtonClickListener = nuevo OnMenuItemClickListener() {
onMenuItemClick público booleano (elemento MenuItem) {
// Abrir la actividad AddEditNotes
Intent addnote = new Intent(MainActivity.this, AddEditNotes.class);
iniciarActividad(añadirnota);
falso retorno;
}
};
// GetNotesAsyncTask
clase privada GetNotes extiende AsyncTask<Objeto, Objeto, Cursor> {
DatabaseConnector dbConnector = new DatabaseConnector(MainActivity.this);
@Anular
Cursor protegido doInBackground(Object... params) {
// Abrimos la base de datos
ConectorBD.open();
volver dbConnector.ListAllNotes();
}
@Anular
vacío protegido en PostExecute (resultado del cursor) {
noteAdapter.changeCursor(resultado);
// Cerrar base de datos
ConectorBD.close();
}
}
}
En esta actividad, mostraremos la lista de elementos en una vista de lista desde la base de datos SQLite mediante el uso de AsyncTask para llamar a la función ListAllNotes desde la clase Conector de base de datos. En el elemento de vista de lista, haga clic en pasar la identificación de la fila a la clase ViewNote. Luego, hemos creado un menú de opciones para abrir la clase AddEditNotes que permite a los usuarios agregar elementos a la vista de lista.
A continuación, cree un diseño gráfico XML para su MainActivity. Vaya a res > diseño > Haga clic con el botón derecho en el diseño > Nuevo > Archivo XML de Android
Nombre su nuevo archivo XML list_note.xml y pegue el siguiente código.
A continuación, cree las funciones de la base de datos en una nueva clase llamada DatabaseConnector .java . Vaya a Archivo > Nuevo > Clase y asígnele el nombre DatabaseConnector.java. Seleccione su paquete llamado com.androidbegin.databasetutorial y haga clic en Finalizar .
Abra su DatabaseConnector .java y pegue los siguientes códigos.
Conector de base de datos .java
paquete com.androidbegin.databasetutorial;
importar android.content.ContentValues;
importar android.content.Context;
importar android.database.Cursor;
importar android.database.SQLException;
importar android.database.sqlite.SQLiteDatabase;
Conector de base de datos de clase pública {
// Declarar Variables
Cadena final estática privada DB_NAME = "MyNotes";
Cadena final estática privada TABLE_NAME = "tablenotes";
Cadena final estática privada TITLE = "título";
ID de cadena final estática privada = "_id";
Cadena final estática privada NOTA = "nota";
privado estático final int DATABASE_VERSION = 1;
base de datos SQLiteDatabase privada;
ayudante de base de datos privada dbOpenHelper;
Conector de base de datos público (contexto contextual) {
dbOpenHelper = new DatabaseHelper(contexto, DB_NAME, nulo,
VERSIÓN_BASE DE DATOS);
}
// Abrir función de base de datos
public void open() lanza SQLException {
// Permitir que la base de datos esté en modo de escritura
base de datos = dbOpenHelper.getWritableDatabase();
}
// Cerrar función de base de datos
cierre de vacío público () {
si (base de datos! = nulo)
base de datos.cerrar();
}
// Crear función de base de datos
public void InsertNote(Título de cadena, Nota de cadena) {
ContentValues newCon = nuevos ContentValues();
newCon.put(TÍTULO, título);
newCon.put(NOTA, nota);
abierto();
base de datos.insertar(TABLE_NAME, null, newCon);
cerca();
}
// Actualizar función de base de datos
Public void UpdateNote (ID largo, título de cadena, nota de cadena) {
ContentValues editCon = new ContentValues();
editCon.put(TÍTULO, título);
editCon.put(NOTA, nota);
abierto();
base de datos.update(TABLE_NAME, editCon, ID + "=" + id, nulo);
cerca();
}
// Eliminar función de base de datos
public void DeleteNote (identificación larga) {
abierto();
base de datos.borrar(NOMBRE_TABLA, ID + "=" + id, nulo);
cerca();
}
// Listar todas las funciones de datos
Cursor público ListAllNotes() {
return base de datos.consulta(NOMBRE_TABLA, nueva Cadena[] { ID, TÍTULO }, nulo,
nulo, nulo, nulo, TÍTULO);
}
// Captura datos individuales por ID
Cursor público GetOneNote (identificación larga) {
volver base de datos.consulta(TABLE_NAME, null, ID + "=" + id, null, null,
nulo, nulo);
}
}
En esta clase, tenemos algunas funciones básicas de bases de datos, como crear, actualizar, eliminar y listar datos. Todas las funciones de la clase DatabaseConnector se pueden llamar desde otras clases.
NOTA: Para restablecer o borrar la base de datos, simplemente cambie el número de versión.
privado estático final int DATABASE_VERSION = 1;
A continuación, cree un asistente de base de datos SQLite para ayudar a administrar la creación de bases de datos y la administración de versiones. Vaya a Archivo > Nuevo > Clase y asígnele el nombre DatabaseHelper.java. Seleccione su paquete llamado com.androidbegin.databasetutorial y haga clic en Finalizar .
Abra su DatabaseHelper .java y pegue los siguientes códigos.
Ayudante de base de datos .java
paquete com.androidbegin.databasetutorial;
importar android.content.Context;
importar android.database.sqlite.SQLiteDatabase;
importar android.database.sqlite.SQLiteDatabase.CursorFactory;
importar android.database.sqlite.SQLiteOpenHelper;
clase pública DatabaseHelper extiende SQLiteOpenHelper {
// Declarar Variables
Cadena final estática privada DB_NAME = "MyNotes";
public static final String TABLE_NAME = "tablenotes";
public static final String TITLE = "título";
public static final String NOTA = "nota";
DatabaseHelper público (contexto de contexto, nombre de cadena, fábrica de CursorFactory,
versión int) {
super(contexto, DB_NAME, fábrica, versión);
}
@Anular
vacío público en Crear (SQLiteDatabase db) {
// Crear una tabla de base de datos
Cadena createQuery = "CREAR TABLA" + TABLE_NAME
+ " (autoincremento de clave principal de número entero _id," + TÍTULO + ", "
+ NOTA + ");";
db.execSQL(createQuery);
}
@Anular
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// La base de datos se borrará con el cambio de versión
db.execSQL("BOTAR TABLA SI EXISTE" + NOMBRE_TABLA);
onCreate(db);
}
}
Hemos creado un ayudante de base de datos utilizando una consulta SQLite simple. Hemos establecido el número entero » id » como CLAVE PRINCIPAL y se utiliza para identificar de forma única cada registro en una tabla de base de datos. La base de datos se borrará o eliminará automáticamente si se realizan cambios en el número de versión como se mencionó anteriormente.
A continuación, cree una actividad para el elemento ListView, haga clic en que muestre los datos de una sola base de datos. Vaya a Archivo > Nuevo > Clase y asígnele el nombre ViewNote.java. Seleccione su paquete llamado com.androidbegin.databasetutorial y haga clic en Finalizar .
Abra su ViewNote.java y pegue el siguiente código.
VerNota.java
paquete com.androidbegin.databasetutorial;
importar android.app.Actividad;
importar android.app.AlertDialog;
importar android.content.DialogInterface;
importar android.content.Intent;
importar android.database.Cursor;
importar android.os.AsyncTask;
importar android.os.Bundle;
importar android.view.Menú;
importar android.view.MenuItem;
importar android.view.MenuItem.OnMenuItemClickListener;
importar android.widget.TextView;
la clase pública ViewNote extiende la actividad {
// Declarar Variables
ID de fila largo privado;
TextView privado TitleTv;
TextView NoteTv privado;
Cadena final estática privada TITLE = "título";
Cadena final estática privada NOTA = "nota";
@Anular
public void onCreate (Paquete guardadoInstanceState) {
super.onCreate(estadoDeInstanciaGuardado);
setContentView(R.layout.view_note);
// Localice TextView en view_note.xml
TitleTv = (TextView) findViewById(R.id.TitleText);
NoteTv = (TextView) findViewById(R.id.NoteText);
// Recuperar el ID de FILA de MainActivity.java
Extras del paquete = getIntent().getExtras();
ID de fila = extras.getLong(Actividadprincipal.ROW_ID);
}
@Anular
vacío protegido en el currículum () {
super.onReanudar();
// Ejecutar LoadNotes() AsyncTask
nuevas LoadNotes().execute(filaID);
}
// CargarNotas() Tarea Asincrónica
clase privada LoadNotes extiende AsyncTask<Long, Object, Cursor> {
// Llama a la clase DatabaseConnector.java
DatabaseConnector dbConnector = new DatabaseConnector(ViewNote.this);
@Anular
Cursor protegido doInBackground(Largo... parámetros) {
// Pasar el ID de fila a la función GetOneNote en
// Clase DatabaseConnector.java
ConectorBD.open();
return dbConnector.GetOneNote(parámetros[0]);
}
@Anular
vacío protegido en PostExecute (resultado del cursor) {
super.onPostExecute(resultado);
resultado.moverAlPrimero();
// Recuperar el índice de columna para cada elemento de datos
int TitleIndex = result.getColumnIndex(TITLE);
int NoteIndex = resultado.getColumnIndex(NOTA);
// Establecer el texto en TextView
TitleTv.setText(result.getString(TitleIndex));
NoteTv.setText(resultado.getString(NoteIndex));
resultado.cerrar();
ConectorBD.close();
}
}
// Crear un menú de opciones
@Anular
public boolean onCreateOptionsMenu(Menú menú) {
menu.add("Editar nota")
.setOnMenuItemClickListener(this.EditButtonClickListener)
.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
menu.add("Eliminar notas")
.setOnMenuItemClickListener(this.DeleteButtonClickListener)
.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
volver super.onCreateOptionsMenu(menú);
}
// Capturar clic en el elemento del menú de edición
OnMenuItemClickListener EditButtonClickListener = nuevo OnMenuItemClickListener() {
onMenuItemClick público booleano (elemento MenuItem) {
// Pasar ID de fila y datos a AddEditNotes.java
Intento addeditnotes = new Intent(ViewNote.this, AddEditNotes.class);
addeditnotes.putExtra(MainActivity.ROW_ID, rowID);
addeditnotes.putExtra(TITLE, TitleTv.getText());
addeditnotes.putExtra(NOTA, NoteTv.getText());
startActivity(addeditnotes);
falso retorno;
}
};
// Capturar elemento de menú eliminar clic
OnMenuItemClickListener DeleteButtonClickListener = nuevo OnMenuItemClickListener() {
onMenuItemClick público booleano (elemento MenuItem) {
// Llama a la función EliminarNota()
Borrar nota();
falso retorno;
}
};
privado vacío DeleteNote () {
// Mostrar un cuadro de diálogo de alerta simple para reconfirmar la eliminación
AlertDialog.Builder alerta = new AlertDialog.Builder(ViewNote.this);
alert.setTitle("Eliminar elemento");
alert.setMessage("¿Realmente desea eliminar esta nota?");
alert.setPositiveButton("Sí", nueva DialogInterface.OnClickListener() {
public void onClick (diálogo de interfaz de diálogo, botón int) {
final DatabaseConnector dbConnector = new DatabaseConnector(
ViewNote.this);
AsyncTask<Largo, Objeto, Objeto> deleteTask = new AsyncTask<Largo, Objeto, Objeto>() {
@Anular
Objeto protegido doInBackground(Long... params) {
// Pasa el ID de fila a la función DeleteNote en
// Conector de base de datos.java
dbConnector.DeleteNote(parámetros[0]);
devolver nulo;
}
@Anular
vacío protegido en PostExecute (resultado del objeto) {
// Cerrar esta actividad
terminar();
}
};
// Ejecute el deleteTask AsyncTask anterior
deleteTask.execute(new Long[] {rowID });
}
});
// No hacer nada en No hacer clic en el botón
alerta.setNegativeButton("No", nulo).show();
}
}
En esta actividad, recuperamos el ID de fila del elemento de vista de lista, haga clic en la clase MainActivity y lo mostramos en la clase ViewNote. Luego, usamos el ID de fila como clave principal para actualizar, editar o eliminar los datos mediante las funciones del conector de la base de datos.
A continuación, cree una vista para mostrar los resultados en ViewNote. Vaya a res > diseño > Haga clic con el botón derecho en el diseño > Nuevo > Archivo XML de Android
Nombre su nuevo archivo XML view_note.xml y pegue el siguiente código.
A continuación, cree una nueva actividad para crear y actualizar datos en la base de datos. Vaya a Archivo > Nuevo > Clase y asígnele el nombre AddEditNotes.java. Seleccione su paquete llamado com.androidbegin.databasetutorial y haga clic en Finalizar .
Abra su AddEditNotes .java y pegue el siguiente código.
AñadirEditarNotas .java
paquete com.androidbegin.databasetutorial;
importar android.app.Actividad;
importar android.app.AlertDialog;
importar android.os.AsyncTask;
importar android.os.Bundle;
importar android.view.Menú;
importar android.view.MenuItem;
importar android.widget.EditText;
importar android.view.MenuItem.OnMenuItemClickListener;
la clase pública AddEditNotes extiende la actividad {
// Declarar Variables
ID de fila largo privado;
editText privado title_edit;
privado EditText note_edit;
Cadena final estática privada TITLE = "título";
Cadena final estática privada NOTA = "nota";
@Anular
public void onCreate (Paquete guardadoInstanceState) {
super.onCreate(estadoDeInstanciaGuardado);
setContentView(R.layout.add_note);
// Localiza EditText en add_note.xml
title_edit = (EditText) findViewById(R.id.titleEdit);
note_edit = (EditText) findViewById(R.id.noteEdit);
// Recuperar el ID de fila de ViewNote.java
Extras del paquete = getIntent().getExtras();
if (extras!= nulo) {
IDfila = extras.getLong("id_fila");
title_edit.setText(extras.getString(TITLE));
note_edit.setText(extras.getString(NOTA));
}
}
// Crear un menú de barra de acción
@Anular
public boolean onCreateOptionsMenu(Menú menú) {
menu.add("Guardar nota")
.setOnMenuItemClickListener(this.SaveButtonClickListener)
.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
volver super.onCreateOptionsMenu(menú);
}
// Captura el elemento del menú Guardar clic
OnMenuItemClickListener SaveButtonClickListener = nuevo OnMenuItemClickListener() {
onMenuItemClick público booleano (elemento MenuItem) {
// Pasa los datos a la función saveNote()
if (editar_título.getText().longitud() != 0) {
AsyncTask<Objeto, Objeto, Objeto> saveNoteAsyncTask = new AsyncTask<Objeto, Objeto, Objeto>() {
@Anular
Objeto protegido doInBackground(Object... params) {
guardarNota();
devolver nulo;
}
@Anular
vacío protegido en PostExecute (resultado del objeto) {
// Cerrar esta actividad
terminar();
}
};
// Ejecutar saveNoteAsyncTask AsyncTask anterior
saveNoteAsyncTask.execute((Objeto[]) nulo);
}
más {
// Mostrar un cuadro de diálogo de alerta simple que obliga al usuario a poner un título
AlertDialog.Builder alerta = new AlertDialog.Builder(
AddEditNotes.this);
alert.setTitle("El título es obligatorio");
alert.setMessage("Pon un título para esta nota");
alert.setPositiveButton("Está bien", nulo);
alerta.mostrar();
}
falso retorno;
}
};
// función guardarNota()
privado void saveNote() {
DatabaseConnector dbConnector = new DatabaseConnector(esto);
if (getIntent().getExtras() == nulo) {
// Pasa los datos a InsertNote en DatabaseConnector.java
dbConnector.InsertNote(title_edit.getText().toString(), note_edit
.getText().toString());
} más {
// Pasa el ID de fila y los datos a UpdateNote en DatabaseConnector.java
dbConnector.UpdateNote(rowID, title_edit.getText().toString(),
nota_editar.getText().toString());
}
}
}
En esta actividad, recuperamos el ID de fila y EditTexts de la clase ViewNote. Luego, los usuarios pueden realizar modificaciones en los datos y usar InsertNote() y UpdateNote() para insertar o actualizar los datos en la base de datos.
A continuación, cree un diseño gráfico XML para la clase AddEditNote. Vaya a res > diseño > Haga clic con el botón derecho en el diseño > Nuevo > Archivo XML de Android
Nombre su nuevo archivo XML add_note.xml y pegue el siguiente código.
