LABORATORIO DE PROGRAMACIÓN III: noviembre 2017

Escuela Profesional De Ingeniería De Sistemas Y Telemática

DOCENT E : MARCO POLO CHULLI

CURSO : LABORATORIO DE PROGRAMACION III

CICLO : VII

INTEGRANTES:

· v INGRID LESLY CORONEL ACUÑA

· v CRISTHIAN SERGIO KAYAP YAGKKAT

JDBC

1. CONTENIDO

CAPA DE ACCESO DE DATOS, CREACIÓN

Modelo de dos capas.

MODELO DE TRES CAPAS.

· MODELO DE DOS CAPAS

“En este modelo la aplicación JAVA o el Applet, se conectan directamente con la BD” (16). Esto significa que el driver JDBC específico para conectarse con la BD estará instalado en el sistema local. La BD puede estar en otra máquina y se accede a ella mediante red. Esta configuración también se llama Cliente/Servidor. El programa cliente envía instrucciones SQL a la BD, y esta las procesa y envía los resultados de vuelta al usuario.

· MODELO DE TRES CAPAS

En este modelo, las instrucciones son enviadas a una capa intermedia que se encarga de enviar las sentencias SQL a la BD.El manejador de BD procesa las sentencias y retorna los resultados a la capa intermedia que se encarga de enviarlos al usuario.

Como último paso, no debemos olvidar arrancar el servidor de Base de Datos, si utilizamos un gestor que incluye uno, como sucede con Interbase.

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 paquetejava.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.

Clases e interfaces definidos por JDBC.

CONFIGURACIÓN DE CONEXIÓN BD CON NETBEANS

Para realizar la conexión a base de datos desde java necesitamos hacer uso de JDBC. Las bases de datos que deseemos conectar deberán proveernos el driver JDBC en un empaquetado JAR para añadirlo a las librerías del proyecto.

Deberemos conseguir la librería de acuerdo a la versión de la Base de Datos al cual deseemos conectarnos. Es posible que su IDE reconozca la existencia del driver si la base de datos ha sido instalada en el mismo ordenador junto con sus librerías, solo haría falta añadirlo a la lista de librerías que se usarán en el proyecto, por ejemplo en NetBeans se podría ir al directorio Libraries del Proyecto, hacer clic derecho sobre él y elegir Add Library y en la lista podría encontrase la que necesitemos, o si queremos agregarla manualmente Add JAR/Folder y seleccionar desde la dirección donde lo tenemos almacenado.

Add Library:

Add JAR/Folder:

Una vez agregada la librería, vamos a realizar el código de conexión, el cual nos debe presentar una clase con 2 métodos que a mi parecer no deberían faltar. Debería existir una función (Las funciones retornan datos) que nos retorne un CachedRowSet que es algo similar al ResultSet que no podemos retornar mientras el Statement esté sin cerrar, pero es obvio que por seguridad deberemos tener todas las conexiones cerradas, por eso no retornamos directamente el ResultSet y hacerlo sin cerrar las conexiones sería de muy mala práctica.

En cambio, el CachedRowSet almacena todos los registros y podemos manipularla con las conexiones cerradas, cosa que no podemos hacer con los ResultSets, ya que éstos necesitan al Statement Abierto, y el Statement a su vez necesita la conexión abierta. Por otro lado deberíamos tener un procedimiento (No retorna ningún dato), no retorna nada ya que se encargará de realizar operaciones unidireccionales.

En conclusión, usamos la Función cuando usemos Sentencias DML SELECT incluyendo las Funciones y usar el Procedimiento cuando usemos INSERT, DELETE O UPDATE, incluyendo los StoreProcedures(Procedimientos Almacenados); aunque podemos conocer algunas bases de datos que permitan retornar datos desde StoreProcedures, lo ideal sería hacerlo desde funciones, manteniendo cada uno para su propósito. Del mismo modo, habrán podido darse cuenta que ambos métodos reciben una variable String como parámetro, ésta es nada menos que la Sentencia DML que deseamos ejecutar.

El manejo de excepciones es relativamente sencillo, lo ideal sería especificar las excepciones por cada conexion, statement y resultset para de esa manera asegurarnos que permanezcan cerradas al finalizar la ejecución o aun cuando existieran errores; de igual manera sería muy útil obligar a cerrar las conexiones desde dentro de una clausula finally anexada al try – catch.

Por último la url de conexión “jdbc:motor:servidor:puerto/basededatos”, variará a continuación de jdbc, según el motor de base de datos al que deseemos conectarnos (PostgreSQL, MySQL, Oracle, Derby, etc) , la dirección IP del servidor, el puerto y finalmente el nombre de la base de datos al que queramos acceder.

DEFINICIÓN DE JDBC. TIPOS. APLICACIONES

¿Qué es JDBC? JDBC es usado para enviar comandos SQL hacia una base de datos relacional, que puede ser Oracle, Infomix, SyBase, etc.
¿Qué hace JDBC? Establece una conexión con una BD Envía sentencias SQL Procesa los resultados Connection con = DriverManager.getConnection ( "jdbc:odbc:wombat", "login", "password"); Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM Table1"); while (rs.next()) { int x = rs.getInt("a"); String s = rs.getString("b"); float f = rs.getFloat("c"); }
JDBC es una API de bajo nivel para API´s de alto nivel Una integración de SQL hacia Java, es decir que las sentencias SQL se puedan mezclar con Java, por ejemplo, que una variable de Java pueda ser usada en una sentencia SQL para recibir o dar valores. Un mapeo directo de las tablas de la BD hacia las clases de Java, donde cala fila de la tabla se convierte en una instancia de la clase, y donde cada columna se corresponde a un atrubuto de esa instancia.
JDBC v/s ODBC y otras API´s ODBC no es apropiado para usar directamente con Java por que usa una interfaz en C. Una traducción literal de la API ODBC en C, no es deseable. Por ejemplo Java no tiene punteros y la ODBC hace gran uso de ellos. ODBC es muy difícil de aprender, hace una mezcla de acciones simples y avanzadas. Una API como JDBC es necesario para poder desarrollar una solución “puramente de Java”
Modelos de dos capas y tres capas

Conformación de SQL El SQL es el idioma normal por acceder las bases de datos correlativas. Una dificultad es que aunque la mayoría del DBMSs (los Sistemas de Dirección de Base de datos) use un formulario normal de SQL para la funcionalidad básica, ellos no conforman la sintaxis de SQL normal más recientemente definida para la funcionalidad más avanzada. Por ejemplo no todas las BD soportar procedimientos almacenados. Una manera que el API de JDBC trata de este problema es permitir cualquier sentencia sea pasada a un driver de DBMS subyacente. Para las aplicaciones complejas, JDBC trata la conformación de SQL de otra manera. Proporciona la información descriptiva sobre el DBMS por medio del DatabaseMetaData para que las aplicaciones puedan adaptar a los requisitos y capacidades de cada DBMS.
El Armazón de JDBC JavaSoft proporciona tres componentes JDBC como la parte de la JDK: el JDBC driver manager, la JDBC driver test suite el puente JDBC-ODBC. El JDBC driver manager es el espinazo de la arquitectura de JDBC. Realmente es bastante pequeño y simple; su función primaria es conectar las aplicaciones de Java al chófer de JDBC correcto y entonces salir de la manera. La JDBC driver test suite proporciona un poco de confianza en que drivers de JDBC ejecutarán su programa. Pueden designarse sólo drivers que pasan la JDBC driver test suite
El Armazón de JDBC El puente de JDBC-ODBC les permite a los drivers de ODBC ser usado como drivers de JDBC. Y a largo plazo proporcionará una manera de acceder alguno del DBMSs menos popular si no se crean los drivers de JDBC para ellos.

Con la ayuda de JDBC, la habilidad de JAVA para integrarse con DBMS comerciales y su naturaleza orientada al manejo de la Red, es posible crear un ambiente ideal tipo cliente-servidor.

JDBC. “Es una API de JAVA para permitir ejecutar instrucciones SQL”(13 (Structured Query Language: Lenguaje estructurado de consultas), que es un lenguaje de alto nivel para crear, manipular, examinar y gestionar bases de datos relacionales

Podemos decir en tres frases lo que hace JDBC:

Establece una conexión con una BD, que puede ser remota o no.

Envía sentencias SQL a la BD.

Procesa los resultados obtenidos de la BD.

JDBC es un API incluido dentro del lenguaje Java para el acceso a bases de datos. Consiste en un conjunto de clases e interfaces escritos en Java que ofrecen un completo API para la programación de bases de datos, por lo tanto, es la una solución 100% Java que permite el acceso a bases de datos, la primera aparición de JDBC (JDBC 1.0) se encuentra dentro del paquete java.sql que ha fue incorporado en la versión del JDK 1.1.x (Java Development Kit) correspondiente a la versión 1.1 del lenguaje Java, JDBC 2.0 sigue estando en el mismo paquete, pero en las versiones JDK 1.2 y JDK 1.3 que se corresponden con la versión 2 del lenguaje Java, o también denominada plataforma Java 2 (Java 2 Platform). JDBC es una especificación formada por una colección de interfaces y clases abstractas, que deben implementar todos los fabricantes de drivers que quieran realizar una implementación de su driver 100% Java y compatible con JDBC (JDBC-compliant driver) Debido a que JDBC está escrito completamente en Java también posee la ventaja de ser independiente de la plataforma. No será necesario escribir un programa para cada tipo de base de datos, una misma aplicación escrita utilizando JDBC podrá manejar bases de datos Oracle, Sybase, o SQL Server. Además, podrá ejecutarse en cualquier sistema que posea una Máquina Virtual de Java, es decir, serán aplicaciones completamente independientes de la plataforma.

FUNCIONES

Básicamente el API JDBC hace posible la realización de las siguientes tareas:

• Establecer una conexión con una base de datos.

• Enviar sentencias SQL.

• Manipular los datos.

• Procesar los resultados de la ejecución de las sentencias.

CARACTERÍSTICAS

JDBC es independiente de la plataforma al estar escrito en Java. “JDBC es una API de bajo nivel ya que hace llamadas SQL directas”(14), Sun desea que JDBC pueda ser llamado desde otra API de más alto nivel que pueda simplificar la labor del programador, aunque la utilización de JDBC es sencilla y potente. Se tiene noticia de que ya existen diversos proyectos en marcha que intentan crear estas APIs de alto nivel. Aquí el término API hace referencia a un conjunto de clases e interfaces. Una forma de ver las características de JDBC es enfrentarlo con otro API que permita también el acceso a bases de datos, uno de los más usados y extendidos es el API de Microsoft ODBC (Open DataBase Connectivity).

ODBC permite la conexión a casi todo tipo de bases de datos en casi todas las plataformas, por lo tanto ¿por qué no podemos simplemente usar ODBC desde Java? El hecho es que se puede utilizar ODBC desde Java, pero a través de JDBC con lo que se denomina el puente JDBC-ODBC (JDBC-ODBC Bridge, desarrollado por Sun e Intersolv), que se tratará más adelante. En este momento la pregunta se transforma en ¿para qué necesitamos entonces JDBC?, hay varias respuestas para esta pregunta:

v Usar ODBC directamente desde Java no es apropiado ya que usa un interfaz en C, y las llamadas desde Java a código nativo de C pueden ocasionar diversos problemas de seguridad y en la portabilidad de las aplicaciones.

v Una traducción literal del API de ODBC escrito en C no es adecuado, ya que,

Java no utiliza punteros y sin embargo ODBC hace un uso bastante frecuente de ellos. Se puede considerar que JDBC es una traducción de ODBC a un interfaz de programación orientada a objetos que es natural para los programadores de Java.

Ø ODBC es más complicado de aprender, mezcla características sencillas con avanzadas y tiene opciones complejas incluso para las consultas más sencillas.

Ø JDBC es necesario para disponer de una solución Java pura (100% puro Java). Cuando se utiliza ODBC el gestor de drivers y los drivers deben ser instalados manualmente en cada máquina cliente. Mientras que JDBC está escrito completamente en Java y su código se instala automáticamente.

TIPOS DE DRIVERS JDBC

“Los drivers nos permiten conectarnos con una base de datos determinada”(15). Existen cuatro tipos de drivers JDBC, cada tipo presenta una filosofía de trabajo diferente, a continuación se pasa a comentar cada uno de los drivers:

· El puente JDBC-ODBC: Este driver conecta Java con el ODBC de Microsoft vía métodos nativos. Este driver fue desarrollado por JavaSoft, y forma parte del JDK para Windows.

Ventajas: Dada la gran popularidad de ODBC, casi todas las bases de datos cuentan actualmente con un driver ODBC. Por esta razón, la conectividad con Java se puede hacer inmediatamente sin hacer ningún desarrollo adicional.
Desventas: El uso de métodos nativos implica que esta conectividad no se puede usar en applets. Además la conexión se vuelve más lenta por usar ODBC.

ü Un driver mixto Java - API Nativo: Este driver convierte las llamadas JDBC en llamados a métodos nátivos del cliente de la base de datos. Este driver típicamente es desarrollado por el mismo fabricante de la base de datos.
Ventajas: Casi todos los motores tienen un cliente ya probado y depurado, que hace que el desarrollo de estos driver pueda ser implementado fácilmente por todos los proveedores.
Desventajas: Tampoco se puede usar en applets debido al llamado a métodos nativos.

ü Un driver Gateway: Este driver traduce los llamados JDBC en un protocolo independiente del motor, que luego es traducido a en protocolo específico de la base de datos en un servidor intermedio. Este servidor (gateway) puede conectar los clientes Java con muchos proveedores de bases de datos diferentes usando un sólo driver en el cliente.
Ventajas: Esta es la alternativa más flexible para conectarse con diferentes motores de bases de datos simultáneamente. Además, como el driver está totalmente desarrollado en Java, puede funcionar en applets y aplicaciones.
Desventajas: El uso de una máquina intermedia hace necesariamente más lenta la transferencia de datos que usando drivers tipo 2 ó 4.
Nota: La versión Cliente/Servidor de JBuilder trae un driver de este tipo llamado "Borland DataGateway", que brinda conexión nativa de muy alto desempeño con los siguientes motores de bases de datos: Oracle, InterBase, Sysbase, Informix, DB2, MS SQL, Access, FoxPro, dBase y Páradox. Este driver también soporta conexiones ODBC.

ü Un driver JDBC 100% Java Puro con Protocolo Nativo: Este driver convierte todas las llamadas JDBC a un protocolo de red específico al manejador de bases de datos. Esta es la solución ideal para casi todas las situaciones.

Ventajas: La eliminación de intermediarios, hace que el rendimiento accesando la base de datos sea óptimo. Al ser un driver sólo Java, puede funcionar tanto en applets como en aplicaciones.

Desventajas: Es el tipo de driver más difícil de implementar por los proveedores de bases de datos, porque involucra desarrollo en el cliente y en el servidor. Muchos proveedores no ofrecen aún esta forma de conectividad.

La forma más apropiada de accesar bases de datos en Java es vía JDBC. Para usarlo debemos conseguir un driver JDBC apropiado para el motor. Existen cuatro tipos de drivers JDBC. Los mejores son los tipos 3 (Gateway) y 4 (driver 100% Java con Protocolo Nativo).

Paquete java.sql

JDBC ofrece el paquete java.sql, en el que existen clases muy útiles para trabajar con bases de datos.

Clase	Descripción
DriverManager	Para cargar un driver
Connection	Para establecer conexiones con las bases de datos
Statement	Para ejecutar sentencias SQL y enviarlas a las BBDD
PreparedStatement	La ruta de ejecución está predeterminada en el servidor de base de datos que le permite ser ejecutado varias veces
ResultSet	Para almacenar el resultado de la consulta

USO DE JDBC EN APLICACIONES JAVA

JDBC (Java Database Connectivity) es un API de Java que nos permite conectarnos con bases de datos y realizar operaciones sobre ellas utilizando instrucciones SQL desde una aplicación Java. Con JDBC tenemos una interfaz para conectarnos con una base de datos sin tener que preocuparnos de si es una base de datos MySQl, Oracle, SQLServer o cualquier otro tipo de base de datos. El único cambio que habría que hacer para cambiar el tipo de base de datos de una aplicación sería cambiar el driver específico de la base de datos en cuestión.

Para usar JDBC hay que seguir los siguientes pasos:

v Incluir el jar con el Driver de la base de datos

El primer paso es obtener el driver de la base de datos que vamos a utilizar, buscamos en google “MySQL jdbc driver”, “Oracle jdbc driver” o el que queramos y descargamos el jar y lo incluimos es nuestro proyecto. Para este ejemplo voy a usar MySQL, puedes descargarlo desde aquí, lo que queremos es el .jar por lo que tienes que elegir Plataform Independent y descargar el zip o el tar.gz, y aunque vienen unos cuantos archivos y carpetas el único que nos interesa es mysql-connector-java-5.1.26-bin.jar que lo tenemos que añadir a nuestro proyecto.

v Cargar el driver

Ya tenemos el jar con el driver, pero hay que cargarlo para que se pueda hacer uso de el en nuestra aplicación. En nuestro caso como vamos a usar MySQL la instrucción es la siguiente y como puede lanzar una excepción pues se mete dentro de un try-catch.

try {

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

} catch (ClassNotFoundException ex) {

log.error("No se encontro el Driver MySQL para JDBC.");

v Establecer una conexión con la base de datos

El siguiente paso es establecer una conexión con la base de datos. Hay dos opciones para obtener una conexión la primera es crear una nueva conexión con la base de datos que será la que veremos en este ejemplo y la otra es obtener la conexión de un pool de conexiones creado previamente que es una opción más eficiente porque no hace falta estar abriendo y cerrando conexiones continuamente ya que simplemente se cogen las conexiones de pool cuando se necesitan y se dejan en el pool cuando ya no se necesitan para que puedan volver a usarse. En un artículo previo, como un pool de conexiones en Tomcat, puedes ver un ejemplo de cómo usar un pool de conexiones con dicho servidor pero para un ejemplo de una aplicación de escritorio como la que vamos a ver supuestamente vamos a tener pocas llamadas a base de datos por lo que no se va a notar mucha diferencia.

1 2	//Connection cn = DriverManager.getConnection("jdbc:mysql://servidor_bd:puerto/nombre_bd", "usuario", "contraseña"); Connection cn = DriverManager.getConnection("jdbc:mysql://localhost:3306/cuentas", "root", "");

Para obtener una conexión tenemos que hacer uso del método getConnection de DriverManager y le tenemos que pasar como parámetros, la base de datos, el usuario y la contraseña. Si en lugar de usar mysql se usa otra base de datos el formato de la url de la base de datos cambia, por ejemplo para oracle el formato es jdbc:oracle:<tipo_driver>:@<<base_datos>.

Realizar una consulta

Una vez obtenida la conexión ya podemos hacer consultas a la base de datos. Hay tres métodos para ejecutar una consulta de tipo Statement que es una consulta normal, PreparedStatement con la que se puede crear una consulta que se precompila en la base de datos y como es de esperar se pueden establecer los distintos datos porque aunque la estructura de la consulta será la misma lo lógico es que los datos de la consulta sean distintos y finalmente están las CallableStatements que sirven para ejecutar procedimientos almacenados.

Vamos a ver cómo hacer una consulta de tipo Statement:

// Creamos el Statement para poder hacer consultas

Statement st = cn.createStatement();

// La consulta es un String con código SQL

String sql1 = "SELECT * FROM cuentas";

// Ejecuta una consulta que devuelve resultados

ResultSet rs = st.executeQuery(sql1);

while (rs.next())

{

System.out.println (rs.getString ("propietario") + " " + rs.getString (2)+ " " + rs.getInt(saldo));

String sql2 = "UPDATE cuentas SET saldo = saldo - "

+ cantidad + " WHERE codigo = '"

+ codigo + "' AND saldo >= "

+ cantidad;

// Ejecuta una consulta de tipo insert, update o delete

st.executeUpdate(sql2);

Como se puede ver el primer paso es crear un statement sobre el que luego podemos hacer las consultas que queramos, una vez creado para hacer nuestra consulta tenemos los métodos execute (para hacer cualquier consulta, pero su valor de devolución es boolean y devuelve true si lo que devuelve es un resulset y falso en caso contrario), exeteQuery (para hacer select) y executeUpdate (para hacer insert, update y delate). Y finalmente si se ejecuta una query podemos obtener el resultado mediante ResultSet, para obtener los valores de las columnas resulset tiene un get para cada tipo de datos que se puede llamar pasándole como parámetro el nombre de la columna de base de datos o el número de la columna según se prefiera.

Como se puede ver el código para hacer una consulta no es muy complicado, pero es muy propenso a errores porque hay que estar creando cadenas de texto concatenadas con variables java y hay que recordar que si el dato es de tipo texto hay que anidar comillas y entre unas cosas y otras es fácil cometer algún error. Para facilitar el trabajo con bases de datos hay alternativas a trabajar directamente con JDBC como JPA o Hibernate, pero estamos hablando de JDBC…

¿Si usamos PreparedStatement además de que son más eficientes nos facilitan la tarea de escribir las consultas SQL porque en lugar de tener que estar concatenando las distintas variables con el código SQL, lo que se hace es sustituir en este las variables por? Y posteriormente se introducen los datos concretos mediante setter. En el siguiente código puedes ver como se crean unas PreparedStatement.

PreparedStatement pstBuscarCodigo;

PreparedStatement pstInsertarCuenta;

String sqlBusqueda = "SELECT codigo FROM cuentas WHERE codigo=?";

pstBuscarCodigo= cn.prepareStatement(sqlBusqueda);

pstBuscarCodigo.setString(1, codigo);

ResultSet= pstBuscarCodigo.executeQuery();

if (! rs.next){...}

String sqlNuevaCuenta = "INSERT INTO cuentas VALUES

pstInsertarCuenta = cn.prepareStatement(sqlNuevaCuenta);

pstInsertarCuenta.setString(1, codigo);

pstInsertarCuenta.setString(2, nombre);

pstInsertarCuenta.setString(3, email);

pstInsertarCuenta.setDouble(4, saldo);

pstInsertarCuenta.executeUpdate();

CERRAR LA CONEXIÓN

Después de hacer las consultas que se necesite se debe de cerrar la conexión para liberar los recursos, también se pueden cerrar el resulset y el statement de forma manual, pero cerrando la conexión se cierran los otros dos porque están creados a partir de la conexión, del mismo modo al cerrar el statement también se liberan los recursos del resulset.

rs.close(); // Cierra el resulset

st.close(); // Cierra el statement

cn.close(); // Cierra la conexión

EJEMPLOS

Una vez visto más o menos como funciona vamos a ver unos ejemplos de cómo usar JDBC.

La base de datos para los ejemplos será la siguiente:

En este primer ejemplo se crea la conexión y los prepareStatements en el constructor por lo que luego podemos usarlo sin tener que crear una nueva conexión para insertar un nuevo dato, pero no cerramos nunca la conexión porque si la cerrásemos como se está creando en el constructor ya no se podría volver a usar.

Este primer ejemplo consiste en una aplicación que permite almacenar una nueva cuenta en la base de datos siempre y cuando el código de la cuenta no esté ya en la base de datos. En este ejemplo se usan PreparedStatements.

Una de las cosas que podemos ver en el ejemplo y que siempre se deben de hacer es declarar la conexión, los statements y los resultsets fuera de los bloques try catch, porque puede pasar que como en este ejemplo la conexión se cree en un sitio y luego se use en otro (lo normal sería tener una clase específica para crear la conexión con la base de datos) y aunque no fuese así lo normal es cerrar la conexión en un bloque finally porque aunque en este no cerramos la conexión lo normal y recomendable es hacerlo, sin ir más lejos en los siguientes ejemplos si se cierra la conexión en el finally porque la conexión hay que cerrarla tanto si la ejecución ha sido correcta como si se produce alguna excepción.

package ejemplo1;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.sql.*;

import javax.swing.JLabel;

import org.apache.log4j.Logger;

@author Ivan Salas Corrales <http://programandoointentandolo.com/>

public class CreaCuenta implements ActionListener {

private Logger log = Logger.getLogger(CreaCuenta.class);

private Ventana v;

private Connection cn;

private PreparedStatement pstBuscarCodigo;

private PreparedStatement pstInsertarCuenta;

public CreaCuenta(Ventana v) {

this.v = v;

try {

// Driver para conectar con MySQL

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

// Conexion con la base de datos cn = DriverManager.getConnection("jdbc:mysql://localhost:3306/cuentas", "root", "");

String sqlBusqueda = "SELECT codigo FROM cuentas WHERE codigo=?";

pstBuscarCodigo = cn.prepareStatement(sqlBusqueda);

String sqlNuevaCuenta = "INSERT INTO cuentas VALUES (?,?,?,?)";

pstInsertarCuenta = cn.prepareStatement(sqlNuevaCuenta);

} catch (SQLException ex) {

log.error("Error " + ex.getErrorCode() + ": " + ex.getMessage());

} catch (ClassNotFoundException ex) {

log.error("No se encontro el Driver MySQL para JDBC."); } }

@Override

public void actionPerformed(ActionEvent e) {

String codigo = v.getTextCodigo().getText();

String nombre = v.getTextNombre().getText();

String email = v.getTextEmail().getText();

double saldo = (double) v.getTextSaldo().getValue();

JLabel lbMensaje = v.getLbMensaje();

try {

pstBuscarCodigo.setString(1, codigo);

// Si el codigo no esta en la bd se añade la cuenta

ResultSet rs = pstBuscarCodigo.executeQuery();

if (!rs.next()) {

pstInsertarCuenta.setString(1, codigo);

pstInsertarCuenta.setString(2, nombre);

pstInsertarCuenta.setString(3, email);

pstInsertarCuenta.setDouble(4, saldo);

pstInsertarCuenta.executeUpdate();

lbMensaje.setText("Cuenta agregada correctamente");

} else {

lbMensaje.setText("El codigo indicado ya esta en la base de datos"); }

} catch (SQLException ex) {

log.error("Error " + ex.getErrorCode() + ": " + ex.getMessage());

} }}

Como supongo que te habrás dado cuenta el código anterior es el de una clase que implementa ActionListener por lo que como te podrás imaginar que es parte de una aplicación Swing, pero como eso no aporta nada al entendimiento de JDBC no lo pongo, aunque al final puedes descargarte el proyecto con los ejemplos y ver y probar los ejemplos concretos.

La aplicación del segundo ejemplo sirve para hacer transferencias entre las cuentas. Con este ejemplo vamos a aprovechar para ver cómo crear transacciones y deshacerlas si falla alguna de las operaciones. En este ejemplo se usan statement para ver lo tedioso que puede ser.

Cuando usamos JDBC por defecto cuando hacemos un execute XXX ya sea con una statement o una preparedstatement la operación se realiza inmediatamente pero hay ocasiones en las que este no será el comportamiento deseado como es el caso de este ejemplo, porque la operación que global que queremos hacer es sacar el dinero de una cuenta y meterlo en otra, pero si usamos el funcionamiento estándar si se extrae el dinero de la primera cuenta y luego hay un error al insertar el dinero en la segunda cuenta el dinero habrá desaparecido y esto no es un comportamiento aceptable por lo que lo lógico sería que si falla la segunda operación se deshaga la primera y todo quede como antes de empezar la operación.

package ejemplo2;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.Date;

import org.apache.log4j.Logger;

@author Ivan Salas Corrales

<http://programandoointentandolo.com/>

public class Transferir implements ActionListener {

private Logger log = Logger.getLogger(Transferir.class);

private Transferencias t;

public Transferir(Transferencias t) {

this.t = t;

}

@Override

public void actionPerformed(ActionEvent e) {

Connection cn = null;

try {

// Driver para conectar con MySQL

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

cn= DriverManager.getConnection("jdbc:mysql://localhost:3306/cuentas", "root", "");

// Obtenemos la fecha actual

Date date = new Date();

Date fecha = new java.sql.Date(date.getTime());

String sqlCuenta1 = "UPDATE cuentas SET saldo = saldo - "

t.getTfCantidad().getValue() + " WHERE codigo = '" + t.getTfCuenta1().getText()

+ "' AND saldo >= " + t.getTfCantidad().getValue();

String sqlMovimiento1 = "INSERT INTO movimientos SET codigo = '

+ t.getTfCuenta1().getText() + "', tipo = '1', cantidad= 0-"

+ t.getTfCantidad().getValue() + ", fecha= '" + fecha + "'";

String sqlCuenta2 = "UPDATE cuentas SET saldo = saldo + "

+ t.getTfCantidad().getValue() + " WHERE codigo = '" + t.getTfCuenta2().getText() + "'";

String sqlMovimiento2 = "INSERT INTO movimientos SET codigo =

+ t.getTfCuenta2().getText() + "', tipo = '1', cantidad= "

+ t.getTfCantidad().getValue() + ", fecha= '" + fecha + "'";

Statement st = cn.createStatement();

// Indica que las operaciones no se validan automaticamente

cn.setAutoCommit(false);

// Si se hacen ambas actualizaciones se hace la transaccion y sino se deshace

if ((st.executeUpdate(sqlCuenta1) != 0) && (st.executeUpdate(sqlCuenta2) != 0)

&&(st.executeUpdate(sqlMovimiento1) != 0) && (st.executeUpdate(sqlMovimiento2) != 0)) {

// Ejecuta la transaccion

cn.commit();

t.setLbResultado("Transeferencia completada.");

} else {

// Deshace los cambios hechos dentro de la transaccion

cn.rollback();

t.setLbResultado("Error: La transeferencia no se ha completado.");

} } catch (SQLException ex) {

log.error("Error " + ex.getErrorCode() + ": " + ex.getMessage());

try {

// Deshace los cambios hechos dentro de la transaccion

cn.rollback();

.setLbResultado("Error: La transeferencia no se ha completado.");

} catch (SQLException ex1) {

log.error("Error " + ex1.getErrorCode() + ": " + ex1.getMessage());

}

} catch (ClassNotFoundException ex) {

log.error("No se encontro el Driver MySQL para JDBC.");

} finally {

try {

cn.close();

} catch (SQLException ex) {

log.error("Error " + ex.getErrorCode() + ": " + ex.getMessage());

} } }}

Para poder controlar cuando se hacen las transacciones para poder englobar las operaciones que nosotros queramos dentro de la misma transacción lo primero es indicar que no queremos que las operaciones se hagan automáticamente (cn.setAutoCommit(false)) y luego se ejecutan las operaciones como se hace normalmente y cuando se han hecho todas se hace el commit o si ha fallado algo se hace un rollback para deshacer las operaciones. Lo normal es comprobar que se han hecho correctamente las operaciones y entonces hacer el commit o el rollback si han fallado, pero también se debería de hacer un rollback en el catch porque si se produce alguna excepción será que algo a fallado por lo que habrá que deshacerlo por si acaso queda la base de datos en algún estado inconsistente (Que no se realice correctamente un executeXXX no quiere decir que se tenga que lanzar una excepción porque por ejemplo si se intenta transferir más saldo del disponible no se produce ninguna excepción pero el update correspondiente no produce ningún cambio en la base de datos por lo que hay que controlarlo).

Y finalmente en último ejemplo vamos a hacer una sencilla aplicación que muestra la lista de operaciones realizadas sobre una cuenta y para ver algo nuevo los datos de la consulta se obtienen de dos tablas distintas usando un join, aunque esto es cosa del sql y para la parte java no hay nada distinto y vamos coger los datos del resulset obtenidos de la consulta para mostrarlos en una tabla.

Java

package ejemplo3;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.sql.*;

import javax.swing.JTextField;

import javax.swing.table.DefaultTableModel;

import org.apache.log4j.Logger;

* @author Ivan Salas Corrales <http://programandoointentandolo.com/>

public class MuestraMovimientos implements ActionListener {

private Logger log = Logger.getLogger(MuestraMovimientos.class);

private DefaultTableModel dtm;

private Connection cn;

private JTextField tfCuenta;

public MuestraMovimientos(DefaultTableModel dtm, JTextField tfCuenta) {

this.dtm = dtm;

this.tfCuenta = tfCuenta;

}

@Override

public void actionPerformed(ActionEvent e) {

String tipo;

String cantidad;

String fecha;

// Se borra el contenido de la tabla

int i = 0;

while (dtm.getRowCount() > 0) {

dtm.removeRow(i);

}

try {

// Driver para conectar con MySQL

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

DriverManager.getConnection("jdbc:mysql://localhost:3306/cuentas", "root", "");

String sqlBusqueda = "SELECT tm.tipo, m.cantidad, m.fecha FROM movimientos AS m INNER JOIN tipos_movimiento AS tm ON tm.id=m.tipo WHERE m.codigo=?";

PreparedStatement psBusqueda = cn.prepareStatement(sqlBusqueda);

psBusqueda.setString(1, tfCuenta.getText());

ResultSet listaMovimientos = psBusqueda.executeQuery();

// Se ponene en la tabla los valores obtenidos de la consulta

while (listaMovimientos.next()) {

tipo = listaMovimientos.getString("tipo");

cantidad = listaMovimientos.getString("cantidad");

fecha = listaMovimientos.getString("fecha");

dtm.addRow(new String[]{tipo, cantidad, fecha});

}

// Cierro el ResultSet y el Statement aunque al cerrar el Statement ya se cierra el ResulSet

listaMovimientos.close();

psBusqueda.close();

} catch (SQLException ex) {

log.error("Error " + ex.getErrorCode() + ": " + ex.getMessage());

} catch (ClassNotFoundException ex) {

log.error("No se encontro el Driver MySQL para JDBC.");

} finally {

try {

// Cierra la conexion con la base de datos

cn.close();

} catch (SQLException ex) {

log.error("Error " + ex.getErrorCode() + ": " + ex.getMessage());

}

RESUMEN

JDBC es el funcionamiento básico de tecnología JAVA de la base de datos, no es la única tecnología. Hibernate Técnica, TopLink, etc. o base de datos Mapping operaciones se construyen en la parte superior de la tecnología JDBC, en términos prácticos, su rendimiento y JDBC es una gran diferencia, pero a la inversa, si JDBC con el mal, no es tan bueno como se hibernar. Dejando a un lado los méritos de estas palabras, de nuevo principalmente sobre la base de la tecnología Java para ser un resumen, con el fin de profundizar la comprensión. En realidad, define un conjunto estándar de interfaces para operar la base de datos. Con el fin de permitir a Java para operar la base de datos, usted debe haber dado cuenta de la JDBC clase estas interfaces, diferentes proveedores de bases de datos con el fin de hacer que el lenguaje Java puede operar su propia base de datos, JDBC proporciona para la implementación de la interfaz - estas clases que implementan las interfaces JDBC pelean en un paquete frasco, lo que solemos ver la base de datos impulsada. Debido a los diferentes mecanismos de datos de las operaciones de base de datos no es lo mismo, por lo que la realización concreta de JDBC variará, pero como programador java, sólo y Java JDBC interfaz entregado juego, no importa cómo lo lograron! Oh, ahora sé cómo el controlador JDBC historia.

SUMARY

JDBC is the basic operation of JAVA technology of the database, it is not the only technology.

 Technical Hibernate, TopLink, etc. or database mapping operations are built on top of the

JDBC technology, in practical terms, its performance and JDBC is a huge difference, but

conversely, if JDBC with evil, it is not as good as hibernate. Leaving aside the merits of these

words , again mainly based on Java technology to be a summary , in order to deepen

understanding . Actually , it defines a standard set of interfaces to operate the database .

In order to allow Java to operate the database , you must have noticed the JDBC class these

interfaces, different providers databases in order to make the Java language can operate

your own database , JDBC It provides for the implementation of the interface - these classes

that implement the JDBC interfaces fight in a jar package, we usually see the database

driven . Due to the different mechanisms of operations data database is not the same , so the

concrete realization of JDBC vary , but as a java programmer , and Java JDBC interface only

given game, no matter how they did it ! Oh , now I know how the story JDBC driver .

RECOMENDACIONES

Para que exista un enlace remoto con la Base de Datos, la aplicación no debe de conectarse directamente a la Base de Datos, sino que mediante los drivers JDBC - ODBC.

Ø El diseño y desarrollo de las nuevas aplicaciones conduce a la minimización del ingreso de datos por parte del usuario; además el lenguaje de desarrollo que se utiliza, está orientado a facilitar la ejecución en cualquier Sistema Operativo, ya que se ajusta a los estándares reconocidos, que permite la flexibilidad de los cambios.

Ø Se recomienda a poner en disposición de los alumnos de la Universidad la Aplicación de consulta de notas, dado que le ahorraría costo y tiempo para la obtención de las notas requeridas, desde el punto de consultas.

CONCLUSIONES

J JDBC se puede utilizar para conectarse a bases de datos relacionales de los programas de Java

J JDBC puede crear una dependencia sin querer a un proveedor de base de datos específica

L Los drvers JDBC y ODBC establecen la estructura para el diseño y generación de conexiones accesos a Base de Datos remotas; por lo que facilita el desarrollo de nuevas aplicaciones que la Universidad desee implementar en un futuro, orientados con este fin.

APRECIACIÓN DEL EQUIPO

La API de JDBC provee acceso a datos desde Java. Usando esta API podemos acceder a variadas fuentes de datos: bases de datos relacionales, hojas de cálculo (spreadsheets) y archivos planos.

Este paquete permite conectarse a una base de datos, consultarla o actualizarla usando SQL. Su manejo es de importancia debido a la frecuencia con que las bases de datos son usadas hasta hoy. En resumen es un puente a los datos

Así como con Java se logra independencia de la plataforma, al trabajar con JDBC se logra además independencia del proveedor de la base de datos.

Una dificultad enfrentada por los desarrolladores de JDBC fue que existen muchos proveedores de bases de datos cada uno usando su propio protocolo. Es así como se acordó el desarrollo de una API Java para SQL, la cual accede la base de datos vía un administrador de drivers de terceros los cuales se conectan a bases de datos específicas. Cada proveedor de bases de datos debía generar su propiodriver conectable al administrador de drivers.

JDBC sigue un modelo similar al de ODBC. Por esto una opción común es conectar JDBC a través de un driver que actúa como puente entre JDBC y ODBC.

Es necesario instalar dicho conector para que las máquinas proveedoras de datos lo usen. Con MySQLinstalado y el driver JDBC instalado podemos ejercitar la conexión de Java con su base de datos.

Todo programa Java que desea conectarse a una base de datos necesita cargar el driver específico para la base de datos a usar.

GLOSARIO DE TÉRMINOS

Ø API: Una API (siglas de 'Application Programming Interface') es un conjunto de reglas (código) y especificaciones que las aplicaciones pueden seguir para comunicarse entre ellas: sirviendo de interfaz entre programas diferentes de la misma manera en que la interfaz de usuario facilita la interacción humano-software.

Ø ODBC: Open DataBase Connectivity (ODBC) es un estándar de acceso a las bases de datos desarrollado por SQL Access Group (SAG) en 1992. El objetivo de ODBC es hacer posible el acceder a cualquier dato desde cualquier aplicación, sin importar qué sistema de gestión de bases de datos (DBMS) almacene los datos.

Ø APPLETS: Un applet es un componente de una aplicación que corre en el contexto de otro programa, por ejemplo un navegador web. El applet debe correr en un contenedor, que lo proporciona un programa anfitrión, mediante un plugin.

LINKOGRAFÍA

https://saforas.wordpress.com/2011/01/17/codigo-java-establecer-conexion-a-base-de-datos-con-jdbc/

http://html.rincondelvago.com/bases-de-datos_puente-jdbc-odbc.html

http://programandoointentandolo.com/2013/09/tutorial-jdbc-con-aplicaciones-de-ejemplo.html

https://users.dcc.uchile.cl/~lmateu/CC60H/Trabajos/jfernand/

http://www.justdocument.com/download/23333667170/resumen-de-programacion-jdbc/

HOLA AMIGOS AQUÍ LES DEJO MIS DIAPOSITIVAS ESTE ES EL LINK
https://www.slideshare.net/INGRIDLESLYCORONELAC/jdbc-82079428

martes, 14 de noviembre de 2017

JDBC