JDBC
Carrera Profesional:
Ingeniería de Sistemas y Telemática
Tema:
Objeto Comand
Docente:
Marco Aurelio Porro Chulli.
Asignatura:
Laboratorio de Programación III
Integrantes:
- Maldonado Idrogo Betzabeth Yameli
- Pérez Saucedo Yordin Alberto
Utcubamba - Bagua Grande - 2017SOLO UN PEDACITO
1. Contenido
Î Capa de Acceso de Datos, creación:
Acceso de JDBC a base de Datos
El API JDBC soporta dos modelos diferentes
de acceso a Bases de Datos, los modelos de dos y tres capas.
·
Modelo de dos Capas
Este
modelo se basa en que la conexión entre la aplicación Java o el applet que se
ejecuta en el navegador, se conectan directamente a la base de datos.
Esto
significa que el driver JDBC específico para conectarse con la base de datos,
debe residir en el sistema local. La base de datos puede estar en cualquier
otra máquina y se accede a ella mediante la red. Esta es la configuración de
típica Cliente/Servidor: el programa cliente envía instrucciones SQL a la base
de datos, ésta las procesa y envía los resultados de vuelta a la aplicación.
·
Modelo de tres capas
En este
modelo de acceso a las bases de datos, las instrucciones son enviadas a una
capa intermedia entre Cliente y Servidor, que es la que se encarga de enviar
las sentencias SQL a la base de datos y recoger el resultado desde la base de
datos. En este caso el usuario no tiene contacto directo, ni a través de la
red, con la máquina donde reside la base de datos.
Este
modelo presenta la ventaja de que el nivel intermedio mantiene en todo momento
el control del tipo de operaciones que se realizan contra la base de datos y,
además, está la ventaja adicional de que los drivers JDBC no tienen que residir
en la máquina cliente, lo cual libera al usuario de la instalación de cualquier
tipo de driver.
-
Importar los paquetes: Normalmente es suficiente con la
sentencia import java.sql.
-
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.
-
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
Para
MySQL, el formato es:
"jdbc:mysql://ordenador_donde_está_la_base_de_datos/base_de_datos".
Deberemos
indicar el nombre o IP del ordenador en el que se encuentra el servidor de base
de datos y a continuación el nombre de la base de datos.
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.
Î
Configuración de conexión
BD con Netbeans.
Configuración de MySQL y
de SQL Server para poder utilizar conexiones mediante el driver JDBC; ambos
DBMS permiten la conexión mediante controladores Java puro de tipo JDBC, Sin
embargo, la instalación de SQL Server es más complicada que la de MySQL, al menos
para poder utilizar el JDBC.
Configurar SQL Server
Express para poder usar el Driver JDBC java:
PASO 1:
SQL Server se instala por
omisión con la Autenticación de Windows. Ocurre que el controlador JDBC;
requiere que se utilice la Autenticación de SQL Server, ya que esta requiere de
usuario y contraseña.
Por lo tanto, hay que
cambiar la configuración para que la Autenticación o instalarlo de modo que sea
mixta: Autenticación para Windows y Autenticación de SQL Server
En mi servidor se puede
ver que admite ambos tipos de autenticación:
Autenticación de Windows:
no pide usuario y contraseña porque utiliza la del Sistema Operativo.
Autenticación de SQL
Server: va a pedir el usuario administrador (sa) y su contraseña. Se puede
configurar al instalar o con posterioridad
Puede apreciarse que la
conexión ha sido exitosa a través de la Autenticación de SQL Server. De lo
contrario, si no está configurada, no se podrá conectar.
PASO 2:
Una vez que se tiene
configurada la Autenticación de SQL Server hay que ejecutar el SQL Server
Configuration Manager.
Allí podemos ver distintos
servicios, tienen que estar iniciados dos servicios, como muestra la imagen (el
agente no es necesario)
PASO 3:
Hay que configurar la capa
de red, de modo que SQL Server acepte conexiones de red TCP/IP, una vez hecho
esto hay que reiniciar estos servicios.
Tienen que estar los tres protocolos
habilitados. Ir a TCP/IP
Al final de la lista de
Direcciones IP en IPALL colocar el número de puerto 1433, Reiniciar este
servicio.
Î
Definición de JDBC. Tipos.
Aplicaciones.
Definición:
Es usado para enviar
comandos SQL hacia una base de datos relacional, que puede ser Oracle, Infomix,
SyBase, etc. Una integración de SQL hacia Java, es decir que las sentencias SQL
se puedan mezclar con Java, por ejemplo, que una variable de Java pueda ser usada
en una sentencia SQL para recibir o dar valores.
JDBC (Java Database
Connectivity) 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 lenguaje SQL del modelo de base de datos que se utilice.
Tipos de Drivers
Un driver
JDBC puede pertenecer a una de cuatro categorías diferentes en cuanto a la
forma de operar
·
Puente JDBC-ODBC
La primera
categoría de drivers es la utilizada por Sun inicialmente para popularizar JDBC
y consiste en aprovechar todo lo existente, estableciendo un puente entre JDBC
y ODBC. Este driver convierte todas las llamadas JDBC a llamadas ODBC y realiza
la conversión correspondiente de los resultados.
La
ventaja de este driver, que se proporciona con el JDK, es que Java dispone de
acceso inmediato a todas las fuentes posibles de bases de datos y no hay que
hacer ninguna configuración adicional aparte de la ya existente. No obstante,
tiene dos desventajas muy importantes; por un lado, la mayoría de los drivers
ODBC a su vez convierten sus llamadas a llamadas a una librería nativa del
fabricante DBMS, con lo cual la lentitud del driver JDBC-ODBC puede ser
exasperante, al llevar dos capas adicionales que no añaden funcionalidad
alguna; y por otra parte, el puente JDBC-ODBC requiere una instalación ODBC ya existente
y configurada.
·
Java/Binario
Este
driver se salta la capa ODBC y habla directamente con la librería nativa del
fabricante del sistema DBMS (como pudiera ser DB-Library para Microsoft SQL
Server o CT-Lib para Sybase SQL Server). Este driver es un driver 100% Java,
pero aun así necesita la existencia de un código binario (la librería DBMS) en la
máquina del cliente, con las limitaciones y problemas que esto implica.
·
100% Java/ Protocolo
nativo
Es un
driver realizado completamente en Java que se comunica con el servidor DBMS
utilizando el protocolo de red nativo del servidor. De esta forma, el driver no
necesita intermediarios para hablar con el servidor y convierte todas las peticiones
JDBC en peticiones de red contra el servidor. La ventaja de este tipo de driver
es que es una solución 100% Java y, por lo tanto, independiente de la máquina
en la que se va a ejecutar el programa.
·
100% Java/ Protocolo
independiente
Esta es
la opción más flexible, se trata de un driver 100% Java / Protocolo
independiente, que requiere la presencia de un intermediario en el servidor. En
este caso, el driver JDBC hace las peticiones de datos al intermediario en un
protocolo de red independiente del servidor DBMS. El intermediario a su vez,
que está ubicado en el lado del servidor, convierte las peticiones JDBC en peticiones
nativas del sistema DBMS. La ventaja de este método es inmediata: el programa
que se ejecuta en el cliente, y aparte de las ventajas de los drivers 100%
Java, también presenta la independencia respecto al sistema de bases de datos
que se encuentra en el servidor.
Aplicaciones:
Hay una gran variedad de arquitecturas
posibles para las aplicaciones de bases de datos (dependiendo de los requisitos
de la aplicación). Elegir el driver JDBC correcto es importante porque tiene un
impacto directo en el rendimiento de la aplicación.
El puente JDBC-ODBC se podría considerar
únicamente como una solución transitoria ya que no soporta todas las
características de Java, y el usuario está limitado por la funcionalidad del
driver ODBC elegido. Las aplicaciones a gran escala utilizarán drivers de los
tipos 2, 3 o 4.
En las aplicaciones de Intranet es
útil considerar los driver de tipo 2, pero estos drivers, como el puente ODBC,
necesitan que ese código se instale en cada cliente. Por lo tanto, tienen los
mismos problemas de mantenimiento que el driver puente JDBC-ODBC. Sin embargo,
los drivers de tipo 2 son más rápidos que los de tipo 1 porque se elimina el
nivel extra de traducción. Como los drivers de tipo 3 y de tipo 4 muestran
mejor rendimiento que los drivers de tipo 2, la tendencia se dirige hacia un
driver Java puro más robusto.
Para las aplicaciones relacionadas con
Internet, no hay otra opción que utilizar drivers del tipo 3 o del tipo 4. Los
drivers de tipo 3 son los que mejor funcionan con los entornos que necesitan
proporcionar conexión a gran cantidad de servidores de bases de datos y a bases
de datos heterogéneas.
Los drivers de tipo 3 funcionan con
aplicaciones intensivas de datos multiusuario, en las que se espera un alto
número de operaciones concurrentes de datos, siendo el rendimiento y la
escalabilidad el principal factor. El servidor puede proporcionar facilidades
de registro y de administración, características del equilibrio de carga y
puede soportar cachés de catálogo y de consultas.
Los drivers de tipo 4 están
generalmente recomendados para aplicaciones que requieren un acceso rápido y
eficiente a bases de datos. Como estos drivers traducen llamadas JDBC
directamente a protocolo nativo sin utilizar ODBC o el API nativos, pueden
aportar acceso a bases de datos de alto rendimiento.
ü Testconnection.java : Aplicación que permite comprobar si
se puede establecer una conexión exitosa con la base de datos.
ü Appl_01.java : Aplicación que permite visualizar las tablas existentes
dentro de la base de datos.
ü Appl_02.java : Aplicación que visualiza los discos e intérpretes dentro
de la base de datos.
ü Appl_03.java : Aplicación que permite crear una tabla con tres campos
en la base de datos.
ü Appl_04.java : Aplicación que permite agregar nuevo registro a la nueva
tabla creada anteriormente con appl_03.java..
Î Uso de JDC en aplicaciones Java
Para usar JDBC hay que seguir los
siguientes pasos:
1.
Incluir el jar con el
Driver de la base de datos
El primer paso es obtener el driver de
la base de datos que vamos a utilizar, buscamos en google “MySQL jdbc driver”,
“Oracle jdbc driver” o el que queramos y descargamos el jar y lo incluimos es
nuestro proyecto. Para este ejemplo voy a usar MySQL, puedes descargarlo desde
aquí, lo que queremos es el .jar por lo que tienes que elegir Plataform
Independent y descargar el zip o el tar.gz, y aunque vienen unos cuantos
archivos y carpetas el único que nos interesa es
mysql-connector-java-5.1.26-bin.jar que lo tenemos que añadir a nuestro
proyecto.
2.
Cargar el driver
Ya tenemos el jar con el driver, pero
hay que cargarlo para que se pueda hacer uso de el en nuestra aplicación. En
nuestro caso como vamos a usar MySQL la instrucción es la siguiente y como
puede lanzar una excepción pues se mete dentro de un try-catch.
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException ex) {
log.error("No se encontro el Driver MySQL para JDBC.");
}
3.
Establecer una conexión
con la base de datos
El siguiente paso es establecer una conexión
con la base de datos. Hay dos opciones para obtener una conexión la primera es
crear una nueva conexión con la base de datos que será la que veremos en este
ejemplo y la otra es obtener la conexión de un pool de conexiones creado
previamente que es una opción más eficiente porque no hace falta estar abriendo
y cerrando conexiones continuamente ya que simplemente se cogen las conexiones
de pool cuando se necesitan y se dejan en el pool cuando ya no se necesitan
para que puedan volver a usarse. En un articulo previo, Como crear un pool de
conexiones en Tomcat, puedes ver un ejemplo de como usar un pool de conexiones
con dicho servidor pero para un ejemplo de una aplicación de escritorio como la
que vamos a ver supuestamente vamos a tener pocas llamadas a base de datos por
lo que no se va a notar mucha diferencia.
//Connection cn =
DriverManager.getConnection("jdbc:mysql://servidor_bd:puerto/nombre_bd",
"usuario", "contraseña");
Connection cn =
DriverManager.getConnection("jdbc:mysql://localhost:3306/cuentas",
"root", "");
Para obtener una conexión tenemos que
hacer uso del método getConnection de DriverManager y le tenemos que pasar como
parámetros, la base de datos, el usuario y la contraseña. Si en lugar de usar
mysql se usa otra base de datos el formato de la url de la base de datos
cambia, por ejemplo para oracle el formato es jdbc:oracle:<tipo_driver>:@<<base_datos>.
4.
Realizar una consulta
Una vez obtenida la conexión ya
podemos hacer consultas a la base de datos. Hay tres métodos para ejecutar una
consulta de tipo Statement que es una consulta normal, PreparedStatement con la
que se puede crear una consulta que se precompila en la base de datos y como es
de esperar se pueden establecer los distintos datos porque aunque la estructura
de la consulta será la misma lo lógico es que los datos de la consulta sean
distintos y finalmente están las CallableStatements que sirven para ejecutar
procedimientos almacenados.
Vamos a ver como hacer una consulta de
tipo Statement:
// Creamos el Statement para poder
hacer consultas
Statement st = cn.createStatement();
// La consulta es un String con código
SQL
String sql1 = "SELECT * FROM
cuentas";
// Ejecuta una consulta que devuelve
resultados
ResultSet rs =
st.executeQuery(sql1);
while (rs.next()) {
System.out.println (rs.getString ("propietario") + "
" + rs.getString (2)+ " " + rs.getInt(saldo));
}
String sql2 = "UPDATE cuentas SET
saldo = saldo - "
+ cantidad + " WHERE
codigo = '"
+ codigo + "' AND saldo >=
"
+ cantidad;
// Ejecuta una consulta de tipo
insert, update o delete
st.executeUpdate(sql2);
Como se puede ver el primer paso es
crear un statement sobre el que luego podemos hacer las consultas que queramos,
una vez creado para hacer nuestra consulta tenemos los métodos execute (para
hacer cualquier consulta, pero su valor de devolución es boolean y devuelve
true si lo que devuelve es un resulset y falso en caso contrario), exeteQuery
(para hacer select) y executeUpdate (para hacer insert, update y delate). Y
finalmente si se ejecuta una query podemos obtener el resultado mediante
ResultSet, para obtener los valores de las columnas resulset tiene un get para
cada tipo de datos que se puede llamar pasándole como parámetro el nombre de la
columna de base de datos o el número de la columna según se prefiera.
Como se puede ver el código para hacer
una consulta no es muy complicado, pero es muy propenso a errores porque hay
que estar creando cadenas de texto concatenadas con variables java y hay que
recordar que si el dato es de tipo texto hay que anidar comillas y entre unas
cosas y otras es fácil cometer algún error. Para facilitar el trabajo con bases
de datos hay alternativas a trabajar directamente con JDBC como JPA o
Hibernate, pero estamos hablando de JDBC…
¿Si usamos PreparedStatement además de
que son más eficientes nos facilitan la tarea de escribir las consultas SQL
porque en lugar de tener que estar concatenando las distintas variables con el
código SQL, lo que se hace es sustituir en este las variables por? y posteriormente se introducen los datos
concretos mediante setters. En el siguiente código puedes ver como se crean
unas PreparedStatement.
PreparedStatement pstBuscarCodigo;
PreparedStatement pstInsertarCuenta;
String sqlBusqueda = "SELECT
codigo FROM cuentas WHERE codigo=?";
pstBuscarCodigo =
cn.prepareStatement(sqlBusqueda);
pstBuscarCodigo.setString(1, codigo);
ResultSet rs =
pstBuscarCodigo.executeQuery();
if (!rs.next){...}
String sqlNuevaCuenta = "INSERT
INTO cuentas VALUES (?,?,?,?)";
pstInsertarCuenta =
cn.prepareStatement(sqlNuevaCuenta);
pstInsertarCuenta.setString(1,
codigo);
pstInsertarCuenta.setString(2,
nombre);
pstInsertarCuenta.setString(3, email);
pstInsertarCuenta.setDouble(4, saldo);
pstInsertarCuenta.executeUpdate();
5.
Cerrar la conexión
Después de hacer las consultas que se
necesite se debe de cerrar la conexión para liberar los recursos, también se
pueden cerrar el resulset y el statement de forma manual, pero cerrando la
conexión se cierran los otros dos porque están creados a partir de la conexión,
del mismo modo al cerrar el statement también se liberan los recursos del
resulset.
rs.close(); // Cierra el resulset
st.close(); // Cierra el statement
cn.close(); // Cierra la conexión
Î
Ejemplos:
Ejemplo:
Crear la tabla BANK
Para ilustrar el API JDBC,
consideraremos la clase CreateTableBank. Esta clase nos ofrece los métodos
initialize() y close() para establecer y liberar una conexión con la base de
datos.
El método createTableBank crea la
tabla BANK, utilizando para ello un objeto de tipo Statement. Sin embargo, dado
que el método executeUpdate() ejecuta una sentencia SQL de tipo CREATE TABLE,
ésta no actualiza ningún registro de la base de datos y por ello este método
devuelve cero. En caso de ejecutar una sentencia de tipo INSERT, UPDATE o
DELETE, el método devolvería el número de filas que resultasen afectadas por el
cambio.
public class CreateTableBank {
String driver =
``com.mysql.jdbc.Driver'';
String url = ``jdbc:mysql:Bank'';
String login = ``root'';
String password =
``nadiuska'';
String createTableBank =
"CREATE TABLE BANK
(" +
"client
VARCHAR(100) NOT NULL, " +
"password
VARCHAR(20) NOT NULL, " +
"balance Integer
NOT NULL, " +
"PRIMARY
KEY(client))";
Connection connection = null;
Statement statement
= null;
public void initialize() throws
SQLException, ClassNotFoundException
{
Class.forName(driver);
connection = DriverManager.getConnection(url,
login,
password);
}
public void createTableBank() throws SQLException {
statement =
connection.createStatement();
statement.executeUpdate(createTableBank);
}
public void close() throws SQLException {
try {
connection.close();
} catch (SQLException e) {
throw e;
}
}
}
Una vez creada la tabla BANK, el
siguiente paso podría ser la introducción en la misma de los datos de los
clientes. Si dichos datos están disponibles en fichero, el código para leerlos
e introducirlos en la base de datos sería el siguiente:
public void insertData() throws
SQLException, IOException {
String client, password;
int balance;
BufferedReader br = new BufferedReader(
new FileReader(``clients.txt''));
try {
do {
client = br.readLine();
password = br.readLine();
balance =
Integer.parseInt(br.readLine());
String sqlString =
``INSERT INTO BANK VALUES('``
+ client + ``',''' + password
+ ``','''
+ balance + ``')'';
statement.executeUpdate(sqlString);
statement.close();
} while (br.readLine() != null);
} catch (IOException e) {
e.printStackTrace();
} finally {
br.close();
}
}
El formato del archivo de entrada es:
nombre del cliente, clave de acceso y saldo, introducidos en líneas separadas,
y seguidos de una línea separatoria como se muestra a continuación:
Iván Samuel Tejera Santana
nadiuska
1000000
--------------------------
En el código anterior, la única
sentencia relevante es el método
statement.executeUpdate(), invocado
para insertar datos en la tabla BANK (dicho método devuelve el número de
registros insertados).
1. Resumen
JDBC
es un API de Java que nos permite conectarnos con bases de datos y realizar
operaciones sobre ellas utilizando instrucciones SQL desde una aplicación Java.
Con JDBC tenemos una interfaz para conectarnos con una base de datos sin tener
que preocuparnos de si es una base de datos MySQl, Oracle, SQLServer o
cualquier otro tipo de base de datos. El único cambio que habría que hacer para
cambiar el tipo de base de datos de una aplicación sería cambiar el driver especifico
de la base de datos en cuestión.
Cuentas
con tres tipos de Drivers JDBC como son:
-
Puente JDBC-ODBC
-
Java/Binario.
-
100% Java/Protocolo Nativo
-
100% Java/Protocolo Independiente
2.
Summary
JDBC is a Java API that
allows us to connect to databases and perform operations on them using SQL
statements from a Java application. With JDBC we have an interface to connect
with a database without having to worry about whether it is a MySQl database,
Oracle, SQLServer or any other type of database. The only change that would
have to be made to change the database type of an application would be to
change the specific driver of the database in question.
You have three types of
JDBC Drivers, such as:
- -
JDBC-ODBC Bridge
-
Java / Binary.
-
100% Java / Native Protocol
-
100% Java / Independent Protocol
1.
Recomendaciones
ü
Si escribe una sentencia SQL que se va a utilizar más de
una vez, el rendimiento será mayor si la sentencia es un objeto
PreparedStatement que si es un objeto Statement.
ü
Utilizar procedimientos almacenados para ejecutar un
grupo de sentencias SQL
ü
La agrupación de conexiones es una estrategia que permite
reutilizar los objetos Connection de JDBC por parte de múltiples usuarios, en
vez de dejar que cada usuario solicite crear su propio objeto Connection.
2.
Conclusiones:
·
El objeto JDBC es importante para poder establecer una conexión
con una base de datos en cualquier Gestor de base de datos ya sea SQL Server,
MySQL Server, etc.
·
Los drivers JDBC y ODBC permite utilizar procedimientos
almacenados para ejecutar un programa de manera eficiente.
·
Un aspecto importante de este prototipo es que permite la
operación global y local desde la misma
interfaz.
3. Apreciación del Equipo:
JDBC permite conectarse a
una base de datos de forma remota. Con la facilidad de utilizar procedimientos
almacenados y sentencias SQL como el SELECT, UPDATE, INSERT y DELETE.
Su manejo es de suma
importancia en la actualidad ya que la plataforma Java utiliza este tipo de
paquete para poder conectarse a cualquier base de datos.
4. Glosario de Términos:
1)
Applet: Un applet es un componente de una aplicación que
se ejecuta en el contexto de otro programa, por ejemplo, en un navegador web.
El applet debe ejecutarse en un contenedor, que le proporciona un programa
anfitrión, mediante un plugin,1o en aplicaciones como teléfonos móviles que
soportan el modelo de programación por "applets".
2)
Residir: Vivir habitualmente [una persona] en una casa,
un país u otro lugar determinado.
3)
Driver: Controlador, rutina o programa que enlaza un
dispositivo periférico al sistema operativo.
4)
Sobrecarga: Efecto de saturación u ocupación completa de
una cosa que impide su funcionamiento normal.
5)
Interfaz: Dispositivo capaz de transformar las señales
generadas por un aparato en señales comprensibles por otro.
6)
Omisión: es una renuncia a realizar o expresar
algo.
7)
Autenticación: Procedimiento informático que permite
asegurar que un usuario de un sitio web u otro servicio similar es auténtico o
quien dice ser.
8)
Parámetro: Variable utilizada para recibir valores de
entrada en una rutina, subrutina o método.
9)
Propenso: Que tiene propensión hacia algo, o que suele
hacerlo.
10)
Concatenar: Enlazar o vincular hechos o ideas que
guardan entre sí una relación lógica o de causa y efecto.
5. Blibliografía o Linkografía:
9. Diapositivas
Comentarios
Publicar un comentario