JAVA CON BASE DE DATOS.

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();

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 ()

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;

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;

public SQLconnection()
{
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;
}

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);
}
}

public String getDb() {
return db;
}

public void setDb(String db) {
this.db = db;
}

public String getHost() {
return host;
}

public void setHost(String host) {
this.host = host;
}

public String getPassword() {
return password;
}

public void setPassword(String password) {
this.password = password;
}

public String getUser() {
return user;
}

public void setUser(String user) {
this.user = user;
}

public ResultSet consultar(String tabla) throws SQLException
{
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;
}

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);
}
}

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);
}
}

public void eliminar(String tabla, String nombre)
{
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));
}

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);
}

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) && (!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.

 VIDEO DE JAVA CON BASE DE DATOS. 

AKI LES DEJO EL LINK DE LA DIAPOSITIVA.

http://es.slideshare.net/VicenteAlberca/java-con-base-de-datos-66393676

8.    Bibliografía o Linkografia

https://fragowb.wordpress.com/2008/07/22/ejemplo-de-java-sql-netbeans/

http://es.slideshare.net/javi2401/java-y-bases-de-datos-presentation

https://es.wikipedia.org/wiki/Java_Database_Connectivity

http://www.euskalnet.net/jaoprogramador/j2ee/JDBC/jdbc17.htm