UNIVERSIDAD SANTO TOMAS

DUAD
PROGRAMA INGENIERIA EN INFORMATICA
ELECTIVA DE ENFASIS I: LENGUAJE CLIENTE SERVIDOR

PRIMER ANTECEDENTE. INSTALACIÓN MySQL Server 5.5.27

Se va a mostrar como instalar MySQL Server 5.5.27 en el sistema operativo

Windows, del conocido y popular motor de bases de datos gratuito de la
empresa MySQL. Descargar del sitio…
https://downloads.mysql.com/archives/community/

Ejecutar
Inicio de Asistente de Instalación

Se iniciará el asistente de instalación de MySQL Server 5.5, se pulsa el botón

"Next" para iniciar el asistente de instalación.

Se acepta los términos. Se Pulsa el Botón Next

Se Selecciona el tipo de instalación en la ventana "Setup Type", en nuestro
caso se marca la opción "Custom" (choose which program features you want
installed and where they will be installed. Recommended for advanced users),
mediante esta opción se puede seleccionar los componentes que se quiera
instalar. Pulsar el Botón Next

Se instala por defecto en archivos de programa\MySQL.

Pulsar el Botón Next.

Pulsar el Botón Install
Pulsar botón Next

Pulse el botón Next

Pulsar el Botón Finish

Pulsar el Boton Next

Puede usted tener servidores activos…entonces…

Seleccionar la opción "Standard Configuration" que pedirá menos parámetros
de configuración, aunque es menos configurable. En este caso se marca
"Detailed Configuration" ("Choose this configuration type to create the optimal
server setup for this machine"). Esta opción pedirá más parámetros de
configuración, por lo que se podra ajustar más la configuración de MySQL
Server 5.5 a nuestras necesidades.

Pulsar el Botón Next

En primer lugar, se indica el tipo de servidor de MySQL Server, según para el

uso que se quiera dar:

• Developer Machine: este tipo de uso del servidor de MySQL Server se

utiliza como testeo y desarrollo de aplicaciones que utilicen MySQL
Server. Se creará la instancia de MySQL Server consumiendo los
mínimos requisitos posibles. Esto es útil sólo para servidores de bases
de datos de pruebas, no es recomendable para servidores de MySQL
Server en producción con conexión de varios usuarios a la vez.
 • Server Machine: este modo de uso de MySQL Server se usa en
situaciones de necesidades "medias", sirve para pruebas y para el uso
de varios usuarios conectados a la vez (no más de 10, aunque esto
depende del volumen de transacciones que se necesiten). Con este
modo SQL Server necesitará un uso de memoria medio, más alto que el
anterior tipo y más bajo que el siguiente.
• Dedicated MySQL Server Machine: este tipo de instalación sólo es
recomendable cuando el servidor donde se instala va a ser un servidor
dedicado, es decir, cuando el equipo sólo servirá como servidor de
bases de datos MySQL Server. Así pues, en este caso, MySQL Server
utilizará toda la memoria disponible.

En este, puesto que MySQL Server sólo lo se utiliza para pruebas y desarrollo
de aplicaciones, se marca la opción " Server Machine " y se pulsa la tecla
"Next" para continuar

A continuación, se debe indicar el tipo de transacciones que se ejecutarán en el

servidor de SQL Server:

• Multifuncional Database: este tipo de configuración de la instancia de

SQL Server se usa para bases de datos de propósito general, sirve para
pruebas y para base de datos en producción. Se podrán utilizar tanto el
motor InnoDB (admite gestión de transacciónes, más lento que MyISAM)
como el motor MyISAM (no admite gestión de transacciones, más rápido
que InnoDB. Esta opción suele ser la más habitual, pues servirá para
aplicaciones que hagan inserciones, modificaciones y consultas de
datos.
• Transactional Database Only: este tipo de instancia de SQL Server
sólo sirve y está optimizada para realizar transacciones. Sólo admite
InnoDB, no admite MyISAM. Es recomendable sólo para aplicaciones
con varios usuarios concurrentes que puedan realizar eliminaciones,
modificaciones e inserciones de datos, pues habrá control de
transacciones y de bloqueos. En cambio no es recomendable para, por
ejemplo, gestores de contenidos web como PHP-Nuke ó PostNuke, pues
éstos a penas permiten modificaciones e inserciones, sólo para usuarios
 administradores, en cambio sí necesitan bastante velocidad en la
consulta.
• Non-Transactional Database Only: este tipo sólo admite el motor
MyISAM, por lo que sólo será útil para aplicaciones que no requieran de
transacciones (monitorización, logeo, aplicaciones web de consulta,
análisis de programas, etc).

Lo más sencillo, para poder disponer de los dos motores: InnoDB

(transaccional) y MyISAM (no transaccional), marcaremos "Multifuncional
Database", de esta forma, al crear las tablas en MySQL Server, podremos
indicar el tipo de motor (engine) a utilizar. Pulsar el Botón Next

A continuación, se indica la ruta donde se ubicarán los archivos de la base de

datos (datafiles), si es una base de datos en producción que tendrá muchos
usuarios conectados concurrentemente y con muchas transacciones
(modificaciones, inserciones, consultas), es recomendable que los archivos de
datos se encuentren en un disco duro diferente del sistema operativo y lo más
rápido posible.

En este caso, al tratarse de una base de datos de pruebas, dejaremos el

directorio de instalación por defecto. Pulsaremos "Next" para continuar.
A continuación, se indica la configuración para el número de usuarios
concurrentes que se estiman que tomaran servicios de la base de datos
MySQL Server:

• Decision Support (DSS)/OLAP: esta opción es recomendable para unos

20 usuarios concurrentes (conectados a la base de datos a la vez).
• Online Transaction Processing (OLTP): para unos 500 usuarios
concurrentes.
• Manual Setting: en esta opción podremos indicar al asistente de
configuración que configure MySQL Server para el número de usuarios
que indiquemos.

En este caso, puesto que sólo tomaran servicios de la base de datos MySQL
Server unos 15 usuarios se marca la opción "Manual Setting" e introduciremos
en "Concurrent connections": 15, pulsaremos "Next" para continuar.
A continuación, se indica al asistente si se quiere permitir conexiones externas
(de otros equipos de la red) al servidor MySQL Server, para ello se marca
"Enable TCP/IP Networking", también, se debe indicar el puerto que utilizará
MySQL Server, en "Port Number", por defecto es el 3306 por donde escucha el
Servidor MySQL. Cambiar a Puerto 3307. Se Pulsa el botón "Next" para
continuar.

Seleccione Best Support for Multilingualismo. Pulse el Boton Next

Se indica que el asistente de configuración de MySQL Server cree un servicio
de Windows o un archivo de proceso por lotes (.bat). Aquí se puede utilizar el
método que más convenga para iniciar MySQL Server, cada uno tiene sus
ventajas e inconvenientes. El más "profesional" es "Install As Windows
Service", pues se puede indicar el modo de inicio: manual, automático, etc.
también se puede deshabilitarlo o reiniciarlo desde otras aplicaciones en caso
necesario. Si se marca esta opción se debe indicar el nombre que se le dará al
servicio en "Service Name", en este caso, seleccione MySQL5. Marcando la
opción "Launch the MySQL Server automatically" se indica que el servicio de
MySQL Server 5.5 arranca de forma automática al iniciarse el sistema
operativo. Si se marca la opción "Include Bin Directory in Windows PATH" el
asistente creará varios archivos de proceso por lotes (.bat), ejecutables, para
iniciar, detener SQL Server 5.5, la carpeta donde se creen será añadida a la
variable de entorno PATH, para que se pueda iniciar o detener MySQL Server
desde cualquier carpeta en modo MS-DOS.
Se indica también la contraseña para el superusuario root, que será el que
tenga acceso a todos los esquemas (schemas). Si marcamos la opción "Enable
root access from remote machines" se indica a MySQL Server que permita el
acceso desde otros equipos de la red (o Internet) mediante este superusuario.
Si se marca la opción "Create An Anonymous Account" creará una cuenta
anónima, por lo que se permitirá el acceso a MySQL sin introducir usuario y
contraseña (sólo recomendable en caso de bases de datos MySQL Server 5.5
de pruebas, no en producción):

En el root password digite root y confirme con root. Pulse tecla Next

• Username: root. Usuario con permisos suficientes para acceder a

MySQL Server 5.5, como es la primera vez sólo se puede acceder con el
superusuario root, luego se podrá crear otros usuarios con permisos
más restringidos.
• Password: root. Contraseña del superusuario root.
Pulse el botón Execute

Si no hay ningún conflicto con el puerto indicado o el nombre del servicio de

Windows indicado aparecerán todas las operaciones (Prepare configuration,
Write configuration file (C:\Archivos de programa\...my.ini), Start Service y
Apply security settings. También mostrará el mensaje: "Configuration file
created, Windows service MySQL installed, Service started succesfully,
Security settings applied".

Pulsar botón "Finish" para terminar.

 ACCESO A LOS SERVICIOS DEL SERVIDOR

Se accede a los Servicios de Windows, desde "Inicio" - "Ejecutar" -

"services.msc", podremos comprobar que el servicio MYSQL5.5 se ha creado e
iniciado correctamente:

Haciendo doble clic sobre el servicio podremos ver sus propiedades:

• Nombre de servicio: MySQL5

• Nombre para mostrar: MySQL5
• Ruta de acceso al ejecutable: "C:/Archivos de programa/MySQL/MySQL
Server 5.5/bin/mysqldt" --defaults-file="C:/Archivos de
programa/MySQL/MySQL Server 5.5/my.ini" MySQL5
• Tipo de inicio: Automático.
• Estado del servicio: Iniciado
También se puede ver el proceso creado al iniciarse el servicio de MySQL5,
"mysqld.exe":
SEGUNDO ANTECDENTE. JDBC

SQL

SQL es un lenguaje estructurado para el acceso y manipulación de Bases de

Datos(BD)

Caracteristicas

- SQL (Structured Query Language) o Lenguaje estructurado de consulta

- SQL sirve para acceder a las bases de datos

- SQL es un lenguaje estándar ANSI, aunque la mayoría de los servidores de

bases de datos añaden extensiones propietarias al lenguaje SQL

- SQL puede ejecutar consultas contra una BD para obtener datos

- SQL puede introducir nuevos registros en una BD

- SQL puede eliminar registros de una BD

- SQL puede modificar los registros de una BD

- SQL es fácil de aprender

DML (Data Manipulation Language)

Los comandos SQL para consulta y modificación se conocen como el lenguaje de

manipulación de datos (DML)

Consultar información

SELECT [ALL | DISTINCT] <seleccion> FROM <tablas>

WHERE <condiciones de seleccion> [ORDER BY <columna> [ASC | DESC]

[,<columna> [ASC | DESC]]...]

Adicionar Registro

INSERT INTO <nombre tabla>

[(<nombre columna> [,<nombre columna>]...)]

VALUES (<expresion> [,<expresion>]...)

Borrar Registro

DELETE FROM <nombre tabla> WHERE <condicion busqueda>

Modificar Registro

UPDATE <nombre tabla>

SET <nombre columna> = ( <expresion> | NULL )

[, <nombre columna> = ( <expresion> | NULL )]... WHERE <condicion busqueda>

DDL (Data Definition Language)

El lenguaje de definición de datos de SQL permite crear y eliminar tablas, definir

índices, especificar relaciones entre tablas e imponer restricciones a

las tablas

- CREATE TABLE: Crea una tabla en la BD

- ALTER TABLE: Modifica una tabla de la BD

- DROP TABLE: Elimina una tabla de la BD

JDBC. JAVA DATABASE CONNECTION API 3.0

FIGURA 1. CLASES JDBC API 3.0

CONEXIÓN API 3.0

Ejemplo Programa de Conexion

final String DRIVER = "sun.jdbc.odbc.JdbcOdbcDriver";

final String URL = "jdbc:odbc:supermercado”;

Class.forName(DRIVER);

Connection conexion = driverManager.getConnection(URL);

Que es JNDI (Java Naming and Directory Interface)
Es un servicio java para nombres de directorios.
Un servicio de nombres realiza tres tareas fundamentales:
- Asociar nombres con objetos
- Permitir la búsqueda de un objeto por su nombre
- Un servicio de directorios es un servicio de nombres extendido que permite operar
con objetos de tipo directorio.
Características JNDI:
- Los objetos directorio tienen asociado atributos.
- Un directorio es un sistema de objetos directorio conectados, usualmente
estructurado en forma jerárquica (un árbol).
- Provee transparencia de ubicación ya que el código de los clientes no depende de
nombres o ubicaciones específicas de equipos. Si el recurso que se está usando
cambia de lugar, no es necesario modificar el código del cliente, el servicio de
nombres actualizará el cambio.
- Las componentes son altamente reusables y portables.
- Localizar Beans

FIGURA 2. CLASES JDBC CON JNDI

Conexión

Connection conexion = null;

Context initCtx = new InitialContext();
Context envCtx = (Context) initCtx.lookup("java:comp/env");
DataSource ds = (DataSource) envCtx.lookup(<nombreJNDI>);
conexion = ds.getConnection();
Ejemplo:

Connection conn = null;

Context initCtx = new InitialContext();
Context envCtx = (Context) initCtx.lookup("java:comp/env");
//Inicia el Contexto y los servicios de directorios
DataSource ds = (DataSource) envCtx.lookup("jdbc/polizas");
// Localizar y Cargar JNDI (jdbc /polizas) . Si existe (no hay excepción) se cargan los
Objetos que son una base de datos, tablas, índices que tienen atributos (metadatos).
conn = ds.getConnection();
// Se establece la conexión a la base de datos.
PARTE 2. Lo común entre Statement y PreparedStatement

1. Se crea a partir de un Objeto Connection

Caso Statemente:

Connection conexion = driverManager.getConnection(URL);

o
Connection conexion = ds.getConnection();
Statement St=conexión.createStatement(SQL);

Caso PreparedStatement:

Connection conexion = driverManager.getConnection(URL);

o
Connection conexion = ds.getConnection();
PreparedStatement insert = conexion.prepareStatement(SQL);

2. Ejecutan Sentencias SQL

3. Se utiliza el método executeQuery() para ejecutar sentencias SELECT y el resultado
de la misma instancia un Objeto ResultSet
Caso Statement:
import java.sql.*;
public class Ejemplo
{
public static void main(String Args[ ])
{
--------
Connection conexion =
Statement select = conexion.createStatement();
ResultSet resultado = select.executeQuery("SELECT * FROM productos ORDER BY
Nom_producto");
while (resultado.next()) {
System.out.println(resultado.getString("nom_producto")+"
"+resultado.getString("costo"));
}
resultado.close(); select.close(); conexion.close();
} catch (Exception e) {
System.out.println("Error: " + e);
}
}
}

Caso PreparedStatement:
import java.sql.*;
public class Ejemplo1
{
public static void main(String Args[ ])
{
----------
Connection conexion
PreparedStatement select = conexion.prepareStatement("SELECT * FROM productos
where stock<=? ORDER BY Nom_producto");
select.setString(1,"20");
ResultSet resultado = select.executeQuery();
while (resultado.next()) {
System.out.println(resultado.getString("nom_producto")+"
"+resultado.getString("costo")+" "+resultado.getString("stock"));
}
resultado.close(); select.close(); conexion.close();
} catch (Exception e) {
System.out.println("Error: " + e);
}
}
}
4. Se utiliza el método executeUpdate para ejecutar Sentencias INSERT, UPDATE,
DELETE
Caso Statement:
import java.sql.*;
public class Ejemplo2
{
public static void main(String Args[ ])
{
------
Connection conexion =
Statement select = conexion.createStatement();
//int k=select.executeUpdate("INSERT INTO CLIENTE VALUES(1212,'ana
mesa',4586236,'bogota')");
int k=select.executeUpdate("update cliente set domcliente='medellin' where
idcliente=1212");
//int k=select.executeUpdate("delete from cliente where idcliente=1212");
select.close(); conexion.close();
} catch (Exception e) {
System.out.println("Error: " + e);
}
}
}
Caso PreparedStatement:
import java.sql.*;
import javax.swing.*;
public class Ejemplo3
{
public static void main(String Args[ ])
{
------
Connection conexion =
String IdSuper=JOptionPane.showInputDialog(null,"Digite Id de Supermercador");
String NomSuper=JOptionPane.showInputDialog(null,"Digite Nombre de
Supermercador");
String DirSuper=JOptionPane.showInputDialog(null,"Digite Dirección de
Supermercador");
String TelSuper=JOptionPane.showInputDialog(null,"Digite Telefono de
Supermercador");
String idProd=JOptionPane.showInputDialog(null,"Digite Codigo de Producto");
PreparedStatement insert = conexion.prepareStatement("INSERT INTO supermercado
VALUES (?,?,?,?,?)");
insert.setString(1,IdSuper);
insert.setString(2,NomSuper);
insert.setString(3,DirSuper);
insert.setString(4,TelSuper);
insert.setString(5,idProd);
int resultado = insert.executeUpdate();
insert.close(); conexion.close();
} catch (Exception e) {
System.out.println("Error: " + e);
}
System.exit(1);
}
}
PARTE 3. La Importancia de la Interfaz ResultSet
En un objeto ResultSet se encuentran los resultados de la ejecución de una sentencia
consulta de SQL, por lo tanto, un objeto ResultSet contiene las filas como columnas
que satisfacen las condiciones de una sentencia de consulta SQL(Select from where).
El aspecto que suele tener un ResultSet es una tabla con cabeceras de columnas y los
valores correspondientes devueltos por una consulta SQL.
Un ResultSet mantiene un cursor que apunta a la fila actual de datos. El cursor se
mueve hacia abajo cada vez que el método next() es lanzado. Inicialmente está
posicionado antes de la primera fila, de esta forma, la primera llamada a next() situará
el cursor en la primera fila, pasando a ser la fila actual. Las filas del ResultSet son
devueltas de arriba a abajo según se va desplazando el cursor con las sucesivas
llamadas al método next(). Un cursor es válido hasta que el objeto ResultSet o su
objeto padre Statement es cerrado.
Métodos de Desplazamiento y Posicionamento
• boolean absolute(int registro): desplaza el cursor al número de registro
indicado.
• void afterLast(): se desplaza al final del objeto ResultSet, después del último
registro.
• void beforeFirst(): mueve el cursor al comienzo del objeto ResultSet, antes del
primer registro.
• boolean first(): desplaza el cursos al primer registro.
• boolean isAfterLast(): indica si nos encontramos después del último registro del
objeto ResultSet.
• boolean isBeforeFirst(): indica si nos encontramos antes del primer registro del
objeto ResultSet.
• boolean isFirst(): indica si el cursor se encuentra en el primer registro.
• boolean isLast(): indica si nos encontramos en el último registro del ResultSet.
• void last(): desplaza el cursor al último registro del objeto ResultSet.
• void moveToCurrentRow(): mueve el cursor a la posición recordada,
normalmente el registro actual.
• boolean isBeforeFirst(): indica si nos encontramos antes del primer registro del
objeto ResultSet.
• boolean isFirst(): indica si el cursor se encuentra en el primer registro.
• boolean isLast(): indica si nos encontramos en el último registro del ResultSet.
• void last(): desplaza el cursor al último registro del objeto ResultSet.
• void moveToCurrentRow(): mueve el cursor a la posición recordada,
normalmente el registro actual.
• boolean next(): desplaza el cursor al siguiente registro.
• boolean previous(): desplaza el cursor al registro anterior.
• boolean relative(int registros): mueve el cursor un número relativo de registros,
este número
• puede ser positivo o negativo.
• int getRow(): devuelve el número de registro actual
Statement select = conexion.createStatement();
ResultSet rs = select.executeQuery("SELECT * FROM productos ORDER BY
Nom_producto");
 Ejemplo 1. Utilizando next():
while (rs.next()) {
System.out.println(rs.getString("nom_producto")+" "+rs.getString("costo"));
}

Ejemplo 2. Utilizando previous():

rs.afterLast();
StringBuffer resultado=new StringBuffer();;
while(rs.previous()){
resultado.append(
rs.getString(1)+" "+rs.getString(2)+" " +rs.getString(3)+""+rs.getString(4)+"\n"};
}

Métodos que permiten obtener el contenido de los distintos campos del

registro actual
Existen diversos métodos getXXX(), cada uno para un tipo de datos correspondiente.
El campo a obtener su valor se puede indicar mediante una cadena que representa su
nombre o a través de su número de orden(indice).
Entonces el formato es el siguiente:
F1: getXXX(int indice)
F2: getXXX(String Nombre-Columna)

• Array getArray(): El contenido de una Columna es llevado a Objeto Array

• InputStream getAsciiStream(): Obtiene el valor de una columna de la fila actual
como objeto InputStream
▪ BigDecimal getBigDecimal(): Obtiene el valor de una columna de la fila actual
como objeto java.math.BigDecimal con precisión completa.
▪ InputStream getBinaryStream(): Se obtiene un flujo de entrada a partir de un
Campo BloB
▪ Blob getBlob(): Obtiene un valor de BLOB(archivos de imagenes, sonidos) de
la fila actual de este objeto ResultSet
▪ boolean getBoolean() Obtiene el valor de una columna de la fila actual como
boolean de Java
▪ byte getByte(). Obtiene el valor de una columna de la fila actual como byte de
Java
▪ byte[ ] getBytes(): Obtiene el valor de una columna de la fila actual como vector
de bytes.
▪ Date getDate(): Obtiene el valor de la columna designada en la fila actual como
objeto java.sql.Date
▪ double getDouble(): Obtiene el valor de una columna de la fila actual como
double de Java
▪ float getFloat(): Obtiene el valor de una columna de la fila actual como float de
Java
▪ int getInt(String nombreCampo): Obtiene el valor de una columna de la fila
actual como int de Java
▪ long getLong(): Obtiene el valor de una columna de la fila actual como long de
Java
▪ Object getObject(): Obtiene el valor de una columna de la fila actual como
Object de Java
▪ short getShort(): Obtiene el valor de una columna de la fila actual como short
de Java
▪ String getString(): Obtiene el valor de una columna de la fila actual como String
de Java
▪ Time getTime(): Obtiene el valor de una columna de la fila actual como Objeto
Time de Java
import java.sql.*;
public class Ejemplo4
{
public static void main(String Args[ ])
{
-------
Connection conexion =
PreparedStatement select = conexion.prepareStatement("SELECT * FROM
PRODUCTOS where costo>3000 and stock>10 order by stock");
ResultSet resultado = select.executeQuery();
while (resultado.next()) {
System.out.println(resultado.getString("nom_producto")+"
"+resultado.getString("costo")+" "+resultado.getString("stock"));
}
resultado.close(); select.close(); conexion.close();
} catch (Exception e) {
System.out.println("Error: " + e);
}
}
}
Métodos relacionados con la obtención de información de Columnas y Filas
• int findColumn(String nombreCampo): devuelve el índice que le corresponde al
nombre de campo que se pasa como parámetro.
▪ int getFetchDirection(): retorna la dirección del ResultSet.
▪ int getFetchSize(): devuelve el número de registros o filas contenidos en el
ResulSet
▪ void setFetchDirection(int dirección): establece la dirección del ResultSet.
▪ void setFetchSize(int registros): establece el número de registros del
ResultSet(menor que getFetchSize() )
▪ boolean wasNull(): indica si el último valor que se obtuvo de un campo de un
ResultSet es nulo.

Modificar el contenido de los campos del registro actual

Existen distintos métodos updateXXX(), cada uno para un tipo de datos
correspondiente.
El campo a modificar se puede indicar mediante una cadena que representa su
nombre o a través de su número de orden(indice).
Entonces el formato es el siguiente:
F1: updateXXX(int indice, <valor>)
F2: updateXXX(String Nombre-Columna, <valor>)
• void updateBoolean(int índice, boolean valor)
• void updateBoolean(String nombreCampo, boolean valor)
• void updateByte(int índice, byte valor)
• void updateByte(String nombreCampo, byte valor)
▪ void updateBytes(int índice, byte[ ] valor)
• void updateBytes(String nombreCampo, byte[ ] valor)
• void updateDate(int índice, Date valor)
▪ void updateDate(String nombreCampo, Date valor)
• void updateDouble(int índice, double valor)
▪ void updateDouble(String nombreCampo, double valor)
• void updateFloat(int índice, float valor)
• void updateFloat(String nombreCampo, float valor)
• void updateInt(int índice, int valor)
• void updateInt(String nombreCampo, int valor)
• void updateLong(int índice, long valor)
• void updateLong(String nombreCampo, long valor)
• void updateNull(int índice)
• void updateNull(String nombreCampo)
• void updateObject(int índice, Object valor)
• void updateObject(String nombreCampo, Object valor)
• void updateShort(int índice, short valor)
• void updateShort(String nombreCampo, short valor)
• void updateString(int índice, String valor)
• void updateString(String nombreCampo, String valor)
• void updateTime(int índice, Time valor)
• void updateTime(String nombreCampo, Time valor)
 Métodos relacionados con la modificación de los Registros
• void cancelRowUpdates(): cancela las modificaciones realizadas sobre el
registro actual de un objeto ResultSet.
• void deleteRow(): borrar el registro actual, tanto del objeto ResultSet como de
la base de datos.
• void insertRow(): añade los contenidos de un nuevo registro en el objeto
ResultSet y en la base de datos.
• void refreshRow(): refresca el registro actual con el valor del registro en la base
de datos
• boolean rowDeleted(): indica si se ha eliminado el registro actual.
• boolean rowInserted(): indica si se ha insertado el registro actual.
• boolean rowUpdated(): indica si se ha modificado el registro actual.
• void updateRow(): actualiza la base de datos correspondiente con los nuevos
contenidos del registro actual de un objeto ResultSet.
• void moveToInsertRow(): desplaza el cursor para añadir un nuevo registro.
main()
ResultSet rs = null;
idcliente=JOptionPane.showInputDialog(null,"Nit Cliente:",idcliente);
adicion();
boolean existe()
{
boolean esta=false;
try
{
Statement Sentencia=conexion.createStatement();
String CadenaSql="SELECT * FROM cliente where idcliente="+idcliente.toString();
rs = sentencia.executeQuery(CadenaSql);
rs.last();
if(rs.getRow()==1)
esta=true;
else
esta=false;
}
catch(Exception e){}
return esta;
}
void primas()
{
nomcliente=JOptionPane.showInputDialog(null,"Nombre Cliente:",nomcliente);
telcliente=JOptionPane.showInputDialog(null,"Telefono Cliente:",telcliente);
domcliente=JOptionPane.showInputDialog(null,"Domicilio Cliente:",domcliente);
}
void adicion()
{
if(!existe())
{
primas();
rs.moveToInsertRow();
rs.updateInt("idcliente", Integer.parseInt(idcliente));
rs.updateString("nomcliente", nomcliente);
rs.updateInt("telcliente",Integer.parseInt(telcliente));
rs.updateString("domcliente", domcliente);
rs.insertRow();
}
}
Otros métodos de ResultSet
• void close(): cierra el ResultSet liberando de forma inmediata todos los
recursos asociados.
• int getConcurrency(): indica si el objeto ResultSet es de lectura o de escritura.
El entero se corresponde con las constantes definidas en el interfaz ResultSet
y que se utilizan como segundo parámetro en el método createStatement() del
interfaz Connection.
• Statement getStatement(): devuelve el objeto Statement que generó con su
ejecución al objeto ResultSet.
• int getType(); devuelve el tipo del objeto ResultSet, el valor devuelto se
corresponde con las constantes definidas en el interfaz ResultSet y que se
utilizan en el primer parámetro del método createStatement del interfaz
Connection
PARTE 4. Interfaz PreparedStatement
Este interfaz, al igual que el interfaz Statement, permite ejecutar sentencias SQL
sobre una conexión establecida con una base de datos. Pero en este caso se ejecuta
sentencias SQL más especializadas, estas sentencias SQL se van a denominar
sentencias SQL precompiladas y van a recibir parámetros de entrada.
El interfaz PreparedStatement hereda del interfaz Statement y se diferencia de él de
dos maneras:
• Las instancias de PreparedStatement contienen sentencias SQL que ya han
sido compiladas. Esto es lo que hace a una sentencia "prepared” (preparada).
• La sentencia SQL que contiene un objeto PreparedStatement puede contener
uno o más parámetros de entrada. Un parámetro de entrada es aquél cuyo
valor no se especifica cuando la sentencia es creada, en su lugar la sentencia
va a tener un signo de interrogación (?) por cada parámetro de entrada. Antes
de ejecutarse la sentencia se debe especificar un valor para cada uno de los
parámetros a través de los métodos setXXX apropiados. Estos métodos
setXXX los añade el interfaz PreparedStatement.
import java.sql.*;
import javax.swing.*;
public class Ejemplo5
{
public static void main(String Args[ ])
{
--------
Connection conexion =
String IdSuper=JOptionPane.showInputDialog(null,"Digite Id de Supermercador");
String NomSuper=JOptionPane.showInputDialog(null,"Digite Nombre de
Supermercador");
String DirSuper=JOptionPane.showInputDialog(null,"Digite Dirección de
Supermercador");
String TelSuper=JOptionPane.showInputDialog(null,"Digite Telefono de
Supermercador");
String idProd=JOptionPane.showInputDialog(null,"Digite Codigo de Producto");
PreparedStatement insert = conexion.prepareStatement("INSERT INTO supermercado
VALUES (?,?,?,?,?)");
insert.setString(1,IdSuper);
insert.setString(2,NomSuper);
insert.setString(3,DirSuper);
insert.setString(4,TelSuper);
insert.setString(5,idProd);
int resultado = insert.executeUpdate();
insert.close(); conexion.close();
} catch (Exception e) {
System.out.println("Error: " + e);
}
System.exit(1);
}
}
OBTENER METADATOS DE JDBC
Tomado de:
http://translate.google.com.co/translate?hl=es&sl=en&u=http://www.roseindia.net/jdbc/
JdbcGetMetadata.shtml&prev=/search%3Fq%3Dgetmetadata%2Bjava.sql%26hl%3De
s%26biw%3D1366%26bih%3D596%26prmd%3Dimvns&sa=X&ei=SwhFULi3E4-
y9gT14ICwCg&ved=0CCMQ7gEwAA
Obtener metadatos JDBC es la estructura de datos colectiva, tipo de datos y las
propiedades de una tabla. Los metadatos get proporciona la información sobre el
nombre de la columna como número de columnas de una tabla. Las operaciones
execute realizan operaciones de consulta como de actualización de una tabla.
Métodos Descripción
Se crea un objeto SQL a partir de un objeto de
la clase de conexión. Este objeto se utiliza
createStatement ()
para ejecutar operaciones de actualizaciones y
consulta de una tabla.
Este método devuelve el conjunto de registros
de una tabla. El conjunto de registros está
executeQuery ()
asignado a un resultado asociado a la
instrucción SELECT de SQL.
executeUpdate() Operaciones de actualización adición, borrado,
edición ( insert into, delete, update set) sobre
una tabla
Este método devuelve el número, tipo y
getMetaData () propiedades del objeto asociado al
executeQuery
Este método devuelve el número de columnas
getColumnCount()
de la tabla
getColumnLabel(entero) Se obtiene el nombre de la columna de la tabla
PRIMER MOMENTO. Haciendo uso de MySQL command Line

Es una interfaz de línea de comandos para los usuarios finales gestionar los
objetos de datos de usuario. “Mysql” tiene las siguientes características
principales:

• “Mysql” es la interfaz de línea de comandos. No se trata de una interfaz

gráfica de usuario (GUI).
• “Mysql” soporta todos los estándares SQL Data Definition Language
(DDL) para el servidor de comandos para ejecutar.
• “Mysql” apoya todos los estándares SQL Lenguaje de manipulación de
datos (DML) instrucciones al servidor a ejecutar.
• “Mysql” apoya muchas de no SQL comandos “mysql” se ejecutará por sí
mismo.
• “Mysql” proporciona acceso al sistema de ayuda del lado del servidor.
• “Mysql” permite que los archivos de comandos que se ejecuta en un
modo por lotes.
• “Mysql” permite salida de la consulta para tener el formato de las tablas
HTML.
• “Mysql” permite salida de la consulta para tener el formato de elementos
XML.

Se ejecuta de la siguiente manera:

Pasaporte root
Se inicia sesión.

DROP DATABASE IF EXISTS `servicios`;

CREATE DATABASE `servicios`;
USE `servicios`;

CREATE TABLE `encuesta` (

`cedula` BIGINT( 10 ) UNSIGNED NOT NULL ,
`nombre` VARCHAR( 30 ) NOT NULL ,
`ciudad` VARCHAR( 30 ) NOT NULL ,
`domicilio` VARCHAR( 30 ) NOT NULL ,
`telefono` INT( 10 ) NOT NULL ,
`idcontrato` INT( 2 ) NOT NULL ,
`idservicio` INT( 2 ) NOT NULL ,
PRIMARY KEY ( `cedula` ) ) ENGINE = InnoDB ;

CREATE TABLE `servicios` (

`idservicio` INT( 2 ) UNSIGNED NOT NULL ,
`nombre` VARCHAR( 20 ) NOT NULL ,
PRIMARY KEY ( `idservicio` ) ) ENGINE = InnoDB ;

CREATE TABLE `contratos` (

`idcontrato` INT( 2 ) UNSIGNED NOT NULL ,
`nombre` VARCHAR( 20 ) NOT NULL ,
PRIMARY KEY ( `idcontrato` ) ) ENGINE = InnoDB ;

INSERT INTO `servicios`.`contratos` (

`idcontrato` ,
`nombre`
)
VALUES (
‘01’, ‘Mensual’
), (
‘02’, ‘Bimensual’
);

INSERT INTO `servicios`.`servicios` (

`idservicio` ,
`nombre`
)
VALUES (
‘01’, ‘Familiar’
), (
‘02’, ‘Premiere’
);

ALTER TABLE encuesta ADD FOREIGN KEY (idcontrato )

REFERENCES contratos (idcontrato);

ALTER TABLE encuesta ADD FOREIGN KEY ( idservicio )

REFERENCES servicios ( idservicio ) ;
SELECT *
FROM encuesta ;
SELECT *
FROM contratos;
SELECT *
FROM servicios;
SEGUNDO MOMENTO. INSTALACION DE SERVIDOR APACHE TOMCAT

Descargar de la dirección http://tomcat.apache.org/download-60.cgi

De la sección

Selecciones y descargue 32-bit Windows zip (pgp, md5)

Ejecutar

Seleccione la Carpeta apache-tomcat-version

Pulse
Seleccionar el Disco c:
 Pulse el Botón Aceptar

Queda instalado

Ahora se debe tener en cuenta:

$CATALINA_HOME = Representa la raíz donde se ha instalado apache-tomcat.

Cada uno de los directorios de la imagen tiene su respectivo significado:

/bin – arranque, cierre, y otros scripts y ejecutables

/temp – archivos temporales
/conf – archivos XML y los correspondientes DTD para la configuración de apache-
tomcat el mas importante es server.xml.
/logs – archivos de registro (log) de apache-tomcat.
/webapps – directorio que contiene las aplicaciones web
/work – almacenamiento temporal de ficheros y directorios

• El siguiente paso quizás es uno de los más importantes y es la creación de la

variable de entorno JAVA_HOME. Ejemplo:

JAVA_HOME = directorio del JDK.

Para acceder a la creación de la variable de entorno: Inicio>Configuración>Panel de
Control>Sistema>Opciones Avanzadas>Variables de Entorno>Nueva

• Existen dos archivos sumamente importantes los cuales nos permitirán iniciar y
parar apache-tomcat se encuentra en el directorio bin.

startup = para iniciar o arrancar

shutdown = para parar o detener
Configuración Servidor Apache-Tomcat

Para poder gestionar y administrar apache-tomcat es posible configurar el servidor con

el siguiente archivo:

$CATALINA_HOME/conf/tomcat-server.xml

Entonces, abra el archive server.xml en la carpeta apache-tomcat-version\conf

Busque la etiqueta </Host>

Coloque lo siguiente antes de la etiqueta </Host>

<Context path="/Servicios" docBase="Servicios" reloadable="true">

<Resource name="jdbc/servicios"

auth="Container"

type="javax.sql.DataSource"

driverClassName="com.mysql.jdbc.Driver"

url="jdbc:mysql://localhost:3307/Servicios?autoReconnect=true"

username="root"

password="root"

/>

</Context>

Se está agregando al contexto un servicio de una Base de Datos mysql cuyo nombre
es Servicios. Entonces, el recurso del contexto se denomina jdbc/servicios para ser
usada por la aplicación Servicios

Guardar Documento
Actualización Usuarios Apache-Tomcat

Para poder acceder a las aplicaciones de gestión y administración de apache-tomcat

es necesario crear un usuario accediendo al siguiente directorio;

$CATALINA_HOME/conf/tomcat-users.xml = este archive permite crear un username,

password and roles

Coloque el siguiente texto:

<tomcat-users>

<role rolename="tomcat"/>

<role rolename="role1"/>

<role rolename="manager-gui"/>

<user username="tomcat" password="tomcat" roles="tomcat"/>

<user username="both" password="tomcat" roles="tomcat,role1"/>

<user username="root" password="tomcat" roles="manager-gui"/>

</tomcat-users>

Guardar Documento
Ejecutar el siguiente archivo de la carpeta

Aparece la ventana de inicializar el apache

• Seguidamente abrimos un navegador web y escribimos en el URL.

http://{host}:{port}/ = donde {host}{port} representa el hostname y el puerto donde corre

apache-tomcat, entonces quedaría http://localhost:8080/ y aparecerá la pagina de
bienvenida de apache-tomcat.
 Procedemos a parar e iniciar apache-tomcat > http://localhost:8080/ en el
navegador > clic en Tomcat Manager > debemos ingresar el username and
password anteriormente creado en el archivo tomcat-users.xml.

Usuario:root

Contraseña: tomcat

Aparece la siguiente pantalla:

Cuando se ejecuta el servidor apache tomcat se crea la carpeta \Catalina\localhost a
partir de la carpeta conf:
TERCER MOMENTO. INSTALACION DE API `s

Instalación de servlet api

El archivo servelt-api se encuentra en la carpeta apache-tomcat-version>lib:

Para su instalación se debe:

1. Entrar al Panel de Control

2. Seleccione el Icono Sistema
3. Seleccione Opciones Avanzadas
4. Pulse el Botón Variables de Entorno
5. Verifique si en la Ventana variables de entorno:
Variable Valor

CLASSPATH C:\apache-tomcat-version\lib\servlet-api.jar

6. Sino esta la variable ClassPath, pulse el botón Nueva y coloque:

Nombre de Variable: ClassPath

Valor de la Variable C:\apache-tomcat-version\lib\servlet-api.jar

Pero si existe pulse el botón Modificar y adicione al final:

 Valor de la Variable ;C:\apache-tomcat-version\lib\servlet-api.jar

Nota: Se debe colocar el signo ; (punto y coma) para adicionar

6. Pulse el Botón Aceptar

7. Salir del Panel de Control

Instalacion MySQL Connector / J

1. Ingresar al aula al ítem Ingresar al aula al ítem APLICACIONES WEB
/SERVIDORES

2. Seleccionar Conector Primitivo MySql

3. Descargar el controlador mysql-connector-java-xxx- bin.jar

4. Copiar mysql-connector-java-xxx- bin.jar en la carpeta C:\apache-tomcat-

version\lib\

5. Establecer el Class Path Conector mySql

Una vez copiado el archivo, se establece el ClassPath para el mysql-connector-
java-xxxx- bin.jar se debe:

1. Se debe entrar al Panel de Control

2. Seleccione el Icono Sistema
3. Seleccione Opciones Avanzadas
4. Pulse el Botón Variables de Entorno
5. Verifique si en la Ventana variables de entorno:
Variable Valor

CLASSPATH C:\apache-tomcat-version\lib\ mysql-connector-java-xxx-

bin.jar

6. Sino esta la variable ClassPath, pulse el botón Nueva y coloque:

Nombre de Variable: ClassPath

Valor de la Variable: C:\apache-tomcat-version\lib\ mysql-connector-java-

xxx- bin.jar

Pero si existe pulse el botón Modificar y adicione al final:

Valor de la Variable ; C:\apache-tomcat-version\lib\ mysql-connector-java-xxx-

bin.jar

Nota: Se debe colocar el signo; (punto y coma) para adicionar

Pulse el Botón Aceptar

Salir del Panel de Control
Que es JNDI (Java Naming and Directory Interface)

Es un servicio java para nombres de directorios.

Un servicio de nombres realiza tres tareas fundamentales:
- Asociar nombres con objetos
- Permitir la búsqueda de un objeto por su nombre
- Un servicio de directorios es un servicio de nombres extendido que permite
operar con objetos de tipo directorio.
Características JNDI:
- Los objetos directorio tienen asociado atributos.
- Un directorio es un sistema de objetos directorio conectados, usualmente
estructurado en forma jerárquica (un árbol).
- Provee transparencia de ubicación ya que el código de los clientes no
depende de nombres o ubicaciones específicas de equipos. Si el recurso que
se está usando cambia de lugar, no es necesario modificar el código del
cliente, el servicio de nombres actualizará el cambio.
- Las componentes son altamente reusables y portables.
- Localizar Beans
- Conectarse a fábrica de recursos en nuestro caso JDBC, mediante el código
java:
ctx= new InitialContext().lookup("jdbc/sql"):: Inicia el Contexto y los servicios de directorios
ds=(DataSource) ctx.lookup("jdbc /polizas"):: Localizar y Cargar JNDI (jdbc /polizas) . Si existe
(no hay excepción) se cargan los Objetos que son una base de datos, tablas, índices que tienen
atributos (metadatos).
conn = ds.getConnection():: Se establece la conexión a la base de datos.
Instalacion JNDI-API
6. Ingresar al aula al ítem APLICACIONES WEB /SERVIDORES
7. Seleccionar Conector jndi.jar

8. Descargar el controlador jndi-xxx.jar

9. Copiar jndi.jar en la carpeta C:\apache-tomcat-version\lib\

10. Establecer el Class Path Conector jndi

Una vez copiado el archivo, se establece el ClassPath para el jndi-xxx.jar se

debe:

1. Se debe entrar al Panel de Control

2. Seleccione el Icono Sistema
 3. Seleccione Opciones Avanzadas
4. Pulse el Botón Variables de Entorno
5. Verifique si en la Ventana variables de entorno:
Variable Valor

CLASSPATH C:\apache-tomcat-version\lib\ jndi-xxx.jar

6. Sino esta la variable ClassPath, pulse el botón Nueva y coloque:

Nombre de Variable: ClassPath

Valor de la Variable: C:\apache-tomcat-version\lib\jndi-xxx.jar

Pero si existe pulse el botón Modificar y adicione al final:

Valor de la Variable: C:\apache-tomcat-version\lib\jndi-xxx.jar

Nota: Se debe colocar el signo ; (punto y coma) para adicionar

Pulse el Botón Aceptar

Salir del Panel de Control
CUARTO MOMENTO.SERVLETS HTTP Y JSP

Tomado de: http://www.altatorre.com/webclase/jsp/jsp0.htm

Los primeros programas de Java que se crearon fueron las aplicaciones de Escritorio
que podían funcionar en la consola de DOS o con ventanas de Windows, luego vienen
los applets que son fragmentos de código en Java que se incrustan en páginas web y
que envían un archivo *.class desde el servidor para que se ejecute en el servidor.

El tercer gran grupo de programas que pueden realizarse en Java son los servlets.
Estos son programas que se parecen más a las aplicaciones básicas de escritorio que
a los applets que antes estudiabamos. Sin embargo, que contienen una complejidad
mucho mayor y por eso se dió un paso más allá llamado JSP que mantiene el poder
de los servlet pero recortando su complejidad.

Servlets de Java

Los servlets son programas que se ejecutan en el servidor pero que se conectan con
el cliente desde allí. El servlet no tiene pantallas locales en el servidor, sino que
reciben y responden datos a través del servidor web. Siempre escriben sobre la
máquina de cliente en HTML/CSS.

Es decir, los servlets son programas de Java que generan HTML/CSS al vuelo y lo
envían desde el servidor al cliente. Para entender qué pasa con el JSP debemos
estudiar un poco qué es lo que pasa con el protocolo HTTP.

Protocolo HTTP: Request, Response y Headers

HTTP es un protocolo simple y sin estados. Un cliente, por ejemplo un web browser,
hace una petición (Request), el servidor web responde y la transacción está hecha.
Cuando el cliente envía una petición, la primera cosa que especifica en un comando
HTTP llamado un método, que dice al servidor qué tipo de acción quiere realizar. Esta
primera Línea de la petición también especifica la dirección de un documento (una
URL) y la versión del protocolo HTTP que está usando. Por ejemplo:

GET /intro.html HTTP/1.0

GET Y POST

Cuando un cliente se conecta a un servidor y hace una petición HTTP, la petición

puede ser de diferentes tipos, llamados métodos. Los métodos más frecuentemente
usados son GET y POST. Para colocarlo de una manera simple GET está hecho para
obtener información, mientras que POST está diseñado para enviar información.

El método GET a pesar de ser hecho para pedir información dentro de su petición
puede incluir información de la petición. Esta información son parámetros de la
dirección URI que se está usando. Por ejemplo:

Ejemplo 1: http://www.server.com/ordenes.htm?cliente=1983

Ejemplo 2: http://www.server.com/ordenes.htm?cliente=1983&ID=1112

Los parámetros se dividen de la dirección con un signo "?". En este caso se añade un
par atributo-valor así: cliente=1983, esta seguramente es una referencia que lleva
información de la petición que se está haciendo. Sin embargo, la cantidad de
información que se puede enviar en la URI es limitada.

Las direcciones anteriores se llaman URI (Uniform Resource Identifier) y usan los
parámetros para puntualizar la petición GET que se está haciendo.

El método POST puede enviar mucha más información y no lo hace de manera visible
como el método GET, por lo que es emás seguro.

La API de Servlets

Habiendo recordado lo anterior, podemos hablar sobre el API de los servlets que se
usa con los servlets HTTP. Los servlets usan dos paquetes, javax.servlet y
javax.servlet.http de la extensión javax de los API. Le recomendamos dar una ojeada a
la definición del API que le permite ver los objetos que tiene disponibles para trabajar
con JSP.

A diferencia de las aplicaciones de escritorio y los applets, un servlet no tiene un

método main(). En su lugar, ciertos métodos son invocados por el servidor al manejar
las peticiones de los usuarios. Cada vez que un servidor despacha una petición a un
servlet, invoca el método service().

Un servlet genérico debería sobreescribir su método service() para manejar sus

peticiones del usuario, pero no lo hace sobreescribe los métodos doGet() y doPost().

Los servlets generan páginas web, es por eso que se usan en las mismas tareas que
un CGI.
Java Server Pages 1.0

JSP es un lenguaje que queda embebido dentro del HTML, y en el que se crean unas
plantillas usadas con un servlet genérico que el programador nunca ve. Estas plantillas
están escritas en HTML/CSS/JavaScript y en Java. Teniendo en cuenta que el
JavaScript se ejecuta en el cliente y el Java en el servidor. En el servidor puede
comunicarse con aplicaciones de escritorio y objetos de Java, así como con applets.

La especificación JSP 1.1 extiene la API de Java Server. Como hemos visto, ambas
forman parte de la Java 2 Platform Enterprise Edition (J2EE). Información específica
de JSP se puede conseugir en el sitio web de Sun en http://java.sun.com/products/jsp.

1. Directivas

Una directiva de JSP es una estamento que proporciona la información del motor de
JSP para la página que la pide. Su sintaxis general es <%@ directiva {atributo
="valor"} %>

dónde la directiva debe tener un número de atributos. Cada directiva tiene un XML
opcional equivalente, pero esto son intentos para una futura herramienta JSP, por esto
no lo consideraremos ahora.

Posibles directivas en JSP 1.0 son:

Page: Información para la página.

Include: Incluye archivos completos palabra por palabra.

Taglib: La dirección de la librería de tags que se usará en la página.

Tal y como esperabamos, la directiva Page posee varios atributos.

Atributos y posibles valores Descripción

- language="java". Comunica al servidor el lenguaje que va a ser utilizado en el

archivo. Java es el único posible es esta especificación

- extends="package.class". La variale extends, define la clase padre del

servlet generado. Normalmente no es necesario utilizar otras que no sean las clases
base del proveedor.

-import="package.*,package.class". Sirve para especificar los paquetes y clases que

se

quieran utilizar.

- session="true|false". Por defecto session vale true, manteniendo los datos de las
sesión para la página.

- isThreadSafe="true|false". Por defecto vale true, le hace señales al motor de

JSP para que multiples pedidos del cliente puedan ser tomadas como una.
-info="text". Información en la página a la que puede accederse a través del método
Servlet.getServletInfo()

- errorPage="pagina_error" Página que manejará las excepciones de errores.

isErrorPage="true|false" Marca a la página como la página que manejará

2. Declaraciones

Una declaración de JSP, puede definirse como una definición de variables y métodos
a nivel de clase que son usadas en la página.

Un bloque de declaraciones típico sería <%! declaración %>

Un ejemplo de declaración de script sería el siguiente:

<HTML>

<HEAD>

<TITLE>Página simple JSP</TITLE>

</HEAD>

<BODY>

<%! String strCadena = "x";

int intContador = 0;

%>

</BODY>

</HTML>

3. Scripts de JSP

Los Scripts son bloques de código Java residentes entre los tags <% y %>.

Este bloques de código estarán dentro del servlets generado incluídos en método
_jspService().

Los Scripts pueden acceder a cualquier variable o Beans que haya sido declarado.
También hay algunos objetos implícitos disponibles para los Scripts desde entorno del
Servlet. Vamos a verlos a continuación.

- request. Es la petición del cliente. Es normalmente una subclase de la case

HttpServletRequest.

-request.getParameter(String arg). Retorna el valor del Atributo (objeto) almacenado

en la sesión actual, y cuyo nombre es arg( que corresponde a un objeto String). Este
método retorna el valor null si el atributo no existe.

String cedula= request.getParameter(“Cedula”);

- request.setAttribute(String nombre, Object valor): almacena un Atributo (objeto) en la
sesión haciendo uso del nombre como del valor en el argumento.

request.setAttribute("area", new String().valueOf(area));

request.setAttribute("formula", tipoArea);

- response. Es la página JSP de respuesta y es una subclase de HttpServletResponse.

- pageContext. Los atributos de la página y los objetos implícitos necesitan ser

accesibles a través de API, para permitir al motor de JSP compilar la página. Pero
cada servidor tiene implementaciones específicas de cada uno de esos atributos y
objetos.

Para solucionar este problema, el motor de JSPutilizar la clase Factory para devolver
la implementación de clase PageContext del servidor. Esta clase PageContext es
inicializada con los objetos response y request y algunos atributos de la directiva de la
página (erropage,session,buffer and autoflush) y facilita los otros objetos implícitos
para la pagina de petición.

- session El objeto de sesión HTTP asociado a la petición.

- application. Lo que devuelve el servlet cuando se llama a

getServletConfig().getContext()

- out. El objeto que representa la salida de texto por pantalla.

- config. El objeto ServletConfig de la página.

- page. Es la forma que tiene la página para referirse a si misma. Se usa como
alternativa al objeto this

- exception. Es una subclase libre de Throwable que es pasada a la página que

maneja los errores

4. Catálogo de tipos de tags JSP

Las páginas en JSP se escriben básicamente en DHTML (HTML +CSS+JavaScript),

pero con introducción de partes adicionales que son scripts de servidor escritos en
Java. Estos scripts de servidor vienen incluidos con los tags <% .. %>

Scriptlets

1. Hacer una página en JSP que liste los 10 primeros números enteros.

<html>
<body>
<%
int i;
for (i=0; i<10; i++) {
out.println(i+"
");
}
%>
</body>
</html>

2. Hacer una página JSP que liste los 100 primeros cuadrados

<html>
<head>
<style>
td { font-family:verdana; font-size:9pt; }
</style>
</head>
<body>
<table>
<%
int i;
for (i=0; i<100; i++) {
out.println("<tr><td>" + i + "</td><td>" + (i*i) + "<br>");
}
%>
</table>
</body>
</html>

3. Hacer una página JSP que muestre el resultado del juego 7 pum hasta 100. El juego consiste en ir
contando y cada vez que el número sea divisible por 7 o terminado en 7 entonces se reemplaza por PUM
y se salta de línea.

<html>
<head>
<style>
body { font-family:verdana; font-size:9pt; }
i { color:red; font-weight:bold; }
</style>
</head>
<body>
<%
int i;
for (i=1; i<100; i++) {
if ( ( i % 7 == 0 ) || ( i % 10 == 7 ))
out.println("<i>PUM</i><br>");
else
out.println( i + " " );
}
%>
</body>
</html>

Expresiones

Cuando necesitamos mostrar una expresión debemos usar los tags <%= ... %>

Así:

Archivo (inicial.jsp)

<%@ page language=java %>

<html>

<body>
 Vamos a crear una variable en JSP<br>

<% int variablePrueba = 10; %>

<p> Y ahora mostramos que la variable es <%= variable %> </p>

</body>

</html>

En el cliente la página que llega es solo HTML:

<html>

<body>

Vamos a crear una variable en JSP<br>

<p> Y ahora mostramos que la variable es 10 </p>

</body>

</html>

Puede ser un cálculo que se va a hacer a través de Java, ya sea usando Java Local o
un bean o un servlet.

Hay otros como <jsp:UseBean ... />, <jsp:getProperty ... />, <jsp:setProperty ... />

Declaraciones

Las variables que son globales a la clase y los métodos que tienen ámbito de clase se
declaran entre los tags <%! ... %>

<html>

<body>

<h1> hola Declaración </h1>

</body>

</html>

<%!

private int i=4;

public void MiMetodo () {

// Ejecuta alguna acción aquí.

%>
5. Acciones

Las acciones son etiquetas HTML que se interpretan en la fase de traducción y que
realizan diferentes operaciones.

jsp:include

Sintaxis:

<jsp:include page="direccion de la otra página">

<jsp:param name="nombreParametro1" value="valorParametro1"/>

<jsp:param name="nombreParametro2" value="valorParametro2"/>

</jsp:include>

Delega “temporalmente” el procesamiento de la sesion al recurso especificado en el

atributo page sobre el que se aplica. Esta acción admite especificar parámetros
mediante la accion jsp:param.

Por ejemplo, si queremos ir temporalmente a una pagina2 y pasar como parámetro

una variable llamada “x” que tenga un valor “y”, bastaría con hacer:

<jsp:include page=”pagina2?>

<jsp:param name=”x” value=”y”/>

<jsp:include/>

jsp:forward

Sintaxis

<jsp:forward page="direccion de la otra página">

<jsp:param name="nombreParametro1" value="valorParametro1"/>

</jsp:forward>

Delega el procesamiento de la sesion al recurso especificado en el atributo page sobre

el que se aplica. Esta acción admite especificar parámetros mediante la acción
jsp:param.

Por ejemplo, si queremos ir a una pagina2 y pasar como parámetro una variable
llamada “x” que tenga un valor “y”, bastaría con hacer:

<jsp:forward page=”pagina2?>

<jsp:param name=”x” value=”y”/>

<jsp:forward/>
Delegar peticiones a otros recursos

Tomado: http://www.adrformacion.com/cursos/javaser/leccion3/tutorial5.html

En el esquema de trabajo típico de los servlets, un servlet recibe una petición http,
ejecuta código ubicado en los métodos de servicio para generar la respuesta html y la
envía al cliente.

En muchas ocasiones, los servlets no generan la respuesta sino que actúan

como gestores de la petición mediante la ejecución de código de control con
instrucciones if condicionales. En función del bloque condicional que se ejecute se
delega la generación de respuesta a otros recursos tales como páginas html, páginas
jsp u otros servlets.

La interface javax.servlet.RequestDispatcher contiene dos métodos que permiten

delegar la generación de respuestas a otros recursos.

• El método forward, que permite delegar el procesamiento de la petición a una

página html, jsp u otro servlet.

• El método include, que permite incluir la respuesta generada por uno de estos
recursos en el servlet sobre el que se aplica

Explicación detallada de ambos métodos:

• void forward(ServletRequest request, ServletResponse response): delega

el procesamiento de la petición al recurso especificado en el argumento del
objeto RequestDispatcher sobre el que se aplica. Toda respuesta vertida al
flujo de salida mediante el objeto out asociada a líneas anteriores y posteriores
a la del método no se considera. El resto de código, sí.

• void include(ServletRequest request, ServletResponse response): delega

“temporalmente” el procesamiento de la petición al recurso especificado en el
argumento del objeto RequestDispatcher sobre el que se aplica, incluyendo en
el servlet en el que se encuentra definido, además de la respuesta generada
hasta la línea del include, una página html, jsp o la respuesta html generada
por otro servlet. Muy usado para incorporar encabezados (headers) y pies de
página (footers) comunes a todos los recursos de una aplicación web.

Para poder aplicar estos métodos es necesario obtener un objeto de la interface

RequestDispatcher.

Se consigue de dos posibles formas:

Para poder aplicar estos métodos es necesario obtener un objeto de la interface
RequestDispatcher.

Se consigue de dos posibles formas:

• Mediante los métodos de la interface javax.servlet.ServletContext

• RequestDispatcher getRequestDispatcher(String
rutaRecursoAlQueSeDelega): se emplea, sobre todo, cuando se
desea delegar en ficheros html o jsps. También sirve para servlets.

• RequestDispatcher getNamedDispatcher(String
nombreServletAlQueSeDelegaEnDescriptor): habitualmente usado
para delegar en otro servlet. Debe especificarse el nombre o alias que
se le ha asignado al servlet en el descriptor de despliegue de la
aplicación

Para poder aplicar estos métodos es necesario obtener un objeto de la interface

ServletContext. Antes de explicar cómo se obtiene conviene explicar el significado de
contexto en el ámbito de las aplicaciones web. Se explica en el siguiente apartado

• Mediante el método de la interface javax.servlet.ServletRequest

• RequestDispatcher getRequestDispatcher(String
rutaRecursoAlQueSeDelega): se emplea, sobre todo, cuando se desea
delegar en ficheros html o jsps
Patrón de Diseño Front Controller

Tomado de:
http://www.programacion.com/articulo/catalogo_de_patrones_de_diseno_j2ee__i
__capa_de_presentacion_240/4

Contexto

El mecanismo de manejo de peticiones de la capa de presentación debe controlar y

coordinar el procesamiento de todos los usuarios a través de varias peticiones. Dichos
mecanismos de control se pueden manejar de una forma centralizada o
descentralizada.

Problema

El sistema requiere un punto de acceso centralizado para que el manejo de peticiones

de la capa de presentación soporte la integración de los servicios del sistema,
recuperación de contenidos, control de vistas, y navegación. Cuando el usuario
accede a la vista directamente sin pasar un mecanismo centralizado, podrían ocurrir
dos problemas:

• Se requiere que cada vista proporcione sus propios servicios del sistema, lo
que normalmente resulta en duplicación de código.
• La vista de navegación se deja a los visores. Esto podría resultar en una
mezcla de contenidos y navegación.

Además, el control distribuido es más difícil de mantener, ya que los cambios se tienen
que realizar en numerosos lugares.

Causas

• El procesamiento de servicios del sistema comunes se completa por cada

petición. Por ejemplo, el servicio de seguridad completa los chequeos de
autentificación y autorización.
• La lógica se maneja mejor en una localización central en lugar de estar
replicada dentro de varias vistas.
• Existen puntos de decisión con respecto a la recuperación y manipulación de
los datos.
• Se utilizan varias vistas para responder a peticiones de negocio similares.
• Puede ser muy útil un punto de contacto centralizado para manejar una
petición, por ejemplo, para controlar y grabar el camino de un usuario por la
site.
• Los servicios del sistema y la lógica de control de vistas son relativamente
sofisticados.

Solución

Usar un controlador como el punto inicial de contacto para manejar las

peticiones. El controlador maneja el control de peticiones, incluyendo la
invocación de los servicios de seguridad como la autentificación y autorización,
delegar el procesamiento de negocio, controlar la elección de una vista
apropiada, el manejo de errores, y el control de la selección de estrategias de
creación de contenido.
El controlador proporciona un punto de entrada centralizado que controla y maneja las
peticiones Web. Centralizando los puntos de decisión y control, el controlador también
ayuda a reducir la cantidad de código Java, llamadas a scriptles, embebidos en la
página JavaServer Pages (JSP).

Centralizar el control en el controlador y reduciendo la lógica de negocios en la vista

permite reutilizar el código entre peticiones. Es una aproximación preferible a la
alternativa de embeber código en varias vistas porque esta aproximación trata con
entornos más propensos a errores, y de reutilización del tipo copiar-y-pegar.

Típicamente, un controlador se coordina con un componente dispatcher. Los

dispatchers son responsable del control de la vista y de la navegación. Así, un
dispatcher elige la siguiente vista por el usuario y dirige el control al recurso. Los
dispatchers podrían encapsularse directametne dentro del controlador o se puede
extraer en un componente separado.

Aunque el patrón Front Controller sugiere la centralización del manejo de peticiones,

no limita el número de manejadores en el sistema, como lo hace Singleton. Una
aplicación podría utilizar varios controladores en un sistema, cada uno mapeado a un
conjunto de servicios distintos.

Estructura

La siguiente figura representa el diagrama de clases del patrón Front Controller.

Participantes y Responsabilidades

La siguiente figura representa el diagrama de la secuencia del patrón Front

Controller. Muestra como el controlador maneja una petición:
Controller

El controlador es el punto de contacto inicial para manejar todas las peticiones en el

sistema. El controlador podría delegar a un helper para completar la autentificación y
la autorización de un usuario o para iniciar la recuperación de un contacto.

Dispatcher

Un dispatcher es el responsable del manejo de la vista y de la navegación,

controlando la elección de la siguiente vista que se le presentará al usuario, y
proporcionando el mecanismo para dirigir el control a ese recurso.

Un dispatcher se puede encapsular dentro de un controlador o se puede separar en

otro componente que trabaja de forma coordinada. El dispatcher puede proporcionar
un re-envío estático de la vista o un mecanismo de re-envío más sofisticado.

El dispatcher utiliza un objeto RequestDispatcher (soportado en la especificación

Servlet) y encapsula algún procesamiento adicional.
Helper

Un helper es el responsable de ayudar a la vista o al controlador a completar su

procesamiento. Así, los helpers tienen muchas responsabilidades, incluyendo la
recopilación de los datos requeridos por la vista y el almacenamiento en el modelo
intermedio, en cuyo caso algunas veces nos podemos referir al helper como un bean
de valor. Además, los helpers pueden adaptar este modelo de datos para usarlo en la
vista.

Una vista podría trabajar con cualquier número de helpers, que normalmente son
componentes JavaBeans (JSP 1.0+) y etiquetas personalizadas (JSP 1.1+). Además,
un helper podría representar un objeto Command o un Transformador XSL, que se
utiliza en combinación con una hoja de estilos para adaptar y convertir el modelo a la
forma apropiada.

View

Una Vista representa y muestra información al cliente. La vista recupera información

desde el modelo. Los helpers soportan las diferentes vistas encapsulando y adaptanto
el modelo de datos subyacente para usarlo en el display.

Estrategias

Hay varias estrategias para implementar un controlador.

Servlet Front

La estrategia de Servlet Frontal sugiere la implementación del controlador como un

servlet. Aunque semánticamente equivalente, es mejor que la Estrategia de JSP
Frontal. El controlador maneja los aspectos del manejo de peticiones que están
relacionados con el procesamiento de negocio y el control de flujo. Estas
responsabilidades están relacionadas con, pero son lógicamente independientes, del
formateo de display, y es más apropiado encapsularlas en un servlet en lugar de en
una página JSP.

Esta estrategia tiene algunos potenciales inconvenientes. En particular, no permite

utilizar algunas de las utilidadess del entorno de ejecución JSP, como es el relleno
automático de parámetros de la peticion. Afortunadamente, este inconveniente es
mínimo porque es relativamente fácil crear u obtener utilidades similares para su uso
general.
OBTENER METADATOS DE JDBC
Tomado de:
http://translate.google.com.co/translate?hl=es&sl=en&u=http://www.roseindia.net/jdbc/Jdbc
GetMetadata.shtml&prev=/search%3Fq%3Dgetmetadata%2Bjava.sql%26hl%3Des%26biw%3D
1366%26bih%3D596%26prmd%3Dimvns&sa=X&ei=SwhFULi3E4-
y9gT14ICwCg&ved=0CCMQ7gEwAA

Obtener metadatos JDBC es la estructura de datos colectiva, tipo de datos y

las propiedades de una tabla. Los metadatos get proporciona la información
sobre el nombre de la columna como número de columnas de una tabla. Las
operaciones execute realizan operaciones de consulta como de actualización
de una tabla.

Métodos Descripción

Se crea un objeto SQL a partir de un objeto

de la clase de conexión. Este objeto se
createStatement ()
utiliza para ejecutar operaciones de
actualizaciones y consulta de una tabla.

Este método devuelve el conjunto de

registros de una tabla. El conjunto de
executeQuery ()
registros está asignado a un resultado
asociado a la instrucción SELECT de SQL.

executeUpdate() Operaciones de actualización adición,

borrado, edición ( insert into, delete, update
set) sobre una tabla

Este método devuelve el número, tipo y

getMetaData () propiedades del objeto asociado al
executeQuery

Este método devuelve el número de

getColumnCount()
columnas de la tabla

Se obtiene el nombre de la columna de la

getColumnLabel(entero)
tabla
RECURSOS PARA EL TALLER

Servlet ServletJSP

import javax.servlet.*;

import javax.servlet.http.*;

import java.io.*;

import java.sql.*;

import javax.sql.*;

import javax.naming.*;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import java.util.*;

import java.text.*;

public class ServletJSP extends HttpServlet{

Connection conn = null;

String Cedula,Nombre,Ciudad,Direccion,Telefono,Contrato,Servicio,SQL;

boolean transmite=true;

public boolean conectar(){

boolean abrir=true;

// Establecimiento de la conexión con la base de datos

try {

Context initCtx = new InitialContext();

Context envCtx = (Context) initCtx.lookup("java:comp/env");

DataSource ds = (DataSource) envCtx.lookup("jdbc/servicios");

conn = ds.getConnection();

} catch (Exception e) {

abrir=false;

return abrir;

@Override

public void doGet(HttpServletRequest peticion,HttpServletResponse respuesta)

throws ServletException, IOException {

}

// Proceso HTTP Post de la petición

@Override

public void doPost(HttpServletRequest peticion,HttpServletResponse respuesta)

throws ServletException,IOException {

// Adquisicion de los campos del formulario

String retorno="";

String Campos="Campos Validados <br>";

Cedula=peticion.getParameter("Cedula");

Nombre=peticion.getParameter("Nombre");

Ciudad=peticion.getParameter("Ciudad");

Direccion=peticion.getParameter("Direccion");

Telefono=peticion.getParameter("Telefono");

Contrato=peticion.getParameter("Contrato");

Servicio=peticion.getParameter("Servicio");

SQL=peticion.getParameter("SQL");

Token T=new Token();

transmite=true;

transmite=transmite & T.soloNumero(Cedula);

transmite=transmite & T.soloNumero(Telefono);

transmite=transmite & T.soloTitulada(Nombre);

transmite=transmite & T.soloTitulada(Ciudad);

Campos=Campos+"Cedula:"+Cedula+"...."+T.esNumero(Cedula)+"<br>";

Campos=Campos+"Nombre:"+Nombre+"..."+T.esTitulada(Nombre)+"<br>";

Campos=Campos+"Ciudad:"+Ciudad+"...."+T.esTitulada(Ciudad)+"<br>";

Campos=Campos+"Telefono:"+Telefono+".."+T.esNumero(Telefono)+"<br>";

if(transmite)

if(conectar())

if (actualizarBaseDeDatos() == 0)

retorno=" Exito en la "+SQL+" de Registro";

else
 retorno="Se ha producido un error al actualizar la base de datos";

else

retorno="No hubo conexion con la Base de Datos";

else

retorno="Error de Validacion de Campos....";

peticion.setAttribute("retorno", retorno);

peticion.setAttribute("Campos", Campos);

RequestDispatcher rd = peticion.getRequestDispatcher("respuesta.jsp");

rd.forward(peticion, respuesta);

public int actualizarBaseDeDatos() {

// crear un statement de SQL

Statement stmt=null;

String Sentencia="";

int error=0;

int numeroFilasActualizadas=0;

System.out.println(" Operacion de "+SQL+" de Registro");

if(SQL.charAt(0)=='E')

Sentencia="Update encuesta set nombre='"+Nombre.toString()+"'";

Sentencia=Sentencia+",Ciudad='"+Ciudad.toString()+"'";;

Sentencia=Sentencia+",telefono='"+Telefono.toString()+"'";;

Sentencia=Sentencia+",domicilio='"+Direccion.toString()+"'";

Sentencia=Sentencia+",idcontrato='"+Contrato.toString()+"'";;

Sentencia=Sentencia+",idservicio='"+Servicio.toString()+"'";

Sentencia=Sentencia+" where cedula='"+Cedula.toString()+"';";

else

Sentencia="insert into encuesta values('";

Sentencia=Sentencia+Cedula+"','";
Sentencia=Sentencia+Nombre+"','";

Sentencia=Sentencia+Ciudad+"','";

Sentencia=Sentencia+Direccion+"','";

Sentencia=Sentencia+Telefono+"','";

Sentencia=Sentencia+Contrato+"','";

Sentencia=Sentencia+Servicio+"');";

// Ejecución del query de actualización de la base de datos

try {

stmt = conn.createStatement();

System.out.println("sentencia sql:"+Sentencia);

numeroFilasActualizadas = stmt.executeUpdate(Sentencia);

if(numeroFilasActualizadas!=1) return -1;

} catch (SQLException sql) {

System.out.println("Aplicacion ServletBasico: Se produjo un error creando Statement");

System.out.println(sql.getMessage());

error=-2;

} finally {

// Se cierra el Statement

if(stmt!=null) {

try {

stmt.close();

} catch(SQLException e){

System.out.println("Error cerrando Statement");

System.out.println(e.getMessage());

error=-3;

return error;

} // fin finally

} // fin método actualizarBaseDeDatos()

}
class Token

int i;

boolean soloFecha(String P)

DateFormat FormatoFecha=DateFormat.getDateInstance(DateFormat.SHORT, new Locale("es"));

if (P == null)

return false;

FormatoFecha.setLenient(false);

try {

FormatoFecha.parse(P.trim());

catch (ParseException pe)

return false;

return true;

boolean soloCorreo(String P)

Pattern correo = Pattern.compile("^([0-9a-zA-Z]([_.w]*[0-9a-zA-Z])*@([0-9a-zA-Z][-w]*[0-9a-zA-Z].)+([a-zA-

Z]{2,9}.)+[a-zA-Z]{2,3})$");

Matcher m = correo.matcher(P);

if ( m.find() )

return true;

else

return false;
 }

boolean soloNumero(String P)

Pattern numero = Pattern.compile("^([0-9])+$");

Matcher m = numero.matcher(P);

if ( m.find() )

return true;

else

return false;

boolean soloTitulada(String P)

Pattern titulada = Pattern.compile("^[A-Z]{1}[a-z]+$");

Matcher m;

String cadena[]=P.split(" ");

for(i=0;i<cadena.length;i++)

m=titulada.matcher(cadena[i]);

if(!m.find())

return false;

return true;

String esFecha(String P)

{
DateFormat FormatoFecha=DateFormat.getDateInstance(DateFormat.SHORT, new Locale("es"));

if (P == null)

return " no expresa una fecha dd/mm/aaaa";

FormatoFecha.setLenient(false);

try {

FormatoFecha.parse(P.trim());

catch (ParseException pe)

return " no expresa una fecha dd/mm/aaaa";

return " expresa una fecha dd/mm/aaaa";

String esCorreo(String P)

Pattern correo = Pattern.compile("^([0-9a-zA-Z]([_.w]*[0-9a-zA-Z])*@([0-9a-zA-Z][-w]*[0-9a-zA-Z].)+([a-zA-

Z]{2,9}.)+[a-zA-Z]{2,3})$");

Matcher m = correo.matcher(P);

if ( m.find() )

return " expresa un correo";

else

return " no expresa un correo";

String esNumero(String P)

Pattern numero = Pattern.compile("^([0-9])+$");

 Matcher m = numero.matcher(P);

if ( m.find() )

return " expresa un numero";

else

return " no expresa un numero";

String esTitulada(String P)

Pattern titulada = Pattern.compile("^[A-Z]{1}[a-z]+$");

Matcher m;

String cadena[]=P.split(" ");

for(i=0;i<cadena.length;i++)

m=titulada.matcher(cadena[i]);

if(!m.find())

return " no expresa titulada";

return " expresa titulada";

}
CONTENIDO estilos.css

html

{ height: 100%;}

{ margin: 0;

padding: 0;}

body

{ font: normal .80em 'trebuchet ms', arial, sans-serif;

background: #F0EFE2;

color: #777;}

{ padding: 0 0 20px 0;

line-height: 1.7em;}

img

{ border: 0;}

h1, h2, h3, h4, h5, h6

{ font: normal 175% 'century gothic', arial, sans-serif;

color: #43423F;

margin: 0 0 15px 0;

padding: 15px 0 5px 0;}

h1

{ font: normal 175% 'century gothic', arial, sans-serif;

color: #A4AA04;}

h2

{ margin: 0;

padding: 0 0 5px 0;

font: normal 120% arial, sans-serif;

color: #A4AA04;}

h3,h4

{ font: normal 100% 'century gothic', arial, sans-serif;

color: #FF0000;
 }

h5, h6

{ font: italic 95% arial, sans-serif;

padding: 0 0 15px 0;

color: #000;}

h7

{ color: #362C20;}

.form_settings

{ margin: 15px 0 0 0;}

.form_settings p

{ padding: 0 0 4px 0;}

.form_settings span

{ float: left;

width: 200px;

text-align: left;}

.form_settings input, .form_settings textarea

{ padding: 5px;

width: 299px;

font: 100% arial;

border: 1px solid #E5E5DB;

background: #FFF;

color: #47433F;}

.form_settings .submit

{ font: 100% arial;

border: 1px solid;

width: 99px;

margin: 0 0 0 212px;

height: 33px;

padding: 2px 0 3px 0;

cursor: pointer;

background: #263C56;

color: #FFF;}
.form_settings textarea, .form_settings select

{ font: 100% arial;

width: 299px;}

.form_settings select

{ width: 310px;}

.form_settings .checkbox

{ margin: 4px 0;

padding: 0;

width: 14px;

border: 0;

background: none;}

.separator

{ width: 100%;

height: 0;

border-top: 1px solid #D9D5CF;

border-bottom: 1px solid #FFF;

margin: 0 0 20px 0;}

table

{ margin: 10px 0 30px 0;}

table tr th, table tr td

{ background: #3B3B3B;

color: #FFF;

padding: 7px 4px;

text-align: left;}

table tr td

{ background: #F0EFE2;

color: #47433F;

border-top: 1px solid #FFF;}

Contenido Captura.html

<html>
<HEAD>
<TITLE> CLIENTES </TITLE>
<link rel="stylesheet" type="text/css" href="estilos.css" title="style" />
<script>
function validar()
{
if(validacion())
visible()
else
alert("No se puede actualizar...hay Fracaso en Validacion")
}
function visible()
{
alert("Se puede actualizar...")
document.getElementById("valida").disabled=true
document.getElementById("envio").disabled=false
}
function validacion()
{
var ced=document.getElementById("Cedula").value;
return esnumero(ced,"Cedula");
}
function esnumero(valor,campo)
{
var numero = /^([0-9])+$/ //digitos
//comprueba campo numerico(solo enteros y digitos)
if(!numero.test(valor))
{
alert("Contenido del campo "+campo+" no válido")
return false
}
return true
}
</script>
</HEAD>
<body>
<center>
<h1> EMPRESA LOS LAURELES</h1>
<h3> BOGOTA D.C </h3>
<h5> Nit 133-1223433-3</h5>
</center>
<br>
<form action="http://localhost:8080/Servicios/captura.jsp" method="POST">
Cedula: <input name="Cedula" type="text" size=10>
<br>
<input type="submit" name="envio" id="envio" value="Adicion/Edicion Encuesta"
disabled="true">
<input type="button" name="valida" id="envio" value="Validacion" onclick="validar()">
</form>
<br>
<form action="http://localhost:8080/Servicios/borrar.jsp" method="POST">
Cedula a Borrar: <input name="Cedula" type="text" size=10>
<br>
<input type="submit" name="enviar" id="enviar" value="Borrar encuesta" >
</form>
<br>
<form action="http://localhost:8080/Servicios/consulta.jsp" method="POST">
Tabla a Consultar: <select name="Tabla">
<option value="Encuesta">Encuesta </option>
<option value="Contratos">Contratos </option>
<option value="Servicios">Servicios </option>
</select>
<br>
<input type="submit" value="Consulta Tabla" >
</form>
</body>
</html>
Contenido Captura.jsp
<%@page contentType="text/html"%>
<%@page pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<HEAD>
<TITLE> CLIENTES </TITLE>
<link rel="stylesheet" type="text/css" href="estilos.css" title="style" />

</HEAD>
<body>
<center>
<h1> EMPRESA LOS LAURELES</h1>
<h3> BOGOTA D.C </h3>
<h5> Nit 133-1223433-3</h5>
</center>
<br>
<%@ page import="java.io.*" %>
<%@ page import="java.sql.*" %>
<%@ page import="javax.sql.*" %>
<%@ page import="javax.naming.*" %>
<%@ page import="java.util.*" %>
<%
Connection conn = null;
ResultSet rs = null;
Statement sentencia=null;
String CadenaSql;
String Cedula=request.getParameter("Cedula");
String Nombre="";
String Ciudad="";
String Direccion="";
String Telefono="";
String Contrato="1";
String Servicio="1";
Vector idservicio;
Vector nomservicio;
Vector idcontrato;
Vector nomcontrato;
String nomcont="";
String nomserv="";
String SQL="";
boolean esta=false;
boolean activa=true;
int i=0,k=0,j=0;
try {
Context initCtx = new InitialContext();
Context envCtx = (Context) initCtx.lookup("java:comp/env");
DataSource ds = (DataSource) envCtx.lookup("jdbc/servicios");
conn = ds.getConnection();
} catch (Exception e) {
%>
<script>
alert("no abre conexion a base de datos");
</script>
< A Href="http://localhost:8080/Servicios/Captura.html">Menu Principal </A>
<%
}
try
{
sentencia=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_
UPDATABLE);
CadenaSql="SELECT * FROM encuesta where cedula="+Cedula.toString();
rs = sentencia.executeQuery(CadenaSql);
rs.last();
if(rs.getRow()==1)
{
esta=true;
Nombre=rs.getString(2);
Ciudad=rs.getString(3);
Direccion=rs.getString(4);
Telefono=rs.getString(5);
Contrato=rs.getString(6);
Servicio=rs.getString(7);
SQL="E";
}
else
{
esta=false;
SQL="A";
}
CadenaSql="SELECT * FROM contratos";
rs = sentencia.executeQuery(CadenaSql);
idcontrato=new Vector();
nomcontrato=new Vector();
while(rs.next())
{
idcontrato.addElement((String) rs.getString(1));
nomcontrato.addElement((String) rs.getString(2));
i++;
}
CadenaSql="SELECT * FROM servicios";
rs = sentencia.executeQuery(CadenaSql);
idservicio=new Vector();
nomservicio=new Vector();
while(rs.next())
{
idservicio.addElement((String) rs.getString(1));
nomservicio.addElement((String) rs.getString(2));
j++;
}
%>
<form name="edicion" action="http://localhost:8080/Servicios/ServletJSP" method="POST">
Cedula: <input name="Cedula" readonly type="text" value="<%=Cedula%>" ><br>
Nombre: <input name="Nombre" type="text"value="<%=Nombre%>" ><br>
Ciudad: <input name="Ciudad" type="text" value="<%=Ciudad%>" ><br>
Direccion: <input name="Direccion" type="text" value="<%=Direccion%>" ><br>
Telefono: <input name="Telefono" type="text" value="<%=Telefono%>" ><br>
Contrato: <select name="Contrato" id="Contrato" >
<%
for(k=0;k<idcontrato.size();k++)
{
if(Integer.parseInt((String) idcontrato.elementAt(k))==Integer.parseInt(Contrato))
out.println("<option value="+(String) idcontrato.elementAt(k)+" selected>"+(String)
nomcontrato.elementAt(k) +"</option>");
else
out.println("<option value="+(String) idcontrato.elementAt(k)+" >"+(String)
nomcontrato.elementAt(k) +"</option>");
}
%>
 </select>
<br>
Servicio: <select name="Servicio" id="Servicio" >
<%
for(k=0;k<idservicio.size();k++)
{
if(Integer.parseInt((String) idservicio.elementAt(k))==Integer.parseInt(Servicio))
out.println("<option value="+(String) idservicio.elementAt(k)+" selected>"+(String)
nomservicio.elementAt(k) +"</option>");
else
out.println("<option value="+(String) idservicio.elementAt(k)+" >"+(String)
nomservicio.elementAt(k) +"</option>");
}
%>
</select>
<br>
Operacion: <input name="SQL" readonly type="text" size=7 value="<%=SQL%>">
<br>
<input type="submit" name="envio" id="envio" value="Adicion/Edicion Encuesta" >
</form>
</body>
</html>
<%
}
catch (Exception e) {
%>
<script>
alert("error en la aplicacion");
</script>
<A Href="http://localhost:8080/Encuesta/entrada.html">Menu Principal </A>
<%
}
%>
Contenido consulta.jsp
<%@page contentType="text/html"%>
<%@page pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<HEAD>
<TITLE> CLIENTES </TITLE>
<link rel="stylesheet" type="text/css" href="estilos.css" title="style" />
</HEAD>
<body>
<center>
<h1> EMPRESA LOS LAURELES</h1>
<h3> BOGOTA D.C </h3>
<h5> Nit 133-1223433-3</h5>
</center>
<br>
<%@ page import="java.io.*" %>
<%@ page import="java.sql.*" %>
<%@ page import="javax.sql.*" %>
<%@ page import="javax.naming.*" %>
<%@ page import="java.util.*" %>
<%
Connection conn = null;
ResultSet rs = null;
Statement stmt=null;
String Tabla=(String)request.getParameter("Tabla");
ResultSetMetaData Lista=null;
String SQL="SELECT * FROM "+Tabla;
int i;
try {
Context initCtx = new InitialContext();
Context envCtx = (Context) initCtx.lookup("java:comp/env");
DataSource ds = (DataSource) envCtx.lookup("jdbc/servicios");
conn = ds.getConnection();
stmt = conn.createStatement();
rs = stmt.executeQuery(SQL);
Lista = rs.getMetaData();
} catch (Exception e) {
%>
<script>
alert("no abre conexion a base de datos");
</script>
<A href="http://localhost:8080/Servicios/captura.html"> Ir a Captura </A>
<%
}
%>

<table width="80%" border="1">

<tr>

<%
try
{
for(i = 1; i <= Lista.getColumnCount();i++ )
{
%>

<th>
<%-- Nombres de las columnas de la tabla MySQL --%>
<%=
Lista.getColumnLabel(i)
%>

</th>

<%
}
%>

</tr>

<%
while(rs.next())
{
%>
<tr>
<%
for(i = 1; i <= Lista.getColumnCount();i++ )
{
%>
<td>
<%=rs.getString(i)%>
</td>
<%
}
%>
</tr>
<%
}
}
catch(Exception e) {}
%>
</table>
<A href="http://localhost:8080/Servicios/captura.html"> Ir a Captura </A>
</body>
</html>
Contenido borrar.jsp
<%@page contentType="text/html"%>
<%@page pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<HEAD>
<TITLE> CLIENTES </TITLE>
<link rel="stylesheet" type="text/css" href="estilos.css" title="style" />
</HEAD>
<body>
<center>
<h1> EMPRESA LOS LAURELES</h1>
<h3> BOGOTA D.C </h3>
<h5> Nit 133-1223433-3</h5>
</center>
<br>
<%@ page import="java.io.*" %>
<%@ page import="java.sql.*" %>
<%@ page import="javax.sql.*" %>
<%@ page import="javax.naming.*" %>
<%@ page import="java.util.*" %>
<%
Connection conn = null;
ResultSet rs = null;
Statement sentencia=null;
String CadenaSql;
String Cedula=(String) request.getParameter("Cedula");
String actual=(String) request.getParameter("actual");
String Nombre="";
String Ciudad="";
String Direccion="";
String Telefono="";
String Contrato="1";
String Servicio="1";
String linea="";
int i=0;
try {
Context initCtx = new InitialContext();
Context envCtx = (Context) initCtx.lookup("java:comp/env");
DataSource ds = (DataSource) envCtx.lookup("jdbc/servicios");
conn = ds.getConnection();
}
catch (Exception e)
{
%>
<script>
alert("no abre conexion a base de datos");
</script>
<A Href="http://localhost:8080/Servicios/Captura.html">Menu Principal </A>
<%
}
try
{
sentencia=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATAB
LE);
CadenaSql="SELECT * FROM encuesta where cedula="+Cedula.toString();
rs = sentencia.executeQuery(CadenaSql);
rs.last();
if(rs.getRow()==1)
{
Nombre=rs.getString(2);
Ciudad=rs.getString(3);
Direccion=rs.getString(4);
Telefono=rs.getString(5);
Contrato=rs.getString(6);
Servicio=rs.getString(7);
out.println( " REGISTRO A E L I M I N A R S E");
linea ="<table border=3>";
linea =linea+"<tr>";
linea =linea+"<td><strong>CEDULA</strong></td>";
linea =linea+"<td>"+Cedula+"</td>";
linea =linea+"</tr>";
linea =linea+"<tr>";
linea =linea+"<td><strong>NOMBRE</strong></td>";
linea =linea+"<td>"+Nombre+"</td>";
linea =linea+"</tr>";
linea =linea+"<tr>";
linea =linea+"<td><strong>TELEFONO</strong></td>";
linea =linea+"<td>"+Telefono+"</td>";
linea =linea+"</tr>";
linea =linea+"<tr>";
linea =linea+"<td><strong>CIUDAD</strong></td>";
linea =linea+"<td>"+Ciudad+"</td>";
linea =linea+"</tr>";
linea =linea+"<tr>";
linea =linea+"<td><strong>DOMICILIO</strong></td>";
linea =linea+"<td>"+Direccion+"</td>";
linea =linea+"</tr>";
linea =linea+"<tr>";
linea =linea+"<td><strong>CONTRATO</strong></td>";
linea =linea+"<td>"+Contrato+"</td>";
linea =linea+"</tr>";
linea =linea+"<tr>";
linea =linea+"<td><strong>SERVICIO</strong></td>";
linea =linea+"<td>"+Servicio+"</td>";
linea =linea+"</tr>";
linea =linea+"</table>";
out.println( linea);
sentencia = conn.createStatement();
i = sentencia.executeUpdate("delete from encuesta where cedula="+Cedula);
}
else
{
out.println( " C E D U L A N O E N C O N T R A D A");
linea ="<table border=3>";
linea =linea+"<tr>";
linea =linea+"<td><strong>CEDULA</strong></td>";
linea =linea+"<td>"+Cedula+"</td>";
linea =linea+"</tr>";
linea =linea+"</table>";
out.println( linea);
}
}
catch (Exception e)
{
}
%>
<A href="http://localhost:8080/Servicios/captura.html"> Ir a Captura </A>
</body>
</html>
Contenido context.xml
<?xml version="1.0" encoding="ISO-8859-1"?>

<Context reloadable="true">

<Resource name="jdbc/servicios"

auth="Container"

type="javax.sql.DataSource"

driverClassName="com.mysql.jdbc.Driver"

url="jdbc:mysql://localhost:3307/Servicios?autoReconnect=true"

username="root"

password="root"

/>

</Context>

Contenido web.xml

<?xml version="1.0" encoding="ISO-8859-1"?>

<web-app>

<servlet>

<servlet-name> Servlet JSP Cliente</servlet-name>

<servlet-class>ServletJSP</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name> Servlet JSP Cliente </servlet-name>

<url-pattern>/ServletJSP </url-pattern>

</servlet-mapping>

<welcome-file-list>

<welcome-file>

captura.html

</welcome-file>

</welcome-file-list>

</web-app>
Contenido respuesta.jsp

<%@page contentType="text/html"%>

<%@page pageEncoding="UTF-8"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<title>JSP Page</title>

</head>

<body>

<%

String Cedula=request.getParameter("Cedula");

String Nombre=request.getParameter("Nombre");

String Ciudad=request.getParameter("Ciudad");

String Direccion=request.getParameter("Direccion");

String Telefono=request.getParameter("Telefono");

String Contrato=request.getParameter("Contrato");

String Servicio=request.getParameter("Servicio");

String retorno=(String) request.getAttribute ("retorno");

String Campos=(String) request.getAttribute ("Campos");

out.println("<html>");

out.println("<head>");

out.println("<title>SERVLET JSP BASE DE DATOS</title>");

out.println("</head>");

out.println("<body>");

out.println("<b><font size=+2>Valores recogidos del");

out.println("formulario: </font></b>");

out.println("<p><font size=+1><b>Cedula: </b>"+Cedula+"</font>");

out.println("<br><fontsize=+1><b>Nombre : </b>"+Nombre+"</font><b><font size=+1></font></b>");

out.println("<br><fontsize=+1><b>Ciudad : </b>"+Ciudad+"</font><b><font size=+1></font></b>");

out.println("<p><font size=+1><b>Direccion: </b>"+Direccion+"</font><b><font size=+1></font></b>");

out.println("<br><fontsize=+1><b>Telefono : </b>"+Telefono+"</font><b><font size=+1></font></b>");

out.println("<p><font size=+1><b>Contrato: </b>"+Contrato+"</font><b><font size=+1></font></b>");

out.println("<br><fontsize=+1><b>Servicio : </b>"+Servicio+"</font><b><font size=+1></font></b>");

out.println("<br><P><HR><CENTER><H5>"+retorno+"</CENTER>");

out.println("<br><P><HR><CENTER><H5>"+Campos+"</CENTER>");

out.println("</body>");

out.println("</html>");

%>

<A href="http://localhost:8080/Servicios/captura.html"> Ir a Captura </A>

</body>

</html>
PRACTICA A REALIZAR

Antecedente

Tomado de: http://www.oracle.com/technetwork/articles/javase/servlets-jsp-140445.html

Una página JSP es básicamente una página Web con HTML tradicional y trozos de
código Java. La extensión de archivo de una página JSP es. Jsp en lugar de. Html o
htm., Que indica al servidor que esta página requiere un manejo especial que se
llevará a cabo mediante una extensión del servidor o un plug-in.

Cuando una página JSP se llama, será compilada (por el motor JSP) en un servlet
Java. En este punto el servlet es manejado por el motor servlet, al igual que cualquier
otro servlet. El motor de servlets luego carga la clase servlet (usando un cargador de
clases) y lo ejecuta para crear HTML dinámico que se envía al navegador, tal como se
muestra en la figura 1. El servlet crea un objeto necesario, y escribe cualquier objeto
como una cadena en una secuencia de salida al navegador.

La próxima vez que se solicite la página, el motor JSP ejecuta el servlet ya cargado a
menos que la página JSP ha cambiado, en cuyo caso se vuelve a compilar
automáticamente en un servlet y ejecutado.
Actividades

Realizar el servlet que valide en el servidor. Sino cumple con las expresiones
regulares requeridas para cada campo no se puede adicionar registro en la tabla
encuesta de la base de datos servicios. La respuesta de validación como actualización
se despliega en el documento JSP (Vista) llamado respuesta.jsp

1. Crear una carpeta en webapps del servidor apache tomcat denominada Servicios
con la siguiente estructura

2. Editar y guardar respuesta.jsp en la carpeta \Servicios

3. Editar y guardar captura.jsp en la carpeta \Servicios
4. Editar y guardar consulta.jsp en la carpeta \Servicios
5. Editar y guardar borrar.jsp en la carpeta \Servicios
6. Editar y guardar estilos.css en la carpeta \Servicios
7. Editar y guardar captura.html en la carpeta \Servicios

8. Editar y guardar context.xml en la carpeta \Servicios\META-INF

9. Editar y guardar web.xml en la carpeta \Servicios\WEB-INF

10. En la carpeta WEB-INF se debe crear la carpeta classes que antes de arrancar el
servidor debe tener los siguientes archivos: ServletJSP.java, ServletJSP.class,
Token.class
Nota. Token.class es el generado al compilar el servlet ServletJSP. Token es
instanciado en el servlet ServletJSP (Token T=new Token())

Como debería quedar….

Se selecciona la aplicación Servicios
Menu

Captura de Datos
Respuesta del servlet en la vista (respuesta.jsp)

Borrado de Encuesta
Consulta tablas
Captura de Datos cumpliendo con reglas de validación

Respuesta del servlet en respuesta.jsp

Se ejecuta el command line del MySQL server

Se ejecuta de la siguiente manera:

Pasaporte root

Salir del Command line con el comando exit

Apagar servidor apache tomcat