DOCENTE :
Ing. Marco Aurelio Porro Chulli.
ASIGNATURA : Desarrollo
de Software I.
INTEGRANTES : Vicente
Wualdir Alberca Rojas.
Wilder Fuentes
Araujo.
AÑO : 2016
JAVA CON BASE DE DATOS
1.
Contenido
A.
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
B.
Objetos Connection,Statement y ResultSet
I.
Objetos Connection
La clase
connection proporciona un interfaz eficiente para el acceso a datos y metadatos
de una base de datos. Conocer los recursos de gambas para acceso a base de datos es fundamental a
la hora de obtener un código transparente al motor de base de datos que utilice
la aplicación.
El objetivo de
este tema es mostrar la forma de realizar accesos a base de datos de forma transparente
al motor de búsqueda que estemos utilizando. De esta forma si por alguna razón
decidimos cambiar nuestra aplicación de sqlite mysql o viceversa el código seguirá
funcionando correctamente con solo cambiar el usuario y tipo de conexión que
usemos.
java.sql.Connection
Public static Connection getConnection (url, usr,
pwr) trows
java.sql.SQLException
Donde: url: Identificador de la Base de Datos
usr: Usuario con el
que se abre la conexión (opcional)
pwr: Contraseña del
Usuario (opcional)
java.sql.Connection A través de la conexión nos
comunicamos con la Base de Datos, enviándole
sentencias SQL ,Las sentencias SQL se envían a través de “Statements”.
Existen tres tipos de “Statements” y un método para
generar cada tipo.
Una vez terminada una Conexión, se debe“Liberar”,
que es cerrarla, de modo análogo a como se trabaja con flujos (Streams). Las
conexiones se cierran con el método: public void close() trows
java.sql.SQLException;
II.
Statement
Un objeto
Statement se usa para enviar sentencias SQL a la base de datos. Actualmente hay
tres tipos de objetos Statement, todos los cuales actúan como contenedores para
la ejecución de sentencias en una conexión dada: Statement, PreparedStatement
que hereda de Statement y CallableStatement que hereda de PreparedStatement.
Estas estàn especializadas para enviar tipos particulares de sentencias SQL, Un
objeto Statement se usa para ejecutar una sentencia SQL simple sin parámetros.
Un objeto PreparedStatement se usa para ejecutar sentencias SQL precompiladas
con o sin parámetros IN; y un objeto CallableStatement se usa para ejecutar un
procedimieno de base de datos almacenado.
La interfase
Statement suminstra métodos básicos para ejecutar sentencias y devolver
resultados. La interfase PreparedStatement añade métodos para trabajat con los
parámetros IN; y la interfase CallableStatement añade métodos para trabajar con
parameters OUT.
Creación de objetos Statement
Una vez establecida la conexión con una
base de datos particular, esta conexión puede usarse para enviar sentencias
SQL. Un objeto Statement se crea mediante el método de Connection
createStatement, como podemos ver en el siguiente fragmento de código.
Connection con = DriverManager.getConnection(url,
"sunny", "");
Statement stmt = con.createStatement();
Statement stmt = con.createStatement();
La sentencia SQL que será enviada a la base de datos es
alimentada como un argumento a uno de los métodos de ejecución del objeto
Statement. Por ejemplo:
ResultSet rs = stmt.executeQuery("SELECT a, b, c
FROM Table2");
Ejecución de sentencias usando objetos Statement.
La interfase Statement nos suministra tres
métodos diferentes para ejecutar sentencias SQL, executeQuery, executeUpdate y
execute. El método a usar esta determinado por el producto de la sentencia SQL
El método executeQuery esta diseñado para
sentencias que producen como resultado un único result set tal como las
sentencias SELECT.
El método execute Update se usa para ejecutar sentencias INSERT, UPDATE ó DELETE así como sentencias SQL DDL (Data Definition Language) como CREATE TABLE o DROP TABLE. El efecto de una sentencia INSERT, UPDATE o DELETE es una modificación de una o más columnas en cero o más filas de una tabla. El valor devuelto de executeUpdate es un entero que indica el número de filas que han sido afectadas (referido como update count).
Para
sentencias tales como CREATE TABLE o DROP TABLE, que no operan sobre filas, le
valor devuelto por executeUpdate es siempre cero.
El método execute se usa para ejecutar
sentencias que devuelven más de un result set, más que un update count o una
combinación de ambos. Como es esta una característica avanzada que muchos
programadores no necesitarñan nunca se verá en su propia sección.
Todos los métodos que ejecutan sentencias
cierran los objetos Resultset abiertos como resultado de las llamadas a
Statement. Esto quiere decir que es necesario completar el proceso con el
actual objeto Resulset antes de reejecutar una sentencia Statement.
Realización de Statement
Cuando una conexión está en modo auto-commit, las sentencias ejecutadas son ‘comitadas’ o rechazadas cuando se completan. Un sentencia se considera completa cuando ha sido ejecutada y se han devuelto todos los resultados. Pare el método executeQuery, que devuelve un único result set, la sentencia se completa cuando todas las filas del objeto ResultSet se han devuelto. Para el método executeUpdate, un sentencia se completa cuando se ejecuta. En los raros casos en que se llama al método execute, de cualquier modo, no se completa hasta que los result sets o update counts que se generan han sido devueltos.
Cerrar objetos Statement.
Los objetos Statement se cerrarán
automáticamente por el colector de basura de Java (garbage collector). No
obstante se recomienda como una buena práctica de programación que se cierren
explicitamente cuando no sean ya necesarios. Esto libera recursos DBMS
inmediatamente y ayuda a evitar potenciales problemas de memoria.
III.
ResultSet
Representa el resultado de la
ejecución de unasentencia SQL. Lleva asociadas las filas y columnas que cumplían
con la sentencia SQL. Implementa métodos para:
ü Acceder a las
filas que componen el resultado. Acceder al valor
de cada columna de la fila seleccionada.
Un ResultSet contiene todas las filas que
satisfacen las condiciones de una sentencia SQL y proporciona el acceso a los
datos de estas filas mediante un conjunto de métodos get que permiten el acceso
a las diferentes columnas de la filas. El método ResultSet.next se usa para
moverse a la siguiente fila del result set, convirtiendo a ésta en la fila
actúal.
Una tabla de
datos que representan un conjunto de resultados de base de datos, que por lo
general se genera mediante la ejecución de una declaración que consulta la base
de datos.
Un ResultSetobjeto
mantiene un cursor que apunta a la fila actual de datos. Inicialmente, el
cursor se coloca antes de la primera fila. El nextmétodo se mueve el
cursor a la siguiente fila, y porque devuelve false cuando no hay más
filas de la ResultSetobjeto, que puede ser utilizado en un whilebucle
para iterar a través del conjunto de resultados.
Un
defecto ResultSetobjeto no es actualizable y tiene un cursor que se mueve
hacia adelante solamente. Por lo tanto, se puede recorrer sólo una vez y
sólo desde la primera fila hasta la última fila. Es posible
producir ResultSetobjetos que son desplazables y / o actualizable. El
siguiente fragmento de código, en el que con es válido
un Connectionobjeto, ilustra cómo hacer que un conjunto de resultados que
es desplazable e insensible a los cambios de los demás, y que es
actualizable. Ver ResultSetcampos para otras opciones.
Declaración stmt
= con.createStatement (
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
ResultSet
rs = stmt.executeQuery ( "SELECT a, b DE TABLA2");
Rs
serán desplazable, no mostrará los cambios realizados por otros,
Y será
actualizable.
Los Métodos
Fila siguiente: next ()
abstract boolean
público al lado () throws SQLException
Pasa a la siguiente
fila, OA La Primera Cuando Se ejecuta Por Primera Vez. Devuelve verdadero
si se consigue falsa si y sin Quedan filas.
Cierre del conjunto de
resultados: close ()
public abstract void
close () throws SQLException
Cierra INMEDIATAMENTE
el conjunto de resultados , Liberando los Recursos utilizados.
Resultados nulos: wasNull ()
wasNull abstract
boolean pública () throws SQLException
Se EE.UU. Despues De
Obtener ONU nula ONU de la estafa Método get () para comprobar v Que
corresponde un valor NULL de SQL ONU.
Obtencion de Valores: get ()
Obtencion de Valores: get ()
pública
abstracta tipoJava get (int indiceColumna) throws
SQLException pública abstracta tipoJava get (String
nombreColumna) throws SQLException
Obtienen el valor
contenido en la columna Como un tipoJava , o la ONU nula si se
trataba de la ONU valor NULL de SQL.
C.
Ejemplos
Ejemplo
de Objeto Connection.
La base de datos
que usaremos para este ejemplo es la siguiente:
ü BD: prueba.
ü tabla: usuarios.
ü campos: id(autoinc),
nombre, contraseña.
Diagrama de
clases:
Bueno, primero
que nada empezaremos con nuestra clase que contendrá los métodos de las
acciones que vamos a realizar.
import java.sql.*;
import java.util.Hashtable;
import java.util.Hashtable;
public class SQLconnection {
private String user;
private String password;
private String db;
private String host;
private String url;
private Connection conn = null;
private Statement stm;
private ResultSet rs;
private String user;
private String password;
private String db;
private String host;
private String url;
private Connection conn = null;
private Statement stm;
private ResultSet rs;
public
SQLconnection()
{
this.url = “jdbc:mysql://” + this.host + “/” + this.db;
}
{
this.url = “jdbc:mysql://” + this.host + “/” + this.db;
}
public
SQLconnection (String server, String usuario, String contraseña, String bd)
{
this.user = usuario;
this.password = contraseña;
this.db = bd;
this.host = server;
this.url = “jdbc:mysql://” + this.host + “/” + this.db;
}
{
this.user = usuario;
this.password = contraseña;
this.db = bd;
this.host = server;
this.url = “jdbc:mysql://” + this.host + “/” + this.db;
}
public void
connectar()
{
try {
Class.forName(“org.gjt.mm.mysql.Driver”);
conn = DriverManager.getConnection(url, user, password);
if (conn != null)
{
System.out.println(“Conexión a base de datos “+url+” … Ok”);
stm = conn.createStatement();
}
}
catch(SQLException ex) {
System.out.println(“Hubo un problema al intentar conectarse con la base de datos “+url);
}
catch(ClassNotFoundException ex) {
System.out.println(ex);
}
}
{
try {
Class.forName(“org.gjt.mm.mysql.Driver”);
conn = DriverManager.getConnection(url, user, password);
if (conn != null)
{
System.out.println(“Conexión a base de datos “+url+” … Ok”);
stm = conn.createStatement();
}
}
catch(SQLException ex) {
System.out.println(“Hubo un problema al intentar conectarse con la base de datos “+url);
}
catch(ClassNotFoundException ex) {
System.out.println(ex);
}
}
public String
getDb() {
return db;
}
return db;
}
public void
setDb(String db) {
this.db = db;
}
this.db = db;
}
public String
getHost() {
return host;
}
return host;
}
public void
setHost(String host) {
this.host = host;
}
this.host = host;
}
public String
getPassword() {
return password;
}
return password;
}
public void
setPassword(String password) {
this.password = password;
}
this.password = password;
}
public String
getUser() {
return user;
}
return user;
}
public void
setUser(String user) {
this.user = user;
}
this.user = user;
}
public ResultSet
consultar(String tabla) throws SQLException
{
rs = stm.executeQuery(“SELECT * FROM ” + tabla);
return rs;
}
{
rs = stm.executeQuery(“SELECT * FROM ” + tabla);
return rs;
}
public String
buscarNombre(String tabla, String nombre) throws SQLException
{
String name = null;
try{
rs = stm.executeQuery(“SELECT * FROM ” + tabla + ” WHERE nombre = ‘”+ nombre +”‘ LIMIT 1″);
rs.next();
name = rs.getString(2);
}catch(SQLException ex){System.out.println(ex);}
return name;
}
{
String name = null;
try{
rs = stm.executeQuery(“SELECT * FROM ” + tabla + ” WHERE nombre = ‘”+ nombre +”‘ LIMIT 1″);
rs.next();
name = rs.getString(2);
}catch(SQLException ex){System.out.println(ex);}
return name;
}
public void
insertar(Hashtable usuario)
{
try {
stm.execute(“INSERT INTO usuarios (nombre, contraseña) VALUES (‘” +usuario.get(“nombre”) + “‘,'” + usuario.get(“contraseña”) + “‘)”);
} catch (SQLException ex) {
System.out.println(ex);
}
}
{
try {
stm.execute(“INSERT INTO usuarios (nombre, contraseña) VALUES (‘” +usuario.get(“nombre”) + “‘,'” + usuario.get(“contraseña”) + “‘)”);
} catch (SQLException ex) {
System.out.println(ex);
}
}
public void
actualizar(String tabla, Hashtable usuario, String nombre)
{
try {
stm.execute(“UPDATE ” + tabla + ” SET nombre='” + usuario.get(“nombre”) + “‘ WHERE nombre='” + nombre + “‘”);
} catch (SQLException ex) {
System.out.println(ex);
}
}
{
try {
stm.execute(“UPDATE ” + tabla + ” SET nombre='” + usuario.get(“nombre”) + “‘ WHERE nombre='” + nombre + “‘”);
} catch (SQLException ex) {
System.out.println(ex);
}
}
public void
eliminar(String tabla, String nombre)
{
try {
stm.execute(“DELETE FROM ” + tabla + ” WHERE nombre='” + nombre + “‘”);
} catch (SQLException ex) {
System.out.println(ex);
}
}
}
{
try {
stm.execute(“DELETE FROM ” + tabla + ” WHERE nombre='” + nombre + “‘”);
} catch (SQLException ex) {
System.out.println(ex);
}
}
}
Como podemos
observar, esta clase cuenta con sobrecarga de constructores lo cual nos permite
conectarnos de 2 maneras distintas a la base de datos. La primera es utilizar
el constructor que no recibe ningún parámetro y definirlos mediante los
métodos set y getpara después llamar al método conectar. La
segunda es enviarle directamente los valores al constructor y, al igual
que en la forma anterior, ejecutar el método conectar, y esta será la
forma que usaremos para nuestro ejemplo.
Primero que nada
vamos a conectarnos a nuestra base de datos y realizaremos
unaconsulta de todos los registros:
SQLconnection
con = new SQLconnection(“localhost”, “usuario”, “contraseña”, “prueba”);
con.connectar();
ResultSet rs;
rs = con.consultar(“usuarios”);
while(rs.next()){
System.out.println(rs.getString(1));
System.out.println(rs.getString(2));
System.out.println(rs.getString(3));
}
con.connectar();
ResultSet rs;
rs = con.consultar(“usuarios”);
while(rs.next()){
System.out.println(rs.getString(1));
System.out.println(rs.getString(2));
System.out.println(rs.getString(3));
}
Ejemplo de Objeto Statement
// Registrar el controlador JDBC nativo. Si el
controlador no puede
//
registrarse, la prueba no puede continuar.
try {
Class.forName(DRIVER);
}
catch (Exception e) {
System.out.println("No se ha podido registrar el
controlador.");
System.out.println(e.getMessage());
System.exit(1);
}
Connection c = null;
Statement s = null;
try {
Crear
las propiedades de conexión.
Properties properties = new Properties ();
properties.put ("user", "userid");
properties.put ("password", "password");
Conectar con la base de datos local.
c
= DriverManager.getConnection(URL, properties);
Crear un objeto Statement.
s
= c.createStatement();
Suprimir la tabla de prueba, si existe. Nota:
en este
ejemplo se presupone que la colección
MYLIBRARY
existe en el sistema.
try {
s.executeUpdate("DROP TABLE MYLIBRARY.MYTABLE");
}
catch (SQLException e) {
Continuar simplemente... es probable que la tabla no exista.
}
Ejemplo de Resultset
ResultSet rs = stmt.executeQuery(sqlString);
ResultSetMetaData rsmd = rs.getMetaData();
int colType [] = new int[rsmd.getColumnCount()];
for (int idx = 0, int col = 1; idx < colType.length; idx++, col++)
colType[idx] = rsmd.getColumnType(col);
ResultSet
resultSet = null;
String campo1;
Integer campo2;
try {
String sql =
“SELECT * FROM TABLA”;
resultSet = executeQuery(sql);
if(resultSet.next()) {
campo1=resultSet.getString(“CAMPO1”);
campo2 = resultSet.getInt(“CAMPO2”);
}
resultSet.close();
} catch (Exception exc) {
throw new RuntimeException(exc);
}
String campo1;
Integer campo2;
try {
String sql =
“SELECT * FROM TABLA”;
resultSet = executeQuery(sql);
if(resultSet.next()) {
campo1=resultSet.getString(“CAMPO1”);
campo2 = resultSet.getInt(“CAMPO2”);
}
resultSet.close();
} catch (Exception exc) {
throw new RuntimeException(exc);
}
public
ResultSet executeQuery(String sql) {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
OracleCachedRowSet cachedRowSet=null;
try {
Class.forName(“oracle.jdbc.OracleDriver”);
connection =
DriverManager.getConnection(databaseURL, databaseUserName,
databaseUserPassword);
connection.setAutoCommit(false);
preparedStatement = connection.prepareStatement(sql);
resultSet = preparedStatement.executeQuery();
cachedRowSet=new OracleCachedRowSet();
cachedRowSet.populate(resultSet);
resultSet.close();
preparedStatement.close();
return cachedRowSet;
} catch (Exception exc) {
throw new RuntimeException(exc);
} finally {
try {
if ((connection != null) &&amp; (!connection.isClosed())) {
connection.close();
}
} catch (Exception exc) {
throw new RuntimeException(exc);
}
}
}
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
OracleCachedRowSet cachedRowSet=null;
try {
Class.forName(“oracle.jdbc.OracleDriver”);
connection =
DriverManager.getConnection(databaseURL, databaseUserName,
databaseUserPassword);
connection.setAutoCommit(false);
preparedStatement = connection.prepareStatement(sql);
resultSet = preparedStatement.executeQuery();
cachedRowSet=new OracleCachedRowSet();
cachedRowSet.populate(resultSet);
resultSet.close();
preparedStatement.close();
return cachedRowSet;
} catch (Exception exc) {
throw new RuntimeException(exc);
} finally {
try {
if ((connection != null) &&amp; (!connection.isClosed())) {
connection.close();
}
} catch (Exception exc) {
throw new RuntimeException(exc);
}
}
}
2.
Resume
Java Database Connectivity, Más Conocida Por
Sus siglas JDBC, Es Una API Que permite la ejecucion de Operaciones Sobre las
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 adhieran,
utilizando el dialecto SQL del modelo de BASE dE DATOS Que se utilice.
El API JDBC Se presenta Como una Colección de
interfaces de 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 es en especial con la ONU Conjunto de clases Que implementan
las interfaces de Java Y Que utilizan los Métodos de registro para declarar los
Tipos de Localizadores una base de Datos (URL) Que pueden manejar.
3.
Summary
Java Database Connectivity, better known by its acronym JDBC is an API that allows the execution of operations on the basis of data from the programming language Java, regardless of operating system you are running or the database to which adhere using the SQL dialect of the database model used. The JDBC API is presented as a collection of Java interfaces and methods handlers Management Connection The Way Each specific database model. A handler Connections Towards a database model is especially the Joint UN classes that implement Java interfaces and they use the methods of registration to declare Rate Locators a database (URL) that can handle.
4.
Recomendaciones
El controlador JDBC nativo se ha diseñado para
ser una interfaz Java de alto rendimiento que permita trabajar con la base de
datos. Sin embargo, para obtener el mejor rendimiento posible, es necesario
crear las aplicaciones de manera que aprovechen el potencial que puede ofrecer
el controlador JDBC nativo. Los siguientes consejos pretenden llevar a la
práctica las mejores técnicas de programación JDBC. La mayoría de ellos no son
específicos del controlador JDBC nativo.
5.
Conclusiones
JDBC ofrece una interfaz estándar para accesar múltiples
bases de datos. Para esto hace uso de SQL lo cual lo hace fácil de usar, sin
embargo, debido a que los controladores JDBC no implementan todas las funciones
o la mayoría de las que se utilizan en un manejador de Bases de Datos como es
la recuperación de metadatos, hace q disminuya su capacidad, limite su uso y su
enfoque multibase de datos.
Al utilizar SQL como lenguaje de consulta para
la multibase de datos hace que
todo parezca transparente al usuario, que da la apariencia que se accede a una
Base de Datos.
6.
Apreciación del Equipo
la conexión a una base de datos
nos permite aprender el entorno del elemento JDBC y conocer nuevas formas de
acceder a una base de datos. Para poder así programar.
7.
Glosario de Términos
JDBC. Es una
interfaz de acceso a bases de datos estándar SQL que proporciona un acceso
uniforme a una gran variedad de bases de datos relacionales.
Base de Datos: Es una serie de datos
organizados y relacionados entre sí, los cuales son recolectados y explotados
por los Sistemas de Información de una empresa o negocio en particular.
Gestor de Base de Datos: Es un conjunto de programas que permiten crear y
mantener una base de datos, asegurando su integridad, confidencialidad y
seguridad.
Programa (program) Un
conjunto de instrucciones (o sentencias) que describen alguna aplicación o
actividad ejecutada en una computadora.
AKI LES DEJO EL LINK DE LA DIAPOSITIVA.
8.
Bibliografía o Linkografia
Bien elaborada la PRESENTACION. Defina claramente las CONCLUSIONES y RECOMENDACIONES. Detalle la APRECIACION con sus propias palabras. Trabajo bien desarrollado y explicado. Proponga un foro de discusión sobre el tema.Gracias por su investigación.Saludos
ResponderEliminar