¿QUÉ HACE JDBC?:
Simplemente JDBC hace posible estas tres cosas:
• Establece una conexión con la base de datos.
• Envía sentencias SQL
• Procesa los resultados.
El siguiente fragmento de código nos muestra un ejemplo básico de estas tres cosas:
Connection con = DriverManager.getConnection (
"jdbc:odbc:wombat", "login", "password");
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM Table1");
while (rs.next()) {
int x = rs.getInt("a");
String s = rs.getString("b");
float f = rs.getFloat("c");
CAPA DE ACCESO A DATOS:
Conectividad JDBC
Para la gente del
mundo Windows, JDBC es para Java lo que ODBC es para Windows.
Windows en general no sabe nada acerca de las bases de datos, pero define el
estándar ODBC consistente en un conjunto de primitivas que cualquier driver o
fuente ODBC debe ser capaz de entender y manipular. Los programadores que a su
vez deseen escribir programas para manejar bases de datos genéricas en Windows
utilizan las llamadas ODBC.
Con JDBC ocurre exactamente lo mismo: JDBC es una especificación
de un conjunto de clases y métodos de operación que permiten a cualquier
programa Java acceder a sistemas de bases de datos de forma homogénea.
Lógicamente, al igual que ODBC, la aplicación de Java debe tener acceso a un
driver JDBC adecuado. Este driver es el que implementa la funcionalidad de
todas las clases de acceso a datos y proporciona la comunicación entre el API
JDBC y la base de datos real.
La necesidad de JDBC, a pesar de la existencia de ODBC, viene dada
porque ODBC es un interfaz escrito en lenguaje C, que al no ser un lenguaje
portable, haría que las aplicaciones Java también perdiesen la portabilidad. Y
además, ODBC tiene el inconveniente de que se ha de instalar manualmente en
cada máquina; al contrario que los drivers JDBC, que al estar escritos en Java
son automáticamente instalables, portables y seguros.
Toda la conectividad de
bases de datos de Java se basa en sentencias SQL, por lo que se hace
imprescindible un conocimiento adecuado de SQL para realizar cualquier clase de
operación de bases de datos. Aunque, afortunadamente, casi todos los entornos
de desarrollo Java ofrecen componentes visuales que proporcionan una
funcionalidad suficientemente potente sin necesidad de que sea necesario
utilizar SQL, aunque para usar directamente el JDK se haga imprescindible. La
especificación JDBC requiere que cualquier driver
JDBC sea compatible con al menos el nivel «de entrada» de ANSI SQL 92 (ANSI SQL 92 Entry Level).
Acceso de JDBC a Bases de Datos:
El API JDBC soporta dos
modelos diferentes de acceso a Bases de Datos, los modelos de dos y tres 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.
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.
Un driver JDBC puede
pertenecer a una de cuatro categorías diferentes en cuanto a la forma de
operar.
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.
Lo anterior implica que para
distribuir con seguridad una aplicación Java que use JDBC habría que limitarse
en primer lugar a entornos Windows (donde está definido ODBC) y en segundo
lugar, proporcionar los drivers ODBC adecuados y configurarlos correctamente.
Esto hace que este tipo de drivers esté totalmente descartado en el caso de
aplicaciones comerciales, e incluso en cualquier otro desarrollo, debe ser
considerado como una solución transitoria, porque el desarrollo de drivers
totalmente en Java hará innecesario el uso de estos puentes.
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 aún 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.
3. 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.
Igualmente, dependiendo de la forma en que esté programado el
driver, puede no necesitar ninguna clase de configuración por parte del usuario.
La única desventaja de este tipo de drivers es que el cliente
está ligado a un servidor DBMS concreto, ya que el protocolo de red que utiliza
MS SQL Server por ejemplo no tiene nada que ver con el utilizado por DB2,
PostGres u Oracle. La mayoría de los fabricantes de bases de datos han
incorporado a sus propios drivers JDBC del segundo o tercer tipo, con la
ventaja de que no suponen un coste adicional.
4. % 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.
De esta forma, si una empresa distribuye una aplicación Java para
que sus usuarios puedan acceder a su servidor MS SQL y posteriormente decide
cambiar el servidor por Oracle, PostGres o DB2, no necesita volver a distribuir
la aplicación, sino que únicamente debe reconfigurar la aplicación residente en
el servidor que se encarga de transformar las peticiones de red en peticiones
nativas. La única desventaja de este tipo de drivers es que la aplicación
intermediaria es una aplicación independiente que suele tener un coste
adicional por servidor físico, que hay que añadir al coste del servidor de
bases de datos.
Configuración de conexión BD con NetBeans.
NetBeans es una plataforma
para el desarrollo de aplicaciones de escritorio usando Java y a un Entorno
integrado de desarrollo (IDE) desarrollado usando la Plataforma NetBeans. Si eres un programador y desarrollas tus
aplicaciones en Java seguramente necesitarás conectar una base de datos tipo SQL Server a este entorno algún día, bueno, si lo necesitas ahora, he aquí una
explicación paso a paso de cómo conectar ambas herramientas. Para una correcta conexión de base de datos con netBeans debes hacer lo siguiente:
Primero que nada necesitas tener un servidor SQL Server instalado en tu equipo o en su defecto en la máquina que actuará como servidor de bases de datos. Recuerda que SQL Server es gratuito y puedes obtenerlo facilmente.
Asimismo, debes de tener el NetBeans instalado, de preferencia su última versión estable (al momento de esta publicación es la 8.1) que viene con el Java Development Kit (JDK)
- Una vez que tengas ambas herramientas instaladas necesitaras el driver o conector a la base de datos de SQL Server.
Aremos los siguiente pasos :
1. Iremos a administrador de configuración de Sql Server.
2. Luego de que hacemos click en aceptar nos vamos al Campo donde dice configuracion de Red de SQL Server, damos click derecho y doble clic en el Protocolos de MSSQLSERVER.
3. Luego doble click en TPC/IP Y habilitamos todos los que están en NO poniendo SI
4. Donde dice dirección de IP También habilitamos los que dicen NO a SI y los puertos ponemos con 1433
5. Luego de eso se pone clave a el sql server de la siguiente manera
6. Cargamos el netBeans: creamos una librería y dentro de esa librería cremos una clase y en esa clase conectamos ya con la base de datos y netBeans
TIPOS DE JDBC:
Los drivers que son susceptibles de clasificarse en una de
estas cuatro categorías.
1.- Puente JDBC-ODBC más driver ODBC:
El producto de
JavaSoft suministra acceso vía drivers ODBC. Nótese que el código binario ODBC,
y en muchos casos el código cliente de base de datos, debe cargarse en cada
máquina cliente que use este driver. Como resultado, este tipo de driver es el
más apropiado en un red corporativa donde las instalaciones clientes no son un
problema mayor, o para una aplicación en el servidor escrito en Java en una
arquitectura en tres-niveles.
2.- Driver Java parcialmente Nativo:
Este tipo de driver
convierte llamadas JDBC en llamadas del API cliente para Oracle, Sybase,
Informix, DB2 y otros DBMS. Nótese que como el driver puente, este estilo de
driver requiere que cierto código binario sea cargado en cada máquina cliente.
3.- Driver Java nativo JDBC-Net:
Este driver traduce
llamadas JDBC al protocolo de red independiente del DBMS que después es
traducido en el protocolo DBMS por el servidor. Este middleware en el servidor
de red es capaz de conectar a los clientes puros Java a muchas bases de datos
diferentes. El protocolo específico usado dependerá del vendedor. En general
esta es la alternativa más flexible.
4.- Driver puro Java y nativo-protocolo..
Este tipo de
driver convierte llamadas JDBC en el protocolo de la red usado por DBMS
directamente. Esto permite llamadas directas desde la máquina cliente al
servidor DBMS y es la solución más práctica para accesos en intranets. Dado que
muchos de estos protocolos son propietarios, los fabricantes de bases de datos
serán los principales suministradores. Esperamos que las alternativas 3 y 4
sean las formas preferidas de acceder a las bases de datos desde JDBC. Las
categorías 1 y 2 son soluciones interinas cuando no están disponibles drivers
directos puros Java.
JDBC CON APLICACIONES DE
EJEMPLO
En esta ocasión voy a poner tres ejemplos de como usar JDBC que podrían
ser parte de una misma aplicación pero lo he dividido en tres para no perderse.
Pero antes vamos a ver como funciona JDBC.
JDBC (Java Database Connectivity) 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.
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. 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, 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 numero de la columna según se prefiera.
EJEMPLOS:
Ejemplo 01:
Aplicación que permite visualizar las tablas existentes dentro de la base de datos.
import java.sql.*;
import javax.swing.*;
public class appl_01
{
public static void main(String[] args) throws Exception
{
String url = "jdbc:mysql://aragorn.elo.utfsm.cl/arg_musiteca";
String login = "antares";
String pass = "";
Connection conn = null;
try
{
Class.forName("com.mysql.jdbc.Driver").newInstance();
conn = DriverManager.getConnection(url,login,pass);
if (conn != null)
{
Statement stmt = conn.createStatement();
String sql = "show tables";
ResultSet rs = stmt.executeQuery(sql);
System.out.println("Tablas");
System.out.println("------");
while (rs.next()) {
String r = rs.getString(1);
System.out.println(r);
}
conn.close();
}
}
catch(SQLException ex)
{
JOptionPane.showMessageDialog(null, ex);
}
catch(ClassNotFoundException ex)
{
JOptionPane.showMessageDialog(null, ex);
}
}
}
Ejemplo 02:
Aplicación que visualiza los discos e interpretes dentro de la base de datos.
import java.sql.*;
import javax.swing.*;
public class appl_02
{
public static void main(String[] args) throws Exception
{
String url = "jdbc:mysql://aragorn.elo.utfsm.cl/arg_musiteca";
String login = "antares";
String pass = "";
Connection conn = null;
try
{
Class.forName("com.mysql.jdbc.Driver").newInstance();
conn = DriverManager.getConnection(url,login,pass);
if (conn != null)
{
Statement stmt = conn.createStatement();
String sql = "select NOMBRE from DISCOS";
ResultSet rs = stmt.executeQuery(sql);
System.out.println("Discos");
System.out.println("------");
while (rs.next()) {
String r = rs.getString("NOMBRE");
System.out.println(r);
}
sql = "select NOMBRE from INTERPRETES";
rs = stmt.executeQuery(sql);
System.out.println(" ");
System.out.println("INTERPRETES");
System.out.println("-----------");
while (rs.next()) {
String r = rs.getString("NOMBRE");
System.out.println(r);
}
conn.close();
}
}
catch(SQLException ex)
{
System.out.println(ex);
}
catch(ClassNotFoundException ex)
{
System.out.println(ex);
}
}
}
Ejemplo 03:
Aplicación que permite crear una tabla con tres campos en la base de datos.
import java.sql.*;
public class appl_03
{
public static void main(String[] args) throws Exception
{
String url = "jdbc:mysql://aragorn.elo.utfsm.cl/arg_musiteca";
String login = "antares";
String pass = "";
Connection conn = null;
try
{
Class.forName("com.mysql.jdbc.Driver").newInstance();
conn = DriverManager.getConnection(url,login,pass);
if (conn != null)
{
Statement stmt = conn.createStatement();
String sql = "create table "+args[0]+" ("+args[1]+" int (5) not null, "+args[2]+" varchar (32) not null, "+args[3]+" varchar (32) not null, primary key ("+args[1]+"))";
stmt.executeUpdate(sql);
conn.close();
}
}
catch(SQLException ex)
{
System.out.println(ex);
}
catch(ClassNotFoundException ex)
{
System.out.println(ex);
}
}
}
Ejemplo 04:
Aplicación que permite agregar nuevo registro a la nueva tabla creada anteriormente con
import java.sql.*;
public class appl_04
{
public static void main(String[] args) throws Exception
{
String url = "jdbc:mysql://aragorn.elo.utfsm.cl/arg_musiteca";
String login = "antares";
String pass = "";
Connection conn = null;
try
{
Class.forName("com.mysql.jdbc.Driver").newInstance();
conn = DriverManager.getConnection(url,login,pass);
if (conn != null)
{
Statement stmt = conn.createStatement();
String sql = "insert into "+args[0]+" values ("+args[1]+",'"+args[2]+"','"+args[3]+"')";
stmt.executeUpdate(sql);
conn.close();
}
}
catch(SQLException ex)
{
System.out.println(ex);
}
catch(ClassNotFoundException ex)
{
System.out.println(ex);
}
}
}
RESUMEN:
Este Blogg explica sobre el JDBC (Java Data Base Connectivity) es el estándar de Java para conectarse con bases de datos. Se estima que aproximadamente la mitad del software que se crea en la actualidad incorpora operaciones de lectura y escritura con bases de datos. JDBC está diseñado para ser independiente de la plataforma e incluso de la base de datos sobre la que se desee actuar. Para conseguir esta independencia, JDBC ofrece un sistema estándar de interconexión con las bases de datos, muy similar al SQL (StructuredQuery Language). JBDC es un conjunto de clases de Java para el acceso a Sistemas de Administración de Bases de Datos Relacionales, RDBMS siglas del ingles Relational Database Management Systemindependientemente de la plataforma y
del gestor de bases de datos utilizado. A este conjunto de clases (reunidas dentro de la API JDBC) se les llama controlador. Se encarga de la traducción a las llamadas estándar que requiere la base de datos compatible con el. De esta manera el programador puede abstraerse de la programación específica de la base de datos creando código que funcionará para todas las RDBMS que cuenten con un driver JDBC con sólo cambiar tal driver.
SUMMARY
JDBC (Java Data Base Connectivity) is the Java standard for connecting to databases. It is estimated that approximately half of the software that is currently created incorporates read and write operations with databases. JDBC is designed to be independent of the platform and also the database on which you want to act. To achieve this independence, JDBC offers a standard database interconnection system, very similar to SQL (Structured Query Language). The different database vendors create the necessary elements that act asa bridge between JDBC and the database itself. JDBC 1.0 is part of JDK 1.1. After several revisions, the JDBC version 2.0, included in the JDK 1.2 and the latest JDBC 3.0 specification, has appeared. JBDC is a set of Java classes for access to Database Management Systems Relationships, RDBMS Relational Database Management Dependency system of the platform and the database manager used. This set of classes (gathered within the JDBC API) are called controller. It handles translation to standard calls that require the database compatible with it. In this way the programmer can abstract from specific database programming by creating code that runs for all the RDBMS that drive with the single driver driver JDBC driver.
RECOMENDACIONES:
.Para que exista un enlace remoto con la Base de Datos, la aplicación no debe de conectarse directamente a la Base de Datos, sino que mediante los drivers JDBC- ODBC.
- 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. Cada vez que se ejecuta una sentencia, se realiza un proceso de dos pasos: la sentencia se prepara y luego se procesa. Si se emplea una sentencia preparada, sentencia, y no se repite cada vez que se ejecuta la sentencia. el paso de preparar la sentencia solo tiene lugar en el momento de construirla.
-El uso deprocedimientos almacenados está soportado en Java. El rendimiento de los procedimientos almacenados puede ser mayor al permitir que el controlador JDBC ejecute SQL estático en vez de SQL dinámico. No cree procedimientos almacenados para cada sentencia SQL individual que ejecute en el programa.No obstante sentencias SQL. cuando sea posible, cree un procedimiento almacenado que ejecute.
CONCLUSIONES:
.JDBC ofrece una interface estándar para acceder a múltiples base de datos. Para esto hace uso de SQL lo cual lo hace fácil de utilizar, 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 base de datos como es la recuperación de metadatos, hace que disminuya su capacidad, limite su uso y su enfoque multibase de datos.
.Tenemos que iterar manualmente sobre las propiedades de objetos como ResultSet cada vez que consultemos algo en la base de datos.
.Utilizar JDBC implica construir y ejecutar repetidamente sentencias SELECT, INSERT, UPDATE y DELETE. Tendríamos que gestionar manualmente el orden de las inserciones, actualizaciones y borrados para que no hubiese problemas con la integridad referencial.
.Los drivers JDBC establecen la estructura para el diseño y generación de conexiones y accesos a Base de Datos remotas; por lo que facilita el desarrollo de nuevas aplicaciones que la empresa desee implementar en un futuro, orientados con este fin.
APRECIACIÓN DE EQUIPO:
Este paquete permite conectarse a una base de datos, consultarla o actualizarla usando SQL. Su manejo es de importancia debido a la frecuencia con que las bases de datos son usadas hoy.Así como con Java se logra independencia de la plataforma, al trabajar con JDBC se logra además independencia del proveedor de la base de datos. Una dificultad enfrentada por los desarrolladores de JDBC fue que existen muchos proveedores de bases de datos cada uno usando su propio protocolo. Es así como se acordó el desarrollo de una API Java para SQL, la cual accede la base de datos vía un administrador de drivers de terceros los cuales se conectan a bases de datos específicas. Cada proveedor de bases de datos debía generar su propio driver conectable al administrador de drivers.
GLOSARIO DE TÉRMINOS:
.Driver: es un pequeño software que conecta el sistema operativo directamente con los componentes del hardware de la PC..API: La interfaz de programación de aplicaciones, abreviada como API del inglés: Application Programming Interface,es un conjunto de subrutinas, funciones y procedimientos (o métodos, en la programación orientada a objetos) que ofrece cierta biblioteca para ser utilizado por otro software como una capa de abstracción.
.Applet: es un componente de una aplicación que se ejecuta en el contexto de otro programa, por ejemplo, en un navegador web.
.Del Java 2 SDK Standard Edition: es el entorno de desarrollo para cualquier aplicación, 'applet' o modulo escrito en el lenguaje Java. Es necesario para la ejecución de cualquier programa java, un paquete de herramientas ('tools'), escritas en el propio lenguaje, que nos facilitaran la tarea de depurar, testear y mejora las aplicaciones, también incluye las APIs de la ultimas tecnologías desarrolladas por SUN para Java.
.Proxis: es un patrón estructural que tiene como propósito proporcionar un subrogado o intermediario de un objeto para controlar su acceso.
.Dialecto: es una variación (relativamente pequeña) o una extensión de un Lenguaje de programación que no cambia su naturaleza intrínseca. Se crea para su uso en algunos Lenguaje específico del dominio, a menudo un subconjunto.
.Parámetros: un parámetro es una variable utilizada para recibir valores de entrada en una rutina, subrutina o método. Dichos valores, que serán enviados desde la rutina invocante, son llamados argumentos.
.JVM: Una máquina virtual Java (en inglés Java Virtual Machine, JVM) es una máquina virtual de proceso nativo, es decir, ejecutable en una plataforma específica, capaz de interpretar y ejecutar instrucciones expresadas en un código binario especial (el bytecode Java), el cual es generado por el compilador del lenguaje Java.
.Firewall: Un cortafuegos (firewall) es una parte de un sistema o una red que está diseñada para bloquear el acceso no autorizado, permitiendo al mismo tiempo comunicaciones autorizadas. Los cortafuegos pueden ser implementados en hardware o software, o en una combinación de ambos.
Una explicación mas detallada:
