Apuntes Tutoría 2:

Contenido
Apuntes Tutoría 2:.....................................................................................................1

1. ¿Qué es JSP ?:............................................................................................2

Un poco de HTML Y XML:.....................................................................................4

2. Tipos de datos en JSP.................................................................................5

3. Funcionalidad de los objetos:.......................................................................9

a) pageContext:................................................................................................9

b) Objeto Request:..........................................................................................10

c) Objeto Response:.......................................................................................11

d) Objeto ServletConfig:.................................................................................11

e) Objeto Session:..........................................................................................12

f) Out:................................................................................................................13

g) Exception:...................................................................................................14

4. Lenguaje de expresión EL en JSP:............................................................15

5. JavaBeans:.................................................................................................16

6. API JDBC:...................................................................................................17

 Driver:.............................................................................................................18

 DriverManager:..............................................................................................18

 DriverPopertyInfo:..........................................................................................19

 Connection:....................................................................................................19

 DatabaseMetaData:.......................................................................................20

 ResultSetMetadata:.......................................................................................21

 Statement:......................................................................................................21

1
  PreapredStatement:.......................................................................................22

 CallableStatement:........................................................................................22

 ResulSet:.......................................................................................................23

1. ¿Qué es JSP ?:
“La tecnología Java para la creación de páginas web con programación en el
servidor.”

JSP es un acrónimo de Java Server Pages, que en castellano vendría a decir

algo como Páginas de Servidor Java. Es, pues, una tecnología orientada a crear
páginas web con programación en Java.

Con JSP podemos crear aplicaciones web que se ejecuten en variados servidores
web, de múltiples plataformas, ya que Java es en esencia un lenguaje
multiplataforma. Las páginas JSP están compuestas de código HTML/XML
mezclado con etiquetas especiales para programar scripts de servidor en sintaxis
Java. Por tanto, las JSP podremos escribirlas con nuestro editor HTML/XML
habitual.

Motor JSP

El motor de las páginas JSP está basado en los servlets de Java -programas en
Java destinados a ejecutarse en el servidor-, aunque el número de desarrolladores
que pueden afrontar la programación de JSP es mucho mayor, dado que resulta
mucho más sencillo aprender que los servlets.

En JSP creamos páginas de manera parecida a como se crean en ASP o PHP

-otras dos tecnologías de servidor-. Generamos archivos con extensión .jsp que
incluyen, dentro de la estructura de etiquetas HTML, las sentencias Java a
ejecutar en el servidor. Antes de que sean funcionales los archivos, el motor JSP
lleva a cabo una fase de traducción de esa página en un servlet, implementado en
un archivo class (Byte codes de Java). Esta fase de traducción se lleva a cabo
2
habitualmente cuando se recibe la primera solicitud de la página .jsp, aunque
existe la opción de precompilar en código para evitar ese tiempo de espera la
primera vez que un cliente solicita la página.

Ejemplo de página JSP

En la imagen siguiente se puede ver un ejemplo extremadamente simple de una

página JSP y el esquema de conversión de esa página en un servlet.

Otra pequeña
definición:

Java Server
Pages (JSP) es una
tecnología que ayuda a
los desarrolladores
de software a
crear páginas
web dinámicas basadas
en HTML y XML, entre
otros tipos de
documentos. JSP es
similar a PHP, pero usa
el lenguaje de
programación Java.

JSP puede considerarse como una manera alternativa, y simplificada, de construir

servlets. Es por ello que una página JSP puede hacer todo lo que hace un servlet,
y viceversa. Cada versión de la especificación de JSP está fuertemente vinculada
a una versión en particular de la especificación de servlets.

La diferencia entre Servlets y JSP es que los Servlets son clases que deben
implementar la clase abstracta HttpServlet, en especial el método doGet() o
doPost() y deben ser previamente compilados, mientras que los archivos JSP
contienen código Java entre código HTML utilizando los símbolos <% y %>. Por
esto un archivo JSP debe ser interpretado por el servidor al momento de la
petición por parte del usuario.
3
Un poco de HTML Y XML:
XML y HTML son lenguajes muy diferentes. Ambos nacen de la misma inspiración
llamada SGML por lo que su sintaxis es similar, aunque cada uno fue diseñado
para cumplir distintas funciones:

El XML (eXtensive Markup Language) es un lenguaje que fue concebido para

describir información. Su función principal es ayudarnos a organizar contenidos y
eso hace que los documentos XML sean portables hacia diferentes tipos de
aplicaciones.

Un archivo XML se divide en dos partes: prolog y body. La parte prolog consiste
en metadatos administrativos, como declaración XML, instrucción de
procesamiento opcional, declaración de tipo de documento y comentarios. La
parte del body se compone de dos partes: estructural y de contenido (presente en
los textos simples).

El HTML (HyperText Markup Language) por otro lado ha sido concebido para
mostrar información, determinar cómo actúa y que hace. Su función radica en
ayudarnos a darle formato a los diversos contenidos de una página.

Resumiendo, el XML sirve para describir información y el HTML sirve para darle
formato y presentarla a través de un navegador. O sea que el XML no es ni será
nunca un reemplazo del HTML sino un complemento que sirve para manejar la
información separada del formato.

Un dato importante es que al hablar de XML hablamos de documentos bien

formados (well formed). Mientras en HTML podemos ser desordenados:
<P><B><i>Este texto estará en negritas e itálicas</b></I><BR>, en XML tenemos
que respetar los tags. Todos deberán ser anidados correctamente:
<TagA><TagB>Contenidos</TagB></TagA>. Algo muy importante es que son
“case sensitive” de tal forma que <B> no es lo mismo que <b> sino son dos tags
diferentes. También debemos prestar atención importante a que todos los tags
deben ser cerrados. Si usamos un tag independiente como el <br> o <hr>, lo
cerramos incluyéndole un diagonal al final: <br />, <hr />. Por lo anterior, el XML

4
está ayudando a que seamos más ordenados y respetemos el lenguaje que
gracias a la tolerancia de los navegadores ha ido decayendo.

Otra característica del XML es que es un lenguaje que puede extenderse. Al

trabajar con documentos XML podemos determinar nuestros propios tags y
estructura de documentos para trabajar. En XML el tag <christian></christian> es
válido por que yo lo puedo definir y utilizar sin ningún problema. Por otro lado, en
el HTML todos los tags ya han sido predefinidos y son parte del estándar HTML
definido por el W3C.

2. Tipos de datos en JSP

<%! declaración de variable o método; %>

Note el signo (!) de admiración que acompaña justo detrás del signo porcentaje
(%), allí donde comienza del código JSP.

Estas variables o métodos así definidos serán globales y por tanto accesibles
desde cualquier lugar de la página JSP. Hay que tener en cuenta que el servidor a
través del motor JSP transforma la página JSP en un servlet, y éste es usado por
múltiples peticiones, lo que provoca que este tipo de variables conserven su valor
entre sucesivas llamadas o ejecuciones. Las declaraciones se ejecutan una única
vez, en la primera llamada al servlet equivalente.

En el caso de una declaración múltiple,

<%! variable1; [variable2;] … %>

También puede inicializarse las variables en el momento de la declaración, como,

por ejemplo:

<%! int contador = 0; %>

Los ocho tipos de datos primitivos incluidos en el lenguaje de programación Java

que pueden declararse para una variable son: byte, short, int, long, float,
double, boolean y char.

5
Para eso tengo la tabla de medidas y sus conversiones:

6
7
 3. Funcionalidad de los objetos:
Los objetos implícitos son objetos creados por el motor que no necesitan ser
declarados para ser usados, sino que se pueden invocar directamente. Por lo
tanto, estos objetos son accesibles al motor JSP, por lo que el desarrollador JSP
puede utilizarlos. En realidad, estos objetos son variables instanciadas de manera
automática en el servlet generado a partir del JSP.

a) pageContext:
PageContext es una clase que aglutina un conjunto de operaciones que se
ejecutan en los diferentes ámbitos. En ese sentido funciona como una
fachada/adaptador a la hora de darnos acceso a diferentes características de la
app. Este objeto permite acceder al espacio de nombres de la página JSP actual,
asimismo, ofrece el acceso a varios atributos de la página, así como una capa
sobre los detalles de implementación. Este objeto también cuenta con la
capacidad de almacenar y recuperar atributos en el ámbito de la página, sin

8
embargo, su uso más frecuente es el acceso y obtención de los objetos integrados
de JSP. El objeto pageContext se utiliza para representar a toda la página JSP.

Este objeto está concebido como un medio para acceder a información sobre la
página evitando al mismo tiempo la mayor parte de los detalles de
implementación.

Este objeto almacena referencias a la solicitud y los objetos de respuesta para

cada solicitud. La aplicación, la configuración, la sesión y objetos fuera derivan
accediendo a los atributos de este objeto.

El objeto pageContext también contiene información sobre las directivas emitidas

a la página JSP, incluyendo la información de buffering, el errorPageURL y
alcance de página.

La clase PageContext define varios campos, incluyendo PAGE_SCOPE,

REQUEST_SCOPE, SESSION_SCOPE y APPLICATION_SCOPE, que identifican
los cuatro ámbitos.

Uno de los métodos importantes es removeAttribute, que acepta uno o dos

argumentos. Por ejemplo, pageContext.removeAttribute(“nombreAtributo”)
elimina el atributo de todos los ámbitos, mientras que el siguiente código sólo la
quita del ámbito de la página:

pageContext.removeAttribute(“nombreAtributo”, PAGE_SCOPE);

Finalmente, cuando se trabaja con Servlets este objeto puede proporcionar los
accesos a los objetos implícitos.

application = pageContext.getServletContext();

config = pageContext.getServletConfig();

session = pageContext.getSession();

out = pageContext.getOut();licación.

9
 b) Objeto Request:
En efecto, la acción de escribir una dirección cualquiera en la línea de URL de tu
navegador, se traduce en solicitar un determinado fichero a un servidor, o dicho en
la jerga técnica, se le hace un request al servidor.

El objeto Request permite el acceso a toda la información que pasa desde el

navegador del cliente al servidor. Al recibir esta información, es repartida y
almacenada entre cinco colecciones. Cada colección es similar en estructura a
una tabla de datos (también llamada matriz de datos o array). Los datos, una vez
cargados, pueden ser accedidos individualmente en cada colección a través de
una única clave asignada a cada ítem.

Todas las variables pueden ser accedidas directamente mediante una llamada del
tipo Request(variable) sin mencionar el nombre de la colección. En este caso, el
servidor web busca entre todas las colecciones la clave pedida (variable),
buscando por este orden:

QueryString, Form, Cookies, ClientCertificate y ServerVariables que son las

cinco colecciones que tiene el objeto. (Mirar el link en favoritos).

c) Objeto Response:
La interfaz Response de la Fetch API representa la respuesta a una petición.

Tú puedes crear un nuevo objeto Response usando el constructor

Response.Response(), pero es más probable encontrar un objeto Response
siendo devuelto como resultado de la operación de otra API.

El objeto Response

Response (respuesta) es posiblemente el objeto más utilizado de todos, ya que

sirve para presentar en la pantalla del navegador del cliente el resultado de
cualquier código que hayamos escrito.

El objeto Response tiene 8 propiedades, 1 colección y 8 métodos.

(Mirar el link en mis favoritos).

10
 d) Objeto ServletConfig:
Comenzaremos estudiando el contexto de los servlets (Servlet Context). Este
objeto de contexto es propio de cada aplicación web, es decir, tendremos un
objeto ServletContext por aplicación web, por lo que nos servirá para comunicar
los servlets de dicha aplicación.

public void init(ServletConfig config)

Objeto de la clase ServletConfig. Permite acceder a parámetros de inicialización

del servlet y a su contexto.

En la inicialización del servlet (método init), se nos proporcionará un objeto

ServletConfig como parámetro. Mediante este objeto podemos:

Obtener el nombre del servlet, que figurará en el descriptor de despliegue de la

aplicación web (web.xml en Tomcat).

String nombre = config.getServletName();

Obtener los valores de los parámetros de inicialización del servlet, que se hayan
establecido en el descriptor de despliegue. Tanto los nombres como los valores de
los parámetros son cadenas de texto (String).

String valor_param = config.getInitParameter(nombre_param);

Enumeration nombres_params = config.getInitParameterNames();

Acceder al objeto de contexto de la aplicación a la que pertenece el servlet.

ServletContext context = config.getServletContext();

Esta última función es la más importante, ya que nos permite acceder al objeto de
contexto global de la aplicación, con el que podremos realizar una serie de
operaciones.

e) Objeto Session:
Es un objeto integrado es una instancia del interfaz javax.servlet.http.HttpSession
y representa la sesión del usuario actual conectado a una aplicación web. Este

11
objeto es usado por sobre todo para almacenar y recuperar información
relacionada con el usuario.

Tanto en servlets como en páginas JSP el objeto session tienen funcionamiento

similar, es decir una sesión se mantiene entre distintas páginas pertenecientes a
una misma aplicación, una ventaja importante es que es posible almacenar en el
objeto session atributos otros objetos que se mantienen entre diferentes páginas
JSP.

Este objeto es muy usado en aplicaciones que tienen controles de usuarios con
base en la aplicación, es decir un usuario se loguea y automáticamente se crea un
atributo de sesión con un valor predefinido que se será verificado en cada una de
las páginas donde el usuario desea acceder, se le permitirá el acceso cuando el
atributo tenga valor predefinido.

Los métodos para almacenar y recuperar atributos son similares a los que tienen
request.

la clase HttpSession que tiene una estructura de HashMap (Dicccionario) y

permite almacenar cualquier tipo de objeto en ella de tal forma que pueda ser
compartido por las diferentes páginas que como usuarios utilizamos.

12
 f) Out:
out, Instancia de javax.servlet.jsp.JspWriter, este objeto permite escribir la
respuesta o parte de ella, en HTML o cualquier otro contenido, como resultado de
la petición del cliente y enviarla al browser.

Los métodos má frecuentemente utilizados son:

print: Escribe directamente en el archivo de salida HTML que se devolverá al

cliente.

println: Escribe directamente en el archivo de salida HTML que se devolverá al

cliente añadiendo una nueva línea.

newLine(): Este método se utiliza para escribir una nueva línea. La sintaxis es
out.newLine()

NOTAS:

Los métodos anteriores se utilizan dentro de un scriptlet o en un servlet.

Un ejemplo sencillo de print o println podría ser

13
<% out.println(“Hola mundo”); %>

La cadena del argumento de print y println no tiene porqué ser una constante,
podría ser también una marca de HTML y así, por ejemplo,

<% out.println(“<br><H2>Hola mundo</H2>”); %>

y también puede incorporar cualquier variable previamente declarada, es decir,

<% out.println(“<font color=’red’>El valor del resultado es: ” + resultado +

“</font>”); %>.

g) Exception:
Es Aquel objeto que representa un error producido en la aplicación. Solo es
accesible si la página se ha designado como página de error (mediante la directiva
page isErrorPage).

Al igual que en una aplicación Java, una excepción es un objeto que es un

ejemplar de java.lang.Throwable o de una de sus subclases. Throwable tiene
dos subclases estándards -java.lang.Exception, que describe excepciones, y
java.lang.Error, que describe errores.

Los errores son diferentes de las excepciones. Los errores normalmente indican
problemas de enlaces o de la máquina virtual de los que nuestra aplicación Web
podría no recuperarse, como errores de memoria. Sin embargo, las excepciones
son condiciones que pueden capturarse y recuperarse de ellas. Estas excepciones
podrían ser, por ejemplo, un NullPointerException o un ClassCastException,
que nos dicen que se ha pasado un valor nulo o un dato del tipo erróneo a nuestra
aplicación mientras se estaba ejecutando.

4. Lenguaje de expresión EL en JSP:

El Unified Expression Language de Java es un lenguaje de programación de
propósito especial utilizado principalmente en aplicaciones web en Java para
incrustar expresiones en páginas web

Se encuentran las Siguientes expresiones:

14
Y los operadores son los clásicos que conocemos

 Aritméticos: +, -, *, /, div, %, mod, - (signo negativo)

 Concatenación de cadenas: +=
 Lógicos: and, &&, or, ||, not, !
 Relacional: ==, eq, !=, ne, <, lt, >, gt, <=, ge, >=, le
 Si es vacío: El operador empty determina si una lista está vacía o un objeto
es nulo
 Condicional: A ? B : C (Lo mismo que en Java SE)
 Lambda: ->(ya lo conocemos)
 Asignación: =
 Punto y coma: ;

JSP Language Expresión (EL) de modo que los datos de acceso almacenados en
un JavaBean se vuelven muy simple. JSP EL o bien se puede utilizar para crear
una expresión aritmética también se puede utilizar para crear una expresión
15
lógica. En las expresiones JSP EL pueden utilizar enteros, números de punto
flotante, cadenas, constantes verdadero, falso, no es nulo.

5. JavaBeans:
Los JavaBeans son un modelo de componentes creado por Sun Microsystems
para la construcción de aplicaciones en Java.

Se usan para encapsular varios objetos en un único objeto (la vaina o Bean en
inglés), para hacer uso de un solo objeto en lugar de varios más simples.

La especificación de JavaBeans de Sun Microsystems los define como

"componentes de software reutilizables que se puedan manipular visualmente en
una herramienta de construcción".

A pesar de haber muchas semejanzas, los JavaBeans no deben confundirse con

los Enterprise JavaBeans (EJB), una tecnología de componentes del lado
servidor que es parte de Java EE.

Las propiedades de un bean pueden examinarse y modificarse mediante

métodos o funciones miembro, que acceden a dicha propiedad, y pueden ser de
dos tipos:

getter method: lee el valor de la propiedad

setter method: cambia el valor de la propiedad.

Mas propiedades:

16
 6. API JDBC:
Java Database Connectivity (en español: Conectividad a bases de datos de
Java), más conocida por sus siglas JDBC,12 es una API que permite la ejecución
de operaciones sobre bases de datos desde el lenguaje de programación Java,
independientemente del sistema operativo donde se ejecute o de la base de datos
a la cual se accede, utilizando el dialecto SQL del modelo de base de datos que se
utilice.

Usando JDBC es fácil enviar sentencias SQL virtualmente a cualquier sistema de

base de datos. En otras palabras, con el API JDBC, no es necesario escribir un
programa que acceda a una base de datos Sybase, otro para acceder a Oracle y
otro para acceder a Informix. Un único programa escrito usando el API JDBC y el
programa será capaz de enviar sentencias SQL a la base de datos apropiada.
Simplemente JDBC hace posible estas tres cosas:

 Establece una conexión con la base de datos.

 Envía sentencias SQL
 Procesa los resultados.

17
  Driver:
Los drivers JDBC son adaptadores del lado del cliente (instalados en la máquina
cliente, no en el servidor) que convierten la petición proveniente del programa
JAVA a un protocolo que el SGBD pueda entender.

Driver JDBC Tipo 1 (también llamado Puente JDBC-ODBC) convierte el método

JDBC a una llamada a una función ODBC. Utiliza los drivers ODBC para conectar
con la base de datos.

Driver JDBC Tipo 2 (también llamado driver API-Nativo) convierte el método JDBC
a llamadas nativas de la API de la base de datos. Es más rápido que el puente
JDBC-ODBC pero se necesita instalar la librería cliente de la base de datos en la
máquina cliente y el driver es dependiente de la plataforma.

Driver JDBC Tipo 3. Hace uso de un Middleware entre el JDBC y el SGBD.

Driver JDBC Tipo 4 (también llamado Driver Java Puro directo a la base de datos).
Es independiente a la plataforma.

 DriverManager:
La clase DriverManager implementa la capa de gestión de JDBC, y trabaja como
intermediaria entre el usuario y los drivers. Guarda la lista de los drivers que están
disponibles y establece la conexión entre la base de datos y el driver apropiado.
Además, la clase DriverManager se ocupa de cosas cómo gestionar los límites de
tiempo de ‘login’ en el driver y de la salida de los mensajes de traza y log.
Para aplicaciones simples, el único método en esta clase que necesita un
18
programador general para su uso directamente es
DriverManager.getConnection. Como su nombre indica, este método
establece una conexión con la base de datos. JDBC permite al usuario llamar a los
métodos de DriverManager getDriver, getDrivers y registerDriver así
como al método de Driver connect, pero en la mayoría de los casos es preferible
dejar que la clase DriverManager gestione los detalles al establecer la conexión.
 DriverPopertyInfo:
Esta permite proporcionar diversa información acerca de un Driver.

 Connection:
El objeto Connection es el principal objeto utilizado para proporcionar un vínculo
entre las bases de datos y una aplicación en Java. Connection proporciona
métodos para manejar el procesamiento de transacciones, para crear objetos y
ejecutar instrucciones SQL, y para crear objetos para la ejecución de
procedimientos almacenados.

19
Se puede emplear tanto el objeto Driver como el objeto DriverManager para crear
un objeto Connection. Se utiliza el método connect() para el objeto Driver, y el
método getConnection() para el objeto DriverManager.

El objeto Connection proporciona una conexión estática a la base de datos. Esto

significa que hasta que se llame en forma explícita a su método close() para
cerrar la conexión o se destruya el objeto Connection, la conexión a la base de
datos permanecerá activa.

La manera más usual de establecer una conexión a una base de datos es

invocando el método getConnection() de la clase DriverManager. A menudo, las
bases de datos están protegidas con nombres de usuario (login) y contraseñas
(password) para restringir el acceso a las mismas. El método getConnection()
permite que el nombre de usuario y la contraseña se pasen también como
parámetros.

 DatabaseMetaData:
En java, las clases DataBaseMetaData y ResultSetMetaData permiten,
respectivamente, analizar la estructura de una base de datos (qué tablas tiene,
que columnas cada tabla, de qué tipos, etc) o de un ResultSet de una consulta,
para averiguar cuántas columnas tiene dicho ResulSet, de qué columnas de base
de datos proceden, de qué tipo son, etc.

Para ver qué catálogos, esquemas, tablas, tipos de tablas, columnas de las tablas
y demás de una base de datos, tenemos la clase DataBaseMetaData. Una vez
establecida la conexión, podemos obtener la instancia correspondiente de dicha
clase con el método getDataBaseMetaData() de la Connection,

20
  ResultSetMetadata:
Objeto que se puede utilizar para obtener información sobre los tipos y
propiedades de las columnas de un ResultSetobjeto. El siguiente fragmento de
código crea el ResultSetobjeto rs, crea el ResultSetMetaDataobjeto rsmd y usa
rsmd para averiguar cuántas columnas tiene rs y si la primera columna de rs se
puede usar en una WHEREcláusula.

 Statement:
Un objeto Statement se usa para enviar sentencias SQL a la base de datos.
Actualmente hay tres tipos de objetos Statement, todos los cuales actúan como
contenedores para la ejecución de sentencias en una conexión dada: Statement,
PreparedStatement que hereda de Statement y CallableStatement que hereda
de PreparedStatement. Estas están especializadas para enviar tipos particulares
de sentencias SQL, Un objeto Statement se usa para ejecutar una sentencia SQL
simple sin parámetros. Un objeto PreparedStatement se usa para ejecutar
sentencias SQL precompiladas con o sin parámetros IN; y un objeto
CallableStatement se usa para ejecutar un procedimiento de base de datos
almacenado. La interfase Statement suministra métodos básicos para ejecutar
sentencias y devolver resultados. La interfase PreparedStatement añade
métodos para trabajar con los parámetros IN; y la interfase CallableStatement
añade métodos para trabajar con parameters OUT.

Los objetos Statement se crean a partir de objetos Connection con el método

createStatement. Por ejemplo, suponiendo que ya exista un objeto Connection
denominado conn, la siguiente línea de código crea un objeto Statement para
pasar sentencias SQL a la base de datos:

21
Statement stmt = conn.createStatement();

 PreparedStatement:
La interfase PreparedStatement hereda de Statement y difiere de esta en dos
maneras.
• Las instancias de PreparedStatement contienen una sentencia SQL que
ya ha sido compilada. Esto es lo que hace que se le llame ‘preparada’.
• La sentencia SQL contenida en un objeto PreparedStatement pueden
tener uno o más parámetros IN. Un parámetro IN es aquel cuyo valor no se
especifica en la sentencia SQL cuando se crea. En vez de ello la sentencia
tiene un interrogante (‘?’) como un ‘encaje’ para cada parámetro IN. Debe
suministrarse un valor para cada interrogante mediante el método apropiado
setXXX antes de ejecutar la sentencia.
Como los objetos PreparedStatement están precompilados, su ejecución, es más
rápida que los objetos Statement. Consecuentemente, una sentencia SQL que se
ejecute muchas veces a menudo se crea como PreparedStatement para
incrementar su eficacia.
Siendo una subclase de Statement, PreparedStatement hereda toda la
funcionalidad de Statement. Además, se añade un set completo de métodos
necesarios para fijar los valores que van a ser enviados a la base de datos en el
lugar de los ‘encajes’ para los parámetros IN. También se modifican los tres
métodos execute, executeQuery y executeUpdate de tal forma que no toman
argumentos.

 CallableStatement:
Un objeto CallableStatement provee de una forma estándar de llamar a
procedimientos almacenados de la base de datos. Un procedimiento almacenado
se
encuentra en la base de datos. La llamada al procedimiento es lo que contiene el

22
objeto CallableStatement. Esta llamada se escribe en una sintaxis de escape que
puede tomar una de dos formas: un formato con un parámetro resultado y el otro
sin él.
La sintaxis para invocar un procedimiento almacenado en JDBC se muestra a
continuación: Notar que los corchetes indican que lo que se encuenta contenido
en ellos es opcional, no froma parte de la sintaxis.
{call procedure_name[(?, ?, ...)]}
La sintaxis para un procedimiento que devuelve un resultado es:
{? = call procedure_name[(?, ?, ...)]}
La sintaxis para un procedimiento almacenado sin parámetros se parece a algo
como:
{call procedure_name}

 ResulSet:
Un ResultSet contiene todas las filas que satisfacen las condiciones de una
sentencia SQL y proporciona el acceso a los datos de estas filas mediante un
conjunto de métodos get que permiten el acceso a las diferentes columnas de la
filas. El método ResultSet.next se usa para moverse a la siguiente fila del result
set,
convirtiendo a ésta en la fila actúal.
El formato general de un result set es una tabla con cabeceras de columna y los
valores correspondientes devueltos por la ‘query’. Por ejemplo, si la ‘query’ es
SELECT a, b, c FROM Table1, el resultado tendrá una forma semejante a :

23
El objeto ResultSet proporciona varios métodos para obtener los datos de columna
correspondientes a una fila. Todos ellos tienen el formato get<Tipo>, siendo
<Tipo> un tipo de datos Java.
Un ResultSet mantiene un cursor que apunta a la fila actual de datos. El cursor se
mueve una fila hacia abajo cada vez que se llama al método next. Inicialmente se
sitúa antes de la primera fila, por lo que hay que llamar al método next para
situarlo
en la primera fila convirtiéndola en la fila actual. Las filas de ResultSet se
recuperan en secuencia desde la fila más alta a la más baja.

 executeUpdate:
Ejecuta la instrucción SQL dada, que puede ser una instrucción INSERT, UPDATE
o DELETE; o una sentencia SQL que no devuelve nada, como una sentencia DDL
SQL. A partir de Microsoft SQL Server JDBC Driver 3.0, executeUpdate devolverá
el número correcto de filas actualizadas en una operación MERGE.

24