El objetivo de este sitio es presentar un conjunto de tutoriales básicos sobre el desarrollo de aplicaciones empresariales utilizando el ambiente Java. Los tutoriales disponibles hasta el momento son los siguientes:
Índice general
1
Desarrollo con Java, Publicación
2
Índice general
CAPÍTULO 1
Contenidos
1.1 Uso de JSP Una de las tecnologías más ampliamente utilizadas para el desarrollo de aplicaciones Web bajo ambiente Java es JSP (Java Server Pages). Esta herramienta permite crear una serie de plantillas HTML que incluyen código incrustado (llamados sniplets) mediante marcadores especiales. El uso de JSP simplifica la programación de servlets pues no es necesario compilar código ya que esto se realiza de forma automática. Además, debido a que la plantilla se escribe directamente en HTML es factible utilizar editores y diseñadores de páginas Web para programar la aplicación.
1.1.1 Creación de la base de datos Para este ejemplo se creará una base de datos de prueba, llamada universidad.db, utilizando SQLite. Es posible utilizar diferentes herramientas para crear bases de datos en este formato, entre ellas se encuentra el plugin para Firefox llamado SQLite Manager, o bien, la herramienta SQLiteBrowser.
3
Desarrollo con Java, Publicación
Por el momento solo se utilizará una tabla con información de profesores de una universidad. El código SQL para crear dicha tabla sería el siguiente: CREATE TABLE "profesor" ( id INTEGER PRIMARY KEY ASC, cedula VARCHAR, nombre VARCHAR, titulo VARCHAR, area VARCHAR, telefono VARCHAR );
Luego de crear la base de datos se agregaron algunos datos de ejemplo a esta tabla. Las siguientes instrucciones SQL permiten poblar la tabla alguna información: INSERT INTO profesor (id,cedula,nombre,titulo,area,telefono) VALUES (1,'101110111','Carlos Perez Rojas','Licenciado', 'Administracion','3456-7890'); INSERT INTO profesor (id,cedula,nombre,titulo,area,telefono) VALUES (2,'202220222','Luis Torres','Master', 'Economia','6677-3456'); INSERT INTO profesor (id,cedula,nombre,titulo,area,telefono) VALUES (3,'303330333','Juan Castro','Licenciado', 'Matematica','67455-7788');
1.1.2 Página de listado de profesores La primer página consistirá del listado de todos los profesores que se encuentran en la base de datos. El código que se muestra a continuación (llamado listaProfesores.jsp) establece la conexión con la base de datos (utilizado JDBC), ejecuta la instrucción de consulta, recupera los datos y crea una tabla HTML con la información obtenida. Sistema Universitario Sistema Universitario Listado de profesores
Cedula
Nombre
Titulo
Acciones
26
Capítulo 1. Contenidos
Desarrollo con Java, Publicación
Actualizar información Se presenta también la rutina de transacción que permite actualizar los datos de un profesor. La lógica de esta rutina se ubica en el archivo ActualizarProfesor.java y reside en el directorio /tutorial2/src/domain/. package domain; import display.FrontCommand; import data.ProfesorFinder; import data.ProfesorRowGateway; import import import import
public class ActualizarProfesor extends FrontCommand {
public void process() throws ServletException, IOException { ProfesorFinder profs = (ProfesorFinder) context.getBean("profesorFinder" String id = request.getParameter("id"); ProfesorRowGateway prof = profs.find(id); if (prof!=null) { String cedula = request.getParameter("cedula"); if (cedula!=null) prof.setCedula(cedula); String nombre = request.getParameter("nombre"); if (nombre!=null) prof.setNombre(nombre); String titulo = request.getParameter("titulo"); if (titulo!=null) prof.setTitulo(titulo); String area = request.getParameter("area"); if (area!=null) prof.setArea(area); String telefono = request.getParameter("telefono"); if (telefono!=null) prof.setTelefono(telefono); prof.update(); } response.sendRedirect("domain.ListaProfesores"); }
1.2. Rutinas de Transacción
27
Desarrollo con Java, Publicación
}
Compilando la capa de dominio Se puede realizar la compilación de estas clases de dominio en forma separada del resto del código de la aplicación. Para ello es necesario contar con las librerías del framework Spring 3 (como se indicó antes) y con la librería servlet-api.jar ubicadas en el directorio /tutorial2/root/WEB-INF/lib/. La siguiente instrucción para ejecutar la compilación puede estar definida en un archivo compileDomainLayer.bat residente en el directorio /tutorial2 (todo en una sola línea):
1.2.4 Configuración del contexto El framework Spring permite crear archivos xml que definen la configuración del contexto de ejecución de la aplicación. El archivo de configuración llamado context.xml se deberá ubicar en el directorio /tutorial2/root/WEB-INF/ y contendrá la siguiente información.
1.2.6 Ejecución del tutorial Este ejemplo se puede ejecutar bajo cualquier contenedor de Servlet. Por ejemplo, para realizar la ejecución de pruebas se puede utilizar un producto como el Winstone Servlet Container que permite ejecutar servlets de forma muy sencilla. Se debe descargar el programa winstone-0.9.10.jar y copiarlo en el directorio /tutorial2/. Sin embargo, para lograr que Winstone ejecute plantillas JSP es necesario descargar algunas librerías adicionales que deben ser copiadas en el directorio /tutorial2/lib: el-api-6.0.18.jar jasper-6.0.18.jar jasper-el-6.0.18.jar jasper-jdt-6.0.18.jar jsp-api-6.0.18.jar jstl-api-1.2.jar jstl-impl-1.2.jar jtds-1.2.4.jar juli-6.0.18.jar servlet-api-2.5.jar servlet-api.jar
1.2. Rutinas de Transacción
31
Desarrollo con Java, Publicación
urlrewrite-3.2.0.jar Para ejecutar el servidor de servlets se puede crear un archivo de instrucciones, llamado run.bat, similar al siguiente en el directorio /tutorial2/ (todo en una sola línea):
Luego se puede acceder a la aplicación desde cualquier visualizador web y apuntando a la dirección http://localhost:8089/domain.ListaProfesores
1.3 Módulo de Tabla A continuación se presenta el mismo ejemplo del tutorial anterior de una aplicación Web de un Sistema Universitario. En este ejemplo se combinarán otros tres patrones descritos por Fowler: módulo de tabla para la lógica del dominio, pasarela a tabla de datos para la capa de acceso a los datos, y controlador de página para la capa de presentación.
1.3.1 Capa de acceso a datos La capa de acceso a datos utilizará una pasarela a tabla de datos que se conectará a una base de datos SQLite. Base de datos Se utilizará la misma base de datos SQLite del tutorial anterior para administrar los datos. Dicha base de datos debe llevar por nombre universidad.db y debe estar ubicada en el directorio /tutorial3/database/. El código SQL utilizado para generar la tabla de profesores sería el siguiente:
32
Capítulo 1. Contenidos
Desarrollo con Java, Publicación
CREATE TABLE profesor (id INTEGER PRIMARY KEY, cedula VARCHAR, nombre VARCHAR, titulo VARCHAR, area VARCHAR, telefono VARCHAR) INSERT INTO profesor VALUES(1,'101110111','Carlos Perez', 'Licenciado','Administracion','3456-7890'); INSERT INTO profesor VALUES(2,'202220222','Luis Torres', 'Master','Economia','6677-3456'); INSERT INTO profesor VALUES(3,'303330333','Juan Castro', 'Licenciado','Matematica','6755-7788');
Para administrar una base de datos SQLite se puede utilizar alguno de los excelentes productos creados para ello, tal como SQLiteman ó el plugin para Firefox llamado SQLite Manager Pasarela a tabla de datos Para implementar la capa de acceso de datos se utiliza una pasarela a tabla de datos. Para ello es necesario crear una clase abstracta que se encargue de almacenar la conexión jdbc. Esta clase se llamará TableGateway.java y residirá en el directorio /tutorial3/src/data/. package data; import java.util.*; import javax.sql.*; import org.springframework.jdbc.core.JdbcTemplate; public abstract class TableGateway { protected JdbcTemplate jdbcTemplate; public void setDataSource(DataSource dataSource) { this.jdbcTemplate = new JdbcTemplate(dataSource); } }
La otra clase necesaria es la que implementa la tabla de datos para los profesores. Este archivo se llama ProfesorGateway.java y reside en el mismo directorio /tutorial3/src/data/.
1.3. Módulo de Tabla
33
Desarrollo con Java, Publicación
package data; import java.util.*; import javax.sql.*; import org.springframework.jdbc.core.JdbcTemplate; public class ProfesorGateway extends TableGateway { private final static String findStatement = "SELECT * "+ "FROM profesor "+ "WHERE id = ?"; public Map find(String id) { List profs = jdbcTemplate.queryForList(findStatement,id); return (Map)profs.get(0); } private final static String findAllStatement = "SELECT * "+ "FROM profesor "; public List findAll() { return jdbcTemplate.queryForList(findAllStatement); } private static final String insertStatement = "INSERT INTO profesor "+ "VALUES (?,?,?,?,?,?)"; public int insert(String cedula,String nombre,String titulo, String area, String telefono) { Random generator = new Random(); int id = generator.nextInt(); jdbcTemplate.update(insertStatement, id,cedula,nombre,titulo,area,telefono); return id; } private static final String updateStatement =
34
Capítulo 1. Contenidos
Desarrollo con Java, Publicación
"UPDATE profesor "+ "SET cedula = ?, nombre = ?, titulo = ?, "+ "area = ?, telefono = ? WHERE id = ?"; public void update(int id,String cedula,String nombre, String titulo, String area, String telefono) { jdbcTemplate.update(updateStatement, cedula,nombre,titulo,area,telefono,id); } private static final String deleteStatement = "DELETE FROM profesor "+ "WHERE id = ?"; public void delete(int id) { jdbcTemplate.update(deleteStatement,id); } }
Compilando la capa de datos Se puede realizar la compilación de estas dos clases en forma separada del resto del código. Para ello es necesario contar con el framework Spring 3 el cual se debe descargar y copiar todas las librerías .jar del directorio lib de dicho framework hacia el directorio /tutorial3/root/WEB-INF/lib/. También es necesario contar en dicho directorio con el driver jdbc para SQLite y las librerías commons para manejo de conexiones a base de datos. Específicamente las librerías que deben residir en el directorio /tutorial3/root/WEB-INF/lib/ son las siguientes: commons-dbcp-1.4.jar commons-logging-1.1.1.jar commons-pool-1.6.jar servlet-api.jar spring-asm-3.2.0.M1.jar 1.3. Módulo de Tabla
35
Desarrollo con Java, Publicación
spring-beans-3.2.0.M1.jar spring-context-3.2.0.M1.jar spring-core-3.2.0.M1.jar spring-expression-3.2.0.M1.jar spring-jdbc-3.2.0.M1.jar spring-tx.3.2.0.M1.jar spring-web-3.2.0.M1.jar sqlite-jdbc-3.5.9.jar La siguiente instrucción para ejecutar la compilación puede estar definida en un archivo compileData.bat residente en el directorio /tutorial3 (todo en una sola línea): javac -cp "root/WEB-INF/classes";"root/WEB-INF/lib/*" -d root/WEB-INF/classes src/data/TableGateway.java src/data/ProfesorGateway.java
Nota: La versión del JDK debe ser superior a 6.0
1.3.2 La capa de lógica del dominio Para implementar la capa de lógica del dominio se utilizará la técnica de módulo de tabla. En este caso el módulo agrupa toda la lógica del dominio, pero no se encarga del acceso a datos. Para acceder a los datos se utiliza la pasarela a tabla de datos mostrada anteriormente. La única clase necesaria sería la llamada ProfesorModule.java y residirá en el directorio /tutorial3/src/domain/. package domain; import data.TableGateway; import data.ProfesorGateway; import java.util.Map; import java.util.List;
36
Capítulo 1. Contenidos
Desarrollo con Java, Publicación
import java.io.IOException; import javax.servlet.ServletException; public class ProfesorModule { private ProfesorGateway gateway; public void setGateway(TableGateway gateway) { this.gateway = (ProfesorGateway)gateway; }
public void actualizar(int id, String cedula, String nombre, String titulo, String area, String telefono) throws Exception if (id
Título:
El controlador para actualizar información Se presenta también el controlador de página que permite actualizar los datos de un profesor. La lógica de este controlador se ubica en el archivo ActualizarProfesor.java y reside en el directorio /tutorial3/src/display/. package display; import java.util.*; import java.io.*; import javax.servlet.*; import javax.servlet.http.*; import org.springframework.web.context.*; import domain.ProfesorModule; public class ActualizarProfesor extends PageController { public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { ProfesorModule module =
44
Capítulo 1. Contenidos
Desarrollo con Java, Publicación
(ProfesorModule) context.getBean("profesorModule"); try { String id = request.getParameter("id"); int idProf = Integer.parseInt(id); String cedula = request.getParameter("cedula"); String nombre = request.getParameter("nombre"); String titulo = request.getParameter("titulo"); String area = request.getParameter("area"); String telefono = request.getParameter("telefono"); module.actualizar(idProf,cedula,nombre,titulo,area,telefono response.sendRedirect("listaProfesores"); } catch (Exception e) { request.setAttribute("mensaje",e.getMessage()); forward("/paginaError.jsp",request,response); } } }
Compilando la capa de presentación Para compilar la capa de presentación es necesario contar con las librerías del framework Spring 3 (como se indicó antes) y con la librería servlet-api.jar ubicadas en el directorio /tutorial3/root/WEB-INF/lib/. La siguiente instrucción para ejecutar la compilación puede estar definida en un archivo compileDisplay.bat residente en el directorio /tutorial3/ (todo en una sola línea):
1.3.4 Configuración del contexto El framework Spring permite crear archivos xml que definen la configuración del contexto de ejecución de la aplicación. El archivo de
1.3. Módulo de Tabla
45
Desarrollo con Java, Publicación
configuración llamado context.xml se deberá ubicar en el directorio /tutorial3/root/WEB-INF/ y contendrá la siguiente información.
Título:
64
Capítulo 1. Contenidos
Desarrollo con Java, Publicación
Sistema Universitario Ejemplo de Rutinas de Transaccion contextConfigLocation /WEB-INF/context.xml org.springframework.web.context.ContextLoaderListener ActualizarProfesor display.ActualizarProfesor DetalleProfesor display.DetalleProfesor ListaProfesores display.ListaProfesores ActualizarProfesor /root/actualizarProfesor DetalleProfesor /root/detalleProfesor ListaProfesores /root/listaProfesores
1.4. Modelo del Dominio
65
Desarrollo con Java, Publicación
1.4.5 Ejecución del tutorial Este ejemplo se puede ejecutar bajo cualquier contenedor de Servlet. Por ejemplo, para realizar la ejecución de pruebas se puede utilizar un producto como el Winstone Servlet Container que permite ejecutar servlets de forma muy sencilla. Se debe descargar el programa winstone-0.9.10.jar y copiarlo en el directorio /tutorial4/. Sin embargo, para lograr que Winstone ejecute plantillas JSP es necesario descargar algunas librerías adicionales que deben ser copiadas en el directorio /tutorial4/lib: el-api-6.0.18.jar jasper-6.0.18.jar jasper-el-6.0.18.jar jasper-jdt-6.0.18.jar jsp-api-6.0.18.jar jstl-api-1.2.jar jstl-impl-1.2.jar jtds-1.2.4.jar juli-6.0.18.jar servlet-api-2.5.jar servlet-api.jar Para ejecutar el servidor de servlets se puede crear un archivo de instrucciones, llamado run.bat, similar al siguiente en el directorio /tutorial4/ (todo en una sola línea):
Luego se puede acceder a la aplicación desde cualquier visualizador web y apuntando a la dirección http://localhost:8089/listaProfesores
66
Capítulo 1. Contenidos
Desarrollo con Java, Publicación
1.5 Mapeo objeto/relacional Este tutorial muestra la forma de desarrollar una aplicación que utilice modelo del dominio como patrón de diseño de la capa de dominio, y mapeador objeto/relacional para la capa de acceso a datos.
1.5.1 Capa de lógica del dominio Para implementar la capa de lógica del dominio se utilizará la técnica de modelo del dominio tal como el tutorial anterior. En este caso el modelo agrupa toda la lógica del dominio, pero no se encarga del acceso a datos. La primer clase necesaria consiste en la entidad profesor Profesor.java y residirá en el directorio /tutorial5/src/domain/. Esta clase es la que contendría la lógica del dominio. package domain; public class Profesor { private int id; private String cedula; private String nombre; private String titulo; private String area; private String telefono; public Profesor () {}; public void setId(int id) {this.id=id;} public void setCedula(String cedula) {this.cedula=cedula;} public void setNombre(String nombre) {this.nombre=nombre;} public void setTitulo(String titulo) throws Exception { if (titulo.toLowerCase().equals("bachiller") || titulo.toLowerCase().equals("licenciado") || titulo.toLowerCase().equals("master") || titulo.toLowerCase().equals("doctor")) this.titulo=titulo; else
1.5. Mapeo objeto/relacional
67
Desarrollo con Java, Publicación
throw new Exception("Error en título de profesor"); } public void setArea(String area) {this.area=area;} public void setTelefono(String telefono) {this.telefono=telefon public int getId() {return id;} public String getCedula() {return cedula;} public String getNombre() {return nombre;} public String getTitulo() {return titulo;} public String getArea() {return area;} public String getTelefono() {return telefono;} }
El repositorio de datos Para mantener almacenados y recuperar los diferentes objetos, se utiliza el objeto llamado ProfesorRepository.java residente en el mismo directorio /tutorial5/src/domain/. Sin embargo, este tipo de objeto solamente es una interfase Java como se puede observar a continuación: package domain; import java.util.Map; import java.util.HashMap; import java.util.Collection; public interface ProfesorRepository { public boolean insertProfesor(Profesor prof); public boolean deleteProfesor(Profesor prof); public Profesor findProfesor(int id); public boolean updateProfesor(Profesor prof); public Collection findAllProfesor(); }
La fábrica de objetos Generalmente cuando se elabora un modelo del dominio es importante crear una clase aparte que se encargue de crear instancias de
68
Capítulo 1. Contenidos
Desarrollo con Java, Publicación
objetos. En este caso se utilizará la clase ProfesorFactory.java y se ubicará en el mismo directorio /tutorial5/src/domain/ package domain; public class ProfesorFactory { public Profesor Create(int id,String cedula,String nombre, String titulo,String area,String telefono) { try { Profesor prof = new Profesor(); prof.setId(id); prof.setCedula(cedula); prof.setNombre(nombre); prof.setTitulo(titulo); prof.setArea(area); prof.setTelefono(telefono); return prof; } catch (Exception e) { return null; } } }
Compilando la capa del dominio Se puede realizar la compilación de estas tres clases en forma separada del resto del código. La siguiente instrucción para ejecutar la compilación puede estar definida en un archivo compileDomainLayer.bat residente en el directorio /tutorial5/ (todo en una sola línea):
1.5.2 Capa de presentación El servicio de la universidad será implementado mediante controladores de página (tal como se hizo en el tutorial anterior), en donde cada página se implementa como un controlador individual. Igual que antes, la clase general para definir los controladores se llama PageController.java y debe residir en el directorio /tutorial5/src/display/. package display; import import import import
El controlador de listado de profesores El primer controlador de página es el que permite mostrar el listado de profesores. Este archivo se llama ListaProfesores.java y reside en el mismo directorio /tutorial5/src/display/. package display; import java.util.*; import java.io.*; import javax.servlet.*; import javax.servlet.http.*; import org.springframework.web.context.*; import domain.ProfesorRepository; import domain.Profesor; import util.ProfesorDTO; import util.ProfesorAssembler; public class ListaProfesores extends PageController {
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { ProfesorRepository profesores = (ProfesorRepository) context.getBean("profesorRepository" try { Collection lista = profesores.findAllProfesor(); List data = new ArrayList(); Iterator itr = lista.iterator(); while (itr.hasNext()) { Profesor prof = (Profesor)itr.next(); ProfesorDTO dto = ProfesorAssembler.CreateDTO(prof); data.add(dto); } request.setAttribute("profesores",data); forward("/listaProfesores.jsp",request,response); } catch (Exception e) { request.setAttribute("mensaje",e.getMessage()); forward("/paginaError.jsp",request,response); } }
1.5. Mapeo objeto/relacional
71
Desarrollo con Java, Publicación
}
La plantilla JSP
Adicionalmente se utilizará, con en el tutorial anterior, una plantilla JSP para realizar el formateo de página en código HTML. El archivo listaProfesores.jsp se encarga de esta tarea y residirá en el directorio /tutorial5/root/.
Sistema Universitario Sistema Universitario Listado de profesores
Nombre
Título
Area
Acciones
1.5. Mapeo objeto/relacional
75
Desarrollo con Java, Publicación
Nombre:
Cédula:
Título:
Area:
Teléfono:
El controlador para actualizar información Se presenta también el controlador de página que permite actualizar los datos de un profesor. La lógica de este controlador se ubica en el archivo ActualizarProfesor.java y reside en el directorio /tutorial5/src/display/. package display; import java.util.*; import java.io.*; import javax.servlet.*; import javax.servlet.http.*; import org.springframework.web.context.*;
76
Capítulo 1. Contenidos
Desarrollo con Java, Publicación
import domain.ProfesorRepository; import domain.Profesor; import util.ProfesorDTO; import util.ProfesorAssembler; public class ActualizarProfesor extends PageController {
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { ProfesorRepository profesores = (ProfesorRepository) context.getBean("profesorRepository" try { String id = request.getParameter("id"); int idProf = Integer.parseInt(id); String cedula = request.getParameter("cedula"); String nombre = request.getParameter("nombre"); String titulo = request.getParameter("titulo"); String area = request.getParameter("area"); String telefono = request.getParameter("telefono"); Profesor prof = profesores.findProfesor(idProf); try { if (cedula!=null) prof.setCedula(cedula); if (nombre!=null) prof.setNombre(nombre); if (titulo!=null) prof.setTitulo(titulo); if (area!=null) prof.setArea(area); if (telefono!=null) prof.setTelefono(telefono); profesores.updateProfesor(prof); } catch (Exception e) {} response.sendRedirect("listaProfesores"); } catch (Exception e) { request.setAttribute("mensaje",e.getMessage()); forward("/paginaError.jsp",request,response); } } }
1.5. Mapeo objeto/relacional
77
Desarrollo con Java, Publicación
Plantilla JSP de mensaje de error
Se puede utilizar un archivo JSP adicional para desplegar los mensajes de error. En particular este archivo será llamado paginaError.jsp y residirá en el directorio /tutorial5/root/.
Sistema Universitario Ejemplo de Mapeo Relacional/Objeto/description> contextConfigLocation /WEB-INF/context.xml org.springframework.web.context.ContextLoaderListener ActualizarProfesor display.ActualizarProfesor DetalleProfesor display.DetalleProfesor ListaProfesores display.ListaProfesores
Ejecución del Tutorial Para ejecutar el servidor de servlets se puede crear un archivo de instrucciones, llamado run.bat (todo en una sola línea), similar al siguiente en el directorio /tutorial5/: java -jar winstone-0.9.10.jar --httpPort=8089 --commonLibFolder=lib --useJasper=true --webroot=root
Luego se puede acceder a la aplicación desde cualquier visualizador web y apuntando a la dirección http://localhost:8089/listaProfesores
1.6 Uso de JSTL La tecnología JavaServer Pages Standard Tag Library (JSTL) es un componente de Java EE. Extiende las ya conocidas JavaServer Pages (JSP) proporcionando cuatro bibliotecas de etiquetas (Tag Libraries) con utilidades ampliamente utilizadas en el desarrollo de páginas web dinámicas. Estas bibliotecas de etiquetas extienden de la especificación de JSP (la cual a su vez extiende de la especificación de Servlet). Su API permite además desarrollar bibliotecas propias de etiquetas. 1.6. Uso de JSTL
93
Desarrollo con Java, Publicación
Las bibliotecas englobadas en JSTL son: core: iteraciones, condicionales, manipulación de URL y otras funciones generales. xml: para la manipulación de XML y para XMLTransformation. sql: para gestionar conexiones a bases de datos. fmt: para la internacionalización y formateo de las cadenas de caracteres como cifras.
1.6.1 Creación de la base de datos Para este ejemplo se utilizará nuevamente la base de datos de prueba, llamada universidad.db, utilizando SQLite. Es posible utilizar diferentes herramientas para crear bases de datos en este formato, entre ellas se encuentra el plugin para Firefox llamado SQLite Manager, o bien, la herramienta SQLiteBrowser. Por el momento solo se utilizará una tabla con información de profesores de una universidad. El código SQL para crear dicha tabla sería el siguiente: CREATE TABLE "profesor" ( id INTEGER PRIMARY KEY ASC, cedula VARCHAR, nombre VARCHAR, titulo VARCHAR, area VARCHAR, telefono VARCHAR );
Luego de crear la base de datos se agregaron algunos datos de ejemplo a esta tabla. Las siguientes instrucciones SQL permiten poblar la tabla alguna información: INSERT INTO profesor (id,cedula,nombre,titulo,area,telefono) VALUES (1,'101110111','Carlos Perez Rojas','Licenciado', 'Administracion','3456-7890');
94
Capítulo 1. Contenidos
Desarrollo con Java, Publicación
INSERT INTO profesor (id,cedula,nombre,titulo,area,telefono) VALUES (2,'202220222','Luis Torres','Master', 'Economia','6677-3456'); INSERT INTO profesor (id,cedula,nombre,titulo,area,telefono) VALUES (3,'303330333','Juan Castro','Licenciado', 'Matematica','67455-7788');
1.6.2 Página de listado de profesores La primer página consistirá del listado de todos los profesores que se encuentran en la base de datos. El código que se muestra a continuación (llamado listaProfesores.jsp) establece la conexión con la base de datos (utilizado JDBC), ejecuta la instrucción de consulta, recupera los datos y crea una tabla HTML con la información obtenida.
select * from profesor Sistema Universitario Sistema Universitario Listado de profesores