S8-BDD

1. Programación
Orientada a Objetos
Tema: 4 Manejo de archivos y Base de
Datos
Docente: Mg. Luis Fernando Aguas B

2. Si supiera que el mundo se acaba mañana, yo, hoy
todavía, plantaría un árbol.

3. Objetivo
1. Adquirir los conceptos
básicos relacionados con
la POO
2. Reconocer las
características de la POO
● 4.2 Conexiones a Base de
Datos
Contenido

4. Objetivos de Desarrollo Sostenible

5. 4.2 Conexiones a Base de Datos

6. JDBC
● Es un API de Java para ejecutar estatutos de SQL
(Structured Query Language)
● Aunque no es un acrónimo, sino una marca
registrada, es común darle el significado de Java
DataBase Connectivity
● Programando con JDBC se puede acceder a casi
cualquier Base de Datos comercial por medio de
comandos SQL

7. JDBC
● Lo más importante es que no necesitamos un
programa diferente para cada tipo de Base de Datos
que manejemos
● Un mismo programa puede accesar la misma
estructura en Bases de Datos comerciales diferentes
● Extiende la universalidad de Java a Bases de Datos
además de las plataformas

8. ODBC
● Open DataBase Connectivity
● Es la respuesta de Microsoft al mismo problema, acceso
a diferentes Bases de Datos con una misma API
● Se puede usar ODBC directamente desde Java pero:
está programada en C y necesita llamar a métodos
nativos, problemas de seguridad y transportabilidad
además de otros factores

9. Puente JDBC-ODBC
● Se puede usar el puente para que los programas
sigan siendo 100% Java
● El acceso a la Base de Datos se hace por medio de
ODBC
● El programador sólo desarrolla en Java y accede a
las Bases de Datos por medio del API JDBC, no
tiene necesidad de aprender a manejar ODBC, sólo
necesita configurarlo

10. Drivers
● (Tipo 1) Puente JDBC-ODBC y driver ODBC
○ La aplicación necesita cargar el código nativo del driver
ODBC
● (Tipo 2) API nativo con acceso a Java
○ Convierte llamadas JDBC a llamadas nativas de las Bases de
Datos
● (Tipo 3) Protocolo de red 100% Java
○ Convierte llamadas JDBC en llamadas a un protocolo de red
independiente el cual es traducido en el servidor a llamadas
nativas de la Base de Datos
● (Tipo 4) Protocolo nativo 100% Java
○ Convierte directamente las llamadas JDBC a llamadas nativas

11. Pasos previos
● Tener instalado JDK con JDBC
○ JDK ya viene con JDBC, puedes conseguir ejemplos en:
http://www.javasoft.com/products/jdbc/book.html
● Instalar el driver en la máquina
○ Nosotros usaremos el puente JDBC-ODBC, asi es que tendremos
que configurar ODBC
● Instalar el manejador de la Base de Datos
○ En caso necesario instalar la aplicación, SQL Server, Oracle,
Foxpro, DBase, etc., nosotros usaremos Access

12. Configuración de ODBC
● En el panel de control seleccionar ODBC

13. Configuración de ODBC
● Ya tenemos en disco
una base de datos
llamada "curso1.mdb"
● Seleccionar agregar
● Selecionar el tipo de
driver que queremos
agregar, en nuestro
caso será "Microsoft
Access Driver (*.mdb)
● Presionar Terminar

14. Configuración de ODBC
● Asignar un
nombre (data
source name)
para hacer
referencia a ella
desde Java

15. Configuración de ODBC
● En la opción avanzado
se puede asignar
usuario y password
para el acceso de la
base de datos

16. Configuración de ODBC
● Después
presionar
seleccionar para
ubicar la base de
datos en el disco
o en la red

17. Ejemplos
● Para los siguientes ejemplos tendremos una base de
datos ya existente (la que acabamos de configurar)
curso1.mdb, el "data source name" también es
curso1 pero no es necesario que coincidan
● curso1 tiene una tabla que se llama lista, la cual es
una lista de alumnos con nombre y matrícula y las
calificaciones de tres parciales

18. Tabla lista de curso1

19. Pasos de un programa
● Cargar driver
– Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
– La instrucción anterior crea un ejemplar del driver y lo registra con el
DriverManager en una sola instrucción
• Establecer una conexión a la base de datos
– Connection conexion = DriverManager.getConnection
("jdbc:odbc:curso1","jdbc","jdbc");
● Crear un estatuto asociado a la conexión para poder
hacer accesos a la base de datos
– Statement estatuto = conexion.createStatement();

20. Consulta a una tabla
● La consulta a una tabla se hace por medio del estatuto:
○ executeQuery("query en SQL")
● Donde el query típicamente es un estatuto SELECT de SQL
● El query es mandado en forma de String y regresa un objeto de
la clase ResultSet que guarda todos los registros obtenidos con
el query
○ ResultSet rs = estatuto.executeQuery("SELECT...");
● rs tiene un apuntador que inicialmente apunta antes del primer
registro del grupo obtenido, la forma de avanzar en los registros
dentro del grupo es con el método next() del ResultSet que
regresa un valor booleano indicando si es que todavía quedan
más registros en el ResutSet

21. Consulta a una tabla
● La forma de obtener los valores particulares de cada
campo en un registro es con los métodos get...() de
ResultSet donde la particular versión de get depende
del tipo de dato y el parámetro es el nombre del campo
o el número de la columna del campo en el registro del
grupo obtenido (resultSet) con el estatuto:
○ getString("nombre"), getInt("EX2"),
getBoolean(3), etc.

22. Ejemplo
import java.sql.*;
public class BaseDeDatos1{
public static void main(String[] args){
try{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
}catch(ClassNotFoundException e){
System.out.println(e.getMessage());
}
try{
Connection conexion = DriverManager.getConnection("jdbc:odbc:curso1");
Statement estatuto = conexion.createStatement();
ResultSet rs = estatuto.executeQuery("select * FROM lista");
while(rs.next()){
String matricula = rs.getString("MATRICULA");
String nombre = rs.getString("NOMBRE");
int ex1 = rs.getInt("EX1");
int ex2 = rs.getInt("EX2");
int ex3 = rs.getInt("EX3");
System.out.println(matricula+" "+nombre+" "+ex1+" "+ex2+" "+ex3);
}
estatuto.close();
conexion.close();
}catch(SQLException e){
System.out.println(e.getMessage());
}
}
}

23. Ejemplo

24. Ejemplo BaseDeDatos2.java
Connection conexion = DriverManager.getConnection("jdbc:odbc:curso1","jdbc","jdbc");
Statement estatuto = conexion.createStatement();
ResultSet rs = estatuto.executeQuery("select MATRICULA,NOMBRE "+
"from lista where NOMBRE>'b' and NOMBRE<
"order by NOMBRE DESC");
while(rs.next()){
String matricula = rs.getString("MATRICULA");
String nombre = rs.getString(2);
System.out.println(matricula+" "+nombre);
}

25. Modificación de una tabla
● La modificación de tablas se realiza con el estatuto
executeUpdate
● estatuto.executeUpdate("comando SQL");
● Los comandos típicos SQL para actualización de tablas
son
○ UPDATE
○ INSERT INTO
○ DELETE FROM

26. Ejemplo BaseDeDatos3.java
estatuto.executeUpdate("update lista set EX1 = EX1 + 10,EX2 = EX2 + 5");
estatuto.executeUpdate("update lista set EX1=100,EX2=100,EX3=100 "+
"where NOMBRE>'a' AND NOMBRE<'b'");
estatuto.executeUpdate("delete from lista where MATRICULA>'7'");
estatuto.executeUpdate("insert into lista values('49052','Pablo Díaz',"+
"100,100,100)");
estatuto.executeUpdate("insert into lista (MATRICULA,NOMBRE,EX3) "+
"values ('123456','Tonto',50)");

27. Ejemplo

28. Ejemplo BaseDeDatos4.java
Statement estatuto = conexion.createStatement();
Statement estatuto1 = conexion.createStatement();
//estatuto.executeUpdate("create table final (MATRICULA text(6), NOTA number)");
//estatuto.executeUpdate("create table final (MATRICULA varchar(6), NOTA int)");
estatuto.executeUpdate("create table final (MATRICULA varchar(6), NOTA double)");
ResultSet rs = estatuto.executeQuery("select * FROM lista");
while(rs.next()){
String matricula = rs.getString("MATRICULA");
int ex1 = rs.getInt("EX1");
int ex2 = rs.getInt("EX2");
int ex3 = rs.getInt("EX3");
double nota = (double)(ex1+ex2+ex3)/3;
estatuto1.executeUpdate("insert into final values("+matricula+","
}
rs = estatuto.executeQuery("select * FROM final");
while(rs.next()){
String mat = rs.getString("MATRICULA");
double not = rs.getDouble("NOTA");
System.out.println(mat+" "+Math.round(not));
}

29. Ejemplo

31. PreparedStatement
● Es una manera de pasar parámetros a estatutos de
query y update
● Se usa para tener estatutos preparados que se
utilizan con frecuencia y que posiblemente ya estén
compilados en el servidor de BdeD. Eficiencia!
● Los parámetros se especifican con ? y mantienen un
orden (índice) que se va incrementando a medida
que usas los ?
● El valor de los parámetros se especifica con las
funciones set...(índice, valor), donde la versión de
set depende del tipo de dato que asignarás al
parámetro
● El estatuto se llama sin el típico parámetro String

32. Ejemplo BaseDeDatos5.java
PreparedStatement estatuto = conexion.prepareStatement("select * from final "+
estatuto.setDouble(1,70);
estatuto.setDouble(2,80);
ResultSet rs = estatuto.executeQuery();
while(rs.next()){
String matricula = rs.getString("MATRICULA");
double nota = rs.getDouble("NOTA");
System.out.println(matricula+" "+nota);
}

33. Acceso a dos o más tablas
● Normalmente se diseñan varias tablas en una base de
datos con campos en común para poder accesar la
información en forma más eficiente
● En nuestro caso tenemos dos tablas que tiene el
campo matrícula
● Cuando se hace un acceso a dos o más tablas se
necesita especificar a que tabla pertenece cada
campo. Tabla.campo
● Esto sólo se necesita para campos que tengan el
mismo nombre en las diferentes tablas

34. Ejemplo BaseDeDatos6.java
ResultSet rs = estatuto.executeQuery("select lista.NOMBRE from lista, "+
"final where final.NOTA>70 and final.NOTA<80 "+
"and
lista.MATRICULA = final.MATRICULA");
while(rs.next()){
String nombre = rs.getString("NOMBRE");
System.out.println(nombre);
}

35. Stored Procedures
● Un stored procedure es un grupo de estatutos SQL
que ejecutan una tarea particular y se toman como
una unidad (es como una rutina en SQL)
● La mayoría de los manejadores de Bases de Datos
tiene la capacidad de programar stored procedures,
pero la sintaxis varía de una a otra, además de
otras particularidades

36. Stored Procedures
● Es conveniente que los programes en la Base de Datos
que uses y los llames desde Java, a pesar de que los
puedes crear en Java
● El llamado a un stored procedure es:
○ CallableStatement estatuto=conexion.prepareCall("{call SP}");
○ ResultSet rs = estatuto.executeQuery();
● Para crearlos desde Java:
○ Statement estatuto = con.createStatement();
○ estatuto.executeUpdate("create procedure as SP . . . . );