universidad don bosco facultad de estudios tecnológicos

UNIVERSIDAD DON BOSCO
FACULTAD DE ESTUDIOS TECNOLÓGICOS
CICLO: 01/ 2015
Nombre de la
Practica:
Lugar de
Ejecución:
Tiempo
Estimado:
MATERIA:
DOCENTES:
GUIA DE LABORATORIO #12
USO DE JDBC
Laboratorio de Redes
2:30 HORAS CLASE
APLICACIONES PARA REDES
Denis Altuve
Marvin Martínez
I. OBJETIVOS.
1. Que el alumno sea capaz de conocer las clases específicas que posee Java para el manejo de base
de datos y el manejo de las API de JDBC.
2. Que al alumno sea capaz de aprender el uso de las API JDBC para la creación de consultas.
II. INTRODUCCIÓN.
JDBC es un API (Application programming interface) que describe o define una librería estándar
para acceso a fuentes de datos, principalmente orientado a Bases de Datos relacionales que usan
SQL (Structured Query Language). 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.
La podemos definir de una manera mas sencillas:
JDBC es una biblioteca de clases que permite la conexión con Bases de Datos utilizando Java.
Permite realizar operaciones (consultas, actualizaciones, ...) sobre base de datos relacionales,
utilizando SQL (Structured Query Language).
¿Que ventajas ofrece acceder a la base de datos utilizando JDBC y Java?
Que la aplicación será independiente de la plataforma y que se puede mover la aplicación de un
sistema gestor de bases de datos a otro (por ejemplo de Oracle a MySQL o a Microsoft SQL Server
o a...).
Los manejadores
Los manejadores, también llamados drivers, son un conjunto de clases que implementan las clases e
interfaces del API JDBC necesarias para que una aplicación Java pueda conectarse
con una BD. Cuando los desarrolladores de una BD desean que esta pueda ser accesible
mediante JDBC éstos deben implementar un manejador para esa base de datos; la misión del
manejador será traducir comandos estándar del API JDBC al protocolo nativo de esa base de datos.
Cada base de datos emplea un protocolo diferente de comunicación, protocolos que
normalmente son propietarios. El uso de un manejador, una capa intermedia entre el código del
desarrollador y la base de datos, permite independizar el código Java que accede a la BD
del sistema de BD concreto a la que estamos accediendo, ya que en nuestro código
Java emplearemos comandos estándar, y estos comandos serán traducidos por el manejador
a comandos propietarios de cada sistema de BD concreto.
Si queremos cambiar el sistema de BD que empleamos lo único que deberemos hacer es reemplazar
el antiguo manejador por el nuevo, y seremos capaces de conectarnos la nueva BD.
Tipos de manejadores
Hay 4 tipos de manejadores JDBC, que difieren en si usan o no tecnología Java Pura, en su
rendimiento y en la flexibilidad para cambiar de base de datos. Veamos cuales son:
Puente JDBC-ODBC (tipo1)
ODBC es un API estándar semejante a JDBC, que permite que lenguajes como C++ o Visual Basic
accedan de un modo estándar a distintos sistemas de BD. Un manejador tipo puente JDBC-ODBC
delega todo el trabajo sobre un manejador ODBC, que es quien realmente se comunica con la BD.
El puente JDBC-ODBC permite la conexión desde Java a BD que no proveen manejadores JDBC.
Fue muy útil cuando se creó el API JDBC, ya que muchas BD no disponían de manejadores JDBC,
pero si de manejadores ODBC. Empleando el puente JDBC-ODBC podía accederse a estas bases de
datos empleando el API JDBC.
El puente forma parte del jdk de SUN, esta en el paquete sun.jdbc.odbc. Inicialmente este tipo de
manejador fue bastante útil por aliviar la carencia de manejadores JDBC.
Manejador de API nativo (tipo2)
Se basa en una librería escrita en código nativo para acceder a la base de datos. El manejador
traduce las llamadas JDBC a llamadas al código de la librería nativa, siendo el código nativo el que
se comunica con las bases de datos. La librería nativa es proporcionada por los desarrolladores de la
BD. Estos manejadores son más eficientes y tienen menos puntos de fallo que el puente JDBCODBC ya que hay menos capas entre el código de la aplicación y la base de datos. Sin embargo
siguen teniendo el problema de pérdida de portabilidad por emplear código nativo.
Manejador de JDBC-Net (tipo3)
El manejador se comunica con un servidor intermedio que se encuentra entre el cliente y la base de
datos. El servidor intermediario se encarga de traducir las al API JDBC al protocolo específico de la
base de datos. No se requiere ningún tipo de código nativo en el cliente, por lo que la portabilidad
de la aplicación está garantizada: el manejador es tecnología 100% Java.. Además si el
intermediario es capaz de traducir las llamadas JDBC a protocolos específicos de diferentes
sistemas de BD podremos emplear un mismo manejador para comunicarnos con
diferentes bases de datos. Esto lo convierte en el manejador más flexible de todos. No obstante se
trata de un driver complejo, ya que requiere la presencia de un midelware, una capa intermedia
entre el cliente y la base de datos, por lo que no es muy común emplearlo en arquitecturas simples,
sino más bien en arquitecturas sofisticadas donde muchas veces entran en juego varias bases de
datos distintas.
Manejador de Protocolo Nativo (tipo4)
El manejador traduce directamente las llamadas al API JDBC al protocolo nativo de la base de
datos. Es el manejador que tiene mejor rendimiento, pero está más ligado a la base de datos
que empleemos que el manejador tipo JDBC-Net, donde el uso del servidor intermedio nos da una
gran flexibilidad a la hora de cambiar de base de datos.
Este tipo de manejadores también emplea tecnología 100% Java.
Los niveles 1 y 2 se usan normalmente cuando no queda otro remedio, porque el único sistema de
acceso final al gestor de bases de datos es ODBC, pero exigen instalación de software en el puesto
cliente. En la mayoría de los casos la opción más adecuada será el nivel 4.
Clase DriverManager
Como su nombre indica esta clase es la gestora de los diversos drivers (manejadores) que haya en
nuestra aplicación. Es posible que sea necesario en una misma aplicación tener varios manejadores
para una misma base de datos, acceder a varias bases de datos que emplean distintos manejadores, o
bien ambas situaciones a la vez. De ahí el interés de contar con este gestor de manejadores.
Los métodos que más nos interesan de esta clase son static Connection getConnection(String url) y
static Connection getConnection(String url, String user String password). Estos métodos intentan
establecer conexión con la base de datos que le indiquemos en el campo url empleando para ellos
todos los manejadores que hemos registrado. La diferencia entre un método y el otro, obviamente,
es que en uno sólo se especifica la base de datos a la que nos queremos conectar, mientras que en el
otro se indica también el nombre de usuario de la base de datos y su password.
Los pasos a realizar para utilizar JDBC en una aplicación son los siguientes:
1.
2.
3.
4.
5.
Cargar la clase que representa al controlador
Establecer una conexión
Ejecución de sentencias SQL
Obtención de los resultados
Cierre de la conexión
1. Cargue el driver específico
¿Por qué necesitamos este paso? Para asegurar portabilidad y reutilización del código, el API fue
diseñado para ser independiente de la versión o el vendedor de una base de datos. Ya que diferentes
DBMS(Sistema de gestión de base de datos) tiene funcionamiento diferente, necesitamos decirle al
driver administrador del DBMS que deseamos usarlo, para que pueda invocar el driver correcto.
Un driver de Oracle es cargado usando el siguiente código:
Class.forName("oracle.jdbc.driver.OracleDriver")
Un driver de Mysql es cargado usando el siguiente código:
Class.forName("com.mysql.jdbc.Driver")
Un driver de SqlServer es cargado usando el siguiente código:
Class.forName(com.microsoft.jdbc.sqlserver.sqlServerDriver)
2. Establecer una conexión
Con Oracle
Una vez el driver es cargado y listo para realizar una conexión, usted puede crear una instancia de
un objeto Connection usando:
Connection con = DriverManager.getConnection(
“jdbc:oracle:thin:@192.168.131.93:1521:ictus”, “scott”, ”tigger”);
Veamos lo que significa esta codigo. El primer string es la dirección URL para la base de datos
incluyendo el protocolo (JDBC), el vendedor (Oracle), el driver (thin), el número del puerto (1521),
y el servidor y por ultimo la base de datos (ictus). El nombre de usuario y la contraseña son scott y
tigger, el mismo con que ingresa a SQLPLUS para acceder su cuenta.
La conexión retornada en el último paso es una conexión abierta que usaremos para pasar las
declaraciones SQL a la base de datos. En este trozo del código, con es una conexión abierta, y
nosotros la usaremos abajo.
Con Mysql
Connection conexion = DriverManager.getConnection (
"jdbc:mysql://localhost/BaseDeDatos","user", "password");
Con SqlServer
Connection conexion =
DriverManager.getConnection(”jdbc:sqlserver://localhost:1433;databaseName=NombreBaseDeDat
os”,user,password);
3. Ejecución de Sentencias
La ejecución de sentencias en la base de datos a través de JDBC se realiza mediante las interfaces
Statement ó PreparedStatement.
Los objetos de estos tipos se obtienen a partir del objeto de tipo Connection
La interfaz Statement
Mediante objetos de este tipo se pueden ejecutar sentencias SQL sencillas y obtener los resultados
mediante la clase ResulSet.
Para obtener un objeto del tipo Statement se llama al método createStatement() del objeto
Connection.
Una vez que se dispone del objeto se pueden ejecutar sentencias SELECT (que no modifican las
tablas) utilizando el método .
Resulset executeQuery(StringSQL)
Para ejecutar sentencias que contengan UPDATE, INSERT o DELETE hay que utilizar el método
executeUpdate(StringSQL)
Interfaz PreparedStatment
Algunas veces, es más conveniente o más eficiente usar un objeto PreparedStatement para enviar
las instrucciones SQL al DBMS. La característica principal que lo distingue de su superclase
Statement, es que a diferencia de la instrucción Statement, ella está dando una instrucción SQL
correcta cuando se crea. Esta instrucción SQL se envía en seguida al DBMS, dónde es compilada.
Entonces, en efecto, un objeto PreparedStatement es asociado como un canal con una conexión y
una instrucción SQL compilada.
La ventaja ofrecida es que si necesita usar la misma, o similar consulta con diferentes parámetros
varias veces, la instrucción puede ser compilada y optimizada por el DBMS sólo una vez. Contrasta
esto con un uso de una Statement normal dónde cada uso de la misma instrucción SQL requiere una
compilación de nuevo.
También se crean PreparedStatements con un método Connection. El siguiente código muestra
cómo crear una instrucción SQL parametrizada con tres parámetros de entrada:
PreparedStatement prepareUpdatePrice = con.prepareStatement(
"UPDATE Venta SET precio = ? WHERE nombreBar = ? AND marcaCerveza = ?");
Antes de que podamos ejecutar un PreparedStatement, necesitamos proporcionar los valores de los
parámetros. Esto puede hacerse llamando uno de los métodos del setXXX definido en la clase
PreparedStatement. Los métodos más usados son los setInt, setFloat, setDouble, setString, etc.
Usted puede poner estos valores antes de cada ejecución de la instrucción preparada.
Continuando el ejemplo anterior, escribiremos:
prepareUpdatePrice.setInt(1, 1000);
prepareUpdatePrice.setString(2, "El Cantinazo");
prepareUpdatePrice.setString(3, "Rivereña");
4.Obtención de los Resultados
Como hemos visto en los puntos anteriores el resultado de una consulta es devuelto en un objeto del
tipo ResultSet.
Podemos imaginar que el resultado se devuelve en forma de tabla donde las filas corresponden a los
registros y las columnas a los datos.
Primero hay que colocarse en una determinada fila y a continuación acceder a la columna deseada.
Para ello, la clase ResultSet dispone de métodos para moverse en filas y de métodos para
seleccionar una determinada columna.
Para desplazar el cursor empleamos el método next().
Procesar los resultados
Tras realizar una consulta tipo SELECT obtenemos como resultado un conjunto de registros, a
los cuales podemos acceder mediante la interface Resulset. Esta provee una serie de métodos
getXXX(columna) que permiten acceder a cada campo de cada registro devuelto como respuesta a
nuestra consulta.
Es importante conocer a qué tipo Java se corresponde cada tipo SQL para saber
mediante qué método debemos acceder al contenido de cada columna. En la Figura mostramos la
equivalencia entre los tipos de dato Java y los tipos de datos SQL.
5. Cierre de la conexión
Una vez que hemos finalizado el cometido de nuestro ejercicio deberemos de cerrar las conexiones
a la base de datos. Para ello invocaremos el método close() sobre los tres objetos mencionados.
III. PROCEDIMIENTO.
1. Para esta guiá deberá de crear un nuevo proyecto de java llamado “Guia12Apr”.
2. Ya que vamos a trabajar con JDBC y para podernos conectarnos a una base de datos
deberemos incluir en las librerías el Driver de mysql , para ello dar click derechos sobre la
carpeta “Libraries” y seleccionar “Add JAR/Folder..”
3. A continuación aparecerá una imagen como la siguiente en la cual deberemos buscar el driver de
mysql que sera proporcionado por el docente.
4. Como se puede ver en la siguiente imagen la librería a sido agregada al proyecto.
5. Como siguiente punto crear una base de datos en mysql llamada “Empleados” y crear una tabla
llamada “datosempleados” con la siguiente estructura, apoyarse del phpmyadmin para hacer este
proceso mas rápido.
Parte II: Después de haber preparado el proyecto con todo lo necesario, pasaremos a crear nuestras
aplicaciones en java, para ello seguir los siguientes puntos.
1. En el proyecto Guia4_POO1 debe crear una clase y colocar el nombre VerEmpleados.
2. Digitar el siguiente código:
import java.sql.*;
public class VerEmpleado {
public VerEmpleado()
{
// Se utiliza un try por los posibles errores de MySQL
try
{
//obtenemos el driver de para mysql
Class.forName("com.mysql.jdbc.Driver");
// Se obtiene una conexión con la base de datos.
Connection conexion = DriverManager.getConnection (
"jdbc:mysql://localhost/Empleados","root", "rafael");
// Permite ejecutar sentencias SQL sin parámetros
Statement s = conexion.createStatement();
// Contiene la tabla resultado de la pregunta SQL que se haya realizado
ResultSet rs = s.executeQuery ("select * from datosempleados");
//Se recorre el ResultSet, mostrando por pantalla los resultados.
while (rs.next())
{
System.out.println ("ID: "+rs.getString(1)+
"\nNombre: "+rs.getString(2)+
"\nApellido1: "+rs.getString(3)+
"\nApellido2: "+rs.getString(4)+
"\nEdad: "+rs.getString(5)
);
System.out.println("**********************************");
}
// Se cierra la conexión con la base de datos.
conexion.close();
}
catch (ClassNotFoundException e1) {
//Error si no puedo leer el driver de MySQL
System.out.println("ERROR:No encuentro el driver de la BD: "+e1.getMessage());
}
catch (SQLException e2) {
//Error SQL: login/passwd ó sentencia sql erronea
System.out.println("ERROR:Fallo en SQL: "+e2.getMessage());
}
}
public static void main(String[] args)
{
new VerEmpleado();
}
}
3. Al correr la aplicación obtendremos un resultado similar al siguiente, siempre y cuando se hayan
ingresado registros en la tabla empleados.
4. Forma alternativa de mostrar los datos.
5. Para obtener los distintos atributos de la base se utilizarán, normalmente, los métodos
getString(atributo), cuyo parámetro es una cadena con el nombre del atributo que queremos
recuperar.
//Se recorre el ResultSet, mostrando por pantalla los resultados.
while (rs.next())
{
System.out.println ("ID: "+rs.getInt("id")+
"\nNombre: "+rs.getString("nombres")+
"\nApellido1: "+rs.getString("apellido1")+
"\nApellido2: "+rs.getString("apellido2")+
"\nEdad: "+rs.getInt("edad"));
System.out.println("**********************************");
}
Parte III: Ingresar datos desde una aplicación a una base de datos
1. En el proyecto Guia4_POO1 debe crear una clase y colocar el nombre IngresoDatos.
2. Digitar el siguiente Código.
import java.sql.*;
import javax.swing.JOptionPane;
public class IngresoDatos {
private String ids;
private String nombre;
private String apellido1;
private String apellido2;
private String telefono;
private String edads;
private int edad;
private Connection conexion=null;
private ResultSet rs=null;
private Statement s=null;
public IngresoDatos()
{
// Se utiliza un try por los posibles errores de MySQL
try
{
//obtenemos el driver de para mysql
Class.forName("com.mysql.jdbc.Driver");
// Se obtiene una conexión con la base de datos.
conexion = DriverManager.getConnection (
"jdbc:mysql://localhost/Empleados","root", "rafael");
// Permite ejecutar sentencias SQL sin parámetros
s = conexion.createStatement();
//Metodo para ingresar valores
ingreso();
s.executeUpdate("Insert into datosempleados
values('"+ids+"','"+nombre+"','"+apellido1+"','"+apellido2+"',"+edad+")");
JOptionPane.showMessageDialog(null,"Persona Ingresada Correctamente");
}
catch (ClassNotFoundException e1) {
//Error si no puedo leer el driver de MySQL
System.out.println("ERROR:No encuentro el driver de la BD: "+e1.getMessage());
System.exit(0);
}
catch (SQLException e2) {
//Error SQL: login/passwd ó sentencia sql erronea
System.out.println("ERROR:Fallo en SQL: "+e2.getMessage());
System.exit(0);
}
}
public void ingreso()
{
ids=JOptionPane.showInputDialog("Ingrese el ID");
nombre=JOptionPane.showInputDialog("Ingrese el Nombre");
apellido1=JOptionPane.showInputDialog("Ingrese su primer apellido");
apellido2=JOptionPane.showInputDialog("Ingrese su segundo apellido");
edads=JOptionPane.showInputDialog("Ingrese su edad");
edad=Integer.parseInt(edads);
}
public void mostrardatos() throws SQLException{
rs = s.executeQuery ("select * from datosempleados");
while (rs.next())
{
JOptionPane.showMessageDialog(null,"ID: "+rs.getString(1)+
"\nNombre: "+rs.getString(2)+
"\nApellido1: "+rs.getString(3)+
"\nApellido2: "+rs.getString(4)+
"\nEdad: "+rs.getInt(5)
);
}
}
public void cierreconexion() throws SQLException{
// Se cierra la conexión con la base de datos.
conexion.close();
}
public static void main(String[] args) throws SQLException
{
IngresoDatos ing=new IngresoDatos();
ing.mostrardatos();
ing.cierreconexion();
}
}