JDBC
INTRODUCCION
Características
• JDBC es una biblioteca de clases e interfaces que
permite la conexión con base de datos utilizando Java.
• La biblioteca JDBC dispone de una interfaz para
ejecutar instrucciones SQL que ofrece una
funcionalidad básica para el acceso a datos. las clases
e interfaces que componen el API de JDBC son
conceptos comunes de acceso a base de datos para
todas las bases de datos.
• JDBC se diseño como una interfaz de programación de
aplicaciones (API) orientado a objetos para acceder
(consultas) a bases de datos y es un estándar.
• El API JDBC se diseño como una interfaz para ejecutar
consultas SQL y admite todos los dialectos de SQL.
Conexión a la Base de Datos
Mecanismo JDBC
El funcionamiento práctico de JDBC obliga a
conocer los siguientes 5 procedimientos, a
saber:
1. Establecer conexión.
2. Crear sentencia.
3. Ejecutar sentencia.
4. Procesar resultados.
5. Cerrar.
1.- Establecer la conexión
Tiene dos operaciones básicas.
a) DriverManager
b) Connection
a.- DriverManager
La clase DriverManager es la capa gestora
de JDBC, trabajando entre el usuario y el
controlador (driver). Se encarga de seguir
el rastro de los controladores que están
disponibles y establecer la conexión entre
la base de datos y el controlador
apropiado.
Para trabajar con el Puente JDBC-ODBC:
try {
Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);
} catch (ClassNotFoundException cnfe) {
System.err.println(“No ha podido encontrarse el
driver de ODBC.”);
}
Para trabajar con MySQL:
try {
Class.forName(“com.mysql.jdbc.Driver”);
} catch (ClassNotFoundException cnfe) {
System.err.println(“No ha podido encontrarse el
driver de MySQL”);
}
Para trabajar con postgreSQL:
try {
Class.forName(“org.postgresql.Driver”);
} catch (ClassNotFoundException cnfe) {
System.err.println(“No ha podido encontrarse el
driver de postgreSQL”);
}
Para trabajar con Oracle:
try {
Class.forName(“oracle.jdbc.driver.OracleDriver”);
} catch (ClassNotFoundException cnfe) {
System.err.println(“No ha podido encontrarse el
driver de Oracle”);
}
b.- 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.
Para trabajar con el Puente JDBC-ODBC con MsAccess (Windows XP):
import java.sql.*;
public static void conexion ( ) throws Exception {
try {
// Carga el driver
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
// Define la cadena de conexión
String sourceURL = "jdbc:odbc:DSNSistema";
// Crea el objeto connection a través de DriverManager
Connection con = DriverManager.getConnection(sourceURL);
System.out.println("La conexion establecida es: "+ con);
} catch(ClassNotFoundException cnfe) {
System.err.println(cnfe);
} catch(SQLException sqle) {
System.err.println(sqle);
};
};
Para trabajar con MySQL.
import java.sql.*;
public static void conexion ( ) throws Exception {
try {
// Carga el driver
Class.forName("com.mysql.jdbc.Driver”);
// Define la cadena de conexión
String sourceURL = "jdbc:mysql://localhost/bd_pruebas”, usuario,
password";
// Crea el objeto connection a través de DriverManager
Connection con = DriverManager.getConnection(sourceURL);
System.out.println("La conexion establecida es: "+ con);
} catch(ClassNotFoundException cnfe) {
System.err.println(cnfe);
} catch(SQLException sqle) {
System.err.println(sqle);
};
};
Para trabajar con postgreSQL:
import java.sql.*;
public static void conexion ( ) throws Exception {
try {
// Carga el driver
Class.forName(“org.postgresql.Driver”);
// Define la cadena de conexión
String database = “Bd”;
String username = “admin”;
String password = “admin”;
String sourceURL = "jdbc:postgresql:”+database, username, password";
// Crea el objeto connection a través de DriverManager
Connection con = DriverManager.getConnection(sourceURL);
System.out.println("La conexion establecida es: "+ con);
} catch(ClassNotFoundException cnfe) {
System.err.println(cnfe);
} catch(SQLException sqle) {
System.err.println(sqle);
};
};
Para trabajar con Oracle XE (version 10g).
import java.sql.*;
public static void conexion ( ) throws Exception {
try {
// Carga el driver
Class.forName("oracle.jdbc.driver.OracleDriver");
// Define la cadena de conexión
String sourceURL =“jdbc:oracle:thin:@localhost:1521:orcl”, “scott”,
“tiger”;
// Crea el objeto connection a través de DriverManager
Connection con = DriverManager.getConnection(sourceURL);
System.out.println("La conexion establecida es: "+ con);
} catch(ClassNotFoundException cnfe) {
System.err.println(cnfe);
} catch(SQLException sqle) {
System.err.println(sqle);
};
};
2.- Crear sentencia.
Statement
Un objeto Statement se usa para enviar sentencias
SQL a una base de datos.
Statement senten = con.createStatement();
En realidad el método createStatement debe llevar
dos parámetros enteros que especifican el
comportamiento del objeto ResultSet u hoja de
datos
public Statement createStatement(int resultSetType,
int resultSetConcurrency) throws SQLException
PreparedStatement
Un objeto PreparedStatement se usa para
sentencias SQL que toman uno o más parámetros
como argumentos de entrada (parámetros IN).
PreparedStatement tiene un grupo de métodos que
fijan los valores de los parámetros IN, los cuales son
enviados a la base de datos cuando se procesa la
sentencia SQL.
PreparedStatement updateSales = con.prepareStatement (
“UPDATE productos SET ventas = ? WHERE COD = ? ” );
3.-Ejecutar sentencia.
La sentencia SQL se ejecuta a través de los
métodos
executeQuery
o
executeUpdate
dependiendo de que no exista o exista
modificación de los datos respectivamente.
1. Consulta – executeQuery() Es una operación
SELECT que devuelve el resultado de una consulta
encapsulado en un objeto de tipo ResultSet
2. Actualización – executeUpdate() Es una operación
INSERT, UPDATE o DELETE que realiza una
modificación sobre la base de datos
ResultSet resul = senten.executeQuery ( “ SELECT a,
b, c FROM Table2″);
Ó
Int filas_afectadas = senten.executeUpdate(“UPDATE
personas set nombre=’Marina’ where id=4″);
4.-Procesar resultados.
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.
El método ResultSet.next() se usa para
moverse al siguiente registro del ResultSet,
haciendo el siguiente registro el registro
actual.
5.-Cerrar.
Es necesario cerrar adecuadamente la sentencia
el ResultSet y la conexión.
• senten.close();
• resul.close();
• con.close();
Conviene recordar:
El mecanismo de funcionamiento básico JDBC,
• Establecer conexión:
Class.forName(“…”) y DriverManager.getConnection
• Crear sentencia:
Statement senten = connexion.createStatement();
• Ejecutar sentencia:
executeUpdate o executeQuery
• Procesar resultados:
while, resul.first(), resul.last(), resul.beforeFirst(),
resul.afterLast(), resul.absolute (int num), resul.next(),
resul.previous, resul.getRow().
• Cerrar:
sentencia.close(), resultados.close(), conexion.close();
FIN
DE LA PRESENTACION
“A LEER EN CANTIDADES
INSDUSTRIALES”
Descargar

catch (ClassNotFoundException cnfe) - Spring-JDBC