TEMA 1 ACCESO A BASE DE DATOS 1. QUE ES UN JDBC –...

Unidad IV: Acceso A Base De Datos Mediante Jdbc- Odbc ________________________________________________________________________________________

TEMA 1 ACCESO A BASE DE DATOS

1. QUE ES UN JDBC – ODBC? JDBC es la API estándar de acceso a Bases de Datos con Java, y se incluye con el Kit de Desarrollo de Java (JDK) a partir de la versión 1.1. Sun optó por crear una nueva API, en lugar de utilizar APIs ya existentes, como ODBC, con la intención de obviar los problemas que presenta el uso desde Java de estas APIs, que suelen ser de muy bajo nivel y utilizar características no soportadas directamente por Java, como punteros, etc. Aunque el nivel de abstracción al que trabaja JDBC es alto en comparación, por ejemplo, con ODBC, la intención de Sun es que sea la base de partida para crear librerías de más alto nivel, en las que incluso el hecho de que se use SQL para acceder a la información sea invisible. Para trabajar con JDBC es necesario tener controladores (drivers) que permitan acceder a las distintas Bases de Datos: cada vez hay más controladores nativos JDBC. Sin embargo, ODBC es hoy en día la API más popular para acceso a Bases de Datos: Sun admite este hecho, por lo que, en colaboración con Intersolv (uno de principales proveedores de drivers ODBC) ha diseñado un puente que permite utilizar la API de JDBC en combinación con controladores ODBC. Algunos fabricantes, como Microsoft, ofrecen sus propias APIs, en lugar de JDBC, como RDO, etc. Aunque estas APIs pueden ser muy eficientes, y perfectamente utilizables con Java, su uso requiere tener muy claras las consecuencias, sobre todo la pérdida de portabilidad, factor decisivo en la mayor parte de los casos para escoger Java en lugar de otro lenguaje. JDBC es un API de Java que permite que programas en Java ejecuten comandos SQL, permitiendo esto que los programas puedan usar bases de datos en ese esquema. Dado que casi todos los sistemas de administración de bases de datos relacionales (DBMS) soportan SQL(Structured Query Language), y que Java corre en la mayoría de las plataformas, JDBC hace posible escribir una sóla aplicación de base de datos que pueda correr en diferentes plataformas e interactuar con distintos DBMS. La conectividad de la base de datos de Java (JDBC) es un marco de rogramación para los desarrolladores de Java que escriben los programas que tienen acceso a la informAción guardada en bases de datos, hojas de calculo, y archivos "planos". JDBC se utiliza comúnmente para conectar un programa del usuario con una base de datos por “detrás de la escena”, sin importar qué software de administración o manejo de base de datos se utilice para controlarlo. De esta manera, JDBC es una plataforma-cruzada. El acceso a la base de datos de los programas de Java

________________________________________________________________________________________ Proyecto de Software 101


utilizan las clases JDBC API, que está disponible para la transferencia directa libre del sitio de Sun. Los puentes de JDBC-ODBC se han creado para permitir que los programas de Java conecten con el software compatible ODBC de la base de datos. JDBC no sólo provee un interfaz para acceso a motores de bases de datos, sino que también define una arquitectura estándar, para que los fabricantes puedan crear los drivers que permitan a las aplicaciones java el acceso a los datos. Sun define JDBC como: “The JDBC API is the industry standard for database-independent connectivity between the Java programming language and a wide range of databases.” 2. FILOSOFIA Y OBJETIVOS DE JDBC Algunas características son:

• API A NIVEL SQL. JDBC es un API de bajo nivel, es decir, que está orientado a permitir ejecutar comandos SQL directamente, y procesar los resultados obtenidos. Esto supone que será tarea del programador crear APIs de más alto nivel apoyándose directamente sobre JDBC.

• COMPATIBLE CON SQL. Cada motor de Base de Datos implementa una

amplia variedad de comandos SQL, y muchos de ellos no tienen porque ser compatibles con el resto de motores de Base de Datos. JDBC, para solventar este problema de incompatibilidad, ha tomado la siguiente posición:

o JDBC permite que cualquier comando SQL pueda ser pasado al driver

directamente, con lo que una aplicación Java puede hacer uso de toda la funcionalidad que provea el motor de Base de Datos, con el riesgo de que esto pueda producir errores o no en función del motor de Base de Datos.

o Con el objetivo de conseguir que un driver sea compatible con SQL (SQL compliant), se obliga a que al menos, el driver cumpla el Estándar ANSI SQL 92.

• JDBC debe ser utilizable sobre cualquier otro API de acceso a Bases de Datos, o más en particular ODBC (Open Database Connectivity)

• JDBC debe proveer un interfaz homogéneo al resto de APIs de Java.

• JDBC debe ser un API simple, y desde ahí, ir creciendo.



• JDBC debe ser fuertemente tipado, y siempre que sea posible de manera estática, es decir, en tiempo de compilación, para evitar errores en tiempo de ejecución.

• JDBC debe mantener los casos comunes de acceso a Base de Datos

lo más sencillo posible: o Mantener la sencillez en los casos más comunes (SELECT, INSERT,

DELETE y UPDATE). o Hacer realizables los casos menos comunes: Invocación de

procedimientos almacenados. • Crear múltiples métodos para múltiple funcionalidad. JDBC ha preferido

incluir gran cantidad de métodos, en lugar de hacer métodos complejos con gran cantidad de parámetros.




CONTROLADORES JDBC 1. LOS CONTROLADORES Los controladores (conectores o drivers) JDBC proveen clases que implementan la interfaz JDBC. JDBC define cuatro tipos de controladores, y cada una tiene una mezcla variada de ejecutables sistema operativo dependientes y código de Java como se indica a continuación: Tipo 1. JDBC-ODBC bridge más driver ODBC: “BRIDGE” Permite el acceso a Base de Datos JDBC mediante un driver ODBC. Cada máquina cliente que use el puente, debe tener librerías clientes de ODBC(dll propias del S.O).

• Ventajas: Buena forma de aprender JDBC. También puede ser buena idea usarlo, en sistemas donde cada máquina cliente tenga ya instalado los drivers ODBC. También es posible que sea la única forma de acceder a ciertos motores de Bases de Datos.

• Inconvenientes: No es buena idea usar esta solución para aplicaciones que

exijan un gran rendimiento, ya que la transformación JDBC-ODBC es costosa. Tampoco es buena solución para aplicaciones con alto nivel de escalabilidad.

Tipo 2. Driver Java parciales: “NATIVE” Traducen las llamadas al API de JDBC Java en llamadas propias del motor de Base de Datos (Oracle, Informix...). Al igual que el tipo anterior, exige en las máquinas clientes código binario propio del cliente de la Base de datos específica y del sistema operativo.

• Ventajas: Mejor rendimiento que el anterior. Quizá puede ser buena solución para entornos controlados como intranets. Ejemplo OCI oracle.

• Inconvenientes: Principalmente la escalabilidad, ya que estos drivers exigen

que en la máquina cliente librerías del cliente de la Base de Datos. Tipo 3. Driver JDBC a través de Middleware: “NETWORK” Traduce las llamadas al API JDBC en llamadas propias del protocolo específico del broker. Éste se encargará de traducirlas de nuevo en sentencias propias del motor de Base de Datos de cada caso.

• Ventajas: Buena solución cuando necesitamos acceder a Bases de Datos distintas y se quiere usar un único driver JDBC para acceder a las mismas.



Al residir la traducción en el servidor del middleware, los clientes no necesitan librerías específicas, tan solo el driver.

• Inconvenientes: La desventaja principal reside en la configuración del servidor donde se encuentra el middleware. Necesitará librerías específicas para cada motor de base de datos distinto, etc.

Tipo 4: Driver java puro (acceso directo a Base de Datos): “THIN” Convierte o traduce las llamadas al API JDBC en llamadas al protocolo de red usado por el motor de bases de datos, lo que en realidad es una invocación directa al motor de bases de datos.

• Ventajas: 100 % portable. Buen rendimiento. El cliente sólo necesita el driver.

• Inconvenientes: Al ser independiente de la plataforma, no aprovecha las

características específicas del S.O. 2. INSTALACION DE JDBC El proceso de instalación de JDBC se podría dividir en tres partes distintas: Descargar el API de JDBC JDBC viene incluido en el corazón de la plataforma Java, tanto en la J2SE como en la J2EE.

http://java.sun.com/products/jdbc/download.html Instalar el driver en la máquina cliente (máquina que crea las conexiones) La instalación del driver dependerá en gran medida del tipo de driver que hayamos seleccionado. Para los tipo 1 y 2, además de las librerías del driver, necesitaremos ciertas librerías propias del cliente del motor de base de datos que estemos usando y quizá ficheros de configuración. Para el tipo 3, en la máquina cliente tan solo necesitaremos el driver. En el servidor donde resida el middleware, necesitaremos drivers específicos de cada motor de base de datos y en su caso, librerías propias del cliente del motor de base de datos. Para el tipo 4, tan solo necesitaremos el driver.


http://java.sun.com/products/jdbc/download.html


Instalar el controlador o motor de base de datos Evidentemente, necesitaremos tener instalado un motor de base de datos. Esta instalación será distinta en función de la Base de Datos y del S.O. donde vaya a correr. 3. ARQUITECTURAS JDBC La arquitectura básica de JDBC es simple. Una clase llamada DriverManager provee un mecanismo para controlar un conjunto de drivers JDBC. Esta clase intenta cargar los drivers especificados en la propiedad del sistema jdbc.drivers. También podemos cargar un driver explicitamente usando Class.forName(). Durante la carga, el driver intentará registrarse a si mismo usando el método clase DriverManager.registerDriver(). Cuando se invoque al método driverManager.getConnection(), ésta buscará el primer driver de los registrados que pueda manejar una conexión como la descrita en la URL y retornará un objeto que implemente el interfaz java.sql.Connection. Sin embargo, en función de la localización de la base de datos, el driver, la aplicación y el protocolo de comunicación usado, nos podemos encontrar distintos escenarios que accedan a Base de Datos a través de JDBC:

1. Aplicaciones standalone 2. Applets comunicando con un servidor Web 3. Aplicaciones y applets comunicando con una base de datos a través de un

puente JDBC/ODBC. 4. Aplicaciones accediendo a recursos remotos usando mecanismos como

Java RMI. Todos ellos se pueden agrupar en dos tipos distintos de arquitecturas: Arquitecturas JDBC en dos capas La aplicación que accede a la base de datos reside en el mismo lugar que el driver de la base de datos. El driver accederá al servidor donde corra el motor de base de datos. En este caso, será el driver el encargado de manejar la comunicación a través de la red. En el ejemplo, una aplicación java corriendo en una máquina cliente que usa el driver también local. Toda la comunicación a través de la red con la base de datos será manejada por el driver de forma transparente a la aplicación Java. Arquitecturas JDBC en tres capas Una aplicación o applet corriendo en una máquina y accediendo a un driver de base de datos situado en otra máquina. Ejemplos de esta situación:



1. Un applet accediendo al driver a través de un Web Server 2. Una aplicación accediendo a un servidor remoto que comunica localmente

con el driver 3. Una aplicación comunicando con un servidor de aplicaciones que accede a

la base de datos por nosotros. 4. PASOS PARA EL ACCESO DE BASE DE DATOS CON JDBC Lo primero que tenemos que hacer es asegurarnos de que disponemos de la configuración apropiada. Esto incluye los siguientes pasos.

1. Instalar Java y el JDBC en nuestra máquina. Para instalar tanto la plataforma JAVA como el API JDBC, simplemente tenemos que seguir las instrucciones de descarga de la última versión del JDK (Java Development Kit). Junto con el JDK también viene el JDBC.. El código de ejemplo de desmostración del API del JDBC 1.0 fue escrito para el JDK 1.1 y se ejecutará en cualquier versión de la plataforma Java compatible con el JDK 1.1, incluyendo el JDK1.2. Teniendo en cuenta que los ejemplos del API del JDBC 2.0 requieren el JDK 1.2 y no se podrán ejecutar sobe el JDK 1.1.

2. Instalar un driver en nuestra máquina. Nuestro Driver debe incluir instrucciones para su instalación. Para los drivers JDBC escritos para controladores de bases de datos específicos la instalación consiste sólo en copiar el driver en nuesta máquina; no se necesita ninguna configuración especial. El driver "puente JDBC-ODBC" no es tan sencillo de configurar. Si descargamos las versiones Solaris o Windows de JDK 1.1, automáticamente obtendremos una versión del driver Bridge JDBC-ODBC, que tampoco requiere una configuración especial. Si embargo, ODBC, si lo necesita. Si no tenemos ODBC en nuestra máquina, necesitaremos preguntarle al vendedor del driver ODBC sobre su instalación y configuración.

3. Instalar nuestro Controlador de Base de Datos si es necesario. Si no tenemos instalado un controlador de base de datos, necesitaremos seguir las instrucciones de instalación del vendedor. La mayoría de los usuarios tienen un controlador de base de datos instalado y trabajarán con un base de datos establecida.



4.1 Procedimiento de conexión y acceso a datos con JDBC Consideraciones previas El proceso de acceso a una Base de Datos a través de JDBC, exige dar una serie de pasos previos antes de crear la conexión al motor de Base de Datos. El primer paso es determinar el entorno en el que el proyecto va a ser instalado, y más en concreto, que parámetros del entorno afectan directamente a JDBC: ¿ Qué motor de Base de Datos vamos a usar ? Debemos considerar las características específicas de una base de datos, como por ejemplo, como mapear los tipos de datos SQL a Java. ¿ Qué driver vamos a usar ? Es probable encontrarnos varios drivers distintos para la misma fuente de datos. Debemos saber detectar cual es el driver más adecuado para nuestra aplicación, por ejemplo, si elegimos un driver ODBC/JDBC, tendremos más flexibilidad para elegir distintas fuentes de datos, pero si por ejemplo trabajamos con una Base de Datos Oracle, un driver JDBC diseñado específicamente para esta base de datos será mucho más eficiente. ¿ Donde estará localizado el driver ? En función de donde se encuentre el driver físicamente, debemos considerar aspectos de rendimiento y seguridad. Por ejemplo, si cargamos el driver desde un servidor remoto tendremos que considerar aspectos sobre seguridad de Java. 4.2 Procedimiento de conexión El procedimiento de conexión con el controlador de la base de datos, independientemente de la arquitectura es siempre muy similar.

1. Cargar el driver. Cualquier driver JDBC, independientemente del tipo debe implementar el interfaz java.sql.Driver. La carga del driver se puede realizar de dos maneras distintas:

• Definiendo los drivers en la variable sql.driver (variable que mantiene

todos las clases de los drivers separados por comas) Cuando la clase DriverManager se inicializa, busca esta propiedad en el sistema.

• El programador puede forzar la carga de un driver específico, usando el

método Class.forName(driver).

2. Registro del driver. Independientemente de la forma de carga del driver que llevemos a cabo, será responsabilidad de cada driver registrarse a sí mismo, usando el método DriverManager.registerDriver. Esto permite a la clase DriverManager, usar cada driver para crear conexiones con el



controlador de Base de Datos. Por motivos de seguridad, la capa que gestiona JDBC, controlará en todo momento que driver es el que se está usando, y cuando se realicen conexiones, sólo se podrán usar drivers que estén en el sistema local de ficheros o que usen el mismo ClassLoader que el código que está intentando crear la conexión.

En el primero de los casos (a través de la propiedad sql.driver), JDBC usará el primer driver que permita conectarse correctamente a la Base de Datos. Crear una conexión. El objetivo es conseguir un objeto del tipo java.sql.Connection a través del método driverManager.getConnection(String url). La capa de gestión, cuando este método es invocado, tratará de encontrar un driver adecuado para conectar a la base de datos especificada en la URL, intentándolo por el orden especificado en la variable sql.driver. Cada driver debería examinar si ellos proveen el “subprotocolo” que especifica la URL. JDBC provee un mecanismo para permitir nombrar las bases de datos, para que los programadores puedan especificar a que base de datos desean conectarse. Este sistema debe tener las siguientes características:

• Drivers de diferentes tipos pueden tener diferentes formas de nombrar las bases de datos.

• Este sistema de nombrado debe ser capaz de acoger diversos parámetros de configuración de la red.

• Debería ser capaz de acoger cierto nivel de indirección, para que los nombres pudiesen ser resueltos de alguna manera (DNS...)

• URL. Estas características están ya estandarizadas en el concepto de URL. JDBC recomienda la siguiente estructura de nombrado de bases de datos: jdbc:<subprotocol>:<subname>

♦ jdbc: parte fija ♦ subprotocol: mecanismo particular se acceso a base de datos ♦ subname: dependerá del subprotocolo. JDBC recomienda seguir

también la convención de nombrado URL: //hostname:port/subsubname

• El subprotocolo odbc: Este subprotocolo ha sido reservado para aquellos

que quieran seguir la convención ODBC para nombrado de bases de datos: jdbc:odbc:<data-source-name>[;<attribute-name>=<attribute-value>]

• El API JDBC, también provee la posibilidad de pasar una lista de propiedades para crear la conexión: DriverManager.getConnection(String URL, Properties props); Dos propiedades definidas por convención son

• user • password




LA API DE JDBC Pasamos en este punto a dar una breve descripción de cada una de las interfaces y clases que componen el paquete java.sql. 1. INTERFACES Driver Es la interfaz que deben implementar todos los controladores JDBC en alguna de sus clases. Cuando se cargue una clase Driver, ésta creará una instancia de sí misma que se registrará posteriormente mediante el administrador de controladores.

Connection Representa una sesión de trabajo con una base de datos. Sus métodos, aparte de permitir modificarla y consultar sus tablas, también permiten obtener información sobre su estructura. Statement Mediante esta interfaz, se envían las órdenes SQL individuales a la base de datos a través del controlador JDBC y se recogen los resultados de las mismas.

ResultSet Mediante esta interfaz, se organizan en tablas los resultados de las órdenes SQL. Las filas deben leerse una detrás de otra, pero las columnas pueden leerse en cualquier orden. ResultSetMetaData Contiene información sobre las columnas de los objetos ResultSet. PreparedStatement Los objetos PreparedStatement contienen órdenes SQL precompiladas que pueden por tanto ejecutarse muchas veces. CallableStatement Los objetos CallableStatement se emplean para ejecutar procedimientos almacenados. DatabaseMetaData Contiene diversa, y abundantísima, información sobre la base de datos. Algunos de sus métodos devuelven los resultados como tablas ResultSet, y pueden tratarse como éstos.



Clases DriverManager Contiene métodos para trabajar con un conjunto de controladores JDBC. Types Define una serie de constantes usadas para identificar los tipos de datos SQL. Time Esta clase añade a la clase Date del paquete java.util los métodos y características para trabajar con cláusulas de escape JDBC identificándolo como un tipo TIME de SQL. Date Esta clase añade a la clase Date del paquete java.util los métodos y características para trabajar con cláusulas de escape JDBC como un tipo DATE de SQL. Timestamp Esta clase añade a la clase Date del paquete java.util los métodos y características para trabajar con cláusulas de escape JDBC identificándolo como un tipo TIMESTAMP de SQL. DriverPropertyInfo Contiene métodos para averiguar y trabajar con las propiedades de los controladores JDBC. SQLException Proporciona diversa inmformación acerca de los errores producidos durante el acceso a una base de datos. SQLWarning Contiene información sobre los avisos que se producen durante el trabajo con una base de datos. Los avisos se encadenan al objeto que los provocó. 2. INSTRUCCIONES SQL En JDBC existen dos formas principales de ejecutar y crear sentencias SQL, la primera es usando un Statement, y la segunda es creando un PreparedStatement. Statement Fue la primera manera de enviar sentencias SQL usando java, este método está cada vez más en desuso, ya que no protege ante la inyección de código SQL. La forma de usarlo seria la siguiente:



Statement stmt = con.createStatement(); String condicion="nombre='"+nombreDeLaWeb+"' AND pass='"+passDeLaWeb+"'";//Creamos la sentencia SQL String sqlSelect = "SELECT * FROM tabla WHERE "+condicion; //Ejecutamos la sentencia SQL stmt.executeQuery(sqlSelect); Nota:Observeseque sipassDeLaWebes = “' OR '1'='1 ”tendríamos una un fallo en la seguridadde la aplicación ya que tendría acceso sin saber la contraseña. PreparedStatement Es otra forma de crear sentencias SQL, esta forma evita la inyección y si la sentencia es más larga se entiende mejor. La forma de usarlo es la siguiente: //Creamos la sentencia SQL String sqlSelect = "SELECT * FROM tabla WHERE nombre=? AND pass=?";//Ejecutamos la sentencia SQL PreparedStatement ps = con.createPreparedStatement(sqlSelect); ps.setString(1,nombreDeLaWeb); ps.setString(2,passDeLaWeb); ps.executeQuery(); Obtener los resultados Cada vez que ejecutamos una sentencia SELECT tanto el Statement como el PreparedStatement al hacer el executeQuery() nos devuelve un objeto de tipo ResultSet, este objeto como se puede adivinar por el nombre es un Set, por lo tanto es iterable. Para obtener los resultados de la base de datos usando esta clase resulta muy facil, solo hay que usar getes, es decir si en la base de datos tenemos almacenado un entero haríamos getInt(“nombreCol”); si es una cadena getString(“nombreCol”); ... veamos un trozo de código: String sqlSelect = "SELECT * FROM tabla"; ResultSetrs = con.createStatement().executeQuery(sqlSelect);while(rs.next()){ System.out.println(rs.getString("nombre")); System.out.println(rs.getString("pass")); }



TEMA 4

ACCESO A BASE DE DATOS MEDIANTE ODBC El puente JDBC-ODBC (Ejemplo de Conexión entre Java y Access). 1. EL PUENTE JDBC-ODBCEn este punto se explica la manera de implementar el puente JDBC-ODBC para que una aplicación escrita en Java pueda acceder una base de datos en MS Access. El puente JDBC-ODBC también puede implementarse para conectar a Java con bases de datos como FoxPro. Se mostrará también la manera de crear y configurar un origen de datos con nombre DSN. Introducción al Puente JDBC-ODBC Existiendo ODBC drivers, estos pueden 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 requiere de la instalación de drivers ODBC y entradas de registro. Los drivers ODBC a su vez son implementados nativamente lo que compromete el soporte multiplataforma y la seguridad de applets. 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. Sun Microsystems y las tecnologías DataDirect estan trabajando para hacerlo más confiable y robusto, pero ellos no lo consideran un producto recomendado. Con el desarrollo de drivers puros en Java, el puente se volverá innecesario. Lo ideal es “Java Puro”: no código nativo, no características de plataforma dependiente. Sin embargo puede utilizarse si se requiere desarrollar inmediatamente sin poder 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 permiten crear programas que pueden fácilmente ser adaptados a drivers puros en Java tan pronto como estén disponibles. Hasta aquí con la pequeña introducción acerca del puente JDBC-ODBC. La última parte de esta introducción nos habla de adaptar nuestras aplicaciones basadas en puentes JDBC-ODBC a drivers puros JDBC. Esto es verdadero, sin casi nada de cambio en el código. Personalmente he creado proyectos que trabajan inicialmente con Access y el puente JDBC-ODBC, posteriormente he migrado estas aplicaciones a servidores como MySQL y SQLServer, para los cuales solo debe implementarse el driver JDBC correspondiente.



2. CONECTANDO UNA APLICACIÓN JAVA CON ACCESS MEDIANTE PUENTE JDBC-ODBC Supongamos ahora que necesita conectar una aplicación en Java con Access, sea porque es su primer pinino o porque realmente los requerimientos de su sistema se adaptan a esta base de datos. Para este ejemplo, supongamos que la base de datos de Access se crea en el siguiente directorio: C:\proyecto\bd1.mdb Antes de mostrar el código en java para conectar la aplicación a esta base de datos, se mostrará la forma de crear el driver u origen de datos (DSN) de la base de datos, para ello se procede de la siguiente manera (Windows 2000, XP)

1. Hacer click en el botón inicio. 2. Seleccionar Panel de Control. 3. Hacer doble click en el icono de Herramientas administrativas. 4. Hacer doble click en orígenes de datos (ODBC). Aparecerá la pantalla

Administrador de orígenes de datos ODBC. 5. De la pantalla anterior elija la pestaña DSN de usuario y posteriormente

oprima el botón Agregar. 6. Elija de la lista de drivers desplegada, el driver “Microsoft Access Driver

(*.mdb)” y enseguida oprima el botón finalizar. 7. Aparecerá la pantalla de Configuración de ODBC Microsoft Access, llene

los campos de esta pantalla como se muestra a continuación. En esta misma pantalla, en el apartado Base de datos oprima el botón Seleccionar y seleccione el directorio de la base de datos (C:\proyecto\bd1.mdb). Oprima enseguida el botón Avanzadas.

8. En la pantalla de opciones avanzadas debe crear un Nombre de inicio de sesión y Contraseña . En nuestro caso el inicio de sesión será cvazquez y la contraseña vazquez. En el apartado Opciones, seleccione el campo Driver y establezca el Valor de Driver como PDRV o como lo haya llamado.

Oprima el botón Aceptar. Oprima a su vez los botones aceptar de las pantallas subsecuentes. Con esto el driver ya ha sido creado y puede ser accedido desde nuestra aplicación. El resultado de la creación del driver de la base de datos que se usa en este proyecto de ejemplo es el siguiente: Nombre de driver: PDRV Nombre de inicio de sesión: cvazquez Contraseña: vazquez Estos campos serán utilizados desde la aplicación en Java para conectarse a la base de datos.



La siguiente clase en Java, contiene los métodos necesarios para conectar nuestra aplicación con la base de datos Access. import java.sql.*; public class cConnection { /*Atributos*/

private String url = "jdbc:odbc:"; private String driver = "PDRV"; private String usr = "cvazquez"; private String pswd = "vazquez"; private Connection con;

/*Constructor, carga puente JDBC-ODBC*/ public cConnection() {

loadDriver(); } /** * Carga el driver de la conexión a la base de datos */ private void loadDriver() { try

{ //Instancía de una nueva clase para el puente //sun.jdbc.odbc.JdbcOdbcDriver //El puente sirve entre la aplicación y el driver. Class.forName( "sun.jdbc.odbc.JdbcOdbcDriver" ); }

catch(ClassNotFoundException e) {

System.out.println("Error al crear el puente JDBC-ODBC"); }

} /** * Obtiene una conexión con el nombre del driver especificado * @param driverName Nombre del driver de la base de datos * @return */ public Connection mkConection() {

url = url + driver; System.out.println("Estableciendo conexión con " + url);



try {

//Obtiene la conexión con = DriverManager.getConnection( url,usr,pswd);

} catch(SQLException sqle) {

System.out.println("No se pudo establecer la conexión"); return null;

} System.out.println("Conexión establecida con:\t " + url);

//Regresa la conexión return con;

} /* Cerrar la conexión. */ public boolean closeConecction() {

try {

con.close(); } catch(SQLException sqle) {

System.out.println("No se cerro la conexión"); return false;

} System.out.println("Conexión cerrada con éxito "); return true;

} } El siguiente fragmento de código muestra la manera de establecer la conexión con la base de datos. … //Crear un objeto de la clase de conexión cConnection conect = new cConnection(); //Obtener la conexión Connection con = conect.mkConection(); if(con == null){

//Error al establecer la conexión }



Si la conexión fue realizada con éxito, podemos ejecutar sentencias SQL. El siguiente fragmento de código muestra la ejecución de la sentencia SQL select (suponiendo que tablas de la base de datos fueron creadas con anterioridad). … ResultSet rs = null; Statement stm = con.createStatement(); String strSQL = "SELECT * FROM mitabla"; //Ejecuta la consulta SQL rs = stm.executeQuery(strSQL); //Trabajar con el result set… //Cerrar todo rs.close(); stm.close(); boolean isClosed = conect.closeConecction() if(!isClosed){ //Error al cerrar la conexión }



TEMA 5

EJEMPLO DE APLICACIÓN ACCESO A UNA BD ACCESS

1. PREPARACIÓN DEL ENTORNO DE DESARROLLO Antes de comenzar a estudiar las distintas clases proporcionadas por JDBC, vamos a abordar la creación de una fuente de datos ODBC, a través de la cuál accederemos a una Base de Datos Interbase. Hemos escogido este modo de acceso en lugar de utilizar un driver JDBC nativo para Interbase porque ello nos permitirá mostrar el uso de drivers ODBC: de este modo, aquél que no disponga de Interbase, podrá crear una Base de Datos Access, BTrieve o de cualquier otro tipo para el que sí tenga un driver ODBC instalado en su sistema, y utilizar el código fuente incluido con el diskette que acompaña a la revista. El Listado A muestra el SQL utilizado para crear nuestra pequeña Base de Datos de ejemplo, incluida en el diskette. Nótese que el campo ID de la tabla CONTACTOS es del tipo contador o autoincremento, y requiere de la definición de un trigger y un contador en Interbase: otros sistemas de Base de Datos pueden tener soporte directo para este tipo de campo, lo que hará innecesario parte del código SQL del Listado A.

/* No se hace commit automatico de sentencias de definicion de datos, DDL */ SET AUTODDL OFF; /********** Creacion de la base de datos **********/ /* Necesario USER y PASSWORD si no se ha hecho login previo */ CONNECT "h:\work\artículos\jdbc\1\fuente\agenda.gdb" USER "SYSDBA" PASSWORD "masterkey"; /* Eliminación de la Base de datos */ DROP DATABASE; CREATE DATABASE "h:\work\artículos\jdbc\1\fuente\agenda.gdb" USER "SYSDBA" PASSWORD "masterkey"; CONNECT "h:\work\artículos\jdbc\1\fuente\agenda.gdb" USER "SYSDBA" PASSWORD "masterkey"; /***** Creación de la tabla de Contactos *****/ CREATE TABLE CONTACTOS ( ID INTEGER NOT NULL, NOMBRE CHAR(30) NOT NULL, EMPRESA CHAR(30), CARGO CHAR(20),



DIRECCION CHAR(40), NOTAS VARCHAR(150), PRIMARY KEY( ID ) ); CREATE INDEX I_NOMBRE ON CONTACTOS( NOMBRE ); /* Creamos un contador para CONTACTOS.ID */ CREATE GENERATOR CONTACTOS_ID_Gen; SET GENERATOR CONTACTOS_ID_Gen TO 0; /* Creamos trigger para insertar código del contador en CONTACTOS */ SET TERM !! ; CREATE TRIGGER Set_CONTACTOS_ID FOR CONTACTOS BEFORE INSERT AS BEGIN New.ID = GEN_ID( CONTACTOS_ID_Gen, 1); END !! SET TERM ; !! /**** Creación de la tabla de teléfonos de contactos ****/ CREATE TABLE TELEFONOS ( CONTACTO INTEGER NOT NULL, TELEFONO CHAR(14) NOT NULL, NOTAS VARCHAR(50), PRIMARY KEY( CONTACTO, TELEFONO ) ); /* Se hace COMMIT */ EXIT;

Listado A: SQL utilizado para crear la Base de Datos de ejemplo, AGENDA.GDB,

con Interbase. El primer paso, evidentemente, será crear la Base de Datos, que en nuestro caso se llama AGENDA.GDB. Una vez hecho esto, debemos crear una fuente de datos ODBC: para ello, se debe escoger en el Panel de Control el icono "32bit ODBC", correspondiente al gestor de fuentes de datos ODBC, y hacer click sobre el botón "Add..." de la página "User DSN", con lo que aparecerá la ventana de la Figura A. Figura A: Ventana del gestor de fuentes de datos ODBC utilizada para añadir nuevas fuentes de datos. Hecho esto, queda configurar la fuente de datos, indicando el nombre que le vamos a dar (que utilizaremos a la hora de conectarnos a la Base de Datos), así



como otros datos. La Figura B muestra la ventana de configuración de una fuente de datos Interbase, utilizando un driver de Visigenic. Data Source Name es el nombre que utilizaremos para identificar la fuente de datos, y en nuestro caso será JDBC_AGENDA. Description es un texto explicativo optativo, y Database especifica cómo se llama y dónde se encuentra la Base de Datos que vamos a acceder a través de esta fuente de datos. Para poder utilizar los programas de ejemplo, deberemos introducir aquí el directorio donde copiemos los ejemplos, seguido del nombre de la Base de Datos, AGENDA.GDB. En mi caso, Database es h:\work\artículos\jdbc\1\fuente\AGENDA.GDB. El hecho de que para acceder una Base de Datos mediante ODBC se utilice el nombre de la fuente de datos, en lugar del nombre de la Base de Datos, nos permite cambiar la ubicación e incluso el nombre de la misma sin tener que modificar el código fuente de nuestros programas, ya que estos utilizarán el nombre de la fuente de datos para identificarla. En cuanto a los demás parámetros de la fuente de datos, se debe escoger como Network Protocol la opción <local>. El nombre de usuario (User name) y la contraseña (Password), se indicarán manualmente desde dentro de nuestro programa: no suele ser aconsejable especificarlo en la misma fuente de datos, dado que esto daría acceso a la Base de Datos a cualquier programa que acceda a la misma a través de la misma. Figura B: Ventana de configuración de una fuente de datos ODBC. Como último paso, no debemos olvidar arrancar el servidor de Base de Datos, si utilizamos un gestor que incluye uno, como sucede con Interbase. 2. EL PRIMER PROGRAMA CON JDBC Como es lógico, la API JDBC incluye varias clases que se deben utilizar para conseguir acceso a una Base de Datos. La Tabla A muestra la lista de clases e interfaces más importantes que JDBC ofrece, junto con una breve descripción. Estas clases se encuentran en el paquete java.sql.

Clase/Interface

Descripción

Driver Permite conectarse a una Base de Datos: cada gestor de Base de Datos requiere un Driver distinto.

DriverManager

Permite gestionar todos los Drivers instalados en el sistema.

DriverPropertyInfo

Proporciona diversa información acerca de un Driver.

Connection Representa una conexión con una Base de Datos. Una aplicación puede tener más de una conexión a



más de una Base de Datos. DatabaseMetadata

Proporciona información acerca de una Base de Datos, como las tablas que contiene, etc.

Statement Permite ejecutar sentencias SQL sin parámetros. PreparedStatement

Permite ejecutar sentencias SQL con parámetros de entrada.

CallableStatement

Permite ejecutar sentencias SQL con parámetros de entrada y salida, típicamente procedimientos almacenados.

ResultSet Contiene las filas o registros obtenidos al ejecutar un SELECT.

ResultSetMetadata

Permite obtener información sobre un ResultSet, como el número de columnas, sus nombres, etc.

Tabla A: Clases e interfaces definidos por JDBC.

El mejor modo de comenzar a estudiar la API de JDBC es empezar con un pequeño programa. El Listado B corresponde a un programa que carga el driver utilizado para conectarnos a bases de datos utilizando controladores ODBC.

// Importamos el paquete que da soporte a JDBC, java.sql import java.sql.*; import java.io.*; class jdbc1 { public static void main( String[] args ) { try { // Accederemos a la fuente de datos // ODBC llamada JDBC_AGENDA String urlBD = "jdbc:odbc:JDBC_AGENDA"; String usuarioBD = "SYSDBA"; String passwordBD = "masterkey"; // Cargamos la clase que implementa // el puente JDBC=>ODBC Class.forName( "sun.jdbc.odbc.JdbcOdbcDriver" ); // Establecemos una conexion con la Base de Datos System.out.println( "Estableciendo conexión con " + urlBD + "..." ); Connection conexion = DriverManager.getConnection( urlBD, usuarioBD, passwordBD ); System.out.println( "Conexión establecida." ); conexion.close(); System.out.println("Conexión a " + urlBD " cerrada.");



} catch( Exception ex ) { System.out.println( "Se produjo un error." ); } } }

Listado B: Código básico para llevar a cabo la conexión con una Base de Datos a

través de ODBC. Establecer una conexión con una Base de Datos mediante JDBC es sencillo: en primer lugar, registramos el Driver a utilizar (que en nuestro caso es el puente JDBC/ODBC), mediante el código: Class.forName( "sun.jdbc.odbc.JdbcOdbcDriver" ); Si no se registra este driver, se producirá un error intentar la conexión. A continuación, se lleva a cabo la conexión a la Base de Datos mediante el código: Connection conexion = DriverManager.getConnection( urlBD, usuarioBD, passwordBD ); La clase DriverManager gestiona los Drivers registrados en el sistema: al llamar a getConnection, recorre la lista de Drivers cargados hasta encontrar uno que sea capaz de gestionar la petición especificada por urlBD, que en nuestro ejemplo es "jdbc:odbc:JDBC_AGENDA". Los parámetros usuarioBD y passwordBD corresponden al nombre del usuario y su contraseña, necesarios la mayor parte de las veces para acceder a cualquier Base de Datos. Cómo se especifica la Base de Datos a utilizar depende del Driver utilizado: en nuestro caso, en que utilizamos el puente ODBC/JDBC, todas las peticiones serán de la forma "jdbc:odbc:NOMBRE_FUENTE_DATOS". La cadena utilizada para indicar la Base de Datos siempre tiene tres partes, separadas por el carácter ":". La primera parte es siempre "jdbc". La segunda parte indica el subprotocolo, y depende del Sistema de Gestión de Base de Datos utilizado: en nuestro caso, es "odbc", pero para SQLAnyware, por ejemplo, es "dbaw". La tercera parte identifica la Base de Datos concreta a la que nos deseamos conectar, en nuestro caso la especificada por la fuente de datos ODBC llamada "JDBC_AGENDA". Aquí también se pueden incluir diversos parámetros necesarios para establecer la conexión, o cualquier otra información que el fabricante del SGBD indique. Siguiendo con el Listado B, a continuación se establece una conexión con la Base de Datos, mediante el código:



Connection conexion = controlador.connect( urlBD, usuarioBD, passwordBD ); Acto seguido cerramos la conexión, con: conexión.close(); Es conveniente cerrar las conexiones a Bases de Datos tan pronto como dejen de utilizarse, para liberar recursos rápidamente. Sin embargo, ha de tenerse en cuenta que establecer una conexión es una operación lenta, por lo que tampoco se debe estar abriendo y cerrando conexiones con frecuencia. 3. CONSULTAS EN JDBC Un programa que realice una consulta y quiera mostrar el resultado de la misma requerirá del uso de varias clases: la priemra es DriverManager, que permitirá llevar a cabo una conexión con una Base de Datos, conexión que se representa mediante un objeto que soporta el interface Connection. También será necesario además ejecutar una sentencia SELECT para llevar a cabo la consulta, que se representará por un objeto que soporte el interface Statement (o PreparedStatement, o CallableStatement, que estudiaremos más adelante). Una sentencia SELECT puede devolver diversos registros o filas: esta información es accesible mediante un objeto que soporte el interface ResultSet. El Listado C muestra el código fuente correspondiente a un pequeño programa que muestra los nombres de todos los contactos que hemos almacenado en la Base de Datos AGENDA.GDB, y que utiliza las clases anteriormente mencionadas.

import java.sql.*; import java.io.*; class jdbc2 { public static void main( String[] args ) { try { // Accederemos al alias ODBC llamado JDBC_DEMO String urlBD = "jdbc:odbc:JDBC_AGENDA"; String usuarioBD = "SYSDBA"; String passwordBD = "masterkey"; // Cargamos el puente JDBC=>ODBC Class.forName ("sun.jdbc.odbc.JdbcOdbcDriver"); // Intentamos conectarnos a la base de datos JDBC_DEMO Connection conexion = DriverManager.getConnection ( urlBD, usuarioBD, passwordBD );



// Creamos una sentencia SQL Statement select = conexion.createStatement(); // Ejecutamos una sentencia SELECT ResultSet resultadoSelect = select.executeQuery( "SELECT * FROM CONTACTOS ORDER BY NOMBRE" ); // Imprimimos el nombre de cada contacto encontrado // por el SELECT System.out.println( "NOMBRE" ); System.out.println( "------" ); int col = resultadoSelect.findColumn( "NOMBRE" ); boolean seguir = resultadoSelect.next(); // Mientras queden registros... while( seguir ) { System.out.println( resultadoSelect.getString( col ) ); seguir = resultadoSelect.next(); }; // Liberamos recursos rápidamente resultadoSelect.close(); select.close(); conexion.close(); } catch( SQLException ex ) { // Mostramos toda la informaci¢n sobre // el error disponible System.out.println( "Error: SQLException" ); while (ex != null) { System.out.println ("SQLState: " + ex.getSQLState ()); System.out.println ("Mensaje: " + ex.getMessage ()); System.out.println ("Vendedor: " + ex.getErrorCode ()); ex = ex.getNextException(); System.out.println (""); } } catch( Exception ex ) { System.out.println( "Se produjo un error inesperado" ); } } }



Listado C: Ejecución de una sentencia SELECT e impresión de los resultados con java.

Echemos un vistazo al código en el Listado C. El código para registrar el controlador (Driver) a utilizar es el mismo del Listado B. A continuación se crea una sentencia SQL (Statement), y se ejecuta, obteniendo seguidamente el resultado de la misma (ResultSet), para lo que se utiliza el siguiente código: // Creamos una sentencia SQL Statement select = conexion.createStatement(); // Ejecutamos una sentencia SELECT ResultSet resultadoSelect = select.executeQuery( "SELECT * FROM CONTACTOS ORDER BY NOMBRE" ); Además del método executeQuery, utilizado para ejecutar sentencias SELECT, Statement también proporciona otros métodos: executeUpdate ejecuta una sentencia UPDATE, DELETE, INSERT o cualquier otra sentencia SQL que no devuelva un conjunto de registros, y retorna el número de registros afectados por la sentencia (o -1 si no los hubo). El método getResultSet devuelve el ResultSet de la sentencia, si lo tiene, mientras que getUpdateCount devuelve el mismo valor que executeUpdate. Es posible limitar el número máximo de registros devuelto al hacer un executeQuery mediante setMaxRows, y averiguar dicho número mediante getMaxRows. Es posible también obtener el último aviso generado al ejecutar una sentencia, mediante getWarning, así como limitar el tiempo en segundos que el controlador esperará hasta que el SGBD devuelva un resultado, mediante setQueryTimeout. Por último, el método close libera los recursos asociados a la sentencia. El interface ResultSet es el que encapsula el resultado de una sentencia SELECT. Para recuperar la información es necesario acceder a las distintas columnas (o campos), y recuperarla mediante una serie de métodos getString, getFloat, getInt, etc. Al utilizar estos métodos debe indicarse el número correspondiente a la columna que estamos accediendo: si lo desconocemos, podemos averiguar el número correspondiente a una columna, dado el nombre, mediante findColumn. Por último, dado que un ResultSet puede contener más de un registro, para ir avanzando por la lista de registros que contiene deberemos utilizar el método next, que devuelve un valor booleano indicando si existe otro registro delante del actual. El uso de los métodos anteriores se ilustra en el Listado C, que recorre la lista de contactos en la Base de Datos, obteniendo el valor del campo (o columna) "NOMBRE", e imprimiéndolo, mediante un bucle en el que se llama repetidamente al método next y a getString. Además de estos métodos, ResultSet también cuenta con getWarnings, que devuelve el primer aviso obtenido al manipular los registros, así como wasNull,



que indica si el contenido de la última columna accedida es un NULL SQL. Por último, el método close libera los recursos asociados al ResultSet.

Excepción Descripción SQLException

Error SQL.

SQLWarning

Advertencia SQL.

DataTruncation

Producida cuando se truncan datos inesperadamente, por ejemplo al intentar almacenar un texto demasiado largo en un campo.

Tabla B: Excepciones que puede generar la API de JDBC

Al utilizar la API JDBC es posible obtener diversos errores debido a que se ha escrito incorrectamente una sentencia SQL, a que no se puede establecer una conexión con la Base de Datos por cualquier problema, etc. El paquete java.sql proporciona tres nuevas excepciones, listadas en la Tabla A. En el Listado C se muestra un ejemplo de uso de las excepciones del tipo SQLException: es posible que se encadenen varias excepciones de este tipo, motivo por el que esta clase proporciona el método getNextException. La excepción SQLWarning es silenciosa, no se suele elevar: para averiguar si la Base de Datos emitió un aviso se debe utilizar el método getWarnings de Statement y otras clases, que devuelve excepciones de esta clase. Dado que es posible que se obtengan varios avisos encadenados, esta clase proporciona el método getNextWarning, que devuelve el siguiente aviso, si lo hay. Por último, las excepciones del tipo DataTruncation se producen cuando se trunca información inesperadamente, ya sea al leerla o al escribirla.


TEMA 1 ACCESO A BASE DE DATOS 1. QUE ES UN JDBC –...

Documents

Transcript of TEMA 1 ACCESO A BASE DE DATOS 1. QUE ES UN JDBC –...