GUÍA PARA

DESARROLLAR UN
PROYECTO WEB DE
JAVA CON MYSQL
SENA - ADSI

Guía con los nueve pasos para desarrollar una sencilla

aplicación web con acceso a datos de una base de dato
MySQL. Para poder entender este manual usted debe
tener conocimientos básicos en: bases de datos, java,
html y javascript.

Yeimmy Lee
Contenido
GUÍA PARA DEARROLLAR UN PROYECTO WEB DE JAVA CON MYSQL ................................................ 2
PASO 1. Crear la base de datos ........................................................................................................... 3
PASO 2. Crear proyecto web en netbeans .......................................................................................... 4
PASO 3. Crear paquetes en la carpeta de recursos............................................................................. 6
PASO 4. Incluir la librería JDBC ............................................................................................................ 8
PASO 5. Crear las clases Value Object ............................................................................................... 11
PASO 6. Crear la clase conexión ........................................................................................................ 14
Paso 7. Crear las clases Data Access Object ...................................................................................... 16
PASO 8. Crear el controlador: Servlet ............................................................................................... 29
PASO 9. Crear los JSP......................................................................................................................... 43
 GUÍA PARA DESARROLLAR UN PROYECTO WEB DE JAVA CON MYSQL

El proyecto a desarrollar consiste en un sistema de notas, donde se guarda el aprendiz, las

evidencias y las notas de cada aprendiz por cada evidencia. El sistema también tendrá manejo de
usuarios.

En este documento voy a tratar de explicar los pasos básicos para poder hacer este proyecto. Yo
les envío el código fuente para que ustedes se puedan guiar.

Recordando nuestro modelo en capas:

VISTA
(JSP, CSS Y JS)
CONTROLADOR
(SERVLET)
MODELO
(SERVICE, DAO y VO)

BD

La recomendación es trabajar de abajo para arriba, es decir, empezar por la base de datos, luego el
modelo, controlador y vista, en ese orden. No es obligatorio, es una recomendación.

PASOS

Les recuerdo los nueve pasos mencionados en clase, en este tutorial los pasos tendrán unos pequeños
ajustes:

1. Crear la base de datos con las tablas necesarias.

2. Crear proyecto web en Netbeans.
3. Crear cuatro paquetes en la carpeta de recursos:
 controlador
 service
 modelo.dao
 modelo.vo
4. Incluir la librería JDBC
5. Crear las clases Value Object.
6. Crear la clase conexión con dos métodos: conectar() y desconectar().
7. Crear las clases Data Access Object que hereden de la clase de conexión.
8. Crear el controlador: Servlet
9. Crear los JSP

A continuación se describirán cada uno de estos pasos.

PASO 1. Crear la base de datos

Creamos la base de datos con sus tres tablas1:

1
Como anexos se adjuntará el archivo .sql con la base de datos.
PASO 2. Crear proyecto web en netbeans

Creamos un proyecto web en netbeans. Para esto seleccionamos Archivo (File) y después Nuevo
proyecto (New Project)

Nos abre un asistente, donde seleccionamos en Categorías (Categories) la opción Java Web, y en el
siguiente panel Proyectos (Projects), seleccionamos Web Application. Clic en Siguiente (Next).
En la siguiente pantalla nos solicita un nombre y una ubicación. Clic en Siguiente (Next)

En la siguiente pantalla nos pregunta qué servidor queremos usar. Clic en Finalizar (Finish).
PASO 3. Crear paquetes en la carpeta de recursos

Creamos tres paquetes: (controlador, modelo.dao y modelo.vo). Para ello simplemente nos
ubicamos sobre la carpeta Source Packages, y seleccionamos Nuevo (New) y luego elegimos la
opción Paquete Java (Java Package).

Nos carga un asistente que nos solicita el nombre del paquete y damos clic en Finalizar (Finish)
De este mismo modo creamos los otros dos paquetes, nuestra aplicación va quedando así:

A su vez, así se ve en el directorio del proyecto:

PASO 4. Incluir la librería JDBC

Para que la conexión a MySQL funcione debemos importar la librería con el driver JDBC para mySQL,
para esto vamos a las propiedades del proyecto. Clic derecho sobre el proyecto y seleccionamos
Propiedades (Properties).

Nos aparece esta ventana de propiedades:

Entramos a la opción Librerías (Libraries)

Seleccionamos la opción Adicionar Librería (Add Library…). Nos carga la siguiente ventana:

Ahí buscamos la librería MySQL JDBC Driver, damos clic en Adicionar Librería (Add Library), nos
deja nuevamente en la ventana de propiedades, allí damos clic en Aceptar (OK).
Si la librería no aparece en el listado de librerías, se puede buscar en Internet, y se carga el archivo
por la opción Agregar JAR/Carpeta (Add JAR/Folder)2.

2
Como parte de los elementos anexos a este documento se enviará el JAR del driver JDBC para MySQL.
PASO 5. Crear las clases Value Object

En la capa de Modelo vamos a tener dos tipos de elementos: Clases VO (Value Object) y clases
DAO (Data Access Object), que nos permiten manipular la información de la base de datos.

Clases Value Object (VO)

Son la representación de cada una de las tablas de nuestra base de datos, es decir por cada tabla
en nuestro modelo de datos vamos a crear una clase Value Object. Es recomendable que la clase
tenga el mismo nombre de la tabla y termine con las letras VO, para así identificar rápidamente
que esa clase es un Value Object. Cada Clase VO, va a tener como atributos los campos de la tabla
y los métodos serán los get y set para encapsular cada atributo.

Ejemplo: la tabla aprendiz tiene siete campos: id_aprendiz, nombre, direccion, telefono,
correo, fecha_nacimiento y ficha. Entonces la clase AprendizVO tendrá siete atributos
privados, siete métodos get y siete métodos set.

Clase AprendizVO

public class AprendizVO {

private long idAprendiz;

private String nombre;
private String correo;
private String direccion;
private long telefono;
private String ficha;
private Date fechaNacimiento;

public String getCorreo() {

return correo;
}

public void setCorreo(String correo) {

this.correo = correo;
}

public String getDireccion() {

return direccion;
}

public void setDireccion(String direccion) {

this.direccion = direccion;
}

public Date getFechaNacimiento() {

return fechaNacimiento;
}
 public void setFechaNacimiento(Date fechaNacimiento) {
this.fechaNacimiento = fechaNacimiento;
}

public String getFicha() {

return ficha;
}

public void setFicha(String ficha) {

this.ficha = ficha;
}

public long getId() {

return idAprendiz;
}

public void setId(long idAprendiz) {

this.idAprendiz = idAprendiz;
}

public String getNombre() {

return nombre;
}

public void setNombre(String nombre) {

this.nombre = nombre;
}

public long getTelefono() {

return telefono;
}

public void setTelefono(long telefono) {

this.telefono = telefono;
}
}

Siguiendo estas recomendaciones generamos las clases Value Object para las otras dos tablas, sin
embargo para el VO de la tabla Calificaciones hay una pequeña diferencia, debido a que esta tabla
solamente tiene el id del aprendiz, el id de la evidencia y el puntaje obtenido, el VO se complementa
un poco para mostrar información útil en la lista, entonces vamos a crear cinco atributos: idAprendiz,
nombreAprendiz, idEvidencia, nombreEvidencia, puntaje. La clase CalificacionVO quedaría así:

Clase CalificacionVO

public class CalificacionVO {

private long idAprendiz;
private int idEvidencia;
private String nombreAprendiz;
 private String nombreEvidencia;
private float puntaje;

public long getIdAprendiz() {

return idAprendiz;
}

public void setIdAprendiz(long idAprendiz) {

this.idAprendiz = idAprendiz;
}

public int getIdEvidencia() {

return idEvidencia;
}

public void setIdEvidencia(int idEvidencia) {

this.idEvidencia = idEvidencia;
}

public String getNombreAprendiz() {

return nombreAprendiz;
}

public void setNombreAprendiz(String nombreAprendiz) {

this.nombreAprendiz = nombreAprendiz;
}

public String getNombreEvidencia() {

return nombreEvidencia;
}

public void setNombreEvidencia(String nombreEvidencia) {

this.nombreEvidencia = nombreEvidencia;
}

public float getPuntaje() {

return puntaje;
}

public void setPuntaje(float puntaje) {

this.puntaje = puntaje;
}
}

La clase VO de la tabla Evidencia si se crea igual que la de Aprendiz, es decir, únicamente con los
atributos correspondientes a los campos de la tabla.
PASO 6. Crear la clase conexión

Teniendo en cuenta que siempre se debe hacer la conexión y la desconexión a la base de datos, se
crea una clase que se encargue de hacer esas dos tareas y todos los DAO heredarán de esa clase. A
esta clase la vamos a llamar ConexionDAO.

Clase ConexionDAO

import java.sql.Connection;
import java.sql.DriverManager;

public class ConexionDAO {

public Connection con;

public void conectar() {

try {
//Importar librería JDBC para MYSQL
Class.forName("com.mysql.jdbc.Driver");

//Conectarme a la BD
this.con = DriverManager.getConnection(
"jdbc:mysql://localhost/notas",
"root",
"root");

} catch (Exception e) {
System.out.println("Error: " + e.getMessage());
}
}

public void desconectar() {

try {
if (this.con != null && !this.con.isClosed()) {
this.con.close();
}
} catch (Exception e) {
System.out.println("Error: " + e.getMessage());
}
}
}

Esta clase tiene únicamente dos métodos: conectar y desconectar. A continuación de explican
algunas cosas importantes en esta clase:

LÍNEA EXPLICACIÓN
Class.forName("com.mys Así se importa el Driver JDBC de MySQL
ql.jdbc.Driver");
this.con = Con esta línea realizamos la conexión. El método getConnection()
DriverManager. recibe tres parámetros:
getConnection("jdbc:my 1. "jdbc:mysql://localhost/notas" //es la cadena de
sql://localhost/notas"
, "root", "root");
conexión, lo sombreado usted debe personalizarlo, la
palabra localhost representa el servidor de base de datos,
en aplicaciones académicas normalmente está en el mismo
servidor por eso se pone localhost, la palabra notas
representa el nombre de la base de datos, en mi caso la base
de datos se llama notas. Lo demás queda igualito.
2. "root" //es el usuario del servidor de bases de datos. El
mismo que usa en heidiSQL.
3. "root" //es la clave del servidor de bases de datos. El
mismo que usa en heidiSQL.

this.con.close(); Para desconectarse se llama el método close(), no recibe ningún

parámetro.
Paso 7. Crear las clases Data Access Object

Clases Data Access Object (DAO)

Ahora, también por cada tabla del modelo de datos, se debe crear una clase DAO, que es la que
nos permite hacer las operaciones sobre cada tabla. Por lo tanto, se creará una clase por cada
tabla, la recomendación es que el nombre de la case sea el mismo nombre de la tabla terminada por
la palabra DAO, también para que sea fácil de identificar.

En cada una de esas clases, se deben crear, cómo mínimo cuatro métodos. Las operaciones básicas
(sentencias DML) son Insert, Update, Delete y Select, estas cuatro operaciones son conocidas en
programación como CRUD (Create, Retrieve, Update y Delete). También nos toca crear un método
que traiga un registro por ID (esto nos sirve cuando vamos a editar o hacer alguna operación en un
registro específico).

Y a su vez, es importante entender que para poder hacer una consulta en la base de datos se
deben seguir estos tres pasos:

 Conexión
 Ejecución de sentencia
 Declarar sentencia
 Preparar sentencia
 Ejecutar sentencia
 Desconexión

Creando los DAO para cada tabla

Teniendo listo el Driver y la clase ConexionDAO. Ahora si creamos cada una de las clase DAO para
cada una de las tablas de nuestra base de datos. Recuerde que todos los DAO deben heredar de la
clase ConexionDAO. A continuación muestro la clase AprendizDAO, va a tener cinco métodos:
insertar, actualizar, eliminar, seleccionar y obtenerPorId.

Clase AprendizDAO

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import modelo.vo.AprendizVO;

public class AprendizDAO extends ConexionDAO {

private AprendizVO aprendizVO;
private long idAprendiz;
private ArrayList<AprendizVO> lista;

public AprendizDAO() {
lista = new ArrayList<AprendizVO>();
}

public AprendizVO getAprendizVO() {

return this.aprendizVO;
}

public void setAprendizVO(AprendizVO aprendizVO) {

this.aprendizVO = aprendizVO;
}

public long getIdAprendiz() {

return idAprendiz;
}

public void setIdAprendiz(long idAprendiz) {

this.idAprendiz = idAprendiz;
}

public ArrayList<AprendizVO> getLista() {

return lista;
}

public void setLista(ArrayList<AprendizVO> lista) {

this.lista = lista;
}

public void insertar() {

try {
//paso 1: Conectar a la bd
conectar();

//paso 2: Ejecutar la transacción

//paso 2.1: Declarar la sentencia
String consulta = "INSERT INTO aprendiz (id_aprendiz, "
+ "nombre, direccion, telefono, correo, "
+ "fecha_nacimiento, ficha) VALUES "
+ "(?,?,?,?,?,?,?)";

//paso 2.2: Preparar la sentencia

PreparedStatement pstm = this.con.prepareStatement(consulta);
pstm.setLong(1, this.aprendizVO.getId());
pstm.setString(2, this.aprendizVO.getNombre());
pstm.setString(3, this.aprendizVO.getDireccion());
pstm.setLong(4, this.aprendizVO.getTelefono());
pstm.setString(5, this.aprendizVO.getCorreo());
pstm.setDate(6, this.aprendizVO.getFechaNacimiento());
pstm.setString(7, this.aprendizVO.getFicha());

//paso 2.3: Ejecutar consulta

 pstm.executeUpdate();

} catch (Exception e) {
System.out.println("Error: " + e.getMessage());
} finally {
//paso 3: Desconectar de la BD
desconectar();
}
}

public void actualizar() {

try {
//Paso 1: Conectar a la base de datos
conectar();

//Paso 2: Ejecutar transacción

//Paso 2.1: Declarar la sentencia
String consulta = "UPDATE aprendiz SET "
+ "nombre = ?, "
+ "direccion = ?, "
+ "telefono = ?, "
+ "correo = ?, "
+ "fecha_nacimiento = ?, "
+ "ficha = ?"
+ "WHERE id_aprendiz = ?";

//paso 2.2: Preparar la sentencia

PreparedStatement pstm = this.con.prepareStatement(consulta);
pstm.setString(1, this.aprendizVO.getNombre());
pstm.setString(2, this.aprendizVO.getDireccion());
pstm.setLong(3, this.aprendizVO.getTelefono());
pstm.setString(4, this.aprendizVO.getCorreo());
pstm.setDate(5, this.aprendizVO.getFechaNacimiento());
pstm.setString(6, this.aprendizVO.getFicha());
pstm.setLong(7, this.aprendizVO.getId());

//Paso 2.3: Ejecutar la sentencia

pstm.executeUpdate();

} catch (Exception e) {
System.out.println("Error:" + e.getMessage());
} finally {
//paso 3: Desconectar de la BD
desconectar();
}
}

public void eliminar() {

try {
//Paso 1: Conectar a la base de datos
conectar();

//Paso 2: Ejecutar transacción

//Paso 2.1: Declarar la sentencia
String consulta = "DELETE FROM aprendiz "
 + "WHERE id_aprendiz = ?";

//paso 2.2: Preparar la sentencia

PreparedStatement pstm = this.con.prepareStatement(consulta);
pstm.setLong(1, this.idAprendiz);

//Paso 2.3: Ejecutar la sentencia

pstm.executeUpdate();

} catch (Exception e) {
System.out.println("Error:" + e.getMessage());
} finally {
//paso 3: Desconectar de la BD
desconectar();
}
}

public void listar() {

try {
//Paso 1: Conectar a la base de datos
conectar();

//Paso 2: Ejecutar transacción

//Paso 2.1: Declarar la sentencia
String consulta = "SELECT * FROM aprendiz";

//paso 2.2: Preparar la sentencia

PreparedStatement pstm = this.con.prepareStatement(consulta);

//paso 2.3: Ejecutar la sentencia

ResultSet rs = pstm.executeQuery();

while (rs.next()) {
this.aprendizVO = new AprendizVO();
this.aprendizVO.setId(rs.getLong(1));
this.aprendizVO.setNombre(rs.getString(2));
this.aprendizVO.setDireccion(rs.getString(3));
this.aprendizVO.setTelefono(rs.getLong(4));
this.aprendizVO.setCorreo(rs.getString(5));
this.aprendizVO.setFechaNacimiento(rs.getDate(6));
this.aprendizVO.setFicha(rs.getString(7));

this.lista.add(this.aprendizVO);

} catch (Exception e) {
System.out.println("Error:" + e.getMessage());
} finally {
//paso 3: Desconectar de la BD
desconectar();
}
}

public void consultarPorId() {

 try {
//Paso 1: Conectar a la base de datos
conectar();

//Paso 2: Ejecutar transacción

//Paso 2.1: Declarar la sentencia
String consulta = "SELECT * FROM aprendiz"
+ " WHERE id_aprendiz = ?";

//paso 2.2: Preparar la sentencia

PreparedStatement pstm = this.con.prepareStatement(consulta);
pstm.setLong(1, this.idAprendiz);

//paso 2.3: Ejecutar la sentencia

ResultSet rs = pstm.executeQuery();

while (rs.next()) {
this.aprendizVO = new AprendizVO();
this.aprendizVO.setId(rs.getLong(1));
this.aprendizVO.setNombre(rs.getString(2));
this.aprendizVO.setDireccion(rs.getString(3));
this.aprendizVO.setTelefono(rs.getLong(4));
this.aprendizVO.setCorreo(rs.getString(5));
this.aprendizVO.setFechaNacimiento(rs.getDate(6));
this.aprendizVO.setFicha(rs.getString(7));
}

} catch (Exception e) {
System.out.println("Error:" + e.getMessage());
} finally {
//paso 3: Desconectar de la BD
desconectar();
}
}
}

Recordemos que cada vez que vayamos a ejecutar una sentencia debemos conectarnos, ejecutar
la sentencia y desconectarnos. A continuación se explican algunas líneas clave:

LÍNEA EXPLICACIÓN
String consulta = "INSERT INTO Aquí se empieza a armar la sentencia SQL, en lugar
aprendiz (id_aprendiz, nombre, de los valores se ponen comodines (?). Más adelante
direccion, telefono, se enviaran los valores a esos comodines.
correo,fecha_nacimiento, ficha)
VALUES (?,?,?,?,?,?,?)";

PreparedStatement pstm = El objeto PreparedStatement nos va a permitir

this.con.prepareStatement(consu preparar la sentencia y ejecutarla. Para crearla
lta); usamos la conexión (objeto con) y el método
prepareStatement y le enviamos la consulta que
habíamos armado.
pstm.setLong(1, Con estas líneas, lo que hacemos es enviarle los
this.aprendizVO.getId()); valores a la sentencia, para eso debemos poner un
identificador (que empieza por 1), se deben enviar
pstm.setString(2, un valor por cada comodín y se debe tener en cuenta
this.aprendizVO.getNombre()); con el tipo de dato, si es entero se envía con
setInt(),si es una cadena se envía con
pstm.setString(3, setString(), también existen setLong() y
this.aprendizVO.getDireccion());
setDate(). Los valores se obtienen del objeto
AprendizVO el cual es un atributo de la clase.
pstm.setLong(4,
this.aprendizVO.getTelefono());

pstm.setString(5,
this.aprendizVO.getCorreo());

pstm.setDate(6,
this.aprendizVO.getFechaNacimien
to());

pstm.setString(7,
this.aprendizVO.getFicha());

pstm.executeUpdate(); Con esta línea ejecutamos la sentencia, aquí se debe

tener en cuenta que si la sentencia es un insert,
update y delete debemos llamar al método
pstm.executeUpdate(), pero si es un select
debemos llamar al método:
pstm.executeQuery().

ResultSet rs = Como se mencionó antes, para ejecutar un select se

pstm.executeQuery(); ejecuta el método pstm.executeQuery(). El cual
devuelve un ResultSet, es decir un listado con el
resultado de lo que estábamos consultando en la
sentencia.

while(rs.next) Para recorrer el ResultSet usamos un while.

this.aprendizVO = new Para obtener cada valor, lo hacemos con el objeto

AprendizVO(); rs y el método getInt() si es un entero,
getString() si es una cadena, también existen
this.aprendizVO.setId(rs.getLon getLong() y getDate().Le debemos enviar el
g(1)); número de columna que queremos obtener, en el
mismo orden como lo ubiqué en la sentencia select,
this.aprendizVO.setNombre(rs.ge
tString(2)); si no escribo los campos sino asterisco (*) debo
respetar el orden que tienen los campos en la tabla.
this.aprendizVO.setDireccion(rs Para mi ejemplo, la tabla aprendiz el orden de los
.getString(3)); campos es id_aprendiz, nombre, direccion, telefono,
 correo, fecha_nacimiento y ficha.
this.aprendizVO.setTelefono(rs.
getLong(4));

this.aprendizVO.setCorreo(rs.ge
tString(5));

this.aprendizVO.setFechaNacimie
nto(rs.getDate(6));

this.aprendizVO.setFicha(rs.get
String(7));

El DAO de Calificaciones tiene también una pequeña diferencia y es que como creamos la clase
CalificacionVO con dos atributos adicionales, tenemos que consultar información de las tres tablas
para poder obtener la información a guardar en todos los atributos. Para eso debemos hacer una
consulta con JOIN, quedaría más o menos de esta forma:

SELECT a.id_aprendiz, a.nombre, e.id_evidencia, e.nombre, c.puntaje

FROM calificacion AS c
LEFT JOIN aprendiz AS a on (a.id_aprendiz = c.id_aprendiz)
LEFT JOIN evidencia AS e on (e.id_evidencia = c.id_evidencia)
ORDER BY e.id_evidencia

Lo anterior es para las consultas (select), la inserción si es normal, y toca tener en cuenta que
para actualizar y eliminar tenemos que enviar los dos id (aprendiz y evidencia) o de lo contrario se
modificarían o eliminarían elementos que no son. Otra cosa a tener en cuenta, es que se crea un
método adicional que se llama listarNotasAprendiz(), el cual nos permite conocer todas las
notas de un aprendiz específico, esta consulta se usa en un botón que se pone en la
administración de aprendices, en la lista frente a cada aprendiz irá un botón que dice Ver
Calificaciones, ese botón usará este método. La clase quedaría así:

Clase CalificacionDAO

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import modelo.vo.CalificacionVO;

public class CalificacionDAO extends ConexionDAO{

private CalificacionVO calificacionVO;

private int idEvidencia;
private long idAprendiz;
private ArrayList<CalificacionVO> lista;

public CalificacionDAO() {
lista = new ArrayList<CalificacionVO>();
}

public CalificacionVO getCalificacionVO() {

return calificacionVO;
}

public void setCalificacionVO(CalificacionVO calificacionVO) {

this.calificacionVO = calificacionVO;
}

public long getIdAprendiz() {

return idAprendiz;
}

public void setIdAprendiz(long idAprendiz) {

this.idAprendiz = idAprendiz;
}

public int getIdEvidencia() {

return idEvidencia;
}

public void setIdEvidencia(int idEvidencia) {

this.idEvidencia = idEvidencia;
}

public ArrayList<CalificacionVO> getLista() {

return lista;
}

public void setLista(ArrayList<CalificacionVO> lista) {

this.lista = lista;
}

public void insertar() {

try {
//paso 1: Conectar a la bd
conectar();

//paso 2: Ejecutar la transacción

//paso 2.1: Declarar la sentencia
String consulta = "INSERT INTO calificacion (id_aprendiz, "
+ "id_evidencia, puntaje) VALUES "
 + "(?,?,?)";

//paso 2.2: Preparar la sentencia

PreparedStatement pstm = this.con.prepareStatement(consulta);
pstm.setLong(1, this.calificacionVO.getIdAprendiz());
pstm.setInt(2, this.calificacionVO.getIdEvidencia());
pstm.setFloat(3, this.calificacionVO.getPuntaje());

//paso 2.3: Ejecutar consulta

pstm.executeUpdate();

} catch (Exception e) {
System.out.println("Error: " + e.getMessage());
} finally {
//paso 3: Desconectar de la BD
desconectar();
}
}

public void listar() {

try {
//Paso 1: Conectar a la base de datos
conectar();
//Paso 2: Ejecutar transacción
//Paso 2.1: Declarar la sentencia
String consulta =
"SELECT a.id_aprendiz, a.nombre, e.id_evidencia, e.nombre,
c.puntaje "
+ "FROM calificacion AS c LEFT JOIN aprendiz AS a on
(a.id_aprendiz = c.id_aprendiz) "
+ "LEFT JOIN evidencia AS e on (e.id_evidencia =
c.id_evidencia) "
+ "ORDER BY e.id_evidencia";

//paso 2.2: Preparar la sentencia

PreparedStatement pstm = this.con.prepareStatement(consulta);

//paso 2.3: Ejecutar la sentencia

ResultSet rs = pstm.executeQuery();

while (rs.next()) {
this.calificacionVO = new CalificacionVO();
this.calificacionVO.setIdAprendiz(rs.getLong(1));
this.calificacionVO.setNombreAprendiz(rs.getString(2));
this.calificacionVO.setIdEvidencia(rs.getInt(3));
this.calificacionVO.setNombreEvidencia(rs.getString(4))
; this.calificacionVO.setPuntaje(rs.getFloat(5));
 this.lista.add(this.calificacionVO);

} catch (Exception e) {
System.out.println("Error:" + e.getMessage());
} finally {
//paso 3: Desconectar de la BD
desconectar();
}
}

public void actualizar() {

try {
//Paso 1: Conectar a la base de datos
conectar();

//Paso 2: Ejecutar transacción

//Paso 2.1: Declarar la sentencia
String consulta = "UPDATE calificacion SET "
+ "puntaje = ? "
+ "WHERE id_aprendiz = ? AND id_evidencia = ?";

//paso 2.2: Preparar la sentencia

PreparedStatement pstm = this.con.prepareStatement(consulta);
pstm.setFloat(1, calificacionVO.getPuntaje());
pstm.setLong(2, calificacionVO.getIdAprendiz());
pstm.setInt(3, calificacionVO.getIdEvidencia());

//Paso 2.3: Ejecutar la sentencia

pstm.executeUpdate();

} catch (Exception e) {
System.out.println("Error:" + e.getMessage());
} finally {
//paso 3: Desconectar de la BD
desconectar();
}
}

public void eliminar() {

try {
//Paso 1: Conectar a la base de datos
conectar();

//Paso 2: Ejecutar transacción

//Paso 2.1: Declarar la sentencia
 String consulta = "DELETE FROM calificacion "
+ "WHERE id_aprendiz = ? AND id_evidencia = ?";

//paso 2.2: Preparar la sentencia

PreparedStatement pstm = this.con.prepareStatement(consulta);
pstm.setLong(1, this.idAprendiz);
pstm.setInt(2, this.idEvidencia);

//Paso 2.3: Ejecutar la sentencia

pstm.executeUpdate();

} catch (Exception e) {
System.out.println("Error:" + e.getMessage());
} finally {
//paso 3: Desconectar de la BD
desconectar();
}
}

public void consultarPorId() {

try {
//Paso 1: Conectar a la base de datos
conectar();

//Paso 2: Ejecutar transacción

//Paso 2.1: Declarar la sentencia
String consulta = "SELECT a.id_aprendiz, a.nombre,
e.id_evidencia, e.nombre, c.puntaje "
+ "FROM calificacion AS c LEFT JOIN aprendiz AS a on
(a.id_aprendiz = c.id_aprendiz) "
+ "LEFT JOIN evidencia AS e on (e.id_evidencia =
c.id_evidencia) "
+ "WHERE c.id_aprendiz = ? AND c.id_evidencia = ? "
+ "ORDER BY e.id_evidencia";

//paso 2.2: Preparar la sentencia

PreparedStatement pstm = this.con.prepareStatement(consulta);
pstm.setLong(1, this.idAprendiz);
pstm.setLong(2, this.idEvidencia);

//paso 2.3: Ejecutar la sentencia

ResultSet rs = pstm.executeQuery();

while (rs.next()) {
this.calificacionVO = new CalificacionVO();
this.calificacionVO.setIdAprendiz(rs.getLong(1));
this.calificacionVO.setNombreAprendiz(rs.getString(2));
 this.calificacionVO.setIdEvidencia(rs.getInt(3));
this.calificacionVO.setNombreEvidencia(rs.getString(4))
; this.calificacionVO.setPuntaje(rs.getFloat(5));
}

} catch (Exception e) {
System.out.println("Error:" + e.getMessage());
} finally {
//paso 3: Desconectar de la BD
desconectar();
}
}

public void listarNotasAprendiz() {

try {
//Paso 1: Conectar a la base de datos
conectar();

//Paso 2: Ejecutar transacción

//Paso 2.1: Declarar la sentencia
String consulta = "SELECT a.id_aprendiz, a.nombre,
e.id_evidencia, e.nombre, c.puntaje "
+ "FROM calificacion AS c LEFT JOIN aprendiz AS a on
(a.id_aprendiz = c.id_aprendiz) "
+ "LEFT JOIN evidencia AS e on (e.id_evidencia =
c.id_evidencia) "
+ "WHERE c.id_aprendiz = ? "
+ "ORDER BY e.id_evidencia";

//paso 2.2: Preparar la sentencia

PreparedStatement pstm = this.con.prepareStatement(consulta);
pstm.setLong(1, this.idAprendiz);

//paso 2.3: Ejecutar la sentencia

ResultSet rs = pstm.executeQuery();

while (rs.next()) {
this.calificacionVO = new CalificacionVO();
this.calificacionVO.setIdAprendiz(rs.getLong(1));
this.calificacionVO.setNombreAprendiz(rs.getString(2));
this.calificacionVO.setIdEvidencia(rs.getInt(3));
this.calificacionVO.setNombreEvidencia(rs.getString(4))
; this.calificacionVO.setPuntaje(rs.getFloat(5));

this.lista.add(this.calificacionVO);

}
 } catch (Exception e) {
System.out.println("Error:" + e.getMessage());
} finally {
//paso 3: Desconectar de la BD
desconectar();
}
}
}

La clase EvidenciaDAO si se generará igual que la clase AprendizDAO, con los cinco métodos
explicados al inicio.
PASO 8. Crear el controlador: Servlet

Como controlador vamos a usar un Servlet. El cual nos permite recibir las peticiones de todos los
formularios y devolver una respuesta. Para crearla debemos hacer dos pasos: Crear una clase que
herede de HttpServlet y crear un archivo de configuración llamado web.xml en la carpeta Web
Pages/WEB-INF.

Crear clase Servlet

Se crea una clase en el paquete controlador, cualquier nombre (recomendación poner nombres
dicientes y claros), en mi caso la llamaré Controlador. Dicha clase debe heredar de HttpServlet. La
clase nos permite implementar varios métodos para recibir las peticiones de los formularios. Para
nuestro caso vamos a implementar el método doPost() El cual recibe dos parámetros un objeto de
la clase HttpServletRequest y HttpServletResponse, respectivamente. Este método recibe todas
las peticiones de los formularios que en la propiedad method tengan el valor POST. El esqueleto
de la clase nos quedaría así:

import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class Controlador extends HttpServlet {

public void doPost(HttpServletRequest req, HttpServletResponse res) {

}
}

Dentro del método doPost, vamos a recibir todas las peticiones y vamos a decidir qué toca hacer
con un switch.

Crear archivo de configuración

Esta es la estructura básica del archivo de configuración:

<web-app xmlns="http://java.sun.com/xml/ns/javaee" version="2.5">

<servlet>
<servlet-name>NOMBRE</servlet-name>
<servlet-class>RUTA DEL PROYECTO (CON EL PAQUETE)</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>NOMBRE</servlet-name>
<url-pattern>/URL PARA ACCEDER A LA APLICACIÓN</url-pattern>
</servlet-mapping>
</web-app>
Así queda el de mi proyecto:

<web-app>
<servlet>
<servlet-name>Controlador</servlet-name>
<servlet-class>controlador.Controlador</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Controlador</servlet-name>
<url-pattern>/controlador</url-pattern>
</servlet-mapping>
</web-app>

Lo que está sombreado lo deben personalizar: en <servlet-class> se pone el nombre del

paquete y de la clase servlet y en <url-pattern>/ se pone el valor que se debe poner en el
atributo action del formulario.

Recibiendo peticiones y devolviendo valores en el controlador

El servlet recibe información de los formularios, para obtener cada campo se debe utilizar el método:
getParameter() del objeto HttpServletRequest. Ejemplo:

String opc = req.getParameter("opcion").toString();

Con esta línea se obtiene el valor de un campo llamado opcion. En todos los formularios vamos a
tener un campo oculto llamado opcion que nos va a permitir saber qué operación se debe realizar.

Para devolver valores a los jsp, debemos usar las siguientes líneas:

RequestDispatcher vista = null;

req.setAttribute("aprendices", lista);
vista = req.getRequestDispatcher("listarAprendiz.jsp");
vista.forward(req, res);

LÍNEA EXPLICACIÓN
RequestDispatcher Se crea un objeto de la clase RequestDispatcher, la cual nos permite
vista = null; decirle al servlet cual jsp vamos a mostrar.

req.setAttribute("apre Con esta línea enviamos los valores que necesitemos al jsp. Se debe
ndices", lista); envía con el método setAttribute(), el cual recibe dos
parámetros: el nombre con el que lo vamos a obtener en el jsp y el
valor que queremos enviar.

vista = Aquí se le indica cual jsp se va a mostrar.

req.getRequestDispatch
er("listarAprendiz.jsp
");
vista.forward(req, Esta es la instrucción para que vaya y muestre el jsp indicado.
res);

Sabiendo cómo obtener los valores y cómo devolver información, vamos a empezar a armar el
switch. Recordemos que el switch se arma porque todos los formularios van a llegar al mismo
método doPost() y con el campo opcion sabremos qué acción ejecutar.

Básicamente por cada tabla debemos tener 6 opciones:

1. Listar: Muestra un listado con los datos y botones para insertar, actualizar y eliminar.
2. Mostrar formulario para insertar: muestra el formulario para guardar un nuevo registro.
3. Insertar: recibe los datos del formulario y guarda la información.
4. Mostrar formulario para actualizar: muestra el formulario para actualizar un registro.
5. Actualizar: recibe los datos del formulario de actualización y actualiza la información.
6. Eliminar: recibe el id a eliminar y elimina el registro.

Para nuestra aplicación las opciones quedarían así:

1. Listar aprendices
2. Mostrar formulario para insertar aprendiz
3. Insertar aprendiz
4. Mostar formulario para actualizar aprendiz
5. Actualizar aprendiz
6. Eliminar aprendiz
7. Listar evidencias
8. Mostrar formulario para insertar evidencia
9. Insertar evidencia
10. Mostar formulario para actualizar evidencia
11. Actualizar evidencia
12. Eliminar evidencia
13. Listar calificaciones
14. Mostrar formulario para insertar calificación
15. Insertar calificación
16. Mostar formulario para actualizar calificación
17. Actualizar calificación
18. Eliminar calificación
19. Listar calificaciones por aprendiz3
99. Muestra el index
Default. Muestra un mensaje de error

A continuación se muestra el esqueleto con el switch y más adelante se explicará cómo se da solución
a cada opción para la tabla Aprendiz. También se deja una opción 99 que es la que nos lleva al index
y en el default muestra un mensaje de opción no válida. Al final después del switch se hace el
forward.

3
Esta es una opción adicional que aparece en el listado de aprendices
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class Controlador extends HttpServlet {

public void doPost(HttpServletRequest req, HttpServletResponse res) {

try {
//Creamos variables generales que usaremos durante todo el método

//Objeto que me permite enviar la respuesta a los jsp

RequestDispatcher vista = null;

//objetos DAO
AprendizDAO aprendizDAO;
EvidenciaDAO evidenciaDAO;
CalificacionDAO calificacionDAO;
//objetos VO
AprendizVO aprendizVO;
EvidenciaVO evidenciaVO;
CalificacionVO calificacionVO;
//un entero id, se usará al actualizar y eliminar
int id , id2;
//variables para el manejo de las fechas
int anio, mes, dia;
Calendar fecha;

//variable que me permite saber la acción a realizar

String opc = req.getParameter("opcion").toString();
//la pasamos a int para usarla en el switch
int opcion = Integer.parseInt(opc);

switch (opcion) {

case 1: //Lista aprendices

break;

case 2: //Muestra formulario insertar aprendices

break;

case 3: //Insertar aprendiz

break;

case 4: //Muestra formulario actualizar aprendices

break;

case 5: //Actualizar aprendiz

break;

case 6: //Eliminar aprendiz

 break;

case 99: //Muestra Index

vista = req.getRequestDispatcher("index.jsp");
break;

default:
//enviamos un mensaje para indicar que están solicitando una
opción no válida
req.setAttribute("mensaje", "Esta opción no ha sido
implementada.");
//le decimos a cual opción ir después de dar clic en el
botón Aceptar del JSP de respuesta
req.setAttribute("opcion", "99");
//Indica cual JSP va a mostrar la información enviada
vista = req.getRequestDispatcher("respuesta.jsp");
break;
}

vista.forward(req, res);

} catch (ServletException ex) {

System.out.println("ServletException " + ex.getMessage());
} catch (IOException ex) {
System.out.println("IOException " + ex.getMessage());
} catch (Exception ex) {
System.out.println("IOException " + ex.getMessage());
}
}
}

Ese era el esqueleto, a continuación explicaré cada opción para la tabla aprendiz y de la tabla
calificaciones, usted tendrá que implementarlo para la tabla evidencias.

1. Listar: Dentro de la opción 1 del switch, simplemente tenemos que listar a los aprendices,
para eso llamamos al método listar() de la clase AprendizDAO, esto deja disponible la
información en el atributo lista de este mismo objeto. Le enviamos la lista al jsp con el
método setAttribute() y le decimos al requestDispatcher que el jsp es listarAprendiz.jsp.

case 1: //Lista aprendices

//inicializa el objeto aprendizDAO

aprendizDAO = new AprendizDAO();
//Crea un listado de los aprendices con el método listar() de la
clase AprendizDAO
aprendizDAO.listar();
//envía el ArrayList al JSP
req.setAttribute("aprendices", aprendizDAO.getLista());
//Indica cual JSP va a mostrar la información enviada
vista = req.getRequestDispatcher("listarAprendices.jsp");
break;
2. Mostrar formulario para insertar: En este caso no tenemos que consultar nada en la base
de datos, por lo tanto, simplemente indicamos cual es el jsp a mostrar.

case 2: //Muestra formulario insertar aprendices

//Indica cual JSP va a mostrar

vista = req.getRequestDispatcher("insertarAprendiz.jsp");
break;

3. Insertar: En esta opción se obtienen los valores del formulario y se llama al método insertar()
de la clase AprendizDAO. Al final, se muestra el archivo respuesta.jsp, antes de eso se envía
un mensaje de transacción exitosa.

case 3: //Insertar aprendiz

//creamos un objeto de la clase AprendizVO para obtener los valores

del form
aprendizVO = new AprendizVO();

//se inicializa el objeto AprendizDAO para insertar los datos en la

BD
aprendizDAO = new AprendizDAO();

//obtenemos los valores de los campos del form

aprendizVO.setId(Integer.parseInt(req.getParameter("id_aprendiz").t
oString()));
aprendizVO.setNombre(req.getParameter("nombre").toString());
aprendizVO.setDireccion(req.getParameter("direccion").toString());
aprendizVO.setTelefono(Long.parseLong(req.getParameter("telefono")
. toString()));
aprendizVO.setCorreo(req.getParameter("correo").toString());
aprendizVO.setFicha(req.getParameter("ficha").toString());
//La fecha tiene un tratamiento especial, ya que toca tomar los
datos y convertirlos en fecha
//La fecha debe venir asi: 01-12-2012
anio = Integer.parseInt(req.getParameter("fecha_nacimiento")
.toString().substring(6, 10));
mes = Integer.parseInt(req.getParameter("fecha_nacimiento")
.toString().substring(3, 5)) - 1;
dia = Integer.parseInt(req.getParameter("fecha_nacimiento")
.toString().substring(0, 2));
fecha = new GregorianCalendar(anio, mes, dia);
aprendizVO.setFechaNacimiento(new Date(fecha.getTimeInMillis()));

//Inicializamos el atributo de la clase aprendizVO con el objeto

que acabamos de armar
aprendizDAO.setAprendizVO(aprendizVO);
//llamamos al método insertar de AprendizDAO
aprendizDAO.insertar();

//enviamos un mensaje de éxito de la inserción

req.setAttribute("mensaje", "Aprendiz " + aprendizVO.getNombre() +
" ingresado con éxito.");
 //le decimos a cual opción ir después de dar clic en el botón
Aceptar del JSP de respuesta
req.setAttribute("opcion", "1"); // 1 para que regrese al listado
de aprendices

//Indica cual JSP va a mostrar la información enviada

vista = req.getRequestDispatcher("respuesta.jsp");

break;

4. Mostrar formulario para actualizar: En esta opción se debe obtener el id que se desea
actualizar, con ese id se busca en la base de datos con el método obtenerPorId() de la
clase AprendizDAO, se envían los datos al JSP y se muestra el jsp actualizarAprendiz.jsp.

case 4: //Muestra formulario actualizar aprendices

//Obtenemos el id para actualizar

id = Integer.parseInt(req.getParameter("id").toString());

//creamos un objeto de la clase AprendizVO para obtener los valores

de la BD
aprendizVO = new AprendizVO();

//se inicializa el objeto AprendizDAO para obtener los datos en la

BD
aprendizDAO = new AprendizDAO();

//Enviamos el id del aprendiz a editar

aprendizDAO.setIdAprendiz(id);

//llamamos al método consultarPorId() para obtener la información

del aprendiz a editar
aprendizDAO.consultarPorId();

//se envian los datos del aprendiz en un objeto AprendizVO

req.setAttribute("aprendizVO", aprendizDAO.getAprendizVO());

//Indica cual JSP va a mostrar la información enviada

vista = req.getRequestDispatcher("actualizarAprendiz.jsp");

break;

5. Actualizar: En esta opción se obtienen los valores del formulario y se llama al método
actualizar de la clase AprendizDAO. Al final, se muestra el archivo respuesta.jsp, antes de
eso se envía un mensaje de transacción exitosa.

case 5: //Actualizar aprendiz

//creamos un objeto de la clase AprendizVO para obtener los valores

del form
aprendizVO = new AprendizVO();
 //se inicializa el objeto AprendizVO para actualizar los datos en
la BD
aprendizDAO = new AprendizDAO();

//obtenemos los valores de los campos del form

aprendizVO.setId(Integer.parseInt(req.getParameter("id_aprendiz").
t oString()));
aprendizVO.setNombre(req.getParameter("nombre").toString());
aprendizVO.setDireccion(req.getParameter("direccion").toString());
aprendizVO.setTelefono(Integer.parseInt(req.getParameter("telefono
"
).toString()));
aprendizVO.setCorreo(req.getParameter("correo").toString())
;
aprendizVO.setFicha(req.getParameter("ficha").toString());
anio = Integer.parseInt(req.getParameter("fecha_nacimiento").
toString().substring(0, 4));
mes =
Integer.parseInt(req.getParameter("fecha_nacimiento").
toString().substring(5, 7)) - 1;
dia =
Integer.parseInt(req.getParameter("fecha_nacimiento").
toString().substring(8, 10));
fecha = new GregorianCalendar(anio, mes, dia);
aprendizVO.setFechaNacimiento(new Date(fecha.getTimeInMillis()));

//Inicializamos el atributo de la clase aprendizVO con el objeto

que acabamos de armar
aprendizDAO.setAprendizVO(aprendizVO);
//llamamos al método actualizar de AprendizDAO
aprendizDAO.actualizar();

//enviamos un mensaje de éxito de la inserción

req.setAttribute("mensaje", "Aprendiz " + aprendizVO.getNombre() +
" actualizado con éxito.");

//le decimos a cual opción ir después de dar clic en el botón

Aceptar del JSP de respuesta
req.setAttribute("opcion", "1"); // 1 para que regrese al listado
de aprendices

//Indica cual JSP va a mostrar la información enviada

vista = req.getRequestDispatcher("respuesta.jsp");

break;

6. Eliminar: Se obtiene el id a eliminar, y se llama al método eliminar de la clase

AprendizDAO, al final se muestra el archivo respuesta.jsp, antes de eso se envía un
mensaje de transacción exitosa.

case 6: //Eliminar aprendiz

//Obtenemos el id para actualizar

id = Integer.parseInt(req.getParameter("id").toString());

//creamos un objeto de la clase AprendizVO para obtener los valores

del form
aprendizVO = new AprendizVO();
 //se inicializa el objeto AprendizDAO para insertar los datos en la
BD
aprendizDAO = new AprendizDAO();

//Enviamos el id del aprendiz a eliminar

aprendizDAO.setIdAprendiz(id);

//llamamos al método eliminar de aprendiz DAO

aprendizDAO.eliminar();

//enviamos un mensaje de éxito de la inserción

req.setAttribute("mensaje", "Usuario se ha eliminada con éxito.");

//le decimos a cual opción ir después de dar clic en el botón

Aceptar del JSP de respuesta
req.setAttribute("opcion", "1"); // 1 para que regrese al listado
de aprendices

//Indica cual JSP va a mostrar la información enviada

vista = req.getRequestDispatcher("respuesta.jsp");

break;

Con esto ya tenemos todas las operaciones para la tabla aprendiz, para las otras tablas tenemos que
repetir desde el case 1 hasta el 6, haciendo los ajustes para que haga las transacciones en la tabla
adecuada. Para la siguiente tabla empezaría en 7, y la otra en 13.

Como se había indicado, en este manual se va a mostrar cómo se implementan las operaciones
para la tabla Aprendiz y para la tabla Calificaciones, a continuación muestro las transacciones en la
tabla Calificaciones:

13. Listar: Dentro de la opción 13 del switch listamos las calificaciones, para eso llamamos al
método listar() de la clase CalificacionDAO, esto deja disponible la información en el
atributo lista de este mismo objeto. Le enviamos la lista al jsp con el método
setAttribute() y le decimos al requestDispatcher que el jsp es listarCalificaciones.jsp.

case 13: //Lista calificaciones

//inicializa el objeto CalificacionDAO

calificacionDAO = new CalificacionDAO();
//Crea un listado de las calificaciones con el método listar() de
la clase CalificacionDAO
calificacionDAO.listar();
//envía el ArrayList al JSP
req.setAttribute("calificaciones", calificacionDAO.getLista());
//Indica cual JSP va a mostrar la información enviada
vista = req.getRequestDispatcher("listarCalificaciones.jsp");
break;
14. Mostrar formulario para insertar: En este caso tenemos que consultar los aprendices y
evidencias existentes para mostrarlos como listas. Hacemos las consultas e indicamos cuál
es el jsp a mostrar.

case 14: //Muestra formulario insertar calificaciones

//aquí necesitamos mostrar en el formulario los aprendices y las
evidencias existentes, para eso los listamos.

//inicializa el objeto aprendizDAO

aprendizDAO = new AprendizDAO();
//Crea un listado de los aprendices con el método listar() de la
clase AprendizDAO
aprendizDAO.listar();
//envía el ArrayList al JSP
req.setAttribute("aprendices", aprendizDAO.getLista());

//inicializa el objeto evidenciaDAO

evidenciaDAO = new EvidenciaDAO();
//Crea un listado de los aprendices con el método listar() de la
clase AprendizDAO
evidenciaDAO.listar();
//envía el ArrayList al JSP
req.setAttribute("evidencias", evidenciaDAO.getLista());

//Indica cual JSP va a mostrar

vista = req.getRequestDispatcher("insertarCalificacion.jsp");
break;

15. Insertar: En esta opción se obtienen los valores del formulario y se llama al método
insertar() de la clase CalificacionDAO. Al final, se muestra el archivo respuesta.jsp, antes de
eso se envía un mensaje de transacción exitosa.

case 15: //Insertar calificación

//creamos un objeto de la clase CalificacionVO para obtener los

valores del form
calificacionVO = new CalificacionVO();

//se inicializa el objeto CalificacionDAO para insertar los datos

en la BD
calificacionDAO = new CalificacionDAO();

//obtenemos los valores de los campos del form

calificacionVO.setIdAprendiz(Integer.parseInt(req.getParameter("id
_ aprendiz").toString()));
calificacionVO.setIdEvidencia(Integer.parseInt(req.getParameter("i
d
_evidencia").toString()));
calificacionVO.setPuntaje(Integer.parseInt(req.getParameter("punta
j e").toString()));

//Inicializamos el atributo de la clase calificacionVO con el

objeto que acabamos de armar
calificacionDAO.setCalificacionVO(calificacionVO);
//llamamos al método insertar de AprendizDAO
 calificacionDAO.insertar();

//enviamos un mensaje de éxito de la inserción

req.setAttribute("mensaje", "La calificación se ha ingresado con
éxito.");

//le decimos a cual opción ir después de dar clic en el botón

Aceptar del JSP de respuesta
req.setAttribute("opcion", "13"); // 13 para que regrese al listado
de calificaciones

//Indica cual JSP va a mostrar la información enviada

vista = req.getRequestDispatcher("respuesta.jsp");

break;

16. Mostrar formulario para actualizar: En esta opción se debe obtener los dos id (aprendiz y
evidencia) para conocer el registro que se desea actualizar, con estos id se busca en la
base de datos con el método obtenerPorId() de la clase CalificacionDAO, se envían los
datos al JSP y se muestra el jsp actualizarCalificacion.jsp.

case 16: //Muestra formulario actualizar calificación

//Obtenemos los id (aprendiz y evidencia) para actualizar

calificación
id = Integer.parseInt(req.getParameter("id").toString());
id2 = Integer.parseInt(req.getParameter("id2").toString());

//creamos un objeto de la clase CalificacionVO para obtener los

valores de la BD
calificacionVO = new CalificacionVO();

//se inicializa el objeto CalificacionDAO para obtener los datos en

la BD
calificacionDAO = new CalificacionDAO();

//Enviamos los id de la calificación a editar (la llave es

compuesta por un id aprendiz y un id evidencia)
calificacionDAO.setIdAprendiz(id);
calificacionDAO.setIdEvidencia(id2);

//llamamos al método consultarPorId() para obtener la información

de la calificación a editar
calificacionDAO.consultarPorId();

//aquí necesitamos mostrar en el formulario los aprendices y las

evidencias existentes, para eso los listamos.
//inicializa el objeto aprendizDAO
aprendizDAO = new AprendizDAO();
//Crea un listado de los aprendices con el método listar() de la
clase AprendizDAO
 aprendizDAO.listar();
//envía el ArrayList al JSP
req.setAttribute("aprendices", aprendizDAO.getLista());

//inicializa el objeto evidenciaDAO

evidenciaDAO = new EvidenciaDAO();
//Crea un listado de los aprendices con el método listar() de la
clase AprendizDAO
evidenciaDAO.listar();
//envía el ArrayList al JSP
req.setAttribute("evidencias", evidenciaDAO.getLista());

//se envian los datos del aprendiz en un objeto AprendizVO

req.setAttribute("calificacionVO",
calificacionDAO.getCalificacionVO());

//Indica cual JSP va a mostrar la información enviada

vista = req.getRequestDispatcher("actualizarCalificacion.jsp");

break;

17. Actualizar: En esta opción se obtienen los valores del formulario y se llama al método
actualizar de la clase CalificacionDAO. Al final, se muestra el archivo respuesta.jsp, antes
de eso se envía un mensaje de transacción exitosa.

case 17: //Actualizar calificación

//creamos un objeto de la clase CalificacionVO para obtener los

valores del form
calificacionVO = new CalificacionVO();

//se inicializa el objeto CalificacionDAO para insertar los datos

en la BD
calificacionDAO = new CalificacionDAO();

//obtenemos los valores de los campos del form

calificacionVO.setIdAprendiz(Integer.parseInt(req.getParameter("id
_ aprendiz").toString()));
calificacionVO.setIdEvidencia(Integer.parseInt(req.getParameter("i
d
_evidencia").toString()));
calificacionVO.setPuntaje(Float.parseFloat(req.getParameter("punta
j e").toString()));

//Inicializamos el atributo de la clase aprendizVO con el objeto

que acabamos de armar
calificacionDAO.setCalificacionVO(calificacionVO);
//llamamos al método actualizar de AprendizDAO
calificacionDAO.actualizar();

//enviamos un mensaje de éxito de la inserción

req.setAttribute("mensaje", "La calificación actualizado con
éxito.");
 //le decimos a cual opción ir después de dar clic en el botón
Aceptar del JSP de respuesta
req.setAttribute("opcion", "13"); // 13 para que regrese al listado
de calificaciones

//Indica cual JSP va a mostrar la información enviada

vista = req.getRequestDispatcher("respuesta.jsp");

break;

18. Eliminar: Se obtienen los id (aprendiz y evidencia) del registro a eliminar, y se llama al
método eliminar de la clase CalificacionDAO, al final se muestra el archivo respuesta.jsp,
antes de eso se envía un mensaje de transacción exitosa.

case 18: //Eliminar calificación

//Obtenemos desde el form los id (aprendiz y evidencia) para

eliminar calificación
id = Integer.parseInt(req.getParameter("id").toString());
id2 = Integer.parseInt(req.getParameter("id2").toString());

//se inicializa el objeto AprendizDAO para insertar los datos en la

BD
calificacionDAO = new CalificacionDAO();

//Enviamos el los id (aprendiz y evidencia) para eliminar

calificación
calificacionDAO.setIdAprendiz(id);
calificacionDAO.setIdEvidencia(id2);

//llamamos al método eliminar de persona DAO

calificacionDAO.eliminar();

//enviamos un mensaje de éxito de la inserción

req.setAttribute("mensaje", "La calificación se ha eliminada con
éxito.");

//le decimos a cual opción ir después de dar clic en el botón

Aceptar del JSP de respuesta
req.setAttribute("opcion", "13"); // 13 para que regrese al listado
de aprendices

//Indica cual JSP va a mostrar la información enviada

vista = req.getRequestDispatcher("respuesta.jsp");

break;

19. Listar calificaciones de un aprendiz: Se obtienen el id del aprendiz al que se le quieren

consultar las calificaciones, y se llama al método eliminar de la clase CalificacionDAO, al final
se muestra el archivo respuesta.jsp, antes de eso se envía un mensaje de transacción
exitosa.

case 19: //Lista calificaciones de un aprendiz específico

 //AQUI OBTENEMOS LAS CALIFICACIONES
//Obtenemos desde el form los id del aprendiz para obtener sus
calificaciones
id = Integer.parseInt(req.getParameter("id").toString());

//inicializa el objeto CalificacionDAO

calificacionDAO = new CalificacionDAO();

//Enviamos el los id del aprendiz

calificacionDAO.setIdAprendiz(id);

//Crea un listado de las calificaciones con el método listar() de

la clase CalificacionDAO
calificacionDAO.listarNotasAprendiz();
//envía el ArrayList al JSP
req.setAttribute("calificaciones", calificacionDAO.getLista());

//AQUI OBTENEMOS LA INFORMACIÓN DEL APRENDIZ

//creamos un objeto de la clase AprendizVO para obtener los valores

de la BD
aprendizVO = new AprendizVO();

//se inicializa el objeto AprendizDAO para obtener los datos en la

BD
aprendizDAO = new AprendizDAO();

//Enviamos el id del aprendiz a editar

aprendizDAO.setIdAprendiz(id);

//llamamos al método consultarPorId() para obtener la información

del aprendiz a editar
aprendizDAO.consultarPorId();

//se envian los datos del aprendiz en un objeto AprendizVO

req.setAttribute("aprendizVO", aprendizDAO.getAprendizVO());

//le decimos a cual opción ir después de dar clic en el botón

Aceptar del JSP de respuesta
req.setAttribute("opcion", "1"); // 1 para que regrese al listado
de aprendices

//Indica cual JSP va a mostrar la información enviada vista =

req.getRequestDispatcher("listarCalificacionesAprendiz.jsp")
; break;

Con esto tenemos implementadas las opciones de la tabla Aprendiz y de la tabla Calificaciones,
quedaría faltando la tabla Evidencias.
PASO 9. Crear los JSP

En la última capa tenemos los archivos jsp. Básicamente los archivos que se deben crear son:

 index.jsp: página inicial que me permite ir a administrar aprendices, administrar

evidencias y administrar notas.

 respuesta.jsp: Permite mostrar un mensaje por cada acción que realicemos en nuestro
sistema.

 JPS específicos de cada tabla: Para poder hacer operaciones en las tablas, se deben crear
tres archivos por cada una de ellas:

 listar: Es la pantalla donde vamos a mostrar el listado de elementos que hay en la base
de datos en una tabla específica, además debe tener botones de adicionar, actualizar y
eliminar.

 insertar: es donde tendremos el formulario para insertar un registro.

 actualizar: es donde tendremos el formulario para actualizar un registro.

INDEX.JSP

Este es primer archivo que muestra la aplicación, nos debe mostrar tres links uno para cada tabla.
Para que el controlador sepa qué opción queremos acceder vamos a hacer uso de una pequeña
función javascript. En el cuerpo del archivo, vamos a crear un formulario con tres links y un campo
oculto para manipular la opción:

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>PROYECTO JAVA WEB - ADSI</title>
<script language="javascript">
function defineOpcion(opcion){
document.forms[0].opcion.value = opcion;
document.forms[0].submit();
}
</script>
</head>
<body>
<h1>APLICACIÓN JAVA WEB</h1>
<h2><em>by Yeimmy Lee</em></h2>
<form action="controlador" method="POST">
<input type="hidden" name="opcion" value=""/>
<input type="button" name="aprendiz"
value="Administrar Aprendiz" onclick="defineOpcion(1)"/>
<input type="button" name="evidecia"
value="Administrar Evidencias" onclick="defineOpcion(7)"/>
<input type="button" name="notas"
 value="Administrar Notas" onclick="defineOpcion(13)"/>
</form>
</body>
</html>

RESPUESTA.JSP

Esta página va a ser llamada cada vez que nuestra aplicación realice alguna operación y necesite
mostrar un mensaje de respuesta, recibe un mensaje y una opción hacía donde debe dirigirse al
dar clic en Aceptar.

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>PROYECTO JAVA WEB - ADSI</title>
</head>
<body>

<% String mensaje = (String) request.getAttribute("mensaje"); %>

<% String opcion = (String) request.getAttribute("opcion"); %>

<h1>APLICACIÓN JAVA WEB</h1>

<h2><em>by Yeimmy Lee</em></h2>
<h2>RESPUESTA</h2>
<p> <%=mensaje%> </p>
<form action="controlador" method="post">
<input type="hidden" name="opcion" value="<%=opcion%>">
<input type="submit" name="persona" value="Aceptar" >
</form>
</body>
</html>

LISTARAPRENDIZ.JSP

En este archivo se muestra un listado y los botones para administrar la tabla Aprendiz.

<!--importa las clases necesarias para poder manipular los elementos java -->
<%@page import="modelo.vo.AprendizVO"%>
<%@page import="java.util.Iterator"%>
<%@page import="java.util.ArrayList"%>

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>PROYECTO JAVA WEB - ADSI</title>

<!--Se crean unos estilos sencillos para la tabla -->

<style type="text/css">
th {
border: 2px solid blue;
width: 130px;
 }
td {
border: 2px solid blue;
}
</style>

<!-- función javascript para manejar las opciones -->

<script language="javascript">
function defineOpcion(opcion, id){
document.forms[0].opcion.value = opcion;
//id es para actualizar y eliminar
document.forms[0].id.value = id;
//si la opción es eliminar (6), debe preguntar si está seguro.
if(opcion != 6) {
document.forms[0].submit();
} else if (confirm("¿esta seguro de borrar al id "+id+"?")) {
document.forms[0].submit();
}
}
</script>
</head>
<body>
<h1>APLICACIÓN JAVA WEB</h1>
<h2><em>by Yeimmy Lee</em></h2>
<h2 style="text-align: center;">ADMINISTRACIÓN DE APRENDICES</h2>

<!--Se obtiene el listado de aprendices del request -->

<%
ArrayList aprendices = (ArrayList) request.getAttribute("aprendices");
%>

<form method="post" action="controlador">

<input type="hidden" name="opcion" value="">
<input type="hidden" name="id" value="">
<input type="button" name="insertar"
value="Insertar Aprendiz" onclick="defineOpcion(2)">
<br/><br/>
<table cellpadding="0" cellspacing="0">
<tr>
<th>Identificación</th>
<th>Nombre</th>
<th>Dirección</th>
<th>Teléfono</th>
<th>Correo Electrónico</th>
<th>Fecha de Nacimiento</th>
<th>Ficha</th>
<th>Opciones</th>
</tr>

<!--Se recorre el listado para mostrarlo en la tabla -->

<%
if (aprendices != null) {
Iterator iterador = aprendices.listIterator();
while (iterador.hasNext()) {
AprendizVO aprendizVO = (AprendizVO) iterador.next();
 %>
<tr style="border: 1px solid;">
<td><%=aprendizVO.getId()%></td>
<td><%=aprendizVO.getNombre()%></td>
<td><%=aprendizVO.getDireccion()%></td>
<td><%=aprendizVO.getTelefono()%></td>
<td><%=aprendizVO.getCorreo()%></td>
<td><%=aprendizVO.getFechaNacimiento()%></td>
<td><%=aprendizVO.getFicha()%></td>
<td>
<input type="button" name="Editar"
value="Editar"
onclick="defineOpcion(4,<%=aprendizVO.getId()%>)">
<input type="button" name="Borrar" value="Borrar"
onclick="defineOpcion(6,<%=aprendizVO.getId()%>)">
</td>
</tr>
<%
} //cierra el while
} //Cierra el if
%>
</table>
<br/>
<input type="button" name="Volver"
value="Volver" onclick="defineOpcion(99)">
</form>
</body>
</html>

INSERTARAPRENDIZ.JSP

Muestra el formulario para ingresar la información de un aprendiz, también se hace uso de la

función javascript para el manejo de opciones:

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2">
<title>PROYECTO JAVA WEB - ADSI</title>
<script language="javascript">
function defineOpcion(opcion){
document.forms[0].opcion.value = opcion;
document.forms[0].submit();
}
</script>
</head>
<body>
<h1>APLICACIÓN JAVA WEB</h1>
<h2><em>by Yeimmy Lee</em></h2>
<h2 style="text-align: center;">INSERTAR APRENDIZ</h2>
<form action="controlador" method="POST">
<input type="hidden" name="opcion" value="3" />
<br/>Identificación
 <br/><input type="text" name="id_aprendiz" />
<br/>Nombre
<br/><input type="text" name="nombre" />
<br/>Dirección
<br/><input type="text" name="direccion" />
<br/>Teléfono
<br/><input type="text" name="telefono" />
<br/>Correo Electrónico
<br/><input type="text" name="correo" />
<br/>Fecha de Nacimiento
<em>(Por favor ingresarlo asi: aaaa-mm-dd</em>
<br/><input type="text" name="fecha_nacimiento" />
<br/>Ficha
<br/><input type="text" name="ficha" />
<br/><input type="submit" value="Guardar" />
<input type="button" name="volver"
value="Volver Administrar Aprendices"
onclick="defineOpcion(1)">
<input type="button" name="inicio"
value="Volver al Inicio" onclick="defineOpcion(99)">
</form>
</body>
</html>

ACTUALIZARAPRENDIZ.JSP

Muestra el formulario para actualizar la información de un aprendiz, en este caso trae en un

objeto AprendizVO la información del aprendiz a editar. También se hace uso de la función
javascript para el manejo de opciones:

<!--importa las clases necesarias para poder manipular los elementos java -->
<%@page import="modelo.vo.AprendizVO"%>

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>PROYECTO JAVA WEB - ADSI</title>
<script language="javascript">
function defineOpcion(opcion){
document.forms[0].opcion.value = opcion;
document.forms[0].submit();
}
</script>
</head>
<body>

<!--Se obtienen los datos del aprendiz del request -->

<%
AprendizVO aprendizVO = (AprendizVO) request.getAttribute("aprendizVO");
%>
<h1>APLICACIÓN JAVA WEB</h1>
<h2><em>by Yeimmy Lee</em></h2>
<h2 style="text-align: center;">ACTUALIZAR APRENDIZ</h2>
 <form action="controlador" method="POST">
<input type="hidden" name="opcion" value="5" />
<br/>Identificación
<br/><input type="text" name="id_aprendiz"
value="<%=aprendizVO.getId()%>" />
<br/>Nombre
<br/><input type="text" name="nombre"
value="<%=aprendizVO.getNombre()%>" />
<br/>Dirección
<br/><input type="text" name="direccion"
value="<%=aprendizVO.getDireccion()%>" />
<br/>Teléfono
<br/><input type="text" name="telefono"
value="<%=aprendizVO.getTelefono()%>" />
<br/>Correo Electrónico
<br/><input type="text" name="correo"
value="<%=aprendizVO.getCorreo()%>" />
<br/>Fecha de Nacimiento
<em>(Por favor ingresarlo asi: aaaa-mm-dd)</em>
<br/><input type="text" name="fecha_nacimiento"
value="<%=aprendizVO.getFechaNacimiento()%>" />
<br/>Ficha
<br/><input type="text" name="ficha"
value="<%=aprendizVO.getFicha()%>" />
<br/><input type="submit" value="Actualizar" />
<input type="button" name="volver"
value="Volver Administrar Aprendices"
onclick="defineOpcion(1)">
<input type="button" name="inicio"
value="Volver al Inicio" onclick="defineOpcion(99)">
</form>
</body>
</html>

Solo quedaría pendiente crear el listar, insertar y actualizar para las otras dos tablas. Ya con eso
tendríamos nuestra aplicación terminada. En los JSP de la tabla calificaciones, solamente toca
tener en cuenta que toca enviar dos id (evidencia y aprendiz) y que en el formulario de insertar se
van a mostrar unos select con la información que hay en la base de datos sobre aprendices y
evidencias, de resto todo es igual.

Es importante aclarar que, como en toda aplicación, hay muchas cosas que se pueden
perfeccionar tanto en programación como en la apariencia, el propósito de esta guía era mostrar
cómo se podía encarar un proyecto Java WEB con conexión a bases de datos MySQL desde ceros.

***