Tutorial de Android ORMLite con base de datos SQLite
Este tutorial lo guiará sobre cómo implementar ORMLite (un ORM muy liviano, de código abierto y compatible con Android) en un proyecto de Android y cuáles son los beneficios que puede lograr en comparación con la forma convencional de usar SQLite desde Android. Aprenderá a crear una aplicación con ORMLite que le permita almacenar y ver datos de una base de datos. Vamos a empezar…
El código fuente adjunto es una aplicación simple de Android llamada » StudentDirectory «, que almacenará los registros de los estudiantes en la base de datos SQLite junto con los detalles del profesor de su clase. Entonces, los casos de uso de las aplicaciones son:
Crear registro de profesor.
Crear registro de estudiante.
Ver la lista de estudiantes almacenados en la base de datos.
Ver la lista de profesores almacenados en la base de datos.
Pantallas de aplicación
Hay 6 pantallas en esta aplicación como se describe a continuación:
ViewStudentRecordActivity y ViewTeacherRecordActivity Para mostrar la lista de registros de estudiantes y maestros almacenados en la base de datos. Ambas actividades comparten el mismo archivo xml gráfico.
Puede descargar ambos y colocarlos en el directorio » libs » del proyecto.
2. Estructura de la tabla de la base de datos
Tenemos dos tablas en nuestra aplicación: detalles_profesor y detalles_estudiante. La tabla detalles_estudiantes contiene una asignación de clave externa a la tabla detalles_profesores como se muestra a continuación:
estudiante_detalles
Identificación del Estudiante
int (automático) – PK
nombre del estudiante
Cuerda
dirección
Cuerda
fecha_añadida
Fecha
profesor_id
Internacional – FC
detalles_del_profesor
profesor_id
int (automático) – PK
Nombre del maestro
Cuerda
dirección
Cuerda
3. Modelos de datos
Hay dos clases de modelos de datos, una para cada una de las dos tablas: TeacherDetails y StudentDetails.
Para crear una clave principal de tipo entero generada automáticamente, debe escribir un código como:
@DatabaseField(generatedId = true, columnName = "teacher_id")
public int teacherId;
Donde, columnName asigna el nombre real de la columna de la tabla de la base de datos, en caso de que tenga diferentes nombres para el campo de la base de datos y el objeto del modelo Java (aquí en la base de datos es teacher_id pero en la clase del modelo Java teacherId)
Para crear una asignación de clave externa, debe escribir un código como:
paquete com.androidbegin.studentdirectory.data;
importar java.io.Serializable;
importar com.j256.ormlite.field.DatabaseField;
clase pública TeacherDetails implementa Serializable {
/**
* Clase modelo para tabla de base de datos teacher_details
*/
privado estático final largo serialVersionUID = -222864131214757024L;
// Clave principal definida como un entero generado automáticamente
// Si el nombre de la columna de la tabla de la base de datos difiere del nombre de la variable de la clase Model, la forma de asignar para usar columnName
@DatabaseField(generatedId = true, columnName = "teacher_id")
public int teacherId;
// Definir un campo de tipo Cadena para contener el nombre del profesor
@DatabaseField(nombreColumna = "nombre_profesor")
public String nombre del maestro;
// Definir un campo de tipo Cadena para contener la dirección del estudiante
dirección de cadena pública;
// Se necesita un constructor predeterminado para SQLite, así que asegúrese de tenerlo también
public TeacherDetails(){
}
//Para nuestro propio propósito, para que sea más fácil crear un objeto TeacherDetails
Public TeacherDetails (nombre de la cadena final, dirección de la cadena final){
this.teacherName = nombre;
esta.dirección = dirección;
}
}
El siguiente código es la clase StudentDetails:
StudentDetails.java
paquete com.androidbegin.studentdirectory.data;
importar java.io.Serializable;
importar java.util.Date;
importar com.j256.ormlite.field.DatabaseField;
clase pública StudentDetails implementa Serializable {
/**
* Clase modelo para la tabla de la base de datos student_details
*/
privado estático final largo serialVersionUID = -222864131214757024L;
Cadena final estática pública ID_FIELD = "student_id";
Cadena final estática pública TEACHER_ID_FIELD = "teacher_id";
// Clave principal definida como un entero generado automáticamente
// Si el nombre de la columna de la tabla de la base de datos difiere del nombre de la variable de la clase Model, la forma de asignar para usar columnName
@DatabaseField(generatedId = true, columnName = ID_FIELD)
ID de estudiante público int;
// Definir un campo de tipo Cadena para contener el nombre del estudiante
@DatabaseField(columnName = "student_name")
public String NombreEstudiante;
// Definir un campo de tipo Cadena para contener la dirección del estudiante
dirección de cadena pública;
// Clave foránea definida para mantener asociaciones
@DatabaseField(canBeNull = falso, extranjero = verdadero, extranjeroAutoRefresh = verdadero)
public TeacherDetails profesor;
// Definir un campo de tipo Cadena para contener la fecha de inserción del estudiante
@DatabaseField(nombreColumna = "fecha_añadida")
public Fecha agregada Fecha;
// Se necesita un constructor predeterminado para SQLite, así que asegúrese de tenerlo también
Detalles del estudiante público(){
}
//Para nuestro propio propósito, para que sea más fácil crear un objeto StudentDetails
public StudentDetails (nombre de cadena final, dirección de cadena final, profesor de TeacherDetails){
this.studentName = nombre;
esta.dirección = dirección;
este.maestro = maestro;
}
}
4. Archivo de configuración ORMLite
ormlite_config.txt: este es el archivo .txt que se ha guardado en el directorio res/raw. Este archivo de configuración debe incluir todos los detalles, como el nombre del archivo bin (con el paquete), tanto el nombre del campo como el nombre de la columna, información sobre la clave externa (como se describe en la aplicación de muestra), etc.
paquete com.androidbegin.studentdirectory.data;
importar java.io.IOException;
importar java.sql.SQLException;
importar com.j256.ormlite.android.apptools.OrmLiteConfigUtil;
clase pública DatabaseConfigUtil extiende OrmLiteConfigUtil {
public static void main(String[] args) lanza SQLException, IOException {
// Proporcione el nombre del archivo .txt que ya ha creado y guardado en el directorio res/raw
writeConfigFile("ormlite_config.txt");
}
}
5. Ayudante de base de datos
Es el archivo más importante desde el punto de vista de la implementación de ORMLite, que consiste en la lógica completa de creación de archivos de base de datos, accesibilidad, etc. A continuación se muestran los puntos clave de este archivo:
Nombre y versión de la base de datos: mantenga el nombre y la versión de la base de datos como se muestra en el ejemplo.
onCreate (): este método debe incluir todas las declaraciones de creación de tablas y otras lógicas de configuración por primera vez.
onUpgrade (): el método onCreate () se ejecuta solo una vez, es decir, cuando la aplicación se ejecuta por primera vez, por lo que en caso de que la aplicación necesite alguna actualización en la base de datos (por ejemplo, creación de una nueva tabla, inserción de una nueva columna en una tabla existente, etc. ), este método debe incorporar todas esas lógicas para que la aplicación no se bloquee después de actualizarse.
DAO: los DAO son uno de los componentes más importantes en el ecosistema ORMLite, ya que son el único identificador para acceder a las tablas de la base de datos. Por lo tanto, cada tabla debe exponer un DAO, para que la aplicación pueda acceder a esta tabla cuando sea necesario.
DatabaseHelper.java
paquete com.androidbegin.studentdirectory.data;
importar java.sql.SQLException;
importar android.content.Context;
importar android.database.sqlite.SQLiteDatabase;
importar android.util.Log;
importar com.androidbegin.studentdirectory.R;
importar com.j256.ormlite.android.apptools.OrmLiteSqliteOpenHelper;
importar com.j256.ormlite.dao.Dao;
importar com.j256.ormlite.support.ConnectionSource;
importar com.j256.ormlite.table.TableUtils;
/**
* Asistente de base de datos que crea y actualiza la base de datos y proporciona los DAO para la aplicación.
*
*
*/
Clase pública DatabaseHelper extiende OrmLiteSqliteOpenHelper {
/****************************************************
* Código de copiar/pegar sugerido. Todo desde aquí hasta el bloque hecho.
***************************************************/
Cadena final estática privada DATABASE_NAME = "studentdir.db";
privado estático final int DATABASE_VERSION = 1;
Dao privado<DetallesEstudiante, Integer> estudianteDao;
privado Dao<Detalles del Profesor, Integer> profesorDao;
Public DatabaseHelper (contexto contextual) {
super(contexto, DATABASE_NAME, null, DATABASE_VERSION, R.raw.ormlite_config);
}
/****************************************************
* Sugerido Copiar/Pegar Listo
***************************************************/
@Anular
public void onCreate(SQLiteDatabase sqliteDatabase, ConnectionSource connectionSource) {
intentar {
// Crear tablas. Este método onCreate() se invocará solo una vez durante la vida útil de la aplicación, es decir, la primera vez que se inicia la aplicación.
TableUtils.createTable(conexiónFuente, TeacherDetails.class);
TableUtils.createTable(conexiónFuente, StudentDetails.class);
} captura (SQLException e) {
Log.e(DatabaseHelper.class.getName(), "No se pueden crear bases de datos", e);
}
}
@Anular
public void onUpgrade(SQLiteDatabase sqliteDatabase, ConnectionSource connectionSource, int oldVer, int newVer) {
intentar {
// En caso de cambio en la base de datos de la próxima versión de la aplicación, aumente el valor de la variable DATABASE_VERSION, luego se invocará este método
//automáticamente. El desarrollador debe manejar la lógica de actualización aquí, es decir, crear una nueva tabla o una nueva columna para una tabla existente, realizar las copias de seguridad de la
// base de datos existente, etc.
TableUtils.dropTable(connectionSource, TeacherDetails.class, true);
TableUtils.dropTable(connectionSource, StudentDetails.class, true);
onCreate(sqliteDatabase, fuente de conexión);
} captura (SQLException e) {
Log.e(DatabaseHelper.class.getName()), "No se puede actualizar la base de datos de la versión " + oldVer + " a la nueva "
+ nuevoVer, e);
}
}
// Cree los métodos getDao de todas las tablas de la base de datos para acceder a ellos desde el código de Android.
// Insertar, eliminar, leer, actualizar, todo se realizará a través de DAO
public Dao<TeacherDetails, Integer> getTeacherDao() lanza SQLException {
if (profesorDao == null) {
profesorDao = obtenerDao(ProfesorDetalles.clase);
}
volver profesorDao;
}
public Dao<StudentDetails, Integer> getStudentDao() lanza SQLException {
if (studentDao == null) {
estudianteDao = getDao(DetallesEstudiante.clase);
}
estudiante de regreso Dao;
}
}
6. ProfesorAñadirActividad
Referencia de DatabaseHelper : como mencioné anteriormente, podemos interactuar con la base de datos SQLite solo a través de los DAO que son parte de DatabaseHelper, por lo que obtener una referencia de la misma es lo siguiente que debe hacer.
Cree el objeto TeacherDetails e insértelo en la base de datos . A continuación, obtenga las entradas del usuario de la pantalla e inserte el registro en la base de datos. Puede escribir el código como:
TeacherAddActivity.java
paquete com.androidbegin.studentdirectory;
importar java.sql.SQLException;
importar android.app.Actividad;
importar android.app.AlertDialog;
importar android.content.DialogInterface;
importar android.content.Intent;
importar android.os.Bundle;
importar android.view.View;
importar android.view.View.OnClickListener;
importar android.widget.Button;
importar android.widget.EditText;
importar com.androidbegin.studentdirectory.data.DatabaseHelper;
importar com.androidbegin.studentdirectory.data.TeacherDetails;
importar com.j256.ormlite.android.apptools.OpenHelperManager;
importar com.j256.ormlite.dao.Dao;
clase pública TeacherAddActivity extiende la actividad implementa OnClickListener {
// Referencia de la clase DatabaseHelper para acceder a sus DAO y otros componentes
privado DatabaseHelper base de datosHelper = nulo;
privado EditText teacher_name_et, address_et;
Botón privado reset_btn, submit_btn;
@Anular
Vacío protegido onCreate (Paquete de estado de instancia guardado) {
super.onCreate(estadoDeInstanciaGuardado);
setContentView(R.layout.activity_add_teacher);
nombre_profesor_et = (EditText) findViewById(R.id.nombre_profesor_et);
address_et = (EditText) findViewById(R.id.address_et);
reset_btn = (Botón) findViewById(R.id.reset_btn);
enviar_btn = (Botón) findViewById(R.id.submit_btn);
reset_btn.setOnClickListener(esto);
enviar_btn.setOnClickListener(esto);
}
// Así es como se puede inicializar DatabaseHelper para uso futuro
ayudante de base de datos privado getHelper() {
si (base de datos de ayuda == nulo) {
base de datosHelper = OpenHelperManager.getHelper(this,DatabaseHelper.class);
}
volver ayudante de base de datos;
}
@Anular
vacío protegido onDestroy () {
super.onDestroy();
/*
* Necesitarás esto en tu clase para liberar al ayudante cuando hayas terminado.
*/
si (base de datos de ayuda! = nulo) {
OpenHelperManager.releaseHelper();
ayudante de base de datos = null;
}
}
@Anular
public void onClick(Ver v) {
si (v == enviar_btn)
{
// Todos los campos de entrada son obligatorios, así que hizo una verificación
if(nombre_del_profesor_et.getText().toString().trim().length() > 0 &&
dirección_et.getText().toString().trim().longitud() > 0)
{
// Una vez que haga clic en "Enviar", primero crea el objeto TeacherDetails
Final TeacherDetails techDetails = new TeacherDetails();
// Luego, establece todos los valores de la entrada del usuario
techDetails.teacherName = teacher_name_et.getText().toString();
techDetails.address = address_et.getText().toString();
intentar {
// Así es como se puede hacer una referencia del objeto DAO
final Dao<Detalles del Profesor, Integer> techerDao = getHelper().getTeacherDao();
//Esta es la forma de insertar datos en una tabla de base de datos
techerDao.create(techDetails);
Reiniciar();
mostrarDiálogo();
} captura (SQLException e) {
e.printStackTrace();
}
}
// Mostrar un cuadro de diálogo con el mensaje apropiado en caso de que los campos de entrada estén en blanco
más
{
showMessageDialog("¡¡Todos los campos son obligatorios!!");
}
}
más si (v == reset_btn)
{
Reiniciar();
}
}
privado void showMessageDialog (mensaje de cadena final)
{
AlertDialog.Builder final alertDialogBuilder = new AlertDialog.Builder(esto);
alertDialogBuilder.setMessage(mensaje);
AlertDialog final alertDialog = alertDialogBuilder.create();
alertaDialog.show();
}
// Limpiar el texto ingresado
reinicio de vacío privado ()
{
nombre_profesor_et.setText("");
dirección_et.setText("");
}
showDialog vacío privado ()
{
// Después del envío, se abre Diálogo con el mensaje "Éxito". Entonces, construya el AlartBox primero
AlertDialog.Builder final alertDialogBuilder = new AlertDialog.Builder(esto);
// Establezca el mensaje apropiado en él.
alertDialogBuilder.setMessage("¡El registro del profesor se agregó con éxito!!");
// Agregue un botón positivo y su acción. En nuestro caso, la acción sería simplemente ocultar el cuadro de diálogo,
// así que no es necesario escribir ningún código para eso.
alertDialogBuilder.setPositiveButton("Agregar más",
nueva DialogInterface.OnClickListener() {
@Anular
onClick public void (DialogInterface arg0, int arg1) {
//terminar();
}
});
// Agrega un botón negativo y su acción. En nuestro caso, simplemente abra la pantalla ViewTeacherRecordActivity
// para mostrar todos los registros
alertDialogBuilder.setNegativeButton("Ver registros",
nueva DialogInterface.OnClickListener() {
@Anular
public void onClick(DialogInterface dialog, int cual) {
Intento actividad negativa = nuevo Intento(getApplicationContext(),ViewTeacherRecordActivity.class);
iniciarActividad(actividadnegativa);
terminar();
}
});
// Ahora, crea el Diálogo y muéstralo.
AlertDialog final alertDialog = alertDialogBuilder.create();
alertaDialog.show();
}
}
7. StudentAddActivity
Obtener registros del maestro : debido a que cada estudiante debe asociar un maestro, es necesario proporcionar una opción de selección del «Profesor» para cada estudiante y, por lo tanto, obtener los registros «Detalles del maestro» de la tabla de la base de datos.
Rellenar la ruleta del maestro : para seleccionar un maestro de la lista de maestros, aquí usé una ruleta con CustomAdapter.
Cree el objeto StudentDetails e insértelo en la base de datos. A continuación, obtenga las entradas del usuario de la pantalla e inserte el registro en la base de datos. Puede escribir el código como:
StudentAddActivity.java
paquete com.androidbegin.studentdirectory;
importar java.sql.SQLException;
importar java.util.Date;
importar java.util.List;
importar android.app.Actividad;
importar android.app.AlertDialog;
importar android.content.Context;
importar android.content.DialogInterface;
importar android.content.Intent;
importar android.os.Bundle;
importar android.view.LayoutInflater;
importar android.view.View;
importar android.view.View.OnClickListener;
importar android.view.ViewGroup;
importar android.widget.ArrayAdapter;
importar android.widget.Button;
importar android.widget.EditText;
importar android.widget.Spinner;
importar android.widget.TextView;
importar com.androidbegin.studentdirectory.data.DatabaseHelper;
importar com.androidbegin.studentdirectory.data.StudentDetails;
importar com.androidbegin.studentdirectory.data.TeacherDetails;
importar com.j256.ormlite.android.apptools.OpenHelperManager;
importar com.j256.ormlite.dao.Dao;
clase pública StudentAddActivity extiende la actividad implementa OnClickListener {
// Referencia de la clase DatabaseHelper para acceder a sus DAO y otros componentes
privado DatabaseHelper base de datosHelper = nulo;
// Declaración de los componentes de la pantalla
privado EditText nombre_estudiante_et, dirección_et;
Botón privado reset_btn, submit_btn;
Spinner privado teacher_sp;
// Este objeto contendría la lista de todos los profesores, por lo que el usuario puede seleccionar uno en particular para asociarlo con un estudiante
lista privada <Detalles del profesor> lista de profesores;
@Anular
Vacío protegido onCreate (Paquete de estado de instancia guardado) {
super.onCreate(estadoDeInstanciaGuardado);
setContentView(R.layout.activity_add_student);
student_name_et = (EditText) findViewById(R.id.student_name_et);
address_et = (EditText) findViewById(R.id.address_et);
teacher_sp = (Spinner) findViewById(R.id.teacher_sp);
reset_btn = (Botón) findViewById(R.id.reset_btn);
enviar_btn = (Botón) findViewById(R.id.submit_btn);
intentar {
// Así es como se puede hacer una referencia del objeto DAO
// Necesito encontrar la lista de TeacherDetails de la base de datos, así que primero inicialice DAO para TeacherDetails
final Dao<Detalles del Profesor, Integer> enseñarDao = getHelper().getTeacherDao();
// Consultar la base de datos. Necesitamos todos los registros, así que usamos queryForAll()
ListaProfesores = enseñarDao.consultarParaTodos();
// Rellene la rueda giratoria con datos de Profesores utilizando CustomAdapter
teacher_sp.setAdapter(nuevo CustomAdapter(this,android.R.layout.simple_spinner_item, android.R.layout.simple_spinner_dropdown_item, teacherList));
} captura (SQLException e) {
e.printStackTrace();
}
reset_btn.setOnClickListener(esto);
enviar_btn.setOnClickListener(esto);
}
// Así es como se puede inicializar DatabaseHelper para uso futuro
ayudante de base de datos privado getHelper() {
si (base de datos de ayuda == nulo) {
base de datosHelper = OpenHelperManager.getHelper(this,DatabaseHelper.class);
}
volver ayudante de base de datos;
}
@Anular
vacío protegido onDestroy () {
super.onDestroy();
/*
* Necesitarás esto en tu clase para liberar al ayudante cuando hayas terminado.
*/
si (base de datos de ayuda! = nulo) {
OpenHelperManager.releaseHelper();
ayudante de base de datos = null;
}
}
@Anular
public void onClick(Ver v) {
si (v == enviar_btn)
{
// El registro de detalles del estudiante solo se agregará si existe al menos un dato de detalles del maestro en la base de datos
if(listaprofesores.tamaño() > 0)
{
// Todos los campos de entrada son obligatorios, así que hizo una verificación
if(student_name_et.getText().toString().trim().length() > 0 &&
dirección_et.getText().toString().trim().longitud() > 0)
{
// Crea el objeto StudentDetails y configura los datos ingresados en él
final StudentDetails stuDetails = new StudentDetails();
stuDetails.studentName = estudiante_nombre_et.getText().toString();
stuDetails.address = address_et.getText().toString();
stuDetails.addedDate = nueva Fecha();
// StudentDetails tiene una referencia a TeacherDetails, así que establezca la referencia también
stuDetails.teacher = (TeacherDetails) teacher_sp.getSelectedItem();
intentar {
// Ahora, necesita interactuar con la tabla/objeto StudentDetails, así que inicialice DAO para eso
final Dao<StudentDetails, Integer> estudianteDao = getHelper().getStudentDao();
//Esta es la forma de insertar datos en una tabla de base de datos
estudianteDao.create(stuDetails);
Reiniciar();
mostrarDiálogo();
} captura (SQLException e) {
e.printStackTrace();
}
}
// Mostrar un cuadro de diálogo con el mensaje apropiado en caso de que los campos de entrada estén en blanco
más
{
showMessageDialog("¡¡Todos los campos son obligatorios!!");
}
}
// Si no se encuentran datos de TeacherDetails en la base de datos, mostrar un cuadro de diálogo con el mensaje apropiado para el usuario
más
{
showMessageDialog("Por favor, agregue los detalles del maestro primero!!");
}
}
más si (v == reset_btn)
{
Reiniciar();
}
}
privado void showMessageDialog (mensaje de cadena final)
{
AlertDialog.Builder final alertDialogBuilder = new AlertDialog.Builder(esto);
alertDialogBuilder.setMessage(mensaje);
AlertDialog final alertDialog = alertDialogBuilder.create();
alertaDialog.show();
}
// Limpiar el texto ingresado
reinicio de vacío privado ()
{
estudiante_nombre_et.setText("");
dirección_et.setText("");
}
showDialog vacío privado ()
{
// Después del envío, se abre Diálogo con el mensaje "Éxito". Entonces, construya el AlartBox primero
AlertDialog.Builder final alertDialogBuilder = new AlertDialog.Builder(esto);
// Establezca el mensaje apropiado en él.
alertDialogBuilder.setMessage("¡Registro de estudiante agregado con éxito!!");
// Agregue un botón positivo y su acción. En nuestro caso, la acción sería simplemente ocultar el cuadro de diálogo.
// así que no es necesario escribir ningún código para eso.
alertDialogBuilder.setPositiveButton("Agregar más",
nueva DialogInterface.OnClickListener() {
@Anular
onClick public void (DialogInterface arg0, int arg1) {
}
});
// Agrega un botón negativo y su acción. En nuestro caso, simplemente abra la pantalla ViewStudentRecordActivity
//para mostrar todos los registros
alertDialogBuilder.setNegativeButton("Ver registros",
nueva DialogInterface.OnClickListener() {
@Anular
public void onClick(DialogInterface dialog, int cual) {
Intención final Actividad negativa = nueva Intención (getApplicationContext(), ViewStudentRecordActivity.class);
iniciarActividad(actividadnegativa);
terminar();
}
});
// Ahora, crea el Diálogo y muéstralo.
AlertDialog final alertDialog = alertDialogBuilder.create();
alertaDialog.show();
}
// Adaptador personalizado para alimentar datos al Teacher Spinner
@SuppressWarnings("tipos sin procesar")
clase CustomAdapter extiende ArrayAdapter<String>
{
LayoutInflater inflador;
// Contiene datos de los detalles del maestro
Listar objetos;
@SuppressWarnings("desmarcado")
public CustomAdapter (contexto contexto, int recurso, int dropDownViewResource, lista de objetos) {
super(contexto, recurso, objetos);
this.setDropDownViewResource(dropDownViewResource);
inflador = (LayoutInflater)context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
// establece los objetos de Detalles del profesor para completar el Spinner
esto.objetos = objetos;
}
@Anular
public View getView (posición int, View convertView, ViewGroup parent) {
return getCustomView(posición, convertView, padre);
}
@Anular
vista pública getDropDownView (posición int, vista convertView, padre de ViewGroup) {
return getCustomView(posición, convertView, padre);
}
// Infle la vista de diseño de la ruleta predeterminada de Android, establezca la etiqueta de acuerdo con los datos pasados y
// devuelve la vista para que se muestre como una fila de Teacher Spinner
vista pública getCustomView (posición int, vista convertView, padre ViewGroup) {
fila de Vista final = inflater.inflate(android.R.layout.simple_spinner_item, padre, falso);
etiqueta final de TextView = (TextView) fila.findViewById(android.R.id.text1);
final TeacherDetails profesor = (TeacherDetails) this.objects.get(position);
etiqueta.setText(profesor.nombredelprofesor);
fila de retorno;
}
}
}
8. Ver actividad del registro del estudiante
Obtener registros de estudiantes de la base de datos
Eliminar una fila seleccionada : para eliminar el registro de un estudiante, debe mantener presionada la fila en particular y continuar.
ViewStudentRecordActivit.java
paquete com.androidbegin.studentdirectory;
importar java.sql.SQLException;
importar java.util.List;
importar android.app.Actividad;
importar android.app.AlertDialog;
importar android.content.Context;
importar android.content.DialogInterface;
importar android.os.Bundle;
importar android.view.LayoutInflater;
importar android.view.View;
importar android.widget.AdapterView;
importar android.widget.AdapterView.OnItemClickListener;
importar android.widget.AdapterView.OnItemLongClickListener;
importar android.widget.ListView;
importar android.widget.TextView;
importar com.androidbegin.studentdirectory.data.DatabaseHelper;
importar com.androidbegin.studentdirectory.data.StudentDetails;
importar com.androidbegin.studentdirectory.data.TeacherDetails;
importar com.j256.ormlite.android.apptools.OpenHelperManager;
importar com.j256.ormlite.dao.Dao;
clase pública ViewStudentRecordActivity extiende la actividad implementa OnItemClickListener, OnItemLongClickListener {
// Referencia de la clase DatabaseHelper para acceder a sus DAO y otros componentes
privado DatabaseHelper base de datosHelper = nulo;
// Este ListView muestra la lista de datos de los detalles del estudiante obtenidos de la base de datos.
vista de lista ListView privada;
// Esto contiene el valor del número de fila, que el usuario ha seleccionado para acciones posteriores
privado int seleccionadoRecordPosition = -1;
// Declaración de DAOs para interactuar con la tabla correspondiente
privado Dao<Detalles del Profesor, Integer> techerDao;
Dao privado<DetallesEstudiante, Integer> estudianteDao;
// Contiene la lista de objetos StudentDetails obtenidos de la base de datos
lista privada <Detalles del estudiante> lista de estudiantes;
@Anular
Vacío protegido onCreate (Paquete de estado de instancia guardado) {
super.onCreate(estadoDeInstanciaGuardado);
setContentView(R.layout.activity_view_recd);
listview = (ListView) findViewById(R.id.listview);
intentar {
// Así es como se puede hacer una referencia del objeto DAO
techerDao = getHelper().getTeacherDao();
estudianteDao = getHelper().getStudentDao();
// Consultar la base de datos. Necesitamos todos los registros, así que usamos queryForAll()
listaEstudiantes = estudianteDao.queryForAll();
// Establecer el encabezado de ListView
inflador LayoutInflater final = (LayoutInflater) this.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
vista final rowView = inflater.inflate(R.layout.list_item, listview, false);
vista de lista.addHeaderView (vista de fila);
// Ahora, vincule RecordArrayAdapter con ListView
listview.setAdapter(nuevo RecordArrayAdapter(this, R.layout.list_item, studentList, techerDao));
// Adjunte OnItemLongClickListener y OnItemClickListener para rastrear la acción del usuario y actuar en consecuencia
listview.setOnItemLongClickListener(esto);
listview.setOnItemClickListener(esto);
// Si no se encuentra ningún registro en la base de datos, se debe mostrar el mensaje correspondiente.
poblarNoRecordMsg();
} captura (SQLException e) {
e.printStackTrace();
}
}
vacío privado populateNoRecordMsg()
{
// Si no se encuentra ningún registro en la base de datos, se debe mostrar el mensaje correspondiente.
if(listaestudiantes.tamaño() == 0)
{
TextView final tv = new TextView(esto);
tv.setPadding(5, 5, 5, 5);
tv.establecerTamañoTexto(15);
tv.setText("¡No se encontraron registros!!");
vista de lista.addFooterView (tv);
}
}
// Así es como se puede inicializar DatabaseHelper para uso futuro
ayudante de base de datos privado getHelper() {
si (base de datos de ayuda == nulo) {
base de datosHelper = OpenHelperManager.getHelper(this, DatabaseHelper.class);
}
volver ayudante de base de datos;
}
@Anular
vacío protegido onDestroy () {
super.onDestroy();
/*
* Necesitarás esto en tu clase para liberar al ayudante cuando hayas terminado.
*/
si (base de datos de ayuda! = nulo) {
OpenHelperManager.releaseHelper();
ayudante de base de datos = null;
}
}
@Anular
public void onItemClick(AdapterView<?> padre, vista de vista, posición int, id largo) {
si (posición > 0)
{
// Pantalla de detalles que muestra el código que se puede colocar aquí
}
}
@Anular
public boolean onItemLongClick(AdapterView<?> padre, vista de vista, posición int, id largo) {
// Si la fila presionada no es un encabezado, actualice la posición del registro seleccionado y muestre el cuadro de diálogo para una selección adicional
si (posición > 0)
{
seleccionóRecordPosition = posición - 1;
mostrarDiálogo();
}
devolver verdadero;
}
showDialog vacío privado ()
{
// Antes de eliminar el registro presionado durante mucho tiempo, debe confirmar con el usuario. Entonces, construya el AlartBox primero
AlertDialog.Builder final alertDialogBuilder = new AlertDialog.Builder(esto);
// Establezca el mensaje apropiado en él.
alertDialogBuilder.setMessage("¿Realmente desea eliminar el registro seleccionado?");
// Agregue un botón positivo y su acción. En nuestro caso la acción sería la eliminación de los datos
alertDialogBuilder.setPositiveButton("Eliminar",
nueva DialogInterface.OnClickListener() {
@Anular
onClick public void (DialogInterface arg0, int arg1) {
intentar {
// Así es como se pueden eliminar los datos de la base de datos
studentDao.delete(studentList.get(selectedRecordPosition));
// Eliminando lo mismo de la Lista para eliminarlo también de la pantalla
listadeestudiantes.remove(posiciónRegistroSeleccionado);
vista de lista.invalidarVistas();
// Restablecer el valor de selectedRecordPosition
posición de registro seleccionado = -1;
poblarNoRecordMsg();
} captura (Excepción e) {
e.printStackTrace();
}
}
});
// Agrega un botón negativo y su acción. En nuestro caso, simplemente oculte el cuadro de diálogo.
alertDialogBuilder.setNegativeButton("Cancelar",
nueva DialogInterface.OnClickListener() {
@Anular
public void onClick(DialogInterface dialog, int cual) {
}
});
// Ahora, crea el Diálogo y muéstralo.
AlertDialog final alertDialog = alertDialogBuilder.create();
alertaDialog.show();
}
}
9. Ver la actividad del registro del profesor
Obtener registros de maestros de la base de datos
Eliminar una fila seleccionada : para eliminar el registro de un maestro, debe mantener presionada la fila en particular y continuar.
Ver detalles del maestro : para ver los detalles del maestro, es decir, los estudiantes asociados a un maestro seleccionado, debe tocar la fila en particular. Puede escribir el código como:
ViewTeacherRecordActivit.java
paquete com.androidbegin.studentdirectory;
importar java.sql.SQLException;
importar java.util.List;
importar android.app.Actividad;
importar android.app.AlertDialog;
importar android.content.Context;
importar android.content.DialogInterface;
importar android.content.Intent;
importar android.os.Bundle;
importar android.view.LayoutInflater;
importar android.view.View;
importar android.widget.AdapterView;
importar android.widget.AdapterView.OnItemClickListener;
importar android.widget.AdapterView.OnItemLongClickListener;
importar android.widget.ListView;
importar android.widget.TextView;
importar com.androidbegin.studentdirectory.data.DatabaseHelper;
importar com.androidbegin.studentdirectory.data.TeacherDetails;
importar com.j256.ormlite.android.apptools.OpenHelperManager;
importar com.j256.ormlite.dao.Dao;
clase pública ViewTeacherRecordActivity extiende la actividad implementa OnItemClickListener, OnItemLongClickListener {
// Referencia de la clase DatabaseHelper para acceder a sus DAO y otros componentes
privado DatabaseHelper base de datosHelper = nulo;
// Este ListView muestra la lista de datos de detalles del profesor obtenidos de la base de datos.
vista de lista ListView privada;
// Esto contiene el valor del número de fila, que el usuario ha seleccionado para acciones posteriores
privado int seleccionadoRecordPosition = -1;
// Declaración de DAO para interactuar con la tabla correspondiente
privado Dao<Detalles del Profesor, Integer> profesorDao;
// Contiene la lista de objetos TeacherDetails obtenidos de la base de datos
lista privada <Detalles del profesor> lista de profesores;
@Anular
Vacío protegido onCreate (Paquete de estado de instancia guardado) {
super.onCreate(estadoDeInstanciaGuardado);
setContentView(R.layout.activity_view_recd);
listview = (ListView) findViewById(R.id.listview);
((TextView)findViewById(R.id.header_tv)).setText("Ver registros del profesor");
intentar {
// Así es como se puede hacer una referencia del objeto DAO
profesorDao = obtenerAyudante().obtenerProfesorDao();
// Consultar la base de datos. Necesitamos todos los registros, así que usamos queryForAll()
listaprofesores = profesorDao.queryForAll();
// Establecer el encabezado de ListView
inflador LayoutInflater final = (LayoutInflater) this.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
vista final rowView = inflater.inflate(R.layout.list_item, listview, false);
((TextView)rowView.findViewById(R.id.teacher_tv)).setText("Dirección");
((TextView)rowView.findViewById(R.id.student_name_tv)).setText("Nombre del profesor");
vista de lista.addHeaderView (vista de fila);
// Ahora, vincule RecordArrayAdapter con ListView
listview.setAdapter(nuevo RecordArrayAdapter(this, R.layout.list_item, teacherList, teacherDao));
// Adjunte OnItemLongClickListener y OnItemClickListener para rastrear la acción del usuario y actuar en consecuencia
listview.setOnItemLongClickListener(esto);
listview.setOnItemClickListener(esto);
// Si no se encuentra ningún registro en la base de datos, se debe mostrar el mensaje correspondiente.
poblarNoRecordMsg();
} captura (SQLException e) {
e.printStackTrace();
}
}
vacío privado populateNoRecordMsg()
{
// Si no se encuentra ningún registro en la base de datos, se debe mostrar el mensaje correspondiente.
if(lista de profesores.tamaño() == 0)
{
TextView final tv = new TextView(esto);
tv.setPadding(5, 5, 5, 5);
tv.establecerTamañoTexto(15);
tv.setText("¡No se encontraron registros!!");
vista de lista.addFooterView (tv);
}
}
// Así es como se puede inicializar DatabaseHelper para uso futuro
ayudante de base de datos privado getHelper() {
si (base de datos de ayuda == nulo) {
base de datosHelper = OpenHelperManager.getHelper(this, DatabaseHelper.class);
}
volver ayudante de base de datos;
}
@Anular
vacío protegido onDestroy () {
super.onDestroy();
/*
* Necesitarás esto en tu clase para liberar al ayudante cuando hayas terminado.
*/
si (base de datos de ayuda! = nulo) {
OpenHelperManager.releaseHelper();
ayudante de base de datos = null;
}
}
@Anular
public void onItemClick(AdapterView<?> padre, vista de vista, posición int, id largo) {
// Si la fila presionada no es un encabezado, actualice la posición del registro seleccionado y represente la pantalla ViewTeacherDetailsActivity
si (posición > 0)
{
seleccionóRecordPosition = posición - 1;
// Pantalla de detalles que muestra el código que se puede colocar aquí
intención final intención = nueva intención (esto, ViewTeacherDetailsActivity.class);
intent.putExtra("detalles",teacherList.get(selectedRecordPosition));
iniciarActividad(intención);
}
}
@Anular
public boolean onItemLongClick(AdapterView<?> padre, vista de vista, posición int, id largo) {
// Si la fila presionada durante mucho tiempo no es un encabezado, actualice la posición del registro seleccionado y muestre el cuadro de diálogo
si (posición > 0)
{
seleccionóRecordPosition = posición - 1;
mostrarDiálogo();
}
devolver verdadero;
}
showDialog vacío privado ()
{
// Antes de eliminar el registro presionado durante mucho tiempo, debe confirmar con el usuario. Entonces, construya el AlartBox primero
AlertDialog.Builder final alertDialogBuilder = new AlertDialog.Builder(esto);
// Establezca el mensaje apropiado en él.
alertDialogBuilder.setMessage("¿Realmente desea eliminar el registro seleccionado?");
// Agregue un botón positivo y su acción. En nuestro caso la acción sería la eliminación de los datos
alertDialogBuilder.setPositiveButton("Eliminar",
nueva DialogInterface.OnClickListener() {
@Anular
onClick public void (DialogInterface arg0, int arg1) {
intentar {
// Así es como se pueden eliminar los datos de la base de datos
teacherDao.delete(teacherList.get(selectedRecordPosition));
// Eliminando lo mismo de la Lista para eliminarlo también de la pantalla
Listadocentes.remove(PosiciónRegistroseleccionado);
vista de lista.invalidarVistas();
// Restablecer el valor de selectedRecordPosition
posición de registro seleccionado = -1;
poblarNoRecordMsg();
} captura (Excepción e) {
e.printStackTrace();
}
}
});
// Agrega un botón negativo y su acción. En nuestro caso, simplemente oculte el cuadro de diálogo.
alertDialogBuilder.setNegativeButton("Cancelar",
nueva DialogInterface.OnClickListener() {
@Anular
public void onClick(DialogInterface dialog, int cual) {
}
});
// Ahora, crea el Diálogo y muéstralo.
AlertDialog final alertDialog = alertDialogBuilder.create();
alertaDialog.show();
}
}
10. Ver actividad de detalles del profesor
Obtener datos del maestro de la intención : primero, debe recibir los datos «Serializables», que pasamos de la pantalla anterior.
Cree y prepare la consulta : lo siguiente es obtener los datos de los estudiantes para el profesor seleccionado y debemos crear y preparar una consulta para el mismo.
Obtenga solo registros de estudiantes coincidentes de la base de datos : puede escribir el código como:
ViewTeacherDetailsActivity.java
paquete com.androidbegin.studentdirectory;
importar java.sql.SQLException;
importar java.util.ArrayList;
importar java.util.Iterator;
importar java.util.List;
importar android.app.Actividad;
importar android.os.Bundle;
importar android.view.View;
importar android.view.View.OnClickListener;
importar android.widget.Button;
importar android.widget.TextView;
importar com.androidbegin.studentdirectory.data.DatabaseHelper;
importar com.androidbegin.studentdirectory.data.StudentDetails;
importar com.androidbegin.studentdirectory.data.TeacherDetails;
importar com.j256.ormlite.android.apptools.OpenHelperManager;
importar com.j256.ormlite.dao.Dao;
importar com.j256.ormlite.stmt.PreparedQuery;
importar com.j256.ormlite.stmt.QueryBuilder;
clase pública ViewTeacherDetailsActivity extiende la actividad implementa OnClickListener {
// Referencia de la clase DatabaseHelper para acceder a sus DAO y otros componentes
privado DatabaseHelper base de datosHelper = nulo;
// Declaración de los componentes de la pantalla
vista de texto privada nombre_del_profesor_et, dirección_et, estudiantes_et;
Botón privado close_btn;
// Declaración de DAO para interactuar con la tabla correspondiente
Dao privado<DetallesEstudiante, Integer> estudianteDao;
@Anular
Vacío protegido onCreate (Paquete de estado de instancia guardado) {
super.onCreate(estadoDeInstanciaGuardado);
setContentView(R.layout.activity_view_teacher);
nombre_del_profesor_et = (TextView) findViewById(R.id.nombre_del_profesor_et);
address_et = (TextView) findViewById(R.id.address_et);
estudiantes_et = (TextView) findViewById(R.id.students_et);
close_btn = (Botón) findViewById(R.id.close_btn);
close_btn.setOnClickListener(esto);
//Recibir el objeto TeacherDetails que se envió en la pantalla anterior a través de Intent
final TeacherDetails tDetails = (TeacherDetails) getIntent().getExtras().getSerializable("detalles");
nombre_del_profesor_et.setText(tDetails.nombredelprofesor);
dirección_et.setText(tDetalles.dirección);
// Esta cadena contendría la lista de todos los nombres de los estudiantes asociados (separados por comas) para el profesor seleccionado
final List<String> estudianteNombre = new ArrayList<String>();
intentar {
// Así es como se puede hacer una referencia del objeto DAO
estudianteDao = getHelper().getStudentDao();
// Obtenga nuestro generador de consultas del DAO
final QueryBuilder<StudentDetails, Integer> queryBuilder = estudianteDao.queryBuilder();
// Solo necesitamos Estudiantes que estén asociados con el Profesor seleccionado, así que cree la consulta mediante la cláusula "Dónde"
queryBuilder.where().eq(StudentDetails.TEACHER_ID_FIELD, tDetails.teacherId);
// Preparar nuestra sentencia SQL
final PreparedQuery<StudentDetails> PreparedQuery = queryBuilder.prepare();
// Obtener la lista de la base de datos consultandola
final Iterator<StudentDetails> StudentsIt = studentDao.query(preparedQuery).iterator();
// Iterar a través del iterador de objetos StudentDetails y completar la cadena separada por comas
while (studentsIt.hasNext()) {
final StudentDetails sDetails = StudentsIt.next();
NombreEstudiante.add(sDetalles.NombreEstudiante);
}
} captura (SQLException e) {
e.printStackTrace();
}
estudiantes_et.setText(studentName.toString());
}
// Así es como se puede inicializar DatabaseHelper para uso futuro
ayudante de base de datos privado getHelper() {
si (base de datos de ayuda == nulo) {
base de datosHelper = OpenHelperManager.getHelper(this,DatabaseHelper.class);
}
volver ayudante de base de datos;
}
@Anular
vacío protegido onDestroy () {
super.onDestroy();
/*
* Necesitarás esto en tu clase para liberar al ayudante cuando hayas terminado.
*/
si (base de datos de ayuda! = nulo) {
OpenHelperManager.releaseHelper();
ayudante de base de datos = null;
}
}
@Anular
public void onClick(Ver v) {
si (v == cerrar_btn){
terminar();
}
}
}
11. Actividad principal
Se crearon cuatro botones para acceder a las clases apropiadas.
MainActivity.java
paquete com.androidbegin.studentdirectory;
importar android.app.Actividad;
importar android.content.Intent;
importar android.os.Bundle;
importar android.util.Log;
importar android.view.View;
importar android.view.View.OnClickListener;
importar android.widget.Button;
clase pública MainActivity extiende la actividad implementa OnClickListener {
// Declaración de los cuatro botones de la pantalla principal
Botón privado add_student_btn, add_teacher_btn, view_btn, view_teacher_btn;
@Anular
Vacío protegido onCreate (Paquete de estado de instancia guardado) {
super.onCreate(estadoDeInstanciaGuardado);
setContentView(R.diseño.actividad_principal);
// Inicialización de los cuatro botones de la pantalla principal
add_student_btn = (Botón) findViewById(R.id.add_student_btn);
add_teacher_btn = (Botón) findViewById(R.id.add_teacher_btn);
view_btn = (Botón) findViewById(R.id.view_btn);
view_teacher_btn = (Botón) findViewById(R.id.view_teacher_btn);
// Adjunto de onClickListner para ellos
add_student_btn.setOnClickListener(esto);
add_teacher_btn.setOnClickListener(esto);
view_btn.setOnClickListener(esto);
view_teacher_btn.setOnClickListener(esto);
}
@Anular
public void onClick(Ver v) {
// Mostrar la pantalla StudentAddActivity una vez que haga clic en el botón "Add Student"
Registro.v("abc", "" + v);
if(v == agregar_estudiante_btn) {
startActivity(new Intent(this, StudentAddActivity.class));
}
// Mostrar la pantalla TeacherAddActivity una vez que haga clic en el botón "Add Teacher"
más si (v == agregar_maestro_btn) {
startActivity(new Intent(this, TeacherAddActivity.class));
}
// Mostrar la pantalla ViewStudentRecordActivity una vez que haga clic en el botón "Ver registros de estudiantes"
más si (v == view_btn) {
startActivity(new Intent(this, ViewStudentRecordActivity.class));
}
// Renderice la pantalla ViewTeacherRecordActivity una vez que haga clic en el botón "Ver registros del maestro"
más si (v == view_teacher_btn) {
startActivity(new Intent(this, ViewTeacherRecordActivity.class));
}
}
}
12. Adaptador de matriz de registros
Un adaptador de matriz para la vista de lista.
RecordArrayAdapte.java
paquete com.androidbegin.studentdirectory;
importar java.util.List;
importar android.content.Context;
importar android.view.LayoutInflater;
importar android.view.View;
importar android.view.ViewGroup;
importar android.widget.ArrayAdapter;
importar android.widget.TextView;
importar com.androidbegin.studentdirectory.data.StudentDetails;
importar com.androidbegin.studentdirectory.data.TeacherDetails;
importar com.j256.ormlite.dao.Dao;
@SuppressWarnings("tipos sin procesar")
clase pública RecordArrayAdapter extiende ArrayAdapter<String> {
inflador LayoutInflater privado;
// Esto mantendría los objetos de la base de datos. Podrían ser objetos TeacherDetails o StudentDetails
registros de listas privadas;
// Declaración de DAO para interactuar con la tabla correspondiente
privado Dao<Detalles del Profesor, Integer> profesorDao;
@SuppressWarnings("desmarcado")
public RecordArrayAdapter(Context context, int resource, List objects, Dao<TeacherDetails, Integer> teacherDao) {
super(contexto, recurso, objetos);
this.records = objetos;
this.teacherDao = teacherDao;
inflador = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
}
@Anular
public View getView (posición int, View convertView, ViewGroup parent) {
//Reutilizar la vista para suavizar el efecto de desplazamiento
si (convertirVista == nulo)
convertView = inflater.inflate(R.layout.list_item, parent, false);
// Si ListView necesita mostrar los registros de los objetos StudentDetails
if(records.get(position).getClass().isInstance(new StudentDetails())){
final StudentDetails studentDetails = (StudentDetails) registros.get(posición);
intentar {
// Invocando el método refresh() para obtener los datos de referencia almacenados en la tabla/objeto TeacherDetails
// Básicamente, es un ejemplo de Lazy loading. Unirá dos mesas internamente solo bajo demanda
profesorDao.refresh(studentDetails.teacher);
} captura (Excepción e) {
e.printStackTrace();
}
((TextView)convertView.findViewById(R.id.student_name_tv)).setText(studentDetails.studentName);
((TextView)convertView.findViewById(R.id.teacher_tv)).setText(studentDetails.teacher.teacherName);
}
// Si ListView necesita mostrar los registros de los objetos TeacherDetails
más{
final TeacherDetails teacherDetails = (TeacherDetails) registros.get(posición);
((TextView)convertView.findViewById(R.id.student_name_tv)).setText(teacherDetails.teacherName);
((TextView) convertView.findViewById(R.id.teacher_tv)).setText(teacherDetails.address);
}
volver convertView;
}
}
13. Manifiesto de Android
Abra su AndroidManifest.xml y declare las actividades requeridas.
