JAVA CON BASE DE DATOS
ÍNDICE:
1
JAVA CON BASE DE DATOS
1.1 Definición:
Java Database Connectivity, más
conocida por sus siglas JDBC, es una API que permite la ejecución de
operaciones sobre bases de datos desde el lenguaje de
programación Java, independientemente del
sistema operativo donde se ejecute o de la base
de datos a la cual se accede,
utilizando el dialecto SQL del modelo de base de datos que se utilice.
El API
JDBC se presenta como una colección de interfaces
Java y
métodos de gestión de manejadores de conexión hacia cada modelo específico de
base de datos. Un manejador de conexiones hacia un modelo de base de datos en
particular es un conjunto de clases que implementan
las interfaces Java y que
utilizan los métodos de registro para declarar los tipos de localizadores a
base de datos (URL) que pueden manejar. Para utilizar una base de datos
particular, el usuario ejecuta su programa junto con la biblioteca de conexión
apropiada al modelo de su base de datos, y accede a ella estableciendo una
conexión; para ello provee el localizador a la base de datos y los parámetros
de conexión específicos. A partir de allí puede realizar cualquier tipo de tarea
con la base de datos a la que tenga permiso: consulta, actualización, creación,
modificación y borrado de tablas, ejecución de procedimientos
almacenados en la base de datos, etc.
JDBC o Java Data Base Connectivity fue creado por la empresa Sun, es la
API estándar de acceso a bases de datos con Java. Sun optó por crear una nueva
API en lugar de utilizar ODBC, porque esta última presentaba algunos problemas
desde ciertas aplicaciones Java. ODBC es una interfaz escrita en lenguaje C, que,
al no ser un lenguaje portable, hacía que las aplicaciones Java también
perdiesen la portabilidad. Además, ODBC ha de instalarse manualmente en cada
máquina, mientras que los controladores (drivers) JDBC
que están escritos en Java son automáticamente instalables y portables. El
nivel de abstracción al que trabaja JDBC es más alto que el de ODBC y, de esta
forma, se pueden crear librerías de más alto nivel.
Fuente: Taller de Base de Datos.
1.2 OBJETOS
CONNECTION, STATEMENT Y RESULTSET:
1.2.1
Connection:
Un objeto Connection
representa una conexión a una base de datos. Una sesión con una conexión incluye
las sentencias SQL que son ejecutadas y los resultados que son devueltos a
través de dicha conexión. Una misma
aplicación puede tener una o más conexiones con una sola base de datos o puede
tener conexiones con varias bases de datos
diferentes.
La forma estándar de establecer una conexión con una base de datos
es llamando al método DriverManager.getConnection.
Este método toma como parámetro una cadena de caracteres que contiene una URL.
La clase DriverManage trata de
localizar el driver que pueda conectar con la base de datos representada por
esa URL.
El siguiente
código ejemplifica cómo abrir una conexión a una base de datos localizada en la
URL “jdbc:odbc:wombat”:
· String url =
_jdbc:odbc:wombat_;
· Connection con =
DriverManager.getConnection(url);
Una URL de JDBC
facilita una forma de identificar una base de datos de forma que el driver
apropiado la reconozca y establezca una conexión con ella. La sintaxis estándar
para URLs de JDBC es la siguiente:
· jdbc:<subprotocolo>:<subnombre>
Una URL de JDBC
tiene tres partes separadas por dos puntos:
· jdbc es el protocolo. El
protocolo en una URL JDBC es siempre jdbc.
<subprotocolo> es usualmente el driver o el mecanismo de conectividad de la base
de datos, el cual debe ser soportado por uno o más drivers. Un ejemplo de un
subprotocolo es odbc, que ha sido
reservado para URLs que especifican fuentes de datos de ODBC. Por ejemplo, para
acceder a una base de datos a través del Puente JDBC-ODBC se usará una URL como
la siguiente:
jdbc:odbc:fred
Donde el
subprotocolo es odbc y el subnombre
es fred, una fuente de datos ODBC.
<subnombre> es una forma de
identificar la base de datos. Puede variar dependiendo del subprotocolo y puede
tener un subsubnombre con cualquier sintaxis interna que el programador del
driver haya elegido.
La función
del <subnombre> es dar la
suficiente información para localizar la base de datos.
1.2.2
Statement:
Un objeto Statement se
usa para enviar sentencias SQL a una base de datos. Una vez que se ha
establecido una conexión con una base de datos particular, esa conexión puede
ser usada para enviar
sentencias SQL. Un objeto Statement
se crea con el método creatStatement
de Connection como en el siguiente
fragmento de código:
Connection con =
DriverManager.getConnection(url);
Statement stmt =
con.createStatement();
La sentencia SQL que será enviada a la base de datos es
proporcionada como argumento a uno de los métodos para ejecutar un objeto Statement:
ResultSet rs =
stmt.executeQuery(“SELECT a, b, c FROM Table2”);
1.2.3
ResultSet:
Un ResultSet contiene
todos los registros (filas) que satisfacen las condiciones impuestas en una
sentencia SQL y proporciona acceso a los datos en dichos registros a través de
un conjunto de métodos get que permiten
acceder a los diferentes campos o atributos (columnas) del registro actual. Un
ResultSet mantiene un cursor que apunta al registro actual. El
método ResultSet.next() se usa para
moverse al siguiente registro del ResultSet, haciendo el siguiente
registro el registro actual.
Los métodos getXXX proporcionan
los medios para obtener los valores de los campos, atributos o columnas del
registro actual. Para cada registro, los valores de las columnas pueden ser
obtenidos en cualquier orden, pero para la mayor portabilidad, se debe hacer de
izquierda a derecha y leer el valor de la columna sólo una vez. Tanto el nombre
de la columna como el número de esta puede ser usado para designar la columna
de la cual se quiere obtener el valor. Si en el ejemplo anterior la columna “a”
es de tipo entero, la “b” del tipo cadena de caracteres y la “c” de tipo coma
flotante, la siguiente porción de código imprimiría los valores de todos los registros:
while(rs.next()){
int i =
rs.getInt(“a”);
String s =
rs.getString(″b″);
Float f =
rs.getFloat(″c″);
System.out.println(″ROW=
″ +i+″″+s+″″+ f);}
JDBC CON
BASE DE DATOS:
Las tecnologías que se emplea para la conectividad entre
los datos y la aplicación, se ha convertido en un factor muy importante a la
hora de desarrollar un proyecto web que cuente con funcionalidad de acceso a
datos. A continuación, se muestra un cuadro comparativo de las dos tecnologías
más importantes en este sentido: ActiveX Data Objects (ADO) y Java Data Base
Connectivity (JDBC).
|
ADO
|
JDBC
|
|
|
Las API's que se describen a
continuación, son un claro ejemplo del proceso correspondiente a la
conectividad de datos.
Ø ODBC (Open Data
Base Connectivity): Esta tecnología
proporciona una interfaz común para tener acceso a bases de datos SQL
heterogéneas. ODBC está basado en SQL (Structured Query Language) como un
estándar para tener acceso a datos. ODBC permite la conexión fácil desde varios
lenguajes de programación y se utiliza mucho en el entorno Windows. Sobre ODBD
Microsoft ha construido sus extensiones OLE DB y ADO. Los OCBD se pueden
clasificar en 3 categorías:
o Los ODBC's que permitan la realización de
consultas y actualizaciones.
o Los ODBC's que mediante ellos se pueda llegar
a la creación de tablas en la base de datos.
o Los ODBC's propios de los DBMS, los cuales se
pueden llegar a manipular ciertas herramientas de administración.
Ø CGI
(Common Gateway Interface): es una de las
soluciones que se está utilizando más para la creación de interfaces Web/DBMS.
Entre las ventajas de la programación CGI, destaca la sencillez, ya que es muy
fácil de entender, además de ser un lenguaje de programación independiente, ya
que los escritos CGI pueden elaborarse en varios lenguajes. También es un
estándar para usarse en todos los servidores Web, y funcionar bajo una
arquitectura independiente, ya que ha sido creado para trabajar con cualquier
arquitectura de servidor Web. Como la aplicación CGI se encuentra funcionando
de forma independiente, no pone en peligro al servidor, en cuanto al
cumplimiento de todas las tareas que éste se encuentre realizando, o al acceso
del estado interno del mismo. Pero el CGI presenta cierta desventaja en su
eficiencia, debido al que el servidor Web tiene que cargar el programa CGI y
conectar y desconectar con la base de datos cada vez que se recibe una
requisición. Además, no existe un registro del estado del servidor, sino que
todo hay que hacerlo manualmente.
Ø ISAPI (Internet Server Application
Programming Interface): Es la interfaz propuesta por Microsoft como
una alternativa más rápida que el CGI, y está incluida en el Servidor Microsoft
Internet Information (IIS). Así como los escritos CGI, los programas escritos
usando ISAPI habilitan un usuario remoto para ejecutar un programa, busca
información dentro de una base de datos, o intercambia información como otro
software localizado en el servidor. Los programas escritos usando la interfaz
ISAPI son compilados como bibliotecas de enlace dinámico (DLL - Dinamic Link
Library), ya que son cargados por el servidor Web cuando éste se inicia. Dichos
programas se vuelven residentes en memoria, por lo que se ejecutan mucho más
rápido que las aplicaciones CGI, debido a que requieren menos tiempo de uso de
CPU al no iniciar procesos separados. Uno de los programas ISAPI más usados es
el HTTPODBC.DLL que se usa para enviar y/o devolver información hacia y desde
las bases de datos, a través de ODBC. Además, ISAPI permite realizar un
procesamiento previo de la solicitud y uno posterior de la respuesta, con lo
cual manipula la solicitud/respuesta HTTP. Los filtros ISAPI pueden utilizarse
para aplicaciones tales como autenticación, acceso o apertura de sesión.
Ø NSPAI. es la API propuesta por Netscape para extender la
funcionalidad de sus servidores.
Ø DBI (PERL): Perl es uno de los lenguajes más utilizados para
programación en la Web y proporciona su propia interfaz de acceso a datos,
llamada DBI (DataBase Interface). Es especialmente utilizado bajo
plataformas Linux/Unix, solucionando las complejidades de ODBC en estos
sistemas. DBI actúa como una abstracción para un conjunto de módulos DBD (DataBase
Driver). Cada módulo DBD actúa como manejador de un sistema gestor de base
de datos distinto. Existen módulos para prácticamente cualquier SGBD (Oracle, Informix, MySQL,
etc.) y puentes hacia otras tecnologías como ADO, JDBC ...
Ø JDBC (Java Data Base Connectivity): se
trata del estándar para la conectividad entre el lenguaje Java y un amplio
rango de sistemas gestores de bases de datos. Los JDBC pueden desenvolverse
tanto en un nivel cliente, esto es, trabajando del lado de la aplicación, o en
el servidor directamente relacionado con la base de datos. Cuando se encuentre
a nivel cliente, trabajará con la tecnología ODBC para acceso a los datos. Hay
diversos tipos de controladores JDBC:
o El puente
JDBC-OBDC: fue uno de los primeros
controladores disponibles, implementa un enlace para utilizar un controlador
ODBC desde Java. Con el tiempo han surgido controladores JDBC específicos para
cada base de datos que mejoran el rendimiento del puente JDBC-ODBC.
o Controladores Java
parcialmente nativos: usan tanto código
Java como binario específico de cada plataforma.
o Controladores
JDBC-Net de Java puro: son controladores
escritos completamente en Java que entienden un protocolo de red estándar
(HTTP, etc.) y permiten comunicarse con un servidor de acceso a bases de datos,
que es el que finalmente provee el acceso al SGBD específico (posiblemente con
ODBC).
o Controladores de
protocolo nativo en Java puro: escritos en Java
puro, utilizan el protocolo específico de la marca del SGBD.
Ø SQL LINKS: se trata de controladores que se encargan de
realizar la comunicación remota entre la aplicación y los servidores remotos de
bases de datos, permitiendo una comunicación casi directa y muy rápida. Los ha
desarrollado la empresa Inprise y permiten conexiones con otros servidores de
bases de datos como Interase, Oracle, Sybase, Informix, Microsoft SQL Server, etc.
JDBC (Java DataBase Connectivity) es la API que permite la conexión de
un programa Java y una base de datos relacional.
Se encuentra dentro del paquete
java.sql.
Incluye clases e interfaces que
permiten el acceso a la base de datos para ejecutar consultas, actualizaciones,
ejecutar procedimientos, etc.
Algunas de las clases e interfaces de JDBC son:
|
Clase / Interface
|
Función
|
|
Clase DriverManager
|
Establece la conexión con la base de datos
|
|
Interface Connection
|
Representa una conexión con la BD
|
|
Interface Statement
|
Ejecución de consultas SQL
|
|
Interface PreparedStatement
|
Ejecución de consultas preparadas y
procedimientos almacenados
|
|
Interface ResultSet
|
Manipulación de registros en consultas de tipo
Select
|
|
Interface
ResultSetMetadata
|
Proporciona
información sobre la estructura de los datos.
|
El objetivo de las
interfaces de JDBC es definir como trabajar con la base de datos: como
establecer la conexión, como ejecutar una consulta, etc.
Para poder ejecutar nuestro programa necesitamos
las clases que implementen estas interfaces.
Driver JDBC:
Llamamos DRIVER al conjunto de
clases que implementan las interfaces JDBC.
El driver proporciona la comunicación entre la
aplicación Java y la base de datos
Cada tipo de bases de datos (Oracle, MySQL,
PostGreSQL, etc) tienen su propio driver.
Los drivers los proporcionan los fabricantes de las
bases de datos. Normalmente se descarga desde la página web del fabricante.
Por lo tanto, el
primer paso para trabajar con bases de datos desde Java es conseguir el driver
adecuado.
ACCESO A BASES DE
DATOS CON JDBC:
Una vez incorporado el driver como librería de la
aplicación, se deben seguir los siguientes pasos para acceder a una base de
datos:
1. Importar los paquetes: Normalmente es suficiente con la
sentencia import java.sql.*;
2. Cargar el driver: El driver se
debe cargar para poder utilizarlo. Esto lo realiza el método estático forName() de la clase Class.
Class.forName(String
driver);
Driver JDBC para MySQL:
Class.forName("com.mysql.jdbc.Driver");
Lanza una excepción ClassNotFoundException
3. Crear la conexión: Esto lo
realiza el método estático getConnection() de
la clase DriveManager.
DriverManager.getConnection(String url);
url es un String que nos permite localizar la base
de datos.
Normalmente se compone de tres campos:
jdbc:tipoBD:datos_de_conexion
Una sobrecarga del método getConnection acepta,
además de la url, el usuario y contraseña de la base de datos.
Este método devuelve un objeto que implementa la
interfaz Connection.
4. Ejecutar una consulta: Las consultas se manejan mediante un objeto que
implementa la interface Statement.
Antes de poder ejecutar una consulta debemos crear
el objeto.
El objeto se crea utilizando el método createStatement() de Connection.
Statement s = conexion.createStatement();
Una vez creado podemos utilizar algunos de los
métodos de Statement para enviar la consulta a la BD.
Algunos de estos métodos son:
|
boolean execute(String sentenciaSQL);
|
Si es una consulta de acción (Insert, Delete,
Update) devuelve false indicando que no se generan resultados. Si es una
consulta de selección (Select) devuelve true.
|
|
int executeUpdate(String sentenciaSQL);
|
Envía una consulta de acción. Devuelve el número
de registros afectados por dicha acción.
|
|
ResultSet executeQuery(String sentenciaSQL);
|
Envía una consulta de selección. Devuelve un
objeto ResultSet con los datos obtenidos de la consulta.
|
Por ejemplo, si en la base de
datos tenemos una tabla llamada persona,
una consulta de todos los registros de la tabla sería:
ResultSet rs =
s.executeQuery("select * from persona");
5. Manipular el resultado de la consulta: El objeto de tipo ResultSet devuelto por la
consulta de selección dispone de un cursor para desplazarse por los registros y
de métodos para acceder al valor de cada campo.
Desplazarse por los
registros de un ResultSet.
Una vez obtenido, su cursor se sitúa justo antes
del primer registro obtenido.
Por defecto, un ResultSet es un objeto de sólo avance y solo lectura. El recorrido se hará siempre desde el
principio hacia delante y los campos no podrán ser modificados. Se pueden crear
también ResultSets desplazables de lectura/escritura.
El método next() permite desplazarnos por los
registros. Una llamada a este método desplaza el cursor al siguiente registro.
Devuelve false si se ha llegado al final y true en caso contrario.
Acceder a los campos del
resultado de una consulta.
Los campos del
registro apuntado por el cursor se pueden acceder mediante dos grupos de
métodos. xxx es cualquier tipo de dato básico Java más String, Date y
Object. Se deberá utilizar el método adecuado al tipo de dato que contiene el
campo. Si no conocemos el tipo de dato podemos utilizar getObject().
|
xxx getXxx(int posición);
|
Obtiene el valor del campo que ocupa la posición
indicada. La primera posición es la 1.
|
|
xxx getXxx(String nombreCampo);
|
Obtiene el valor del campo que coincide con el
nombre indicado.
|
Por ejemplo, si la
tabla persona contiene
3 campos en este orden: id de tipo int, nombre de tipo String y
fecha de tipo Date:
while (rs.next()) {
System.out.println(rs.getInt("Id")
+ " " + rs.getString(2) + " " + rs.getDate(3));
}
Además de estos métodos, la interfaz ResultSet
proporciona una gran cantidad de métodos para acceder y manejar los resultados
de la consulta entre ellos:
ü boolean isFirst() que devuelve true
si el cursor apunta al primer registro.
ü boolean isLast() que
devuelve true si el cursor apunta al último.
ü int getRow() que devuelve
la posición del registro actual, siendo 1 la posición del primer registro, etc.
6. Desconexión de la base de datos: Permite liberar recursos de memoria y CPU. El
cierre de una conexión se realiza mediante el métodoclose() de la interfaz Connection.
conexion.close();
La interfaz Statement también dispone de un método
close() para liberar los recursos utilizados por el objeto. Esto debe hacerse
antes de cerrar la conexión.
Cuando se cierra una conexión todos los objetos
Statement se cierran automáticamente.
La mayoría de métodos usados, el API JDBC lanzan
una excepción de tipo SQLException que
se debe capturar.
Ejemplos de acceso a
bases de datos MySQL con Java y JDBC
Para realizar los siguientes ejemplos de acceso a
una base de datos supondremos lo siguiente:
El servidor de base de da.tos debe estar arrancado
y suponemos que utiliza el puerto por defecto (3306)
La base de datos que vamos a utilizar se
llama prueba con un
usuario root y
contraseña 1daw.
La base de datos tiene una tabla persona con tres campos:
ü id: smallint auto_increment
primary key
nombre: varchar(60)
nacimiento: date.
1.3 EJEMPLOS:
Ejemplo
1: Conexión a una base de datos MySQL y consulta de
una tabla.
import java.sql.*;
public class EjemploAccesoBD1 {
public static void main(String[] args) {
Connection conexion =
null;
try {
// Cargar el driver
Class.forName("com.mysql.jdbc.Driver");
//
Se obtiene una conexión con la base de datos.
//
En este caso nos conectamos a la base de datos prueba
//
con el usuario root y contraseña 1daw
conexion
= DriverManager.getConnection("jdbc:mysql://localhost/prueba",
"root", "1daw");
//
Se crea un Statement, para realizar la consulta
Statement
s = conexion.createStatement();
//
Se realiza la consulta. Los resultados se guardan en el ResultSet rs
ResultSet rs = s.executeQuery("select * from
persona");
//
Se recorre el ResultSet, mostrando por pantalla los resultados.
while
(rs.next()) {
System.out.println(rs.getInt("Id")
+ " " + rs.getString(2) + " " + rs.getDate(3));
}
} catch (SQLException e)
{
System.out.println(e.getMessage());
} catch
(ClassNotFoundException e) {
System.out.println(e.getMessage());
}
finally { // Se cierra la conexión con la base de datos.
try {
if
(conexion != null) {
conexion.close();
}
}
catch (SQLException ex) {
System.out.println(ex.getMessage());
}
}
}
}
Ejemplo
2: Crear una tabla e insertar datos.
Crearemos
la tabla contactos dentro de la base de datos prueba.
import java.sql.*;
public class EjemploAccesoBD2 {
public static void
main(String[] args) {
Connection
conexion = null;
try
{
//
Cargar el driver
Class.forName("com.mysql.jdbc.Driver");
//
Se obtiene una conexión con la base de datos.
conexion =
DriverManager.getConnection("jdbc:mysql://localhost/prueba",
"root", "1daw");
//
Se crea un Statement, para realizar el query
Statement
s = conexion.createStatement();
//se
crea una tabla nueva
s.executeUpdate("CREATE
TABLE contacto (id INT AUTO_INCREMENT,
PRIMARY
KEY(id), nombre VARCHAR(20),
apellidos
VARCHAR(20), telefono VARCHAR(20))");
//Los
datos que vamos a insertar los tenemos en 3 arrays
String
nombres[] = {"Juan", "Pedro", "Antonio"};
String
apellidos[] = {"Gomez", "Lopez", "Alvarez"};
String
telefonos[] = {"987452154", "989654125",
"985321478"};
//se
insertan datos en la tabla
for (int i = 0; i < nombres.length; i++) {
s.executeUpdate("INSERT
INTO contacto (nombre, apellidos, telefono)
VALUES
('" + nombres[i] + "','" + apellidos[i] + "','" +
telefonos[i] + "' )");
}
// Se realiza una
consulta sobre la tabla contacto.
ResultSet rs = s.executeQuery("select * from
contacto");
// Se recorre el
ResultSet, mostrando por pantalla los resultados.
while (rs.next())
{
System.out.println(rs.getInt(1) + " " +
rs.getString(2) + " " +
rs.getString(3) + " " + rs.getString(4));
}
} catch (SQLException e) {
System.out.println(e.getMessage());
} catch (ClassNotFoundException e) {
System.out.println(e.getMessage());
} finally { // Se
cierra la conexión con la base de datos.
try {
if (conexion != null) {
conexion.close();
}
} catch (SQLException ex) {
System.out.println(ex.getMessage());
}
}
}
}
1.3.1
ResultSet desplazables y modificables:
Se pueden crear ResultSet con más prestaciones que
las que tienen los que hemos creado hasta ahora. Recuerda que los creados por
defecto solo se pueden recorrer desde el principio hasta el final y no permiten
modificar los datos.
Para ello tenemos que modificar la forma de crear
el Statement.
En lugar de crear un Statement
así: Statement s = conexion.createStatement();
Utilizaremos esta versión del método
createStatement():
Statement
createStatement(int tipoResultSet, int concurrenciaResultSet);
tipoResulSet puede ser
uno de estos valores:
|
ResultSet.TYPE_FORWARD_ONLY
|
ResultSet
de solo avance. Es el valor por defecto
|
|
ResultSet.TYPE_SCROLL_INSENSITIVE
|
ResultSet
desplazable en ambas direcciones. No refleja los cambios en los datos que se
puedan producir en la base de datos.
|
|
ResultSet.TYPE_SCROLL_SENSITIVE
|
ResultSet
desplazable en ambas direcciones. Refleja los cambios en los datos que se
puedan producir en la base de datos.
|
ConcurrenciaResultSet puede
ser uno de estos valores:
|
ResultSet.CONCUR_READ_ONLY
|
Campos
de solo lectura. Es el valor por defecto
|
|
ResultSet.CONCUR_UPDATABLE
|
Campos
modificables.
|
Además de los métodos utilizados por los ResultSet por defecto, algunos
de los métodos que se pueden usar son los siguientes:
|
Método
|
Descripcióm
|
|
boolean first()
|
Desplaza el cursor al primer registro. Devuelve
true si estamos ante una fila válida y false en caso contrario.
|
|
void beforeFirst()
|
Desplaza el cursor a la posición situada antes
del primer registro.
|
|
boolean last()
|
Desplaza el cursor al último registro. Devuelve
true si estamos ante una fila válida y false en caso contrario.
|
|
void afterLast()
|
Desplaza el cursor a la posición situada después
del último registro.
|
|
boolean absolute(int pos)
|
Desplaza el cursor a la posición indicada por
pos. Devuelve true si estamos ante una fila válida y false en caso contrario.
|
Para
modificar un campo del ResultSet, utilizamos métodos updateXxx donde Xxx es el
tipo de dato del campo que vamos a actualizar.
Por ejemplo:
modificamos el campo 2 (de tipo String) del registro 2 de la tabla persona.
ü
rs.absolute(2); //nos situamos en el
registro a modificar
ü
rs.updateString(2, "Ana
Lozano"); // Modificamos el campo 2. Nuevo valor: "Ana
Lozano"
ü
rs.updateRow(); // se actualiza el registro.
Ejemplo
de ResultSet desplazable y modificable:
En
este ejemplo se crea un ResultSet que se va recorrer de forma inversa, desde el
final al principio. Además, se va a utilizar para modificar un registro de la
tabla persona.
import java.sql.*;
public class
EjemploAccesoBD6 {
public static void main(String[] args) {
Connection
conexion = null;
try
{
Class.forName("com.mysql.jdbc.Driver");
conexion
=
DriverManager.getConnection("jdbc:mysql://localhost/prueba",
"root", "1daw");
//Indicamos
que el ResultSet será desplazable y modificable
Statement
s= conexion.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
ResultSet
rs = s.executeQuery("select * from persona");
//Recorrer
el ResultSet desde el final hasta el principio
rs.afterLast();
while
(rs.previous()) {
System.out.println(rs.getInt(1)
+ " " + rs.getString(2) + " " + rs.getDate(3));
}
//
modificar el campo nombre (2) del registro 2 del ResultSet
//
el cambio también se produce en la base de datos
rs.absolute(2);
rs.updateString(2,
"Ana Lozano");
rs.updateRow();
//Recorrer
el ResultSet para comprobar la modificación.
//Para
recorrer el ResultSet desde el principio hasta el final nos debemos situar
//de
nuevo al principio
rs.beforeFirst();
while
(rs.next()) {
System.out.println(rs.getInt(1)
+ " " + rs.getString(2) + " " + rs.getDate(3));
}
}
catch (SQLException e) {
System.out.println(e.getMessage());
} catch (ClassNotFoundException e) {
System.out.println(e.getMessage());
}
finally {
try
{
if
(conexion != null) {
conexion.close();
}
}
catch (SQLException ex) {
System.out.println(ex.getMessage());
}
}
}
}
Para insertar
filas el ResultSet tiene el método moveToInsertRow() que nos lleva a
una fila vacía para que llenemos sus campos mediante métodos updateXxx y
finalmente la insertemos en la tabla mediante el método insertRow().
Construccion
de un Administrador de Conexiones:
Para poder obtener una conexión, una forma simple y comoda de trabajar es armar una clase llamada, por ejemplo, AdministradorDeConexiones, que contenga dentro de un método (obtenerConexion()) el código necesario para obtenerla.
Para poder obtener una conexión, una forma simple y comoda de trabajar es armar una clase llamada, por ejemplo, AdministradorDeConexiones, que contenga dentro de un método (obtenerConexion()) el código necesario para obtenerla.
A continuación se
presenta un ejemplo de la clase con su correspondiente método:
package ar.com.et3.lab8.ejercicio1.administrador;
package ar.com.et3.lab8.ejercicio1.administrador;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.DriverManager;
/**
* @author Martin
*/
public abstract class AdministradorDeConexiones
{
public
AdministradorDeConexiones() {
}
public static Connection
getConnection() throws Exception
{
//
Establece el nombre del driver a utilizar
String dbDriver = "com.mysql.jdbc.Driver";
String dbDriver = "com.mysql.jdbc.Driver";
//
Establece la conexion a utilizar contra la base de datos
String dbConnString = "jdbc:mysql://localhost/6to_ET3";
String dbConnString = "jdbc:mysql://localhost/6to_ET3";
//
Establece el usuario de la base de datos
String dbUser = "root";
String dbUser = "root";
//
Establece la contraseña de la base de datos
String dbPassword = "";
String dbPassword = "";
//
Establece el driver de conexión
Class.forName(dbDriver).newInstance();
Class.forName(dbDriver).newInstance();
//
Retorna la conexión
return DriverManager.getConnection(dbConnString, dbUser, dbPassword);
return DriverManager.getConnection(dbConnString, dbUser, dbPassword);
}
}
Como consultar datos:
El metodo createStatement(): El método createStatement() se utiliza para crear un objeto que modela a una sentencia SQL. Es un objeto del tipo de una clase que implementa la interfaz Statement, y provee la infraestructura para ejecutar sentencias SQL sobre una conexión con una base de datos.
La forma de construir un objeto de este tipo es:
Statement stmtConsulta = laconexion.createStatement();
El método executeQuery(): El método executeQuery() se utiliza para ejecutar una sentencia SQL y obtener el resultado correspondiente dentro de un objeto del tipo ResulSet. Este objeto representa un conjunto de resultados que se obtienen como consecuencia de ejecutar la sentencia SQL del tipo SELECT a través de la conexión.
La forma de generar un objeto de este tipo es:
ResulSet rs = stmConsulta.executeQuery(laConsulta);
Como consultar datos:
El metodo createStatement(): El método createStatement() se utiliza para crear un objeto que modela a una sentencia SQL. Es un objeto del tipo de una clase que implementa la interfaz Statement, y provee la infraestructura para ejecutar sentencias SQL sobre una conexión con una base de datos.
La forma de construir un objeto de este tipo es:
Statement stmtConsulta = laconexion.createStatement();
El método executeQuery(): El método executeQuery() se utiliza para ejecutar una sentencia SQL y obtener el resultado correspondiente dentro de un objeto del tipo ResulSet. Este objeto representa un conjunto de resultados que se obtienen como consecuencia de ejecutar la sentencia SQL del tipo SELECT a través de la conexión.
La forma de generar un objeto de este tipo es:
ResulSet rs = stmConsulta.executeQuery(laConsulta);
Como realizar una consulta:
// Define la conexión
Connection laConexion = AdministradorDeConexiones.getConnection();
// Arma
la consulta y la ejecuta
String laConsulta = "SELECT * FROM alumnos";
String laConsulta = "SELECT * FROM alumnos";
Statement stmtConsulta = laConexion.createStatement();
ResultSet rs = stmtConsulta.executeQuery(laConsulta);
ResultSet rs = stmtConsulta.executeQuery(laConsulta);
//
Muestra los datos
while( rs.next() )
System.out.println( "ID: " + rs.getInt("alu_id") + " -- " + "Nombre: " + rs.getString("alu_nombre") + " -- " + "Apellido: " + rs.getString("alu_apellido") );
while( rs.next() )
System.out.println( "ID: " + rs.getInt("alu_id") + " -- " + "Nombre: " + rs.getString("alu_nombre") + " -- " + "Apellido: " + rs.getString("alu_apellido") );
// Cierra el Statement y la Connection
stmtConsulta.close();
laConexion.close();
Como insertar datos:
El método createStatement(): El método createStatement() es el mismo presentado en la sección Consulta.
El método execute(): El método execute() se utiliza para ejecutar sentencias SQL del tipo INSERT, UPDATE o DELETE, y a diferencia del método executeQuery() no retorna un conjunto de resultados.
La forma de utilizar el método execute() es:
String laInsercion = "INSERT INTO alumnos (alu_id, alu_nombre, alu_apellido) VALUES (101, 'Manuel', 'Santos')"
Como realizar una inserción:
// Define la conexión
Connection laConexion = AdministradorDeConexiones.getConnection();
stmtConsulta.close();
laConexion.close();
Como insertar datos:
El método createStatement(): El método createStatement() es el mismo presentado en la sección Consulta.
El método execute(): El método execute() se utiliza para ejecutar sentencias SQL del tipo INSERT, UPDATE o DELETE, y a diferencia del método executeQuery() no retorna un conjunto de resultados.
La forma de utilizar el método execute() es:
String laInsercion = "INSERT INTO alumnos (alu_id, alu_nombre, alu_apellido) VALUES (101, 'Manuel', 'Santos')"
Como realizar una inserción:
// Define la conexión
Connection laConexion = AdministradorDeConexiones.getConnection();
// Arma
la sentencia de inserción y la ejecuta
String laInsercion = "INSERT INTO alumnos (alu_id, alu_nombre, alu_apellido) VALUES (101, 'Manuel', 'Santos')";
String laInsercion = "INSERT INTO alumnos (alu_id, alu_nombre, alu_apellido) VALUES (101, 'Manuel', 'Santos')";
Statement stmtInsercion = laConexion.createStatement();
stmtInsercion.execute(laInsercion);
stmtInsercion.execute(laInsercion);
//
Cierra el Statement y la Connection
stmtInsercion.close();
laConexion.close();
stmtInsercion.close();
laConexion.close();
//
Informa que la inserción ha sido realizada con éxito
System.out.println("La inserción ha sido realizada con éxito...");
Como actualizar datos:
El método createStatement(): El método createStatement() es el mismo presentado en la sección Consulta.
El método execute(): El método execute() es el mismo presentado en la sección Inserción.
Como realizar una actualización:
// Define la conexión
Connection laConexion = AdministradorDeConexiones.getConnection();
System.out.println("La inserción ha sido realizada con éxito...");
Como actualizar datos:
El método createStatement(): El método createStatement() es el mismo presentado en la sección Consulta.
El método execute(): El método execute() es el mismo presentado en la sección Inserción.
Como realizar una actualización:
// Define la conexión
Connection laConexion = AdministradorDeConexiones.getConnection();
// Arma
la sentencia de actualización y la ejecuta
String laActualizacion = "UPDATE alumnos SET alu_apellido = 'Trobbiani' WHERE alu_id = 101";
String laActualizacion = "UPDATE alumnos SET alu_apellido = 'Trobbiani' WHERE alu_id = 101";
Statement stmtActualizacion = laConexion.createStatement();
stmtActualizacion.execute(laActualizacion);
stmtActualizacion.execute(laActualizacion);
//
Cierra el Statement y la Connection
stmtActualizacion.close();
laConexion.close();
stmtActualizacion.close();
laConexion.close();
//
Informa que la actualización ha sido realizada con éxito
System.out.println("La actualización ha sido realizada con éxito...");
System.out.println("La actualización ha sido realizada con éxito...");
Como eliminar datos:
El método createStatement(): El método createStatement() es el mismo presentado en la sección Consulta.
El método execute(): El método execute() es el mismo presentado en la sección Insercion.
Como realizar una eliminación:
// Define la conexión
Connection laConexion = AdministradorDeConexiones.getConnection();
// Arma
la sentencia de eliminación y la ejecuta
String laEliminacion = "DELETE FROM alumnos WHERE alu_id = 101";
String laEliminacion = "DELETE FROM alumnos WHERE alu_id = 101";
Statement stmtEliminacion = laConexion.createStatement();
stmtEliminacion.execute(laEliminacion);
stmtEliminacion.execute(laEliminacion);
//
Cierra el Statement y la Connection
stmtEliminacion.close();
laConexion.close();
stmtEliminacion.close();
laConexion.close();
//
Informa que la eliminación ha sido realizada con éxito
System.out.println("La eliminación ha sido realizada con éxito...");
System.out.println("La eliminación ha sido realizada con éxito...");
//
Declara el objeto de conexión
Connection laConexion = null;
Connection laConexion = null;
try
{
// Obtiene la conexión
laConexion = AdministradorDeConexiones.getConnection();
{
// Obtiene la conexión
laConexion = AdministradorDeConexiones.getConnection();
// Muestra los alumnos en pantalla
mostrarAlumnos(laConexion);
} catch(Exception e) {
System.out.println( e.getMessage() );
} finally {
// Cierra la conexión
try
{
if(laConexion != null)
laConexion.close();
} catch(Exception e){}
}
}
mostrarAlumnos(laConexion);
} catch(Exception e) {
System.out.println( e.getMessage() );
} finally {
// Cierra la conexión
try
{
if(laConexion != null)
laConexion.close();
} catch(Exception e){}
}
}
public static void
mostrarAlumnos(Connection conn) throws SQLException
{
{
Statement stmtAlumnos = null;
// Arma
la sentencia SQL en forma de text
String consulta = "SELECT * FROM alumnos";
String consulta = "SELECT * FROM alumnos";
// Arma
la sentencia SQL y la ejecuta
stmtAlumnos = conn.createStatement();
ResultSet rs = stmtAlumnos.executeQuery( consulta );
stmtAlumnos = conn.createStatement();
ResultSet rs = stmtAlumnos.executeQuery( consulta );
// Muestra los alumnos en pantalla
while(rs.next())
System.out.println( rs.getString("alu_nombre") + " -- " + rs.getString("alu_apellido") );
}
while(rs.next())
System.out.println( rs.getString("alu_nombre") + " -- " + rs.getString("alu_apellido") );
}
2
RESUMEN:
Java Data
Base Connectivity o JDBC fue
creado por la empresa Sun, es la API estándar de acceso a bases de datos con
Java. El API JDBC se presenta
como una colección de interfaces
Java y
métodos de gestión de manejadores de conexión hacia cada modelo específico de
base de datos. Sun optó por
crear una nueva API en lugar de utilizar ODBC, porque esta última presentaba
algunos problemas desde ciertas aplicaciones Java. ODBC es una interfaz escrita
en lenguaje C, que se instala manualmente en cada máquina, mientras que los
controladores (drivers) JDBC
que están escritos en Java son automáticamente instalables y portables. El
nivel de abstracción al que trabaja JDBC es más alto que el de ODBC y, de esta
forma, se pueden crear librerías de más alto nivel.
Los objetos de Java con Base de Datos son:
ü Connection: Representa una conexión a una base de datos. Una sesión con una
conexión incluye las sentencias SQL que son ejecutadas y los resultados que son
devueltos a través de dicha conexión. La
forma estándar de establecer una conexión con una base de datos es llamando al
método DriverManager.getConnection.
ü Statement: Se usa para enviar sentencias SQL a una base de datos. Una vez
que se ha establecido una conexión con una base de datos particular, esa
conexión puede ser usada para enviar sentencias SQL. Un objeto Statement se crea con el método creatStatement de Connection como en el siguiente fragmento de código:
· Connection con = DriverManager.getConnection(url);
· Statement stmt = con.createStatement();
ü
ResultSet: Contiene todos los registros
que satisfacen las condiciones impuestas en una sentencia SQL y proporciona
acceso a los datos a través de un conjunto de métodos get que permiten acceder a los diferentes campos o atributos.
Un ResultSet mantiene un cursor que apunta al registro actual. El
método ResultSet.next() se usa para
moverse al siguiente registro del ResultSet. Los métodos getXXX proporcionan los medios para
obtener los valores de los campos, atributos o columnas del registro actual.
3
SUMMARY:
Java Data Base Connectivity or JDBC was
created by Sun, is the standard API for accessing databases with Java. The JDBC
API is presented as a collection of Java management methods handlers connection
to each specific database model and interfaces. Sun chose to create a new API
instead of using ODBC, because the latter had some problems from certain Java
applications. ODBC is a C language interface, which is manually installed on
each machine, while the drivers (drivers) JDBC that are written in Java are
automatically installable and portable. The level of abstraction to working
JDBC is higher than the ODBC and, in this way, you can create libraries highest
level.
Java objects with Database are:
ü Connection: Represents a connection to a database. A
session with a connection includes the SQL statements that are executed and
results are returned through that connection. The standard way to establish a
connection to a database is calling DriverManager.getConnection
method.
ü Statement: Used to send SQL statements to a database.
Once you have established a connection to a particular database, that
connection can be used to send SQL statements. A Statement object is created
with the Connection creatStatement
method as in the following code fragment:
• Connection con =
DriverManager.getConnection (url);
• Statement stmt = con.createStatement ();
ü ResultSet: Contains all records that meet the
conditions imposed in an SQL statement and provides access to data through a
set of get methods that allow access
to different fields or attributes. A ResultSet maintains a cursor that points
to the current record. The ResultSet.next
() method is used to move to the next record in the ResultSet. The getXXX methods
provide the means to obtain the values of the fields, attributes or columns
of the current record.
4
RECOMENDACIONES:
Éstos conceptos y ejemplos son muy útiles e
importantes para todos aquellos que quieran dedicarse al desarrollo y hayan
dedicado unos cuantos años a formarse para ello. No hace falta ser un experto
en nada (eso requiere mucho más tiempo), pero sí tener una idea más o menos
clara de los conceptos básicos y una base lo bastante sólida como para poder
seguir profundizando en aquello que necesites.
Connection:
Dentro de
este punto, considero especialmente útil que un objeto Connection representa una conexión a
una base de datos. Además, la forma estándar de establecer una conexión con una
base de datos es el método DriverManager.getConnection.
La clase DriverManage trata de
localizar el driver que pueda conectar con la base de datos. Statement:
En este punto hay que
tener claro que Statement se usa
para enviar sentencias SQL a una base de datos. Una vez que se ha establecido
una conexión con una base de datos particular, esa conexión puede ser usada
para enviar sentencias SQL. Además, un objeto Statement se crea con el método creatStatement de Connection como en el siguiente fragmento de código:
Connection con =
DriverManager.getConnection(url);
Statement stmt = con.createStatement();
ResultSet: En este punto hay que tener en cuenta que ResutSet contiene todos
los registros que satisfacen las condiciones impuestas en una sentencia SQL y
proporciona acceso a los datos en dichos registros a través de un conjunto de
métodos
“get” que permiten acceder a los diferentes campos o atributos
del registro actual. Un ResultSet mantiene un
cursor que apunta al registro actual. El método ResultSet.next() se usa para
moverse al siguiente registro del ResultSet. Además,
los métodos getXXX proporcionan los medios para obtener los valores de los
campos, atributos o columnas del registro actual.
5
CONCLUCIONES:
El acceso mediante Java con Base de Datyos
conviene utilizarlo cuando tenemos pocas clases, escasos conocimientos, escaso
tiempo para formación, modelo de datos muy desnormalizado.
En
realidad, Java con Base de Datos, más conocida como JDBC, es una API que permite la
ejecución de operaciones sobre bases de datos desde el lenguaje de
programación Java, independientemente del
sistema operativo donde se ejecute o de la base
de datos a la cual se accede,
utilizando el dialecto SQL del modelo de base de datos que se utilice. Este API JDBC se presenta como una
colección de interfaces Java y métodos de gestión de manejadores de conexión hacia cada modelo
específico de base de datos. Para utilizar una base de datos particular, el
usuario ejecuta su programa junto con la biblioteca de conexión apropiada al
modelo de su base de datos, y accede a ella estableciendo una conexión; para
ello provee el localizador a la base de datos y los parámetros de conexión
específicos. A partir de allí puede realizar cualquier tipo de tarea con la
base de datos a la que tenga permiso: consulta, actualización, creación,
modificación y borrado de tablas, ejecución de procedimientos almacenados en la base de datos, etc.
Java con Base de Datos presenta 3 objetos muy
importantes los cuales son:
ü Connection.
ü Statement.
ü ResutSet.
6
APRECIACIÓN DEL EQUIPO:
Java con Base de
Datos es un tema muy importante para todo estudiante de Sistemas o Computación
y para todos aquellos que quieran aprender acerca de estos lenguajes de
programación ya que nos enseñan a crear tablas, insertar datos, conectar
nuestra base de datos, ya sea con NetBeans, MySQL, etc.
Además, nos
presenta tres objetos muy importantes para realizar la conexión, enviar
sentencias a nuestra base de datos y nos explica detalladamente con cada
ejemplo todo el proceso que debemos seguir.
7
GLOSARIO:
v Interfaz: Dispositivo capaz de
transformar las señales generadas por un aparato en señales comprensibles por
otro.
v Portable: Es una aplicación
informática que puede ser utilizada en cualquier ordenador que posea el sistema
operativo para el que fue programada; esto significa que no es necesaria la instalación de
bibliotecas adicionales en el sistema para su funcionamiento.
v Subprotocolo: Es un caso especial
que sido reservado para URL’s que especifican el estilo ODBC de nombres de
fuentes de datos y que tiene la característica de permitir especificar
cualquier número de valores de atributos después del subnombre (el nombre de la
fuente de datos).
v Boolean: Es un tipo de variable que sólo tiene dos valores
posibles: "true" (verdadero, 1) y "false" (falso, 0).
v Cursor: Señal, normalmente
parpadeante, que indica en una pantalla de computadora la posición en la que se
puede realizar una acción.
v Statement: Declaración.
v DriveManager: Gerente de la unidad.
v ResultSet: Conjunto resultante.
v Sintaxis: Disciplina lingüística que
estudia el orden y la relación de las palabras o sintagmas en la oración, así
como las funciones que cumplen.
v Relacional: Perteneciente o relativo a la relación o correspondencia entre cosas.
8
LINKOGRAFÍA:
ü http://www.ibm.com/support/knowledgecenter/es/ssw_ibm_i_72/rzaha/statemnt.htm
Comentarios
Publicar un comentario