Existen dos formas básicas de instalar esta combinación en Windows:

A) De forma conjunta, es decir, el mismo instalador monta conjuntamente ambos productos.

Esta opción presenta el inconveniente de que la instalación se realiza con un grupo de opciones y componentes elegidos por Oracle – Sun, y por ello, pudiera ser que dichos componentes o plugins no sean exactamente los que necesitemos para la tarea prevista.

B) De forma separada. Es decir, primero se instala independientemente JDK 6 update 25 y luego mas tarde NetBeans 7.0

Esta opción, resulta mas conveniente, ya que, como mas tarde se verá, en el momento de la descarga de NetBeans podemos elegir los componentes, plugins, etc…, de acuerdo a las necesidades del proyecto que se quiere realizar.

Adoptaremos aquí la opción B, para ello necesitamos

1.- Descargar e Instalar JDK 6 Update 25

2.- Descargar e Instalar NetBeans 7.0 con la máxima versatilidad posible. (servidores y lenguajes).

Empecemos pues con la descarga de JDK 6 Update 25. Ésta puede hacerse desde la página

http://www.oracle.com/technetwork/java/javase/downloads/index.html , desde donde seleccionamos la opción:

“Download JDK”, aparecerá una nueva página desde donde tendremos que aceptar los términos de la licencia

y finalmente seleccionar la versión del sistema operativo deseado:

Para Windows,

•  Windows x86,76.66 MB,jdk-6u25-windows-i586.exe

•  Windows Intel Itanium,67.27 MB,jdk-6u25-windows-ia64.exe

•  Windows x64,67.27 MB,jdk-6u25-windows-x64.exe

Para Linux,

•  Linux x86 – RPM Installer,76.85 MB, jdk-6u25-linux-i586-rpm.bin

•  Linux x86 – Self Extracting Installer,81.11 MB, jdk-6u25-linux-i586.bin

•  Linux Intel Itanium – RPM Installer,76.85 MB, jdk-6u25-linux-ia64-rpm.bin

•  Linux Intel Itanium – Self Extracting Installer,81.11 MB, jdk-6u25-linux-ia64.bin

•  Linux x64 – RPM Installer,77.06 MB, jdk-6u25-linux-x64-rpm.bin

•  Linux x64 – Self Extracting Installer,81.36 MB, jdk-6u25-linux-x64.bin

Tal como puede verse, podemos seleccionar la plataforma o sistema operativo (Windows, Linux, Solaris) en distintas versiones.  En la pantalla anterior hacemos click sobre jdk-6u25-windows-i586.exe, y obtendremos el programa instalador. Para instalar ahora JDK hacemos doble click sobre dicho ejecutable

Aparecerá

Hacemos click en “Ejecutar” y aparecerán los términos de la licencia

Si hacemos Next, después de cambiar la carpeta donde deseamos la instalación

Tal como puede verse en la pantalla anterior, existen 5 componentes : Development Tools, Demos and Samples, Source Code, Public JRE y Java DB. Hacemos ahora Next y comenzará la instalación,

Todavía pedirá la carpeta donde deseamos instalar jre6

Hacemos Next,

Development Tools:

Este es el único elemento de instalación obligatoria. (Aunque lo recomendable es instalar TODO).

Este elemento es el Java SE Development Kit 6 Update 14, que incluye JRE (Java Runtime Environment) a Update 14.

El paquete JRE proporciona la máquina virtual de JAVA ó JVM (Java Virtual Machine), para que el código sea interpretado para un determinado  sistema operativo. Además, contiene todo el conjunto de APIs indispensables para que el código JAVA pueda ejecutarse. Existe un JVM por cada sistema operativo (Windows, Linux, Solaris), e incluso plataforma, como por ejemplo dispositivos móviles, PDA y otros.

El componente necesita 300 Mb. en disco duro.

Demos and Samples:

Este componente proporciona el código fuente de algunas Demos y Applets.

El componente necesita 46 Mb de disco duro.

Source Code:

Este componente contiene el código fuente de las clases que componen el API de Java.

El componente necesita 49 Mb de disco duro.

Public JRE:

El componente necesita 173 Mb de disco duro.

Java DB:

Este componente es la base de datos desarrollada por Oracle-  Sun con un código 100 % Java.

El componente necesita 25 Mb de disco duro. (Este no lo incluyo en la instalación)

Finalmente

Esta pantalla pretende servir de puente entre los “desarrolladores” y el equipo de Oracle – Sun que desarrolla las herramientas para así  establecer una adecuada política de uso y satisfacción de los desarrolladores. Aunque el registro no es obligatorio es interesante realizarlo por las ventajas que ello supone.

Vamos ahora con la segunda parte de la instalación, de decir, la descarga e instalación del propio NetBeans 7.0 para Windows

Para ello vamos a la página principal de NetBeans   http://netbeans.org/downloads/index.html

Tal como puede observarse, podemos elegir inicialmente tanto el lenguaje como el sistema operativo en que deseamos trabajar. Por otra parte podemos seleccionar las opciones que se ajusten a los proyectos con los que deseamos trabajar, así como los servidores web que permitirán ejecutar las aplicaciones y finalmente también puede seleccionarse las distintas plataformas con las que deseamos trabajar según el proyecto: J2SE, J2EE y J2ME.

Si elegimos la combinación “All” en Español y en Windows, finalmente se descargará

NetBeans 7.0 Instalador para Windows/Español (es) (netbeans-7.0-ml-windows.exe)

Una vez descargado, para instalar, hacemos doble click en

y aparecerá

Si hacemos Ejecutar

antes de continuar y con objeto de disponer del servidor de aplicaciones Apache, hacemos click en “Personalizar”, con lo que aparecerá

Seleccionamos o deseleccionamos el servidor o servidores de aplicaciones deseados. En mi caso, y para darle la máxima versatilidad seleccionamos todos los lenguajes. Aceptamos con OK y aparece

Hacemos ahora click en “Siguiente”

Aceptamos los términos de la licencia y hacemos click en “Siguiente”

Aceptamos los términos de la licencia de JUnit y pulsamos Next

Fijamos el directorio y subdirectorios donde deseamos instalar el IDE y el JDK y pulsamos “Siguiente”

Fijamos el directorio y subdirectorios donde deseamos instalar GlassFish y pulsamos “Siguiente”

Fijamos el directorio y subdirectorios donde deseamos instalar Apache y pulsamos “Siguiente”

La pantalla anterior presenta el resumen de todas las carpetas indicadas así como la cantidad de memoria disco necesaria.

Si estamos conformes, hacemos click en “Instalar”. Comenzará la instalación,

y cuando finalice, nos registramos, si lo deseamos, y finalmente pulsamos “Terminar”.

La pantalla anterior aparecerá cuando finalice el proceso de instalación. Creamos una cuenta si lo deseamos, y cerramos el navegador, y con esto queda terminada la instalación de NetBeans 7.0

Comprobamos que en el escritorio se ha incluido un nuevo icono que permite ejecutar NetBeans IDE 6.9

Si hacemos doble click aparecerá el IDE

Aunque no es necesario, pero para comenzar sería conveniente realizar dos tareas previas con el entorno integrado, una se refiere a los complementos y la forma de actualizar los módulos y la otra a la carga de la librería necesaria para trabajar con MySQL.

En el primer caso, y una vez abierto el IDE, vamos a la opción del menú principal “Herramientas” y “Complementos” y aparecerá

En la pestaña “Instalado” podemos comprobar los 11 módulos instalados, de acuerdo a la instalación realizada.

En la pestaña “Plugins disponibles” podemos comprobar que existen 40 plugins disponibles para su instalación y que no están instalados.

Merecería la pena instalar como mínimo la documentación del API de  NetBeans, es decir, lo señalamos y pulsamos instalar

aparecerá

en la siguiente pantalla aceptamos la licencia

Pulsamos ahora “Instalar” y …

Como quiera que sea que aún nos queda otra cuestión relativa al IDE, seleccionamos el botón “Reiniciar el IDE luego” y hacemos “Terminar”.

Seleccionamos ahora la pestaña “Configuración” y aparecerá

Ahora sólo quedaría indicar que deseamos buscar actualizaciones de los módulos en “cada inicio”, es decir

Hacemos ahora Reiniciamos,

Pulsamos ahora Terminar para reiniciar el IDE.

Si después de reiniciar volviera apareciera el mensaje de que existen actualizaciones, vamos a Herramientas/Complementos y actualizamos.

Aún queda una cuestión relacionada con el manejo de las bases de datos MySQL, y es la instalación del conector J o JDBC para MySQL.

Para resolver esto vamos a la dirección http://www.mysql.com/products/connector/ , desde donde podemos descargar el conector J para MySQL (entre otros),  para descargar el archivo mysql-connector-java-5.1.16.zip.

No sería mala idea crear otra carpeta llamada “Otraslibrerias”, (dentro de la carpeta NetBeans) donde colocar la carpeta descomprimida tanto del conector J bajado, así como otras librerías de interés tal como la JFreeChart .

Una última cuestión necesaria es definir el navegador que utilizará el IDE de NetBeans, para ello, seleccione Herramientas/Opciones

Seleccione el navegador desde la lista,

Para montar el conector J es necesario tener abierto cualquier proyecto. Vamos a abrir los ejemplos, para ello, haga Archivo/Proyecto nuevo y localice la categoría Java Web y los proyectos denominados “JSP examples”,

Haga siguiente,

Asigne un nombre al proyecto y haga Terminar, y aparecerán una serie de proyectos Web escritos en JSP. Ahora observe que el menú principal está contextualizado, ahora aparece una opción llamada “Herramientas”, sitúese en “Bibliotecas” y localice “Driver MySQL JDBC”. Es muy posible que el fichero jar que describe esta biblioteca (Conector J de MySQL) no esté actualizado. En nuestra instalación,

Como vemos la versión instalada por NetBeans es la 5.1.13 y hemos bajado anteriormente la 5.1.16, será necesario cambiarla. Para ello, descomprima la carpeta que contiene la version en formato comprimido de 5.1.16, es decir:

Observe que en dicha carpeta se encuentra el elemento musql-connector-java-5.1.16-bin.jar.

Sitúese ahora dentro del IDE en el Administrador de Bibliotecas, (Herramientas y Bibliotecas)

Localice el “Driver MySQL JDBC”, pulse en “Agregar archivo JAR/Carpeta” y localice el fichero jar que contiene al conector J que ha descomprimido,

Haga Agregar … y obtendrá

Suprima el archivo jar antigüo y acepte.

Finalmente, le deseo que disfrute del IDE de NetBeans  7.0. …

Existen dos formas básicas de instalar esta combinación en Windows:

A) De forma conjunta, es decir, el mismo instalador monta conjuntamente ambos productos.

Esta opción presenta el inconveniente de que la instalación se realiza con un grupo de opciones y componentes elegidos por Oracle – Sun, y por ello, pudiera ser que dichos componentes o plugins no sean exactamente los que necesitemos para la tarea prevista.

B) De forma separada. Es decir, primero se instala independientemente JDK 6 update 22 y luego mas tarde NetBeans 6.9.1

Esta opción, resulta mas conveniente, ya que, como mas tarde se verá, en el momento de la descarga de NetBeans podemos elegir los componentes, plugins, etc…, de acuerdo a las necesidades del proyecto que se quiere realizar.

Adoptaremos aquí la opción B, para ello necesitamos

1.- Descargar e Instalar JDK 6 Update 22

2.- Descargar e Instalar NetBeans 6.9 con la máxima versatilidad posible. (servidores y lenguajes).

Empecemos pues con la descarga de JDK 6 Update 22. Ésta puede hacerse desde la página http://www.oracle.com/technetwork/java/javase/downloads/index.html , desde donde seleccionamos la opción:

Si hacemos “Download” aparecerá

Tal como puede verse, podemos seleccionar la plataforma o sistema operativo (Windows, Linux, Solaris) en distintas versiones. En relación al lenguaje sólo está disponible la opción Multilenguaje.

También, como es obvio, necesitamos estar de acuerdo con los términos de la licencia. Para continuar, seleccionamos “Windows”, “Multi-language”, marcamos la caja de comprobación y pulsamos

finalmente  “Continue”.

Finalmente, en esta pantalla hacemos click sobre jdk-6u22-windows-i586.exe, y obtendremos el programa instalador.

Para instalar JDK hacemos doble click sobre

Aparecerá

Hacemos click en “Ejecutar” y aparecerán los términos de la licencia

Si hacemos Next, después de cambiar la carpeta donde deseamos la instalación y desmarcar Java DB

Tal como puede verse en la pantalla anterior, existen 5 componentes : Development Tools, Demos and Samples, Source Code, Public JRE y Java DB. Dado que no voy a utilizar inicialmente Java DB, no lo incluyo.Hacemos ahora Next comenzará la instalación,

Development Tools:

Este es el único elemento de instalación obligatoria. (Aunque lo recomendable es instalar TODO).

Este elemento es el Java SE Development Kit 6 Update 14, que incluye JRE (Java Runtime Environment) a Update 14.

El paquete JRE proporciona la máquina virtual de JAVA ó JVM (Java Virtual Machine), para que el código sea interpretado para un determinado  sistema operativo. Además, contiene todo el conjunto de APIs indispensables para que el código JAVA pueda ejecutarse. Existe un JVM por cada sistema operativo (Windows, Linux, Solaris), e incluso plataforma, como por ejemplo dispositivos móviles, PDA y otros.

El componente necesita 300 Mb. en disco duro.

Demos and Samples:

Este componente proporciona el código fuente de algunas Demos y Applets.

El componente necesita 46 Mb de disco duro.

Source Code:

Este componente contiene el código fuente de las clases que componen el API de Java.

El componente necesita 49 Mb de disco duro.

Public JRE:

El componente necesita 173 Mb de disco duro.

Java DB:

Este componente es la base de datos desarrollada por Oracle-  Sun con un código 100 % Java.

El componente necesita 25 Mb de disco duro. (Este no lo incluyo en la instalación)

y cuando termine

Desde esta pantalla podemos seleccionar la carpeta donde colocaremos el jre6 (runtime). En mi caso,

Finalmente

Esta pantalla pretende servir de puente entre los “desarrolladores” y el equipo de Sun que desarrolla las herramientas para así  establecer

una adecuada política de uso y satisfacción de los desarrolladores. Aunque el registro no es obligatorio es interesante realizarlo

por las ventajas que ello supone.

Vamos ahora con la segunda parte de la instalación, de decir, la descarga e instalación del propio NetBeans 6.9.1 para Windows

Para ello vamos a la página principal de NetBeans   http://netbeans.org/downloads/index.html

Tal como puede observarse, podemos elegir inicialmente tanto el lenguaje como el sistema operativo en que deseamos trabajar. Por otra parte podemos seleccionar las opciones que se ajusten a los proyectos con los que deseamos trabajar, así como los servidores web que permitirán ejecutar las aplicaciones y finalmente también puede seleccionarse las distintas plataformas con las que deseamos trabajar según el proyecto: J2SE, J2EE y J2ME.

Si elegimos la combinación “All” en Español y en Windows, finalmente se descargará

NetBeans 6.9 Instalador para Windows/Español (es) (netbeans-6.9.1-ml-windows.exe)

Una vez descargado, para instalar, hacemos doble click en

y aparecerá

antes de continuar y con objeto de disponer del servidor de aplicaciones Apache, hacemos click en “Personalizar”, con lo que aparecerá

Seleccionamos o deseleccionamos el servidor de aplicaciones deseado. En mi caso selecciono Apache Tomcat 6.0.26. Por otro, como no voy a utilizar Ruby, C/C++, Groovy, por ello, los deselecciono para no ocupar un espacio innecesario. Aceptamos y aparece

Hacemos ahora click en “Siguiente”

Aceptamos los términos de la licencia y hacemos click en “Siguiente”

Fijamos el directorio y subdirectorios donde deseamos instalar Glassfish y pulsamos “Siguiente”

Fijamos el directorio y subdirectorios donde deseamos instalar Apache y pulsamos “Siguiente”

Si hacemos ahora Siguiente,

La pantalla anterior presenta el resumen de todas las carpetas indicadas así como la cantidad de memoria disco necesaria.

Si estamos conformes, hacemos click en “Instalar”

Nos registramos, si lo deseamos, y finalmente pulsamos “Terminar”.

La pantalla anterior aparecerá cuando finalice el proceso de instalación. Creamos una cuenta si lo deseamos, y cerramos el navegador, y con esto queda terminada la instalación de NetBeans 6.9.1

Comprobamos que en el escritorio se ha incluido un nuevo icono que permite ejecutar NetBeans IDE 6.9

Si hacemos doble click aparecerá el IDE

Aunque no es necesario, pero para comenzar sería conveniente realizar dos tareas previas con el entorno integrado, una se refiere a los complementos y la forma de actualizar los módulos y la otra a la carga de la librería necesaria para trabajar con MySQL.

En el primer caso, y una vez abierto el IDE, vamos a la opción del menú principal “Herramientas” y “Complementos” y aparecerá

En la pestaña “Instalado” podemos comprobar los 7 módulos instalados, de acuerdo a la instalación realizada.

En la pestaña “Plugins disponibles” podemos comprobar que existen 70 plugins disponibles para su instalación y que no están instalados. Merecería la pena instalar como mínimo la documentación del API de  NetBeans, es decir, lo señalamos y pulsamos instalar

aparecerá

en la siguiente pantalla aceptamos la licencia

Pulsamos ahora “Instalar” y …

Como quiera que sea que aún nos queda otra cuestión relativa al IDE, seleccionamos el botón “Reiniciar el IDE luego” y hacemos “Terminar”.

Seleccionamos ahora la pestaña “Configuración” y aparecerá

Ahora sólo quedaría indicar que deseamos buscar actualizaciones de los módulos en “cada inicio”, es decir

Vemos que existe una acttualización. Vamos a la pestaña de Actualización

Hacemos inmediatamente Actualizar

Hacemos ahora Siguiente,

Pulsamos ahora Terminar para reiniciar el IDE.

Si después de reiniciar volviera apareciera el mensaje de que existen actualizaciones, vamos a Herramientas/Complementos y actualizamos.

Aún queda una cuestión relacionada con el manejo de las bases de datos MySQL, y es la instalación del conector J o JDBC para MySQL.

Para resolver esto vamos a la dirección http://www.mysql.com/products/connector/ , desde donde podemos descargar el conector J para MySQL (entre otros),  para descargar el archivo mysql-connector-java-5.1.13.zip.

No sería mala idea crear otra carpeta llamada “Otraslibrerias”, (dentro de la carpeta NetBeans) donde colocar la carpeta descomprimida tanto del conector J bajado, así como otras librerías de interés tal como la JFreeChart .

Una última cuestión necesaria es definir el navegador que utilizará el IDE de NetBeans, para ello, seleccione Herramientas/Opciones

Seleccione el navegador desde la lista,

Para montar el conector J es necesario tener abierto cualquier proyecto. Vamos a abrir los ejemplos, para ello, haga Archivo/Proyecto nuevo y localice la categoría Java Web y los proyectos denominados “JSP examples”,

Haga siguiente,

Asigne un nombre al proyecto y haga Terminar, y aparecerán una serie de proyectos Web escritos en JSP. Ahora observe que el menú principal está contextualizado, ahora aparece una opción llamada “Herramientas”, sitúese en “Bibliotecas” y localice “Driver MySQL JDBC”. Es muy posible que el fichero jar que describe esta biblioteca (Conector J de MySQL) no esté actualizado. En nuestra instalación,

Como vemos la versión instalada por NetBeans es la 5.1.6 y hemos bajado anteriormente la 5.1.13, será necesario cambiarla, para ello, pulse en “Agregar archivo JAR/Carpeta” y localice el fichero jar que contiene al conector J,

Haga Agregar … y obtendrá

Suprima el archivo jar antigüo y acepte.

Finalmente, le deseo que disfrute del IDE de NetBeans  6.9.1. …

Los Servlets son programas escritos en Java y que dan una respuesta alternativa a la programación Web con CGI , ampliando su funcionalidad. Se ejecutan en un servidor Web dentro de un contenedor de servlets (por ejemplo Apache Tomcat) y construyen páginas Web.

Algunas de las ventajas de los Servlet frente a los CGI podrían ser:

• Más Eficiencia. Con CGI tradicional, se arranca un nuevo proceso para cada solicitud HTTP. Con los Servlets, cada petición es manejada por un hilo y no un proceso del sistema operativo. De forma similar, en CGI tradicional, si hay N peticiones simultáneas para el mismo programa CGI, el código de este problema se cargará N veces en memoria. Sin embargo, con los Servlets, hay N hilos pero sólo una copia de la clase Servlet.
• Más Potencia. Los Servlets Java nos permiten fácilmente hacer muchas tareas que son difíciles con un CGI normal. Esto simplifica las operaciones que se necesitan para buscar imágenes y otros datos almacenados en situaciones estándards. Los Servlets también pueden compartir los datos entre ellos, también pueden mantener información de solicitud en solicitud, simplificando el seguimiento de sesiones,manejas cookies y cabeceras. La razón básica de esta potencia es la propia potencia de Java.
• Más Portablilidad. Los Servlets están escritos en Java y siguen un API bien estandarizado y por tanto, están soportados directamente en la mayoría de los servidores Web.
• Más Barato. Hay un número de servidores Web gratuitos o muy baratos que son buenos para el uso “personal” y la mayoría de instalaciones empresariales y este es el caso de Apache Tomcat.

El API Servlets y el ciclo de vida.

Los servlets usan clases e interfaces de dos paquetes:

1. javax.servlet que contiene clases para servlets genéricos (independientes del protocolo que usen) y,
2. javax.servlet.http (que añade funcionalidad particular de http). El nombre javax indica que los servlets son una extensión.

Los servlets no tienen el método main() como los programas Java, sino que se invocan unos métodos cuando se reciben peticiones. A esta metodología se le llama ciclo de vida de un servlet y viene dado por tres métodos: init, service, destroy:

De esta manera, una vez se carga el servlet, es muy eficiente, pues sólo hay una copia cargada en memoria (se ejecutan uno o varios hilos), no hay que crear nuevos objetos (un solo objeto servlet), y tiene persistencia: puede guardar información entre peticiones, como contadores o conexiones a una base de datos. Esto último puede ser muchísimo más eficiente hacerlo en el método init que abrir y cerrar la conexión con la base de datos en cada petición.

Métodos GET y POST

Para entender cómo funciona un servlet vamos a diseñar uno muy básico y que a modo de plantilla nos sirva para construir otros, para hacer esto, iniciamos una sesión del IDE de NetBeans. Hacemos proyecto Web nuevo al que llamaremos “Ejem0Servlet”, una vez tengamos la plantilla de la página index.jsp vamos a hacer que ésta llame a un servlet a través de un enlace href, es decir, el código de index.jsp será:

Ahora vamos a añadir un paquete al que llamaremos “paquete0″, para hacer esto, bastaría situarse con el botón derecho sobre el nombre del proyecto y seleccionar Nuevo Paquete. Cuando tengamos el paquete, nos situamos en él y con el botón derecho seleccionamos Nuevo Servlet, llamamos al nuevo servlet “Servlet0″ y aparecerá la siguiente plantilla,

donde hemos “descomentado” las instrucciones de processRequest . Como vemos en este servlet elemental, comienza con una cabecera donde se indica el paquete que lo contiene y seis importaciones de paquetes que son necesarios para su correcta ejecución,

luego vemos que la clase que define el servlet es una clase pública extendida o derivada de HttpServlet. Esta clase, naturalmente es pública para poder ser “vista” desde cualquier otro servlet o jsp del proyecto, es decir,

La contiene varios métodos, a saber:

1.- Método  protected void processRequest(HttpServletRequest request, HttpServletResponse response)

Como0 vemos este método se ejecuta tanto si la petición se realiza a través de GET como si es a través de POST y lo único que hace es devolver un texto. Merece especial consideración las instrucciones:

1. response.setContentType(“text/html;charset=UTF-8″); Esta instrucción fija el tipo de contenido que será devuelto al peticionario, al cliente.
2. PrintWriter out = response.getWriter(); Esta instrucción crea el objeto “out” que permitirá escribir la salida. Este objeto es distinto al objeto out implícito de los jsp.
3. request.getContextPath; , contiene el path desde donde se ha reaklizado la petición.

2.-Método protected void doGet(HttpServletRequest request, HttpServletResponse response)

Este método llama al método processRequest, se prejuzga que las tareas a ejecutar son las mismas con una llamada GET que con una llamara POST. En caso de error se lanza la excepción ServletException.

3.-Método protected void doPost(HttpServletRequest request, HttpServletResponse response)

Este método llama al método processRequest, se prejuzga que las tareas a ejecutar son las mismas con una llamada GET que con una llamara POST. En caso de error se lanza la excepción ServletException.

4.-Método public String getServletInfo()

Podemos observar que la clase no tiene ni método init() ni método destroy. No son necesarios, ni obligatorios.

Si ejecutamos,

EJEMPLO2.

En el ejemplo anterior no queda claro quien atiende específicamente la petición, si doGet() o doPOst(). En realidad queda claro, pero de manera implícita, ya que cuando no existe un atributo “method”  en una etiqueta form de HTML que especifique el método GET o POST, el servlet SIEMPRE, por defecto, responde con el método doGet(). Vamos a modificar el programa anterior y construiremos otro al que llamaremos ejem1Servlet (la mejor idea es copiarlo con el IDE de Netbeans).

Modificaremos el Servlet0 de manera que no exista el método processRequest. Esta vez haremos que cada uno de los métodos doGet() y doPOst() responda cada uno por sí sólo.

He aquí los métodos:

y

Si ejecutamos el programa

como vemos, el servlet ha respondido con el método doGet(), que es el que utiliza por defecto cuando no se explicita el método de llamada.

Descriptor de despliegue:

El archivo web.xml se denomina descriptor de despliegue y es necesario cuando se utilizan servlet, porque con él se define su nombre y se identifica al paquete y clase que lo contiene, entre otras cuestiones. Mas adelante en este tutorial se analizarán otros usos, tales como los filtros, los parametros de contexto, los parametros iniciales, etc…En NetBeans se encuentra en la carpeta WEB-INF.

Conviene recordar:

El ciclo de vida de un servlet.

Los distintos métodos fundamentales de un servlet: init, service, doGet, doPost, destroy.

Relación entre los métodos GET y POST de un formulario, llamadas desde la etiqueta

Cuando utilizar GET y POST en función de la seguridad.

El uso de web.xml o descriptor de despliegue.

Para comenzar lo primero que haremos será descargar el SDK de Android que actualmente (Sep/2010) se encuentra en la revisión 7. En Windows se obtiene el archivo  android-sdk_r07-windows.zip con un peso de 23.115 Kb, mientras que en Linux se descarga el archivo android-sdk_r07-linux_x86.tgz.tar con un peso de 16.714 Kb

En Windows,

bastaría descomprimir la carpeta en cualquier unidad y directorio. En mi caso yo lo he descomprimido en C:/Androidr7.

La carpeta, una vez descomprimida, contiene los siguientes elementos,

En linux,

bastará con

sudo mkdir –p /opt/google
cd /opt/google
sudo tar xvzf /tmp/android-sdk_r07-linux_86.tgz

y

cd android-sdk-linux_86/tools
sudo ./android

1.-Instalación de SDK Manager.

Para Windows, lo primero que tenemos que hacer es actualizar los fuentes, para ello nos aseguramos que tenemos conexión a internet y hacemos doble click en SDK Manager,

se inicia en SDK Manager y inicia “Refresh Source” desde internet, cuando finaliza aparece la siguiente pantalla,

A partir de aquí, rechazamos las opciones obsoletas y aceptamos las demás, es decir,

Hacemos ahora Install y comenzará la actualización,

Cuando termine aparecerá,

Pulsamos “Yes”, y cerramos,

hacemos click en “Update All” y cuando termine cerramos.

NOTA: recuerde añadir al path la carpeta y ruta completa “tools” de Android.

2.-Creación de un dispositivo virtual (con skin HTC Magic).

Tenemos que localizar la piel del teléfono para el que deamos desarrollar, en el caso de HTC Magic, que es mi caso tenemos que descomprimir el archivo la  (

Ahora localizamos el “scrin” para poder emular HTC Magic en la siguiente dirección, y lo descomprimimos en todas y cada una de los subdirectorios skin de las distintas plataformas montadas de AQndroid.

Después iniciamos Android SDK Manager, seleccionamos “Virtual Device”, en el menú de la izquierda,

hacemos seguidamente “New”  y cumplimentamos la siguiente caja de diálogo

donde puede verse que hemos seleccionado el skin HVGA-P-HTCMagic que previamente habíamos descargado y descomprimido. También añadimos el Hardware que soporte el teléfono o el dispositivo. A efectos de desarrollo conviene indicar todo el hardware disponible. Y finalmente asignamos una memoria de la tarjeta de 10024 Kb.

Si hacemos “Create AVD”,

Pulsamos OK,

Vamos a comprobar en skin del HTC Magic, para ello hacemos “Start”,

Finalmente “Launch”,

Finalmente cerramos “Android SDK Manager”

2.-Instalación del plugin de Android en Netbeans. (Es idéntica en cualquier sistema operativo Windows, Linux, Mac).

Iniciamos una sesión del IDE de Netbeans, seleccionamos Herramientas/Complementos, vamos a la pestaña “Configuración” y hacemos “Agregar”, aparecerá

Hacemos “Aceptar”. Vamos ahora a la pestaña Plugin disponibles,

Marcamos “Android” y pulsamos “Instalar”,

Hacemos “Siguiente”,

Aceptamos los términos de la licencia y pulsamos en “Instalar”,

Cuando finalice,

Pulse ahora “continuar”,

Finalmente pulse “Terminar”.

Localice la pestaña “Instalado” y asegúrese que Java ME está activo.

Cierre el IDE e inícielo de nuevo.

3.-Instalación de la plataforma Android en NetBeans, (Es idéntica en cualquier sistema operativo Windows, Linux, Mac).

Iniciamos una sesión del IDE de NetBeans, seleccionamos Herramientas/Plataforma Java y aparecerá,

Hacemos click en “Añadir plataforma”,

Seleccione Google Android y pulse “Siguiente”,

Seleccionamos la carpeta donde descomprimimos Android y pulsamos “Siguiente”,

Marcamos una plataforma, en este caso Android 2.1 y damos nombre “Android 2.1″ a dicha plataforma.

Hacemos Terminar.

Y hacemos finalmente “Cerrar”.

4.-Hola Mundo en Android.

Vamos a probar el desarrollo con Android, para ello iniciamos el IDE de Netbean y hacemos “Proyecto nuevo”,

Hacemos “Siguiente”,

Hemos dado como nombre al nuevo proyecto “HolaAndroid”, si hacemos ahora Terminar, tendremos un código de MainActivity creado por la plantilla,

incorporamos ahora el paquete

import android.widget.TextView;

además hemos de incluir

TextView tv = new TextView(this);
tv.setText(“Hola, Android …”);
setContentView(tv);

de esta manera crearemos un objeto TextView, le asignaremos un texto y lo mostraremos. Es decir el programa MainActivity quedará de la siguiente forma

Ejecutamos ahora, Y DESPUÉS DE CIERTA ESPERA, obtengo

Si hacemos “Menu”,

Cualquier información respecto de un dato de una base de datos que nos ayuda a comprenderlo o utilizarlo. Los primeros metadatos de interés son aquellos que tienen que ver con la estructura de una base de datos: Tablas, Filas, Columnas …

Existe una gran variedad de métodos en el API DataBaseMetaData que nos permiten conocer los metadatos de una base de datos.

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.

Y así por ejemplo, una vez obtenido un objeto connection de forma adecuada podemos hacer

DataBaseMetaData metaDatos = con.getMetaData();

donde con es el objeto connection y metaDatos es el objeto.

A partir de aquí, podemos averiguar cuantos y cuáles son los catálogos de la base de datos,

ResultSet catalogos = metaDatos.getCatalogs();

y recorrer el conjunto de datos para escribirlo en pantalla, por ejemplo,

while (catalogos.next()) {
out.println( catalogos.getString(1)+”<br>”);
}

Para ver las tablas de cierto esquema

ResultSet resul = metaDatos.getTables(null, null, “%”, null);

donde los cuatro parámetros que hemos pasado son:

• catálogo de la base de datos. Al poner null, estamos preguntando por el catálogo actual, que en nuestro ejemplo es de la cadena de conexión, “rs23“.
• Esquema de la base de datos. Al poner null, es el actual.
• Patrón para las tablas en las que tenemos interés. En SQL el carácter que indica “todo” es %, equivalente al * a la hora de listar ficheros. Esto nos dará todas las tablas del catálogo y esquema actual. Podríamos poner cosas como “usu%“, con lo que obtendríamos todas las tablas cuyo nombre empiece por “usu“.
• El cuarto parámetro es un array de String, en el que pondríamos qué tipos de tablas queremos (normales, vistas, etc). Al poner null, nos devolverá todos los tipos de tablas.

Una vez obtenido el conjunto de datos resul, puede recorrerse con un bucle while como en métodos anteriores, teniendo en cuenta que

resul.tablas.getString(1), entrega el catálogo,

resul.tablas.getString(2), entrega el esquema,

resul.tablas.getString(3), entrega el nombre de la tabla.

resul.tablas.getString(4), entrega el tipo de tabla (TABLE, VIEW, SYSTEM TABLE, …)

resul.tablas.getString(5), entrega la descripción de la tabla.

Finalmente, podemos obtener para cada tabla las columnas que la componen: su nombre y tipo. Para ello, podemos usar el método getColumns() de DataBaseMetaData.

ResultSet resul = metaDatos.getColumns(catalogo, null, tabla, null);

en el que los parámetros de la llamada son:

• El nombre del catálogo al que pertenece la tabla.
• El nombre del esquema, null para el esquema actual.
• El nombre de la tabla. Nuevamente podríamos poner comodines al estilo SQL para obtener, por ejemplo, las columnas de todas las tablas “person%” que empiecen por person.
• El nombre de las columnas buscadas, usando comodines. null nos devuelve todas las columnas.

El contenido del ResultSet será una fila por cada columna de la tabla. Las columnas del ResultSet mas utilizadas son el nombre de la columna de la tabla y el nombre del tipo de dato de la columna, es decir, nos interesa

resul.tablas.getString(4), entrega el nombre de la columna,

resul.tablas.getString(6), entrega el tipo de dato de una columna.

Migración de MsAccess a MySQL.

En este ejercicio trabajaremos de nuevo con la base de datos del Departamento de Agricultura de los Estados Unidos, sólo que en lugar de hacer uso de la base de datos de MsAccess migraremos el archivo sr23.mdb a MySQL. Para hacer esto iniciamos la utilidad “MySQL Migration Toolkit “, es decir:

Hacemos ahora Next,

Hacemos Next,

Indicamos el sistema gestor de base de datos de la base de datos que deseamos migrar, en nuestro caso, MsAccess, e indicamos la localización de dicha base de datos (sr23.mdb), hacemos next,

donde hemos tomado como Hostname “localhost” y hemos introducido el usuario y password del administrador de MYSQL. Si hacemos Next ahora,

en esta pantalla vemos que se ha producido las dos conexiones a las dos bases de datos, si hacemos Next,

Vemos que se ha creado un nuevo esquema (base de datos) en MySQL con el mismo nombre que la base de datos origen. Seleccionamos dicho esquema y pulsamos Next

Vemos que todos los preparativos están OK. Pulsamos seguidamente Next

Observamos que la base de datos que se va a emigrar contiene 13 tablas (aquí tenemos la posibilidad de personalizar y por tanto migrar exclusivamente aquellas tablas que nos interesen). Hacemos Next,

Desde aquí podemos parametrizar la migración o adoptar una migración standard. Hacemos Next,

Vemos que las operaciones previas se han realizado con éxito. Hacemos seguidamente Next,

Comprobamos que el mapeo de las tablas y de los campos de estas tablas se ha realizado con éxito entre las dos bases de datos. Hacemos ahora Next,

A partir de esta pantalla podemos “crear los objetos” de la base de datos, es decir, las tablas, vistas, procedimientos almacenados etc.. y/o crear simplemente un fichero de script de todo el proceso de migración. Hacemos Next,

Comprobamos que se crean con éxito el esquema de la base de datos y las tablas. Hacemos Next,

Nuevas comprobaciones. Hacemos Next,

Desde esta pantalla podemos migrar todos los datos de todos los objetos o dejarlo para otra ocasión y crear un script para procesar de nuevo la migración. Hacemos Next,

Cuando aparezca esta pantalla la transferencia de datos ha concluido. Hacemos Next,

y finalmente Finish, si no queremos salvar el script que compendia toda la operación de migración.

Finalmente, vamos a realizar un backup de esta base de datos, para ello vamos a “MySQL Administrator” y seleccionamos “backup”,

Hacemos click ahora en New Project,

donde hemos selecciona el esquema o base de datos sr23. Si hacemos ahora Save Project y finalmente Execute Backup

EJERCICIO1:

En este ejercicio trabajaremos de nuevo con la base de datos del Departamento de Agricultura de los Estados Unidos, sólo que en lugar de hacer uso de la base de datos de MsAccess trabajaremos con la correspondiente una ver que ha migrado a MYSQL.

El ejercicio consiste en replicar el ejercicio 2 del Tutorial de JSP (): cambiando tanto el driver como la cadena de conexión a la base de datos. Si todo funciona bien, que es lo esperado, queda PROBADO QUE UNA VEZ SE TENGA UNA APLICACIÓN QUE GESTIONE UNA BASE DE DATOS A TRAVÉS DE JDBC, ÉSTA FUNCIONARÁ CON CUALQUIER OTRA BASE DE DATOS SIN MAS QUE CAMBIAR EL DRIVER Y LA CADENA DE CONEXIÓN.

Recuerde incorporar la librería de MySQL, después de haber instalado en el IDE el conector J para MYSQL.

EJERCICIO2:

En este ejercicio trabajaremos de nuevo con la base de datos del Departamento de Agricultura de los Estados Unidos, sólo que en lugar de hacer uso de la base de datos de MsAccess TRABAJAREMOS CON LA VERSIÓN sr23 en MYSQL. Tratamos de buscar el catálogo, los esquemas de bases de datos, las tablas para un esquema dado y las columnas para una tabla dada.

Iniciamos un nuevo proyecto en el IDE de NetBeans y sustituimos el código del fichero index.jsp por el siguiente código,

index.jsp y añadimos en el paquete pbd la clase que controla los accesos a la base de datos clase.java

Usando JDBC es fácil ejecutar sentencias SQL a cualquier base de datos relacional. Por esta razón, no es necesario escribir un programa para acceder a una base de datos tipo Access, otro programa para acceder a una base de datos tipo Oracle y así para cada tipo de base de datos. Se puede escribir un solo programa usando la API JDBC y el programa será capaz de enviar sentencias SQL a la base de datos apropiada. Además con una aplicación escrita en Java, se puede ejecutar en diferentes plataformas.

Aunque la API ODBC de Microsoft es probablemente la interface de programación para acceder a bases de datos relacionales bastante usada y ofrece la posibilidad de conectar a casi la totalidad de bases de datos, tiene en contra de la API JDBC que está escrita en C y por tanto no es portable entre distintos sistemas operativos.

En la siguiente página de Oracle puede ver todas las APIS para todas las bases de datos disponibles.

El JDBC está compuesto por dos capas:

1. El API JDBC se encarga de comunicar con la API del administrador de controladores JDBC enviándole las sentencias SQL.
2. Un administrador de controladores de JDBC que se comunica de forma transparente para el programador con los distintos controladores disponibles para la base de datos.

La JDBC 3.0 API comprende dos paquetes, El paquete java.sql y el paquete javax.sql. Esto obliga a mantener

Para descargar e instalar el conector J que permitirá utilizar MySQL en el IDE NetBeans pulse aquí.

Mecanismo JDBC

El funcionamiento práctico de JDBC obliga a conocer los siguientes 6 procedimientos, a saber,

1. Establecer conexión.
2. Crear sentencia.
3. Ejecutar sentencia.
4. Procesar resultados.
5. Cerrar.

1.-Establecer la conexión.

Tiene dos operaciones básicas.

DriverManager

La clase DriverManager es la capa gestora de JDBC, trabajando entre el usuario y el controlador (driver). Se encarga de seguir el rastro de los controladores que están disponibles y establecer la conexión entre la base de datos y el controlador apropiado. La clase DriverManager mantiene una lista de clases Driver que se han registrado llamando al método DriverManager.registerDriver. Un usuario normalmente no llamará al método DriverManager.registerDriver directamente, sino que será llamado automáticamente por el controlador (driver) cuando este se carga.

El usuario lo que hace es forzar que se cargue el driver, lo cual puede hacerse de dos formas, aunque la recomendada es llamando al método Class.forName(). Esto carga la clase driver explícitamente.

Para trabajar con el Puente JDBC-ODBC:

try {
Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);
} catch (ClassNotFoundException cnfe) {
System.err.println(“No ha podido encontrarse el driver de ODBC.”);
}

Para trabajar con MySQL:

try {
Class.forName(“com.mysql.jdbc.Driver”);
} catch (ClassNotFoundException cnfe) {
System.err.println(“No ha podido encontrarse el driver de MySQL”);
}

Para trabajar con postgreSQL:

try {
Class.forName(“org.postgresql.Driver”);
} catch (ClassNotFoundException cnfe) {
System.err.println(“No ha podido encontrarse el driver de postgreSQL”);
}

Para trabajar con Oracle:

try {
Class.forName(“oracle.jdbc.driver.OracleDriver”);
} catch (ClassNotFoundException cnfe) {
System.err.println(“No ha podido encontrarse el driver de Oracle”);
}

No necesitamos crear un ejemplar de un driver y registrarlo con el DriverManager porque la llamada a Class.forName lo hace automáticamente. Si hubiéramos creado nuestro propio ejemplar, creariamos un duplicado innecesario, pero no pasaría nada.

Una vez cargado el driver, es posible hacer una conexión con un controlador de base de datos.

Connection

Un objeto Connection representa una conexión a una base de datos. Una sesión con una conexión incluye las sentencias SQL que son ejecutadas y los resultados que son devueltos a través de dicha conexión. Una misma aplicación puede tener una o más conexiones con una sola base de datos o puede tener conexiones con varias bases de datos diferentes.
La forma estándar de establecer una conexión con una base de datos es llamando al método DriverManager.getConnection. Este método toma como parámetro una cadena de caracteres que contiene una URL. La clase DriverManage trata de localizar el driver que pueda conectar con la base de datos representada por esa URL.

Para trabajar con el Puente JDBC-ODBC con MsAccess (Windows XP):

import java.sql.*;

public static void conexion ( ) throws Exception {

try {

// Carga el driver

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

// Define la cadena de conexión


String sourceURL = "jdbc:odbc:DSNSistema";


// Crea el objeto connection a través de DriverManager


Connection con = DriverManager.getConnection(sourceURL);


System.out.println("La conexion establecida es: "+ con);


} catch(ClassNotFoundException cnfe) {


System.err.println(cnfe);


} catch(SQLException sqle) {


System.err.println(sqle);


};


};



Para trabajar con MySQL.

import java.sql.*;

public static void conexion ( ) throws Exception {

try {

// Carga el driver

Class.forName("com.mysql.jdbc.Driver”);

// Define la cadena de conexión


String sourceURL = "jdbc:mysql://localhost/bd_pruebas”, usuario, password";


// Crea el objeto connection a través de DriverManager


Connection con = DriverManager.getConnection(sourceURL);


System.out.println("La conexion establecida es: "+ con);


} catch(ClassNotFoundException cnfe) {


System.err.println(cnfe);


} catch(SQLException sqle) {


System.err.println(sqle);


};


};

Para trabajar con postgreSQL:

import java.sql.*;

public static void conexion ( ) throws Exception {

try {

// Carga el driver

Class.forName(“org.postgresql.Driver”);

// Define la cadena de conexión

String database = “Bd”;
String username = “admin”;
String password = “admin”;

String sourceURL = "jdbc:postgresql:”+database, username, password";


// Crea el objeto connection a través de DriverManager


Connection con = DriverManager.getConnection(sourceURL);


System.out.println("La conexion establecida es: "+ con);


} catch(ClassNotFoundException cnfe) {


System.err.println(cnfe);


} catch(SQLException sqle) {


System.err.println(sqle);


};


};


Para trabajar con Oracle XE (version 10g).

import java.sql.*;

public static void conexion ( ) throws Exception {

try {

// Carga el driver

Class.forName("oracle.jdbc.driver.OracleDriver");

// Define la cadena de conexión


String sourceURL =“jdbc:oracle:thin:@localhost:1521:orcl”, “scott”, “tiger”;

// Crea el objeto connection a través de DriverManager


Connection con = DriverManager.getConnection(sourceURL);


System.out.println("La conexion establecida es: "+ con);


} catch(ClassNotFoundException cnfe) {


System.err.println(cnfe);


} catch(SQLException sqle) {


System.err.println(sqle);


};


};

2.-Crear sentencia.

Statement

Un objeto Statement se usa para enviar sentencias SQL a una base de datos. Una vez que se ha establecido una conexión con una base de datos particular, esa conexión puede ser usada para enviar sentencias SQL. Un objeto Statement se crea con el método creatStatement de Connection como en el siguiente  código:

Statement senten = con.createStatement();

En realidad el método createStatement debe llevar dos parámetros enteros que especifican el comportamiento del objeto ResultSet u hoja de datos y que luego se analizará con detalle. La sintaxis general será

public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException

donde:

int resulSetType, puede tener un valor de ResultSet.TYPE_SCROLL_SENSITIVE o ResultSet.TYPE_SCROLL_INSENSITIVE si queremos que el ResultSet mantenga los cambios realizados en dicha hoja de datos o no respectivamente. Finalmente ResultSet.TYPE_FORWARD_ONLY que sólo permite desplazamientos del cursor del ResultSet hacia adelante (Valor por defecto).

int resulSetCurrency, puede tener un valor de ResultSet.CONCUR_UPDATABLE cuando deseamos actualizar cualquier componente de dicho objeto u hoja de datos, en caso contrario indicaremos como valor ResulSet.CONCUR_READ_ONLY (Valor por defecto).

PreparedStatement

Un objeto PreparedStatement se usa para sentencias SQL que toman uno o más parámetros como argumentos de entrada (parámetros IN). PreparedStatement tiene un grupo de métodos que fijan los valores de los parámetros IN, los cuales son enviados a la base de datos cuando se procesa la sentencia SQL.
Un objeto PreparedStatement es potencialmente más eficiente que un objeto Statement porque este ha sido precompilado y almacenado para su uso futuro.

Son muy útiles cuando una sentencia SQL se ejecuta muchas veces cambiando sólo algunos valores.

Una sentencia preparada (PreparedStatement) se crea de la misma forma que un Statement convencional:

PreparedStatement updateSales = con.prepareStatement(“UPDATE productos SET ventas = ? WHERE COD = ?”);

después de esta instrucción habría que añadir

updateSales.setInt(1,75);
updateSales.setString(2,”110001″);

para finalmente ejecutar la sentencia con

updateSales.executeUpdate();

en las que la primera instrucción fija el valor del primer parámetro (ventas=75), la segunda fija el valor del segundo parámetro (Código del producto = 110001) y la tercera ejecuta la instrucción.

3.-Ejecutar sentencia.

La sentencia SQL se ejecuta a través de los métodos executeQuery o executeUpdate dependiendo de que no exista o exista modificación de los datos respectivamente. En los dos casos. Es decir,

1. Consulta – executeQuery() Es una operación SELECT que devuelve el resultado de una consulta encapsulado en un objeto de tipo ResultSet
2. Actualización – executeUpdate() Es una operación INSERT, UPDATE o DELETE que realiza una modificación sobre la base de datos; su resultado es un valor entero indicando el número de tuplas afectadas por esta operación.

ResultSet resul = senten.executeQuery(“SELECT a, b, c FROM Table2″);

Ó

Int filas_afectadas = senten.executeUpdate(“UPDATE personas set nombre=’Marina’ where id=4″);

Ó

Int filas_afectadas = senten.executeUpdate(“INSERT INTO contacto (nombre, apellidos, telefono) VALUES (‘Juan’, ‘Gomez’, ’123′”);

3.1.-Método executeUpdate

Este método se usa para ejecutar todas las sentencias SQL que impliquen la creación, modificación o borrado de una tabla (INSERT, DELETE, UPDATE y comandos DDL – CREATE, DROP, ALTER,…). Por tanto, con este método realizaremos sentencias de creación de tablas (CREATE), modificación de la estructura de tablas (ALTER), destrucción de tablas (DROP), inserción de filas (INSERT), modificación de filas (UPDATE) y destrucción de filas (DELETE).

Para ejecutar una sentencia SQL con el método executeStatement es necesario pasarle como parámetro (en forma de String) la sentencia SQL que queramos ejecutar. El objeto Statement se encargará de enviar la sentencia SQL a la base de datos para que se ejecute y de devolvernos los resultados.

Devuelve un entero con las filas afectadas.

4.-Procesar resultados.

ResultSet

Un ResultSet contiene todos los registros (filas) que satisfacen las condiciones impuestas en una sentencia SQL y proporciona acceso a los datos en dichos registros a través de un conjunto de métodos get que permiten acceder a los diferentes campos o atributos (columnas) del registro actual. Un ResultSet mantiene un cursor que apunta al registro actual. El método ResultSet.next() se usa para moverse al siguiente registro del ResultSet, haciendo el siguiente registro el registro actual.

Los métodos getXXX proporcionan los medios para obtener los valores de los campos, atributos o columnas del registro actual.

Para cada registro, los valores de las columnas pueden ser obtenidos en cualquier orden, pero para la mayor portabilidad, se debe hacer de izquierda a derecha y leer el valor de la columna sólo una vez. Tanto el nombre de la columna como el número de esta puede ser usado para designar la columna de la cual se quiere obtener el valor. Si en el ejemplo anterior la columna “a” es de tipo entero, la “b” del tipo cadena de caracteres y la “c” de tipo coma flotante, la siguiente porción de código imprimiría los valores de todos los registros:

while(resul.next()){
int i = resul.getInt(“a”);
String s = resul.getString(“b”);
Float f = resul.getFloat(“c”);
System.out.println(“FILA= ” + i + ” ” + s + ” ” + f);
}

o lo que es lo mismo

while(resul.next()){
int i = resul.getInt(1);
String s = resul.getString(2);
Float f = resul.getFloat(3);
System.out.println(“FILA= ” + i + ” ” + s + ” ” + f);
}

En la tabla que sigue se muestra el método adecuado para recuperar los distintos tipos de datos,

Métodos relacionados con el cursor de ResultSet

El conjunto de datos ResultSet y hoja de datos en el caso de que el tipo no sea ResultSet.TYPE_FORWARD_ONLY, podemos mover el cursor por el conjunto de datos con diferentes métodos:

resul.first(), moverá el cursor al principio.

resul.last(), moverá el cursor al final.

resul.beforeFirst(), moverá el cursor antes del principio.

resul.afterLast(), moverá el cursor después del final.

resul.absolute (int num), moverá el cursor al número de fila indicado en su argumento entero. Si el número es positivo, el cursor se mueve al número dado desde el principio, y así absolute(1) pone el cursor en la primera fila. Si el número es negativo, mueve el cursor al número dado desde el final, por eso llamar a absolute(-1) pone el cursor en la última fila.

resul.next() mueve el cursor a la fila siguiente.

resul.previous, mueve el cursor a la fila anterior.

Otros métodos de ResultSet.

resul.getRow() permite comprobar el número de fila donde está el cursor.

resul.isFirst, resul.isLast, resul.isBeforeFirst(), resul.isAfterLast() devuelven true si el cursor se encuentra en la posición indicada por el método, en caso contrario false.

La mayor parte de las operaciones que nos proporciona el API JDBC lanzarán la excepción java.sql.SQLException en caso de que se produzca algún error en el acceso a la base de datos (por ejemplo: errores en la conexión, sentencias SQL incorrectas, falta de privilegios,…). Por este motivo es necesario dar un tratamiento adecuado a estas excepciones y encerrar todo el código JDBC entre bloques try/catch.

// Informamos al usuario de los errores SQL que se han producido
System.out.println(“SQL Exception: “ + se.getMessage());
se.printStackTrace(System.out);

5.-Cerrar.

Es necesario cerrar adecuadamente la sentencia el ResultSet y la conexión.

senten.close();

resul.close();

con.close();

Conviene recordar:

El mecanismo de funcionamiento básico JDBC,

Establecer conexión: Class.forName(“…”)  y DriverManager.getConnection

Crear sentencia: Statement senten = connexion.createStatement();

Ejecutar sentencia: executeUpdate o executeQuery.

Procesar resultados: while, resul.first(), resul.last(), resul.beforeFirst(), resul.afterLast(), resul.absolute (int num), resul.next(), resul.previous, resul.getRow().

Cerrar: sentencia.close(), resultados.close(), conexion.close();

Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);

Mientras que la cadena de conexión necesaria para crear el objeto connection será,

String bd = “jdbc:odbc:Driver={Microsoft Access Driver (*.mdb)};DBQ=H:/DSNPruebas.MDB”;
con = DriverManager.getConnection(bd, “admin”, “admin”);

Vea que ahora no es necesario especificar Un DSN (Origen de datos), estaríamos en el caso de conexión directa o dinámica.

EJERCICIO1:

Repita el ejercicio1 indicado en el Tutorial de JSP (19) realizando estos cambios convenientemente.

EJERCICIO2:

Realizaremos ahora un nuevo ejercicio para manejar la base de datos creada en MsAcces de USDA National Nutrient. Esta base de datos denominada “sr23.MDB” contiene una tabla de nutrientes denominada “ABBREV”, alguno de los cuales contiene azúcar y lo que pretendemos es listarlos ordenados desde mayores cantidades de azúcar a menores.

Es decir buscamos una instrucción SQL que responda a,

SELECT ABBREV.NDB_No, ABBREV.Shrt_Desc, ABBREV.Sugar_Tot FROM ABBREV WHERE (((ABBREV.Sugar_Tot)>0)) ORDER BY ABBREV.Sugar_Tot DESC;

donde:

ABBREV.NDB_No, es el código o identificativo del nutriente.

ABBREV.Shrt_Desc, es la descripción del nutriente

ABBREV.Sugar_Tot, es la cantidad total de Azúcar que contiene el nutriente.

Es decir la página tendrá que mostrar

Tal como puede verse la página muestra inicialmente los 20 primeros registros, existiendo un sistema de paginación que permite recorrer el conjunto completo de registros.

Para resolver el problema necesitamos una página index.jsp con un código igual al que se indica seguidamente:

Se requiere igualmente de un paquete al que hemos denominado “pbd” y dentro de él una clase a la que llamamos “claseBD” con el siguiente código,

Existiendo ODBC drivers oportuno, éste puede utilizarse para aplicaciones Java por medio de el puente JDBC-ODBC proporcionado por Sun. Usar el puente JDBC-ODBC no es una solución ideal dado que:

1. Requiere de la instalación de drivers ODBC y entradas de registro.
2. Los drivers ODBC a su vez son implementados nativamente lo que compromete el soporte multiplataforma.

El puente es por si mismo un driver basado en tecnología JDBC que está definida en la clase sun.jdbc.odbc.JdbcOdbcDriver.

El puente JDBC-ODBC debe ser considerado como una solución transitoria. Con el desarrollo de drivers puros en Java, el puente se volverá innecesario.

Lo ideal es “Java Puro” y por ello, no al código nativo y no a las características de plataforma dependiente. Sin embargo puede utilizarse si se requiere desarrollar de forma rápida sin necesidad de esperar a que el fabricante de la base de datos utilizada proporcione el driver JDBC. Los drivers parcialmente nativos, como el puente JDBC-ODBC, le permite crear programas que pueden fácilmente ser adaptados a drivers puros en Java tan pronto como estén disponibles.

En términos de programación JDBC, el manejar ODBC obliga, a parte de definir un DSN (fuente de datos), a utilizar un driver especial, se trata de

Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);

Mientras que la cadena de conexión necesaria para crear el objeto connection será,

con = DriverManager.getConnection(“jdbc:odbc:DNSPruebas”, “root”, “root”);

este driver es específico, así como tasmbién lo es para cada una de las distintas bases de datos arriba enumeradas.

EJERCICIO1:

Vamos a realizar un ejercicio sencillo con MsAccess vía ODBC. Se tratará de crear una tabla en una base de datos ya existente y asociada a un DSN (o fuente de datos) al que llamaremos DNSPruebas, también crearemos una tabla e insertaremos varios registros.

Comenzaremos creando la base de datos, para ello abrimos una sesión de MsAccess y creamos la base de datos vacía denominada “DNSPruebas”,

Inmediatamente después creamos el DSN denominado DSNPruebas, para ello vamos al panel de control Windows y hacemos click sobre Herramientas Administrativas, es decir,

y después hacemos click en orígenes de Datos (ODBC),

aparecerá

Seleccionamos la pestaña “DNS de Sistema” y hacemos “Agregar”,

Seleccionamos el driver correspondiente a “Microsoft Access”, y hacemos Finalizar,

Nombramos el origen de datos como “DNSPruebas” y seleccionamos la base de datos DNSPruebas creada con anterioridad,

Aceptamos y finalmente,

Abrimos ahora una sesión de NetBeans y generamos un nuevo proyecto al que podríamos llamar “jdbc_odbc_msaccess_dsn”. Cuando aparezca la plantilla del index.jsp sustituimos el código por el siguiente otro:

Consideraciones:

1.-Vea que tenemos dos bloques try …catch, el primero de ellos controla y supervisa los errores de clase no encontrada y posibles errores en la creación del objeto connection. Pruebe, provocando un error intencionado este bloque.

2.-El segundo bloque try … catch controla las operaciones de creación de la tabla, las inserciones de registros y la instrucción select. Pruebe a provocar un error intencionado.

3.-Ensaye eliminar la tabla con la instrucción del sql “delete”.

Esta técnica permite al cliente ciertas ventajas:

Identificar a un usuario durante una sesión de comercio electrónico:
Si alguna vez ha utilizado un carrito de compras (Shopping Cart), habrá notado que cuando selecciona un ítem, lo añade a su carrito. Dado que las conexiones HTTP se cierran después de que cada pagina se envía, cuando el usuario selecciona un nuevo ítem para su carrito, ¿como sabe el sistema de tienda virtual que ese usuario que acaba de conectar de nuevo ya tiene iniciada una compra con uno o mas item en su carrito?… las cookies.

Evitar la autentificación constantemente:
Muchos sitios web grandes, requieren un registro para utilizar sus servicios (Twitter, SlideShare, Facebook, Yahoo! Mail, etc), sería un grave inconveniente, que cada vez que el usuario realiza una acción (cambiar de página por ejemplo) se pregunte constantemente por el usuario y la contraseña a un usuario si ya se ha autentificado al ingresar por primera vez. Las cookies permiten evitar esto.

Personalizar un sitio:
iGoogle es un ejemplo perfecto de la personalización de un sitio. iGoogle, entre otras cosas, usa una cookie para “recordar” que widgets le agregaste, cuantas pestañas tienes, etc…

Publicidad personalizada:
Un motor de búsqueda, como Google, puede mantener una pista de las preferencias de un usuario a lo largo del tiempo, de esta forma, la publicidad que se le muestra a ese usuario, estará enfocada a sus preferencias de búsqueda.

¿Y la seguridad?…

Las cookies no se “interpretan” o ejecutan en un sistema, por lo que no se puede insertar virus en ellas para comprometer la integridad del sistema. Los navegadores, generalmente sólo aceptan 20 cookies por sitio, además un navegador nunca poseerá más de 300 cookies en total, y cada cookie esta limitada a un tamaño de 4 KB, así que no se pueden usar para llenar el disco duro de un cliente (especialmente con el tamaño de los discos duros modernos).

Sin embargo, aunque las cookies no presentan una amenaza a la seguridad, si pueden presentar una seria amenaza a la privacidad. Pero más que culpa de la cookie en si, los problemas de privacidad radican en programadores con prácticas poco seguras.

El funcionamiento esquemático de las cookies es el siguiente:

Las cookies en Java son objetos de la clase Cookie que se encuentra en el paquete javax.servlet.http

Conviene recordar:

A)No utilizar caracteres tales como []()=,”"/?@:; o espacios en blanco.

B)Las cookies hay que enviarlas al cliente en la cabecera de la respuesta y por tanto es necesario no haber escrito absolutamente nada en el cuerpo del mensaje previamente.

Ejemplo:

En este ejemplo vamos a

1.-Crear un objeto cookie a partir de la clase Cookie con

Cookie Galleta = new Cookie(NomCookie, ValCookie);

donde “NomCookie” será el nombre de la cookie y “ValCookie” será el valor asociado a esta cookie.

2.-Vamos a fijar su fecha de caducidad/expiración por medio del método,

Galleta.setMaxAge(1*365*24*60*60); //Expira dentro de un año.

Galleta.setMaxAge(-1); //Expira al finalizar la sesión del cliente/navegador.

3.- Vamos a eliminar una cookie haciendo que su expiración sea cero, con

Galleta.setMaxAge(0); //El cliente/navegador eliminará la cookie en la siguiente llamada.

4.- Vamos a limitar el directorio donde se encuentra la página jsp o servlet que tendrá acceso a las cookies, con

Galleta.setPath(“/”); //Directorio por defecto desde donde se capturarán las cookies.

3.-Vamos a enviar esta cookie al solicitante de la página a través del objeto implícito response con

response.addCookie(Galleta);

5.-Vamos a recuperar todas las posibles cookies almacenadas en el cliente con,

Cookie[] galleta = request.getCookies(); //Recuperar todas las cookies

Cookie[] galleta = request.getCookies(“kuki”); //Recuperar una cookies llamada kuki

Para ello inicie una nuevo proyecto en el IDE NetBeans y llámelo por ejemplo, GestionCookies, sustituya la plantilla de index.jsp por el siguiente código

este código genera un formulario en la forma,

Como puede verse, existen cuatro botones tipo “submit” asociados al mismo identificador o “name”, los cuatro tienen valores (value) distintos, a saber: Crear, Visualizar, Modificar y Eliminar. Es precisamente este botón quien determinará el bloque de código que es necesario ejecutar para resolver los cuatro procesos.

Puede verse también en index.jsp, que capturamos un parámetro llamado “men” que envían cada uno de los procesos anteriores para informar que se ha ejecutado con éxito o que no ha podido realizarse la operación. Y así, aparecerán mensajes tales como:

A) En el caso  “Crear” cookie (se necesita el nombre y el valor, que no están comprobados, aunque no habría técnicamente ningún problema en crear un cookie sin nombre y sin valor), aparecerá en el caso favorable el mensaje por ejemplo

Creada cookie JuanTagua con valor 2010

B) En el caso  “Visualizar”  cookies (No se necesita ni el nombre ni el valor), aparecerá, por ejemplo,

En la pantalla anterior podemos ver la cookie que se genera automáticamente en cada sesión en JSP además de la cookie generada anteriormente en la opción anterior.

C) En el caso  “Modificar” cookie (se necesita el nombre y el nuevo valor al que se desea modificar la cookie), aparecerá en el caso favorable el mensaje por ejemplo,

Modificada cookie JuanTagua

y en el caso de que no exista la cookie cuyo valor se desea modificar, aparecerá

No ha podido modificarse la cookie porque no existe.

D) En el caso  “Eliminar” cookie (se necesita el nombre de la cookie que se quiere eliminar), aparecerá en el caso favorable el mensaje por ejemplo,

Eliminada la cookie JuanTagua

y en el caso de que no exista la cookie que se desea eliminar, aparecerá

No ha podido modificarse la cookie porque no existe.

Finalmente, cualquiera que sea la opción elegida, tal como puede ver en la etiqueta <form …, siempre se reenvía el formulario a la página GestionCookie.jsp que es la encargada de realizar las operaciones pertinentes.

El código de GestiónCookie.jsp, es el siguiente:

Consideraciones Finales:

Se deja al lector, como ejercicio,

1.-Que controle la existencia o no de entrada tanto en la caja de texto Nombre como en Valor de la cookie según los casos.

Buscar una cookie en el navegador Firefox:

• Abra el navegador Firefox. Seleccione Herramientas y luego Opciones en el menú del programa. Elija la pestaña Privacidad. Localice la parte del panel titulado “eliminar cookies de forma individual”.

• Introduzca en la caja de texto “Buscar” el dominio que envió la cookie. Si está desarrollando un proyecto jsp o servlet escriba “localhost”.

• Ver las cookies individual obtenida por dominio pulsando el signo + junto al nombre del sitio web y su carpeta. Algunas cookies tienen nombres fácilmente identificables, mientras que otras son una serie de letras al azar, números y símbolos.

• Compruebe el nombre, Valor/contenido, Servidor, Ruta/path y fecha de expiración de la cookie seleccionada.

request, Tiene un ámbito relativo a la petición, y es una instancia de la clase javax.servlet.ServletRequest. Representa la petición del cliente, proporciona entre otras informaciones, los parámetros recibidos del cliente vía formulario o url, el tipo de petición (GET/POST), etc.

response, Tiene un ámbito relativo a la pagina, y es una instancia de javax.servlet.ServletResponse. Encapsula la respuesta generada por la página JSP o servlet que será enviada al cliente en respuesta a su solicitud

session, Instancia de javax.servlet.http.HttpSession, permite acceder a la sesión para leer/escribir datos en ella. En JSP se crea siempre una sesión de trabajo por defecto, para que esto no sea así tendrá que ser específicamente indicado con el atributo session de la directiva page.

out, Instancia de javax.servlet.jsp.JspWriter, este objeto permite escribir la respuesta o parte de ella, en HTML, como resultado de la petición del cliente.

Objeto response

Los métodos más utilizados son:

• setContentType(): se utiliza para establecer el tipo MIME y la codificación de caracteres de la página.
• addCookie (cookie Cookie): se utiliza para agregar una nueva cookie a la respuesta.
• setHeader (String nombre, String value):
• sendRedirect (String): Se utiliza para reenviar la petición a otra url o servlet.
• sendError (status_code int): Se utiliza para enviar como respuesta un error usando un estado específico.

public void setContentType(java.lang.String type)

Parámetros:

type – Una cadena que especifica el tipo MIME del contenido.

MIME, (Multipurpose Internet Mail Extensions) es un standard en Internet que determina el tipo de mensaje o contenido como respuesta a una petición HTTP vía web. Estos contenidos pueden contener textos, imágenes, audio, video y otros datos específicos de aplicaciones.

La directiva page de una página JSP especifica este valor sin embargo pudiera cambiarse dentro de un scriptlet o en un servlet, sin mas que

response.setContentType(“text/plain”);

public void addCookie( Cookie cookie)

Parámetros:

cookie – Nombre de la Cookie que se enviará al cliente.

Este método añade una cookie específica a la respuesta. Puede ser llamado en repetidas ocasiones para añadir varias cookies.

(Este método será analizado mas adelante, cuando tratemos específica las cookies y las sesiones). Es importante señalar que para enviar una cookie al cliente desde una página Jsp o un servlet, esta tarea se recomienda que ser anterior al envío de ninguna otra información html.

void setHeader (java.lang.String name, java.lang.String value)

Parametros:

name – Nombre del parámetro de cabecera.

value – Valor asignado al parámetro de cabecera.

Este método permite escribir una parte de la cabecera de la página a devolver indicando el parámetro y el valor

Ejemplo 1:

Por ejemplo, existe la posibilidad de refrescar una página de forma periódica cada cierto tiempo, esto puede hacerse con

response.setHeader(“Refresh”, “5″);

con este método podemos refrescar una página cada 5 segundos aproximadamente.

Inicie una sesión del IDE de NetBeans y haga proyecto nuevo, llame a este proyecto por ejemplo, setHarder_refresh y sustituya la plantilla del index.jsp por el siguiente código,

La ejecución del la página producirá la siguiente salida,

void sendRedirect (java.lang.String location)

Parámetros:

location – URL de la redirección.

Este método se utiliza para reenviar la petición a otra url o servlet. La sintaxis es,

la sintaxis anterior, en determinados casos, aquellos en los que tuviéramos que trasladar el identificador de sesión a la nueva página de destino habría que utilizarla con otro formato. Tendríamos que utilizar,

De esta manera garantizamos que se transmita al nuevo destino el identificador de sesión.

void sendError(int sc, java.lang.String msg)

Parametros:

sc – Código de estado del error.

msg – Mensaje

Este método envía como respuesta un error usando un estado específico.

Por ejemplo, si cierta página jsp debe recibir un parámetro necesariamente el siguiente scriplet enviaría al cliente un error

Consideraciones a recordar:

Concepto, sintaxis y uso del objeto response.

Uso de los métodos del objeto response: setContentType(),  addCookie, setHeader, sendRedirect, sendError.