Diferencias

Muestra las diferencias entre dos versiones de la página.

--- apuntes:bbdd [17/10/2017 21:18] – Fernando Valdeón
+++ apuntes:bbdd [17/10/2017 21:44] (actual) – borrado Fernando Valdeón
@@ Línea 1: / Línea 1: @@
-===== Conexión a bases de datos =====
-La librería Java Database Connectivity (JDBC) es una API que proporciona acceso a bases de datos desde Java. Consta de dos paquetes:
-	java.sql
-	javax.sql
-Para poder trabajar con un sistema gestor de bases de datos determinado, necesitamos un controlador que haga de intermediario entre la tecnología JDBC y la base de datos.
-{{ :apuntes:jdbc-architecture.jpg?200 |}}
-Para trabajar con los distintos SGBD solo tenemos que descargar el controlador o driver concreto para dicha plataforma.
-Para trabajar con cualquier SGDB que use SQL las sentencias son siempre las mismas, solo cambia el driver de conexión.
-==== Añadir el conector JDBC a nuestro proyecto ====
-{{ :apuntes:jdbcconnector.png?400|}}
-Para conectarnos con MySQL desde Java necesitamos el driver JDBC para MySql. Lo podemos descargar desde la web de Mysql. https://www.mysql.com/products/connector/
-Para usar otro SGBD debemos buscar el driver conector en su soporte web.
-Una vez que lo tenemos descargado debemos añadirlo al classpath de nuestro proyecto. Click derecho sobre nuestro proyecto en el explorador de proyectos de **eclipse -> Build Path -> Configure Build Path**.
-En la ventana que se abre seleccionamos Libraries y pulsamos sobre Add External JARs. Y añadimos el fichero jar que acabamos de descargar.
-==== Conexión con la Base de Datos MySQL====
-Desde la versión 7 de Java ya no necesitamos cargar el driver; se carga automáticamente. Anteriormente debíamos indicar la siguiente instrucción:
-<code java>
-Class.forName("com.mysql.jdbc.Driver").newInstance();
-</code>
-Lo siguiente que necesitamos es conectarnos a la base de datos mediante la clase **Connection** y la clase **DriverManager** con su método estático **getConnection()**. Estas clases esperan una cadena que indique todos los parámetros de conexión con la base de datos. __Siempre usaremos las clases del paquete java.sql__.
-<code java>
-Connection conexionBD = null;
-String SERVIDOR = "jdbc:mysql://localhost:3306/";
-String baseDatos = "reservas";
-String user = "root";
-String pass = "";
-conexionBD = DriverManager.getConnection(SERVIDOR+baseDatos,user,pass);
-</code>
-user es el nombre de usuario con el que te conectas a la base de datos, y pass representa la contraseña, que estará en blanco si no la hemos definido en MySql.
-=== Conexión con otros SGBD ===
-(p.e. PostgreSql, MariaDb)
-El proceso es el mismo, pero varía el tipo de servidor de bases de datos y también el driver:
-<code java>
-String SERVIDOR = "jdbc:postgresql://localhost:5432/";
-String SERVIDOR = "jdbc:mariadb://localhost:3306/";
-</code>
-==== Consultas sobre la base de datos ====
-=== Preparación de consultas ===
-Para preparar una consulta para su ejecución necesitamos usar la clase **PreparedStatement**. Su sintaxis de uso es bastante sencilla, ya que el método **preparedStatement**(String consulta) de la clase **Connection** nos devuelve un objeto de este tipo:
-<code java>
-String consulta = "INSERT INTO usuarios VALUES ('Juan','Sola')";
-PreparedStatement sentencia = conexion.prepareStatement(consulta)
-</code>
-=== Ejecución de consultas ===
-La clase PreparedStatement contiene principalmente 3 tipos de métodos de ejecución de consultas:
-  * Consultas de acción (INSERT, UPDATE, DELETE)
-Usaremos el método **executeUpdate()**, que devuelve un **int** con el número de registros afectados. Ese valor podemos usarlo o no.
-<code java>
-int numeroRegistros = sentencia.executeUpdate();
-</code>
-  * Consultas de selección (SELECT, funciones, procedimientos)
-Si consulta devuelve registros, usaremos el método **executeQuery()**, que devuelve un tipo de datos **ResultSet** con el conjunto de registros obtenidos:
-<code java>
-ResultSet resultado = sentencia.executeQuery();
-</code>
-Una vez que tenemos el objeto **ResultSet** con el conjunto de registros obtenidos, podemos acceder a ellos mediante el método **getString()** de la clase ResultSet.
-<code java>
-while(resultado.next()){
-System.out.println(resultado.getString(1)+", "+ resultado.getString(2));
-}
-</code>
-De esta forma mostraríamos por pantalla las columnas 1 y 2 de cada registro obtenido. También podemos usar **getString**("id") para obtener la columna "id", o cualquier otro nombre de columna.
-  * Cualquier tipo de consulta
-El método boolean **execute()** se usa cuando la consulta puede devolver uno o varios conjuntos de registros **ResultSet**.
-<code java>
-boolean estado = sentencia.execute();
-</code>
-Si el método devuelve true, quiere decir que el primer resultado obtenido es un ResultSet. Podemos acceder a dicho conjunto de registros con el método **getResultSet()**.
-<code java>
-boolean estado = sentencia.execute();
-if(estado){
-	ResultSet resultado = sentencia.getResultSet();
-	//procesamos el resultado
-}
-</code>
-Si devuelve false indica que la consulta es del tipo (INSERT, UPDATE o DELETE), o que no ha devuelto resultados. Podemos acceder al número de registros afectados mediante el método int getUpdateCount().
-=== Obtener el número de columnas de una consulta ===
-Si en algún caso al realizar una consulta no sabemos cuántas columnas nos va a devolver, podemos usar el método getMetaData() que devuelve un objeto del tipo ResultSetMetaData.
-Existen dos formas de usar dicho método. Puede invocarlo desde un objeto de tipo ResultSet obtenido de la ejecución de una consulta:
-<code java>
-	…
-	ResultSet resultado = sentencia.executeQuery();
-ResultSetMetaData resultadoMetaData = resultado.getMetaData();
-int numeroColumnas = resultadoMetaData.getColumnCount();
-</code>
-También puedo obtenerlo antes de ejecutar la consulta llamando al método desde un objeto de tipo PreparedStatement:
-<code java>
-…
-PreparedStatement sentencia = conexión.preparedStatement(consulta);
-ResultSetMetaData resultadoMetaData = sentencia.getMetaData();
-int numeroColumnas = resultadoMetaData.getColumnCount();
-</code>
-=== Cerrar conexión ===
-El método close() de la clase Connection, cierra la conexión con la base de datos.
-<code java>
-	conexion.close();
-</code>
-==== Anexo: Ejemplos ====
-=== Insertar datos ===
-<code java>
-String sentenciaSql = "INSERT INTO productos (nombre, precio) VALUES (?, ?)";
-PreparedStatement sentencia = null;
-try {
-  sentencia = conexion.prepareStatement(sentenciaSql);
-  sentencia.setString(1, nombreProducto);
-  sentencia.setFloat(2, precioProducto);
-  sentencia.executeUpdate();
-} catch (SQLException sqle) {
-  sqle.printStackTrace();
-} finally {
-  if (sentencia != null)
-    try {
-      sentencia.close();
-    } catch (SQLException sqle) {
-      sqle.printStackTrace();
-    }
-}
-</code>
-=== Modificar datos ===
-<code java>
-String sentenciaSql = "UPDATE productos SET nombre = ?, precio = ? " +
-                      "WHERE nombre = ?";
-PreparedStatement sentencia = null;
-try {
-  sentencia = conexion.prepareStatement(sentenciaSql);
-  sentencia.setString(1, nuevoNombreProducto);
-  sentencia.setFloat(2, precioProducto);
-  sentencia.setString(3, nombreProducto);
-  sentencia.executeUpdate();
-} catch (SQLException sqle) {
-  sqle.printStackTrace();
-} finally {
-  if (sentencia != null)
-    try {
-      sentencia.close();
-    } catch (SQLException sqle) {
-      sqle.printStackTrace();
-    }
-}
-</code>
- === Eliminar datos ===
-<code java>
-String sentenciaSql = "DELETE productos WHERE nombre = ?";
-PreparedStatement sentencia = null;
-try {
-  sentencia = conexion.prepareStatement(sentenciaSql);
-  sentencia.setString(1, nombreProducto);
-  sentencia.executeUpdate();
-} catch (SQLException sqle) {
-  sqle.printStackTrace();
-} finally {
-  if (sentencia != null)
-    try {
-      sentencia.close();
-    } catch (SQLException sqle) {
-      sqle.printStackTrace();
-    }
-}
-</code>
-=== Otras Clases ===
-  - HashMap
-  - HashSet
-  - HashTable
-  - Enum
-----
-(c) 2017 Fernando Valdeón