JDBC y ODBC
La capacidad para acceder a bases de datos desde Java la ofrece la API JDBC (Java DataBase Conectivity). JDBC es un estándar para manejar bases de datos en Java. ODBC es un estándar de Windows para manejar bases de datos, de forma que cualquier programa en Windows que desee acceder a bases de datos genéricas debe usar este estándar. La necesidad de crear un estándar propio para acceder a bases de datos desde Java se explica porque el estándar ODBC está programado en C y un programa que use este estándar, por lo tanto, depende de la plataforma.
Controladores JDBC-ODBC
Necesitamos acceder a un origren de datos ODBC pero contamos con una API que usa el estándar JDBC. Para solventar este problema las empresas realizan drivers que traducen el ODBC a JDBC. Hay varios tipos de Driver, pero para nuestro ejemplo usaremos los llamados puentes JDBC-ODBC. Estamos de suerte porque el JDK de Windows incorpora el driver necesario para conectar bases de datos Access.[1]
"...Acces no es una Base de Datos que sirva para grandes volúmenes de datos, ni que se la pueda pedir una gran concurrencia de peticiones. Si bien, esta es una base de datos con la que se puede empezar a aprender, además de dar funcionalidad a usuarios domésticos.
Access puede ser también un buen inicio para empezar a aprender a conectar bases de datos mediante JDBC. Los pasos que tendremos que seguir para conseguir esto son los siguientes:
Deberemos de crear una conexión ODBC. Una conexión ODBC permite crear una forma unificada de accesos entre una base de datos, sea cual sea su tipo (MS Access, FoxPro, MySQL,…) y el sistema Windows, y por ende los programas que corren sobre el.
Para crear una conexión ODBC deberemos de ir al Panel de Control >> Herramientas Administrativas >> Orígenes de Datos (ODBC). Si bien, esto puede cambiar dependiendo de la versión del sistema operativo y del lenguaje del sistema instalado. Al final nos aparecerá una imagen como la que sigue:
Lo siguiente que deberemos de hacer es crear un DSN del sistema. Esto lo que va a hacer es dar un nombre representativo a la base de datos que elijamos. Para ello deberemos de ir a la pestaña DSN de Sistema y pulsar sobre el botón de “Agregar…”. Saliendonos la siguiente ventana:[2]
Crear un nuevo DNS (Data Source Name):Para realizar la conexión a una base de datos ODBC necesitaremos crear un perfil DSN desde el panel de control y posteriormente accederemos a la base de datos a partir del nombre del perfil. En el perfil DSN lo que se hace es indicar el driver a utilizar, así como el archivo o archivos del origen de datos. Estos son los pasos a llevar a cabo para configurar un perfil DSN.
1.- Iremos a Panel de Control. Ello se hace desde Inicio->Configuración o desde MiPC.
2.- Ahora hacemos doble-click en el icono de Fuentes de datos ODBC (32 bits).
3.- En nuestra pantalla aparecerá ahora la pestaña DSN usuario seleccionada. Para crear un nuevo perfil haremos click en Agregar...
4.- A continuación se nos pide que ingresemos el controlador que vamos a usar en el nuevo perfil. En nuestro caso será Microsoft Access Driver (*.mdb).
5.- Una vez aquí sólo nos queda dar un nombre al origen de datos y especificar el archivo .mdb de origen. Tras aceptar la ventana ya tenemos creado un perfil con lo que ya podemos comenzar a programar.[1]
El tipo de base de datos que añadiremos será el MS Access. (*.mdb). Ahora deberemos de indicar el nombre del DSN y la ubicación de nuestra base de datos. La ventana será la que sigue:
Una vez que tenemos creado el DSN del sistema pasaremos a nuestro programa Java. Hay que recordar que para establecer una conexión JDBC necesitaremos dos cosas: el nombre del driver que realizará la conexión y la URL destino donde está la base de datos. En el caso de las conexiones ODBC existe un driver estandar que se llama
sun.jdbc.odbc.JdbcOdbcDriver.
Veamos como sería la línea de conexión de dicho driver.
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
Por lo que se refiere a la URL de destino, en el caso de ODBC se sigue la siguiente nomenclatura:"jdbc::" Donde el subprotocol sería odbc y el subname el nombre de DSN de sistema que hayamos asignado a nuestra base de datos. Quedándonos la URL de conexión de la siguiente forma:
String url = "jdbc:odbc:DSN_LineaDeCodigo"; Solo nos quedará el realizar la conexión:
Connection db = DriverManager.getConnection (url, "usuario","password");
En usuario y password deberemos de poner el nombre del usuario y password que tenga de acceso la base de datos. Si es que los tiene. En caso negativo se debarán vacios. [1]
Cargar el Driver: Lo primero es hacer una llamada al Driver JDBC-ODBC para cargarlo. Eso se consigue con las siguientes líneas de código:
try{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
}
catch(Exception e){ System.out.println("No se ha podido cargar el Driver JDBC-ODBC");
}
Con esto ya tenemos cargado el Driver. Ahora básicamente trabajaremos con tres objetos. Estos objetos son: Connection, Statement y ResultSet. El objeto Connection se obtiene al realizar la conexión a la base de datos. El objeto Statement se crea a partir del anterior y nos permite ejecutar SQL para hacer consultas o modificaciones en la base de datos. En caso de hacer una consulta (SELECT ... FROM ...) se nos devolverá un objeto que representa los datos que deseamos consultar; este objeto es un objeto ResultSet (Hoja de resultados).[2]"
El objeto Connection Connection con = DriverManager.getConnection("jdbc:odbc:Nombre_Perfil_DSN", "Nombre_Usuario", "Contraseña");[2]
2.Conexión con Oracle: Para poder conectar a Java con ORACLE lo primero que necesitamos es la implementación de JDBC para ORACLE. Esta implementación se encuentra en el archivo Classes12.jar que podemos encontrar en el siguiente directorio del servidor de Oracle.
ORACLE_HOME es una variable de entorno que se crea durante la instalación del servidor ORACLE, y que indica donde está instalado fisicamente ORACLE dentro del sistema de archivos, normalmente C:\oracle\ora92 para servidores Windows y ORACLE 9i. Esta .misma nomenclatura se aplica al hablar de la instalación cliente
Debemos configurar correctamente nuestra variable CLASSPATH para incluir en ella el archivo Classes12.jar.
- JDBC Thin Driver: No requiere de la instalación cliente de ORACLE. Ideal para Applets.
- JDBC OCI : API nativa de ORACLE, para aplicaciones J2EE.
- JDBC KPRB driver: (default connection) para Java Stored Procedures y Database JSP's.
Todos los drivers soportan la misma sintaxis y funcionalidad, por lo que nuestro código variará únicamente en la forma de crear la conexion.
Conectar a ORACLE con JDBC Thin Driver: El driver JDBC Thin se conecta y comunica con ORACLE a nivel de sockets. Proporciona su propia versión del protocolo Net8 (SQL*Net) sobre TCP/IP, por lo que no es necesario que exista una instalación de la parte cliente de ORACLE. Dado que este driver es código 100% Java es completamente independiente de la plataforma de ejecución, y como implementa su propia versión del protocolo es ideal para aplicaciones que se ejecutan sobre un navegador Web (applets)
import java.sql.*;
class dbAccess
{
public static void main (String args [])
throws SQLException
{
try
{ Class.forName
("oracle.jdbc.driver.OracleDriver");
}
catch (ClassNotFoundException e)
{
e.printStackTrace();
}
Connection conn = DriverManager.getConnection
("jdbc:oracle:oci:@ORACLEBD", "user", "passw");
// @TNSNames_Entry, userid, password
Statement stmt = conn.createStatement();
ResultSet rset = stmt.executeQuery("select BANNER from SYS.V_$VERSION");
while (rset.next()) System.out.println (rset.getString(1));
// Print col 1 stmt.close();
}
}
Conectar a ORACLE con JDBC OCI Driver: El driver JDBC OCI usa el API ORACLE OCI (Oracle Call Interface) para interactuar con ORACLE, por lo que es necesaria la instalación y configuración de la parte cliente de ORACLE. El driver OCI trabaja con SQL*Net o Net8, por lo que tamdebemos haber creado un alias en el archivo TNS names (%ORACLE_HOME%\network\ADMIN):
ORACLEBD =
(DESCRIPTION =
(ADDRESS_LIST =
(ADDRESS = (PROTOCOL = TCP)(HOST = WIN01)(PORT = 1521))
)
(CONNECT_DATA =
(SERVICE_NAME = ORACLEBD)
)
)
El driver JDBC OCI permite realizar llamadas a ORACLE OCI directamente desde Java proporcionandoun alto grado de compatibilidad con una versión específica de ORACLE utilizando métodos nativos, pero específicos de la plataforma.
import java.sql.*; }
class dbAccess
{
public static void main (String args []) throws SQLException
{
try
{
Class.forName ("oracle.jdbc.driver.OracleDriver");
}
catch (ClassNotFoundException e)
{
e.printStackTrace();
}
Connection conn = DriverManager.getConnection
("jdbc:oracle:oci:@ORACLEBD", "user", "passw");
// @TNSNames_Entry, userid, password
Statement stmt = conn.createStatement();
ResultSet rset = stmt.executeQuery("select BANNER from SYS.V_$VERSION");
while (rset.next())
System.out.println (rset.getString(1));
// Print col 1 stmt.close();
}
}
Conectar a ORACLE con JDBC KPRB Driver:Por último el driver ORACLE JDBC KPRB es utilizado para escribir en Java procedimientos almacenados, funciones, triggers ... Ofrece acceso a la conexion activa por lo que no es necesario crear ninguna conexión adicional.
El driver JDBC KPRB de ORACLE permite obtener un handle de la conexion actual del contexto a través del método OracleDriver.defaultConenction(). Como hemos dicho, se utiliza para procedimientos almacenados, triggers .... Para ejecutar un procedimiento almacenado debemos estar conectados a ORACLE a través de una herramienta cliente como SQL*Plus., lo que hacemos con defaultConenction() es acceder a está conexion.
import java.sql.*;
class dbAccess{
public static String showBanner() throws SQLException
{
String banner=""; Connection conn = (new oracle.jdbc.driver.OracleDriver)).defaultConnection();
Statement stmt = conn.createStatement();
ResultSet rset = stmt.executeQuery("select BANNER from SYS.V_$VERSION");
while (rset.next()) banner += rset.getString(1);
//stmt.close(); NO CERRAR LA CONEXION return banner;
}
}
[3]
3. CONEXIÓN CON SQL SERVER: En esencia las dos líneas que hacen la magia son estas y van en la clase principal:
String jdbc_driver ="com.mysql.jdbc.Driver"; // Driver para MySQL
String jdbc_url="jdbc:mysql://localhost/discoteca?user=root&password=kimono";
// Nombre de la base de datos
Aquí la base de datos se llama discoteca y el password es kimono. La BD esta en la misma computadora (localhost)
Para una BD en Access usa:
String jdbc_driver = "sun.jdbc.odbc.JdbcOdbcDriver";
String jdbc_url = "jdbc:odbc:inventario_cd";
Para una BD en SQL usa:
String jdbc_driver = "com.mysql.jdbc.Driver"; // Driver para MySQL
String jdbc_url = "jdbc:mysql://localhost/discoteca?user=root&password=kimono";
// Nombre de la base de datos
[4]
4.CONEXIÓN CON POSTGREST:“…Primero, es necesario descargarse el JDBC Driver para PostgreSQL. Este se encuentra en la página http://jdbc.postgresql.org/index.html Obviamente, será necesario contar con nuestra Base de Datos funcionando para realizar las consultas necesarias.
Posteriormente hay que determinar la manera de agregar este Driver a nuestro proyecto. NetBeans ofrece una manera más que sencilla.
Conociendo la ubicación de nuestro Driver y con el proyecto abierto, en el Panel de Proyectos, ubicamos en el Árbol de Proyecto la opción Libraries, clic Derecho en ella y seleccionamos Add JAR / Folder..., de esta manera estaremos agregando ej .JAR del Driver que descargamos. Esto nos crea en nuestro proyecto una carpeta llamada "dist" y en ella otra de nombre "lib" donde esta nuestro Driver.
Ahora, teniendo lo necesario, podemos probar nuestra conexión con PostgreSQL
Para empezar, debemos de importar lo siguiente:
import java.sql.*;
public class Main{
public static void main(String[] args){
/*Variable para almacenar la URL de conexión a nuestra Base de Datos, si esta estuviera en otra máquina, necesitaríamos estar registrados en ella y contar con su IP*/
String url = "jdbc:postgresql://localhost/moo";
try{
//Acceso al Driver
Class.forName("org.postgresql.Driver");
//La conexión con los parámetros necesarios
Connection con = DriverManager.getConnection( url,"postgres","postgres");
//Abrimos la conexión y la iniciamos
Statement stmt = con.createStatement();
/*Un ResultSet es como en .NET un DataSet, un arreglo temporal donde se almacenará el resultado de la consulta SQL*/
ResultSet rs;
//Una variable String para almacenar la sentencia SQL
String query = "select id as ID from moo.usuarios";
//En el ResultSet guardamos el resultado de ejecutar la consulta
rs = stmt.executeQuery(query);
//En un ciclo while recorremos cada fila del resultado de nuestro
Select while ( rs.next()){
/*Aqui practicamente podemos hacer lo que deseemos con el resultado, en mi caso solo lo mande a imprimir*/
System.out.println(rs.getString("ID") + "\t" + rs.getString("ID"));
}
//Cerramos la conexión
stmt.execute("END");
stmt.close();
con.close();
}
catch( Exception e ){
//Por si ocurre un error
System.out.println(e.getMessage());
e.printStackTrace();
}
}
}
[5]
BIBLIOGRAFIA
[1] http://www.gamarod.com.ar/articulos/como_conectar_java_y_access.asp
[2] http://codigosjava.blogspot.com/2007/08/jdbc-conectarse-una-base-de-datos-ms.html
[3] http://www.devjoker.com/contenidos/Articulos/132/Como-conectar-a-ORACLE-con-Java.aspx
[4] http://www.yoreparo.com/foros/programacion/100248.html
[5]http://www.mygnet.net/articulos/java/conectando_postgresql_con_java.1162