I.JDBC.
1. Contenido:
Capa de Acceso de
Datos, creación:
Las conexiones de datos se utilizan
para recuperar datos y enviar cambios hacia bases de datos externas.
Acerca de esta tarea
Debe definir todos los orígenes de
datos para campos de objeto de negocio utilizados en reglas de sucesos. También
debe definir todos los orígenes de datos utilizados para llenar los campos de
objeto de acción que no se han llenado mediante cargas útiles de sucesos.
Por ejemplo, información sobre el nivel
de valor para un cliente (por ejemplo, Oro o Platino) puede no formar parte de
los datos proporcionados en la carga útil de sucesos, pero está disponible
desde el registro maestro del cliente que se contiene en otra base de
datos.También se requiere la definición de conexión de datos antes de que se
pueda definir un conector de tecnología de JDBC que haga referencia a la
conexión de datos.
Puede definir como una base de datos
alojada, cualquiera de las bases de datos soportadas (por ejemplo, DB2) para la
que se puede definir una conexión de datos. La base de datos alojada debe ser
accesible para Event Designer y para el servidor de ejecución de
suceso.
Para definir una base de datos alojada:
Procedimiento
- En la vista Explorador de suceso, pulse con el
botón derecho del ratón Nuevo > Conexión de
datos. Se abre el asistente de Conexión de datos.En la ventana Nueva
Conexión, seleccione Base de datos utilizando una conexión JDBC,
luego pulse Siguiente. Se visualiza la ventana propiedad de
configuración de JDBC.
- Nombre de origen de datos JNDI : Ingrese el nombre JNDI de la fuente de
datos WebSphere Application Server que se utiliza por el
colector de datos y el conector de JDBC. Debe especificar el nombre JNDI
si está utilizando el conector JDBC. El colector de datos utiliza el nombre
JNDI si se especifica, de otro modo utiliza las propiedades explícitas de
JDBC que se especifican por la conexión de datos en pasos 4 a través de 8.
- Controlador JDBC: Seleccione el controlador que desee utilizar:
- DB2 Linux,
Unix y Windows
- DB2 z/OS
- SQL Server
- Oracle
- Derby
Si está
ejecutando Operational Decision Manager en z/OS y quiere utilizar un
tipo de conexión 2 JDBC para acceder a una base de datos IBM® DB2, consulte la
información relativa al formato del URL para IBM Data Server Driver para JDBC y
SQLJ tipo de conexión 2 en el Information Center de WebSphere Application
Server.
- Pulse Editar lista JAR para
especificar cualquier archivo .jar o .zip que requiera el controlador
JDBC.
- Base de datos: Ingrese el nombre de la base de datos a conectar.
- Sistema principal, Número de puerto, y Esquema predeterminado:
Ingrese los detalles de la conectividad para la base de datos.
- Nombre de usuario y Contraseña: Proporciona los detalles apropiados
para permitir el acceso a los datos de conexión.
Nota:
- Las
restricciones de seguridad específicas del gestor de la base de datos son
respetadas por Event Designer al acceder a una base de datos
alojada. Debe proporcionar el usuario apropiado y la combinación de
contraseña como se define en la base de datos del sistema principal.
- Se importan todas las tablas y vistas asociadas a un
usuario/contraseña de administrador de base de datos. Para restringir las
tablas que se van a importar, cree un identificador de usuario y una
contraseña especiales con acceso únicamente a las tablas que Event
Designer necesite.
- Pulse Finalizar y guarde sus
cambios.
v 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 MySQL 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.
- Primero
que nada necesitas tener un servidor MySQL instalado en tu equipo o en su
defecto en la máquina que actuará como servidor de bases de datos.
Recuerda que MySQL es gratuito y puedes obtenerlo desde aquí.
El proceso de instalación es algo en lo que no
entraré en detalle, para cualquier duda puedes consultar la documentación oficial que se encuentra en
su sitio web.
- Asimismo,
debes de tener el NetBeans instalado, de preferencia su última versión
estable (al momento de esta publicación es la 5.5.1) que viene con el Java
Development Kit (JDK) 1.6, lo anterior puedes obtenerlo desde aquí.
- Una vez
que tengas ambas herramientas instaladas necesitaras el driver o conector
a la base de datos de MySQL.
Copiar lo necesario:
Una vez que tengas el NetBeans y el
MySQL Server instalado lo que vas a necesitar es copiar el driver que
descargaste, en mi caso el mysql-connector-java-3.1.11-bin.jar dentro
de la carpeta del JDK, en mi caso es la siguiente ruta:
C:\Archivos de programa\Java\jdk1.6.0_01\jre\lib\ext
*NOTA: Debes tener el conector dentro de la carpeta
anterior antes de ejecutar el NetBeans, en caso de que esté abierto ciérralo y
vuélvelo a abrir.
Ya que lo hayas copiado ahora sí abre el NetBeans y espera a que cargue.
Configurar NetBeans::
Una vez que hayas abierto el NetBeans localiza la sección de Runtime o Tiempo de ejecución que se localiza en el lado izquierdo de la pantalla, como se muestra a continuación:
Al expandir la sección de Databases o Bases
de datos debe de aparecer el MySQL (Connector/J driver), en caso
contrario debes de agregarlo manualmente como se describe a continuación:
2. En la ventana que aparece da clic en el botón de Add o Agregar y
busca el archivo .jar que descargaste anteriormente, el mismo que copiaste
dentro de la carpeta del JDK.
3. Una vez hecho lo anterior da clic en el botón de Ok o Aceptar.
Cuando realices los pasos anteriores
debe de aparecer un elemento nuevo en la sección de Drivers dentro de Databases
de nombre MySQL (Connector/J driver).
Crear y probar una conexión::
Dentro de la sección de Runtime o Tiempo de ejecución > Databases o Bases de datos >Drivers da un clic derecho sobre MySQL (Connector/J driver) y selecciona Connect Usingo Conectar usando... para que aparezca la pantalla de configuración de la conexión como se muestra a continuación:
Crear y probar una conexión::
Dentro de la sección de Runtime o Tiempo de ejecución > Databases o Bases de datos >Drivers da un clic derecho sobre MySQL (Connector/J driver) y selecciona Connect Usingo Conectar usando... para que aparezca la pantalla de configuración de la conexión como se muestra a continuación:
En la sección de Name o Nombre selecciona MySQL
(Connector/J driver), en la sección Database URL cambia la parte
indicada por por la dirección del servidor de bases de datos, si es la
misma computadora escribe localhost, en la parte de establece
el puerto que definiste al instalar el servidor MySQL , por defecto es el 3306, en
la sección de escribe el nombre de la base de datos a la cual te quieres
conectar. Un ejemplo completo seríajdbc:mysql://localhost:3306/base_de_datos.
Posteriormente escribe el nombre de
usuario para accesar a la base de datos y la contraseña respectivamente.
Da un clic en el checkbox inferior para que NetBeans recuerde la contraseña durante la conexión.
Da un clic en el checkbox inferior para que NetBeans recuerde la contraseña durante la conexión.
Si todo se realizó correctamente podrás ver un nuevo elemento debajo del Driver con las especificaciones de la conexión actual, si das un clic en el símbolo '+' que aparece de lado izquierdo del mismo podrás ver las tablas de la base de datos y realizar consultas hacia la misma.
Implementar el código::
Hasta aquí ya hemos establecido la conexión a la base de datos y probado su funcionamiento desde el NetBeans, sin embargo, nos hace falta implementar el código directamente en una aplicación. Para este ejemplo crearemos una clase de nombre Conexion que se podrá reutilizar las veces que sea necesario en cualquier tipo de aplicación Java que requiera conectarse y realizar consultas a una base de datos en MySQL.
Empecemos por el principio...
- Da un
clic en el menú de File o Archivo que se
localiza en la esquina superior izquierda de la ventana de NetBeans.
- Selecciona
la opción de Nuevo Proyecto o New Project, posteriormente
en la sección de Categories o Categorías selecciona General y
en Projects o Proyectos seleccionaJava
Application o Aplicación Java y da un clic en Siguiente.
*NOTA: La clase que crearemos funciona con cualquier tipo de proyecto, para fines de este ejemplo utilizamos una aplicación java convencional.
- Posteriormente
damos un nombre a la aplicación y definimos su ubicación, una vez hecho
esto damos clic en el botón de Finish o Finalizar.
- En este
momento aparece del lado izquierdo en la pestaña de Projects o Proyectosuna
especie de árbol jerárquico en el cual tenemos 4 carpetas, al dar clic en
el símbolo '+' de la carpeta Source Packages o Paquetes
Fuente nos desplegará el único paquete con el cual cuenta nuestra
aplicación hasta este punto, dentro de él se crea la clase Main.
- Ahora
debemos de dar un clic derecho sobre Source Packages o Paquetes
Fuente y dar un nombre al paquete, en mi caso es database. Este
paquete contendrá la clase desde la cual estaremos realizando todas las
consultas a la base de datos.
- Posteriormente
damos un clic derecho sobre el paquete recién creado y seleccionamosNueva o New > Java
Class. Posteriormente le damos el nombre de Conexion y
damos clic en el botón de Finalizar o Finish.
- Dentro
de la clase Conexion importamos algunas librerías con el
siguiente código:
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
- Una vez
que tenemos las librerías creamos los métodos a utilizar descritos a
continuación:
/**
9. * Método utilizado para recuperar el valor del
atributo conexion
10. * @return conexion contiene el estado de la
conexión
*
*/
public Connection getConexion()
{
return conexion;
}
/**
* Método utilizado para establecer la
conexión con la base de datos
* @return estado regresa el estado de
la conexión, true si se estableció la conexión,
* falso en caso contrario
*/
public boolean crearConexion()
{
try {
Class.forName("com.mysql.jdbc.Driver");
conexion =
DriverManager.getConnection("jdbc:mysql://host:puerto/baseDatos","usuario","contraseña");
} catch (SQLException ex) {
ex.printStackTrace();
Return false;
} catch (ClassNotFoundException ex) {
ex.printStackTrace();
return false;
}
return true;
}
/**
*
*Método utilizado para realizar las
instrucciones: INSERT, DELETE y UPDATE
*@param sql Cadena que contiene la
instrucción SQL a ejecutar
*@return estado regresa el estado de
la ejecución, true(éxito) o false(error)
*
*/
public boolean ejecutarSQL(String sql)
{
try {
Statement sentencia = conexion.createStatement();
sentencia.executeUpdate(sql);
} catch (SQLException ex) {
ex.printStackTrace();
return false;
}
return true;
}
/**
*
*Método utilizado para realizar la
instrucción SELECT
*@param sql Cadena que contiene la
instrucción SQL a ejecutar
*@return resultado regresa los
registros generados por la consulta
*
*/
public ResultSet
ejecutarSQLSelect(String sql)
{
ResultSet resultado;
try {
Statement sentencia = conexion.createStatement();
resultado = sentencia.executeQuery(sql);
} catch (SQLException ex) {
ex.printStackTrace();
return null;
}
return resultado;
}
- Finalmente
compilamos el archivo localizándolo en el árbol jerárquico del lado
izquierdo dando un clic derecho sobre él y seleccionando la opción de Compilar o Compile. Podrás
utilizar la clase en cualquier parte de tu proyecto creando una instancia
de la misma en el momento que sea necesario.
*TIP: Crea únicamente una vez la conexión con el método crear Conexion() desde la clase Main y pasa tu conexión como parámetro a todas las ventanas y módulos de la aplicación que la utilicen.
Una vez realizado lo anterior estarás
listo para conectarte a bases de datos en MySQL desde NetBeans, la clase Conexión
y el driver para MySQL puedes descargarlos este
vínculo en un archivo comprimido tipo rar, este manual se
encuentra en formato PDF.
v Definición de
JDBC, Tipos y Aplicaciones:
Drivers JDBC
Para usar JDBC con un sistema gestor de base de datos en particular, es necesario disponer del driver JDBC apropiado que haga de intermediario entre
ésta y JDBC. Dependiendo de
varios factores, este driver puede estar escrito en Java puro, o ser una mezcla
de Java y métodos nativos JNI (Java Native
Interface).
1.1 ¿Qué es JDBC?
JDBC es el API para la ejecución
de sentencias SQL. (Como punto de interés JDBC
es una marca registrada y no un acrónimo, no obstante a menudo es conocido
como “Java Database Connectivity”). Consiste
en un conjunto de clases e interfases escritas en el lenguaje
de programación Java. JDBC suministra un API estándar para los desarrolladores y hace posible
escribir aplicaciones de base de
datos usando un API puro Java.
Usando JDBC es fácil enviar sentencias SQL virtualmente a cualquier sistema
de base de datos. En otras palabras, con el
API JDBC, no es necesario
escribir un programa que
acceda a una base de datos Sybase, otro para acceder a Oracle y otro
para acceder a Informix. Un único programa escrito
usando el API JDBC y el
programa será capaz de enviar sentencias
SQL a la base de datos apropiada. Y, con una aplicación
escrita en el lenguaje de programación Java, tampoco es necesario escribir diferentes aplicaciones para ejecutar en diferentes plataformas. La combinación de Java y JDBC permite
al programador escribir una sola vez
y ejecutarlo en cualquier
entorno.
Java, siendo robusto, seguro, fácil de
usar, fácil de entender, y descargable
automáticamente desde la red, es un lenguaje
base excelente para aplicaciones de base de datos.
JDBC expande las posibilidades de Java. Por ejemplo,
con Java y JDBC API, es
posible publicar una página web que contenga un applet que usa información obtenida de una base de datos
remota. O una empresa puede usar JDBC
para conectar a todos sus empleados (incluso
si usan un conglomerado de máquinas
Windows, Macintosh y UNIX) a una base de datos interna vía intranet. Con cada
vez más y más programadores desarrollando en lenguaje Java, la necesidad
de acceso fácil a base de datos desde Java continúa creciendo.
1.1.1 ¿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");
}
1.1.2 JDBC es un API de bajo nivel y una base para API’s de alto nivel.
JDBC es una interfase de bajo nivel, lo que quiere
decir que se usa para ‘invocar’ o
llamar a comandos SQL directamente. En esta función trabaja muy bien y es más fácil de usar que
otros API’s de conexión a bases de datos, pero está diseñado de forma
que también sea la base sobre la cual construir interfaces y herramientas de alto nivel. Una interfase de alto nivel es ‘amigable’, usa un API mas entendible o más conveniente que luego se traduce en la interfase de bajo
nivel tal como JDBC.
1.1.3 JDBC
frente a ODBC y otros API’s
En este punto, el ODBC de Microsoft (Open Database Connectvity), es probablemente el API
más extendido para el acceso a bases de datos relacionales.
Ofrece la posibilidad de conectar a la mayoría de las bases de datos en casi todas
las plataformas. ¿Por qué no usar, entonces,
ODBC, desde Java?.
La respuesta es que se puede usar ODBC desde Java, pero es preferible hacerlo con
la ayuda de JDBC mediante
el puente JDBC-ODBC. La pregunta es ahora ¿por qué necesito JDBC?. Hay varias respuestas a estas
preguntas:
1.- ODBC no es apropiado para su uso directo con Java porque usa una
interface C. Las llamadas desde Java a código nativo C tienen un número de
inconvenientes en la seguridad, la implementación, la robustez y en la
portabilidad automática de las aplicaciones.
2.- Una traducción literal del API C de ODBC en el API Java podría no ser deseable. Por ejemplo, Java no tiene punteros,
y ODBC hace un uso copioso de ellos, incluyendo el notoriamente propenso a errores
“void * “. Se puede pensar en JDBC como un ODBC traducido
a una interfase orientada a objeto que es el natural
para programadores Java.
3. ODBC es difícil de aprender. Mezcla características simples
y avanzadas juntas, y sus opciones
son complejas para ‘querys’
simples. JDBC por otro
lado, ha sido diseñado para mantener las cosas sencillas mientras
que permite las características avanzadas cuando éstas son necesarias.
4. Un API Java como JDBC es necesario en orden a permitir una solución
Java “pura”. Cuando se usa ODBC, el gestor de drivers de ODBC y los drivers deben
instalarse manualmente en cada máquina cliente. Como el driver JDBC
esta completamente escrito
en Java, el código JDBC es automáticamente
instalable, portable y seguro en todas
las plataformas Java.
En resumen, el API JDBC es el interfase natural de Java para las abstracciones y conceptos básicos de SQL. JDBC retiene las características básicas de diseño de
ODBC; de hecho, ambos interfaces están basados en el X/Open SQL CLI (Call
Level Interface).
Más recientemente Microsoft ha introducido nuevas API detrás de ODBC. RDO,
ADO y OLE DB. Estos diseños se mueven en la misma dirección
que JDBC en muchas maneras, puesto que se les da
una orientación a objeto basándose en
clases que se implementan sobre ODBC.
1.1.4 Modelos en dos y tres pisos.
El API JDBC soporta
los modelos en dos y tres pisos de acceso a base de datos. En
el modelo de dos-pisos, un applet Java o
una aplicación habla directamente con
la base de datos. Esto requiere un driver JDBC que pueda comunicar con el gestor
de base de datos particular al que se pretende
acceder. Las sentencias SQL de usuario se envían a la base de datos, y el resultado de estas sentencias se envían al usuario.
La base de datos puede estar localizada
en otra máquina a la que el
usuario se conecta
mediante la red. Esta es una configuración Cliente/Servidor en
la que la máquina del usuario es el cliente
y la máquina que hospeda a la base de datos es el servidor.
La red puede ser una intranet,
por ejemplo, que conecta a los
empleados dentro de la corporación, o puede ser Internet.
En el modelo de tres-pisos, los comandos se envían a un ‘piso intermedio’ de servicios, que envía las sentencias SQL a la base de datos. La base de datos
procesa las sentencias SQL y devuelve los resultados a el ‘piso intermedio’, que a
su vez lo envía al usuario. Los directores de IS encuentran este modelo muy atractivo por que el ‘piso intermedio’ hace posible
mantener el control
sobre los datos y los tipos de actualizaciones que pueden hacerse en los datos corporativos. Otra ventaja es que el
usuario puede emplear un API de alto nivel más sencillo que es traducido por el ‘piso intermedio’ en las llamadas de bajo
nivel apropiadas. Finalmente en muchos casos la arquitectura de tres niveles puede proporcionar
ventajas de rendimiento.
Hasta ahora, este nivel intermedio ha sido escrito en lenguajes como C ó C++, que
ofrecen un rendimiento más rápido. De cualquier
modo, con la introducción de
compiladores optimizadores que traducen el bytecode en código máquina
eficiente, se está convirtiendo en práctico desarrollar este nivel intermedio en Java.
Esta es una gran ventaja
al hacer posible
aprovechar las características de robustez, multiproceso
y seguridad de Java.
1.1.5 SQL Conforme
SQL es el lenguaje estándar para el acceso
a las bases de datos
relacionales. Una de las áreas de
dificultad es que aunque muchas DBMS’s (Data Base Management
Systems) usan un formato estándar de SQL para
la funcionalidad básica,
estos no conforman la sintaxis más recientemente definidas
o semánticas para funcionalidades más avanzadas. Por ejemplo, no todas las bases de datos soportan
procedimientos almacenados o joins de salida, y aquellas que lo hacen no son consistentes con otras. Es de
esperar que la porción de SQL que es
verdaderamente estándar se expandirá para
incluir más y más funcionalidad. Entretanto,
de cualquier modo, el API de
JDBC debe soportar SQL tal como es.
Una forma en que el API JDBC trata este problema es permitir que cualquier
cadena de búsqueda se pase al driver subyacente del DBMS. Esto quiere decir que una
aplicación es libre de usar la sentencia SQL tal como quiera, pero
se corre el riesgo de recibir un error en el DBMS. De hecho una consulta de una
aplicación incluso no tiene
por que ser SQL, o puede ser una derivación especializada de SQL diseñada para especificas DBMS (para
consultas a imágenes o documentos por ejemplo).
Una segunda forma en que JDBC trata este
problema es proveer cláusulas
de escape al estilo de ODBC , que se discutirán en el 4.1.5. ”Sintaxis de escape en Sentencias Objetos”.
La sintaxis de escape provee una sintaxis JDBC estándar para varias de las áreas más
comunes de divergencia SQL. Por ejemplo, ahí escapes para literales de fecha
o procedimientos almacenados.
Para aplicaciones
complejas, JDBC trata la conformidad SQL de una tercera
manera. Y es proveer información descriptiva
sobre el DBMS por medio de la interfase DatabaseMetaData por la que las aplicaciones pueden adaptarse a los
requerimientos y posibilidades de cada DBMS:
Como el API JDBC se usará como base para el desarrollo de herramientas de acceso y API’s de alto nivel , direccionará el problema de la conformidad a cualquiera de estas. La designación “JDBC COMPLIANT” se creó para situar un nivel
estándar de funcionalidad JDBC en la que los
usuarios puedan confiar. En orden a usar esta designación, un driver debe soportar al menos el nivel de entrada
ANSI SQL-2 Entry Level. Los desarrolladores de drivers pueden cerciorarse que
sus drivers cumplan estas especificaciones
mediante la suite de test disponible
en el
API JDBC.
La designación “JDBC COMPLIANT” indica que la implementación JDBC de un vendedor ha pasado los tests de conformidad suministrados por JavaSoft. Estas pruebas de conformidad chequean
la existencia de todas las clases y métodos definidos en el API JDBC, y chequean tanto como es posible que la funcionalidad SQL Entry Level esté
disponible. Tales tests no son exhaustivos, por supuesto, y JavaSoft no esta distribuyendo implementaciones de vendedores, pero esta definición de compliance tiene algún grado
de seguridad en una implementación JDBC. Con la mayor aceptación de JDBC por parte de vendedores de bases de datos,
de servicios de Internet y desarrolladores, JDBC se está convirtiendo en el
estándar de acceso a bases de datos.
1.
Tipos de drivers 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.
|
Aplicaciones del controlador JDBC de ejemplo
Las aplicaciones de
ejemplo del Controlador JDBC de Microsoft para SQL Server muestran varias
características del controlador JDBC. Además, describen las prácticas
recomendadas de programación que puede aplicar al usar el controlador JDBC con
una base de datos de SQL Server.
Todas las aplicaciones
de ejemplo se incluyen en archivos de código *.java que se pueden compilar y
ejecutar en el equipo local, y se encuentran en varias subcarpetas de la
siguiente ubicación:
<directorio de
instalación de>
\sqljdbc_ <versión> \ <idioma> \muestras
En los temas de esta
sección se describe cómo configurar y ejecutar las aplicaciones de ejemplo, y
se incluye una descripción de lo que demuestran.
1.
En esta sección
|
Tema
|
Descripción
|
|
Estas aplicaciones de ejemplo
demuestran cómo conectarse a una base de datos de SQL Server. Además,
explican los distintos modos en que se pueden recuperar datos de una base de
datos de SQL Server.
|
|
|
Estas aplicaciones de ejemplo
demuestran cómo usar los métodos de tipos de datos del controlador JDBC para
trabajar con los datos de una base de datos de SQL Server.
|
|
|
Estas aplicaciones de ejemplo
demuestran cómo usar los conjuntos de resultados para procesar los datos de
una base de datos de SQL Server.
|
|
|
Estas aplicaciones de ejemplo
demuestran cómo utilizar el almacenamiento en búfer adaptable para recuperar
datos de valores grandes de una base de datos de SQL Server sin la sobrecarga
que suponen los cursores de servidor.
|
Uso de JDBC en apliaciones java:
Visual
Studio 2005
Una conexión a bases de datos Java (JDBC) es un controlador de bases de
datos que permite la conexión mediante programación a una base de datos. Debe
utilizar la conexión como un puente entre la aplicación y la base de datos
real.
Visual J#
incluye una implementación de JDBC sobre ODBC [puente JDBC-ODBC]. Este puente
puede permitir a la aplicación conectarse con cualquier servidor de bases de
datos que tenga instalado el controlador ODBC en el equipo cliente con Visual
J#.
El primer
paso establece un nombre de origen de datos (DSN) para administrar las
credenciales de contraseña e identificador de usuario en la base de datos de
Access denominada Northwind. El segundo paso utiliza el DSN y JdbcOdbcDriver
para conectarse a la base de datos y devolver datos. El código denomina al
controlador, Class.forName("com.ms.jdbc.odbc.JdbcOdbcDriver"), y
genera una cadena de conexión que denomina al DSN con las credenciales de
servidor y de autenticación, del siguiente modo: String url =
"jdbc:odbc:vbuetools";
En el
último ejemplo se ejecuta la consulta. Si se utiliza la instrucción while (rs.next()), el
código recorre los conjuntos de resultados y obtiene los datos. Una vez
imprimidos los datos en la consola, la instrucción con.close() cierra el conjunto de registros así como la
conexión con la base de datos.
1.
Para establecer
un nombre de origen de datos
2.
Haga
clic en Inicio, elija Panel de control, seleccione Herramientas administrativas y, a continuación, haga clic en Orígenes de datos (ODBC).
3.
En
la pantalla Herramientas administrativas, seleccione Orígenes de datos.
4.
En
la página Administrador de orígenes de datos ODBC, haga
clic en la ficha DSN de sistema y haga clic en Agregar.
5.
En
la página Crear nuevo origen de datos , seleccione Controlador de Microsoft Access (*.mdb) y haga clic en Finalizar.
6.
Esto
indica el tipo de base de datos. En las aplicaciones propias, asegúrese de
elegir el controlador que coincida con la base de datos. En el caso de SQL
Server, desplácese por la lista y elija el controlador correspondiente a la
versión de SQL Server.
7.
En
la página Configuración de Microsoft Access ODBC, en el
cuadro Nombre de origen de datos, escriba JDBCdsn y haga clic enSeleccionar.
8.
Seleccione Northwind.mdb y haga clic en Aceptar.
9.
En la página Configuración de DSN de Microsoft SQL Server,
haga clic en Con autenticación de Windows NT mediante el id. de inicio
de sesión en red.
Esta
opción permite el acceso a los datos utilizando el identificador de usuario y
la contraseña de NT.
10.
Haga clic en Siguinte.
11.
La
Herramienta administrativa de ODBC almacena el nombre del servidor y las
credenciales en el archivo binario JDBCdsn.dsn. En tiempo de ejecución, el
código de J# obtiene acceso a esta información para establecer conexión con la
base de datos.
12.
Para
obtener acceso a los datos
13.
En
el menú Archivo, elija Nuevo y, a continuación, haga clic en Proyecto.
14.
Haga clic en Aplicación de consola y escriba JDBC2 en el cuadro Nombre.
15.
Reemplace el contenido de
Program.jsl por el código siguiente:
import java.*;
import java.sql.*;
import java.util.*;
import com.ms.jdbc.odbc.JdbcOdbcDriver;
public class Connect{
private java.sql.Connection con = null;
private ResultSet rs;
// Constructor:
public Connect(){}
private void FindEmployee() throws SQLException, ClassNotFoundException
{
try
{
Class.forName("com.ms.jdbc.odbc.JdbcOdbcDriver");
String url = "jdbc:odbc:JDBCdsn";
con = DriverManager.getConnection(url, "", "");
Statement stmt = con.createStatement();
rs = stmt.executeQuery("Select EmployeeID, LastName, Title from Employees");
while (rs.next())
{
//Column names:
System.out.println(rs.getInt("EmployeeID") + " " + rs.getString("LastName") + " " + rs.getString("Title"));
}
if(con != null)
con.close();
con = null;
}
catch (SQLException ex)
{
throw ex;
}
catch (ClassNotFoundException clex)
{
throw clex;
}
}
private void closeConnection(){
try{
if(con != null)
con.close();
con = null;
}catch(Exception ex){
ex.printStackTrace();
}
}
public static void main(String[] args) throws Exception
{
Connect myDbTest = new Connect();
try
{
myDbTest.FindEmployee();
}
catch (Exception ex)
{
ex.printStackTrace();
System.out.println("Error Trace in getConnection() : " + ex.getMessage());
}
}
}
En el
código que acaba de agregar, compruebe que el nombre de origen de datos
coincide con el que se creó con las Herramientas administrativas. Por ejemplo:
String url = "jdbc:odbc: JDBCdsn";
Presione
F5 para compilar y ejecutar el código.
El
programa obtiene el número de serie, el apellido y el título de cada empleado
de la tabla Employees de la base de datos Northwind.
Ejemplos:
Crear una clase pública para encapsular
el programa.
public class BasicJDBC {
// La conexión es una variable privada del objeto.
private Connection connection = null;
// Cualquier clase que deba ser un "punto de entrada" para
ejecutar
// un programa debe tener un método main. El método main
// es donde empieza el proceso cuando se llama al programa.
public static void main(java.lang.String[] args) {
// Crear un objeto de tipo BasicJDBC. Esto
// es fundamental en la programación orientada a objetos. Una vez
// creado un objeto, llamar a diversos métodos de
// ese objeto para realizar el trabajo.
// En este caso, al llamar al constructor del objeto
// se crea una conexión de base de datos que los otros
// métodos utilizan para realizar el trabajo en la base de datos.
BasicJDBC test = new BasicJDBC();
// Llamar al método rebuildTable. Este método asegura que
// la tabla utilizada en este programa existe y tiene el aspecto
// correcto. El valor de retorno es un booleano para indicar
// si la reconstrucción de la tabla se ha completado
// satisfactoriamente. Si no es así, visualizar un mensaje
// y salir del programa.
if (!test.rebuildTable()) {
System.out.println("Se produjo
una anomalía al configurar " +
" para
ejecutar la prueba.");
System.out.println("La prueba no
continuará.");
System.exit(0);
}
// A continuación, se llama al método para ejecutar la consulta. Este
método
// procesa una sentencia SQL select con respecto a la tabla que
// se creó en el método rebuildTable. La salida de
// esa consulta va a la salida estándar de visualización.
test.runQuery();
// Por último, se llama al método cleanup. Este método
// garantiza que la conexión de base de datos en la que el objeto
// ha estado a la espera se ha cerrado.
test.cleanup();
}
/**
Este es el constructor de la prueba básica JDBC. Crea una conexión
de base de datos que se almacena
en una variable de instancia que se usará en
posteriores llamadas de método.
**/
public BasicJDBC() {
// Una forma de crear una conexión de base de datos es pasar un URL
// y un objeto java Properties al DriverManager. El siguiente
// código construye un objeto Properties que contiene el ID de usuario y
// la contraseña. Estos datos se emplean para establecer conexión
// con la base de datos.
Properties properties = new Properties ();
properties.put("user", "cujo");
properties.put("password", "newtiger");
// Utilizar un bloque try/catch para capturar todas las excepciones que
// puedan surgir del código siguiente.
try {
// DriverManager debe
saber que existe un controlador JDBC disponible
// para manejar una petición de
conexión de usuario. La siguiente línea hace
// que el controlador JDBC nativo
se cargue y registre con DriverManager.
Class.forName("com.ibm.db2.jdbc.app.DB2Driver");
// Crear el objeto Connection de
base de datos que este programa utiliza
// en las demás llamadas de método
que se realicen. El código que sigue
// especifica que debe establecerse
una conexión con la base de datos local
// y que dicha conexión debe
ajustarse a las propiedades configuradas
// anteriormente (es decir, debe
utilizar el ID de usuario
// y la contraseña especificados).
connection =
DriverManager.getConnection("jdbc:db2:*local", properties);
} catch (Exception e) {
// Si falla alguna de las líneas
del bloque try/catch, el control pasa
// a la siguiente línea de código.
Una aplicación robusta intenta manejar
// el problema o proporcionar más
detalles. En este programa, se visualiza
// el mensaje de error de la
excepción, y la aplicación permite
// el retorno del programa.
System.out.println("Excepción
capturada: " + e.getMessage());
}
}
/**
Garantiza que la tabla qgpl.basicjdbc tiene el aspecto deseado al
principio de
a prueba.
@returns boolean Devuelve true
si la tabla se ha reconstruido satisfactoriamente;
Devuelve false si se ha
producido alguna anomalía.
**/
public boolean rebuildTable() {
// Reiniciar todas las funciones de un bloque try/catch para que se
realice
// un intento de manejar los errores que puedan producirse dentro de
este
// método.
try {
// Se utilizan objetos Statement
para procesar sentencias SQL en la
// base de datos. El objeto
Connection se utiliza para crear un
// objeto Statement.
Statement s =
connection.createStatement();
try {
// Construir la tabla de prueba
desde cero. Procesar una sentencia update
// que intenta suprimir la
tabla si existe actualmente.
s.executeUpdate("drop table
qgpl.basicjdbc");
} catch (SQLException e) {
// No realizar nada si se
produjo una excepción. Presuponer
// que el problema es que la
tabla que se ha eliminado no
// existe y que se puede crear a
continuación.
}
// Utilizar el objeto sentencia
para crear la tabla.
s.executeUpdate("create table
qgpl.basicjdbc(id int, name char(15))");
// Utilizar el objeto sentencia
para llenar la tabla con algunos
// datos.
s.executeUpdate("insert into
qgpl.basicjdbc values(1, 'Frank Johnson')");
s.executeUpdate("insert into
qgpl.basicjdbc values(2, 'Neil Schwartz')");
s.executeUpdate("insert into
qgpl.basicjdbc values(3, 'Ben Rodman')");
s.executeUpdate("insert into
qgpl.basicjdbc values(4, 'Dan Gloore')");
// Cerrar la sentencia SQL para
indicar a la base de datos que ya no es
// necesaria.
s.close();
// Si todo el método se ha
procesado satisfactoriamente, devolver true. En este punto,
// la tabla se ha creado o renovado
correctamente.
return true;
} catch (SQLException sqle) {
// Si ha fallado alguna de las
sentencias SQL (que no sea la eliminación de la tabla
// manejada en el bloque try/catch
interno), el mensaje de error
// se visualiza y se devuelve false
al llamador, para indicar que la tabla
// no puede completarse.
System.out.println("Error in
rebuildTable: " + sqle.getMessage());
return false;
}
}
/**
Ejecuta una consulta a la tabla de muestra y los resultados se
visualizan en
la salida estándar.
**/
public void runQuery() {
// Reiniciar todas las funciones de un bloque try/catch para que se
realice
// un intento de manejar los errores que puedan producirse dentro de
este
// método.
try {
// Crear un objeto
Statement.
Statement s =
connection.createStatement();
// Usar el objeto Statement para
ejecutar una consulta SQL. Las consultas devuelven
// objetos ResultSet que se
utilizan para observar los datos que la consulta
// proporciona.
ResultSet rs =
s.executeQuery("select * from qgpl.basicjdbc");
// Visualizar el principio de la
'tabla' e inicializar el contador del
// número de filas devueltas.
System.out.println("--------------------");
int i = 0;
// El método next de ResultSet se
utiliza para procesar las filas de un
// ResultSet. Hay que llamar al
método next una vez antes de que
// los primeros datos estén
disponibles para verlos. Siempre que next devuelva
// true, existe otra fila de datos
que puede utilizarse.
while (rs.next()) {
// Obtener ambas columnas de la
tabla para cada fila y escribir una fila en
// nuestra tabla en pantalla
con los datos. Luego, incrementar la cuenta
// de filas que se han
procesado.
System.out.println("|
" + rs.getInt(1) + " | " + rs.getString(2) + "|");
i++;
}
// Colocar un borde al final de la
tabla y visualizar el número de filas
// como salida.
System.out.println("--------------------");
System.out.println("Se han
devuelto " + i + " filas.");
System.out.println("Salida
completada.");
} catch (SQLException e) {
// Visualizar más información
acerca de las excepciones SQL
// generadas como salida.
System.out.println("Excepción
SQLException: ");
System.out.println("Mensaje:....." + e.getMessage());
System.out.println("SQLState:...." + e.getSQLState());
System.out.println("Código
proveedor:." + e.getErrorCode());
e.printStackTrace();
}
}
/**
El siguiente método garantiza que se
liberen los recursos JDBC que aún
están asignados.
**/
public void cleanup() {
try {
if (connection != null)
connection.close();
} catch (Exception e) {
System.out.println("Excepción
capturada: ");
e.printStackTrace();
}
2. Resumen:
I.JDBC
1. Contenido:
v Capa de Acceso de Datos, creación:
Acerca de esta tarea
Debe definir todos los orígenes de
datos para campos de objeto de negocio utilizados en reglas de sucesos. También
debe definir todos los orígenes de datos utilizados para llenar los campos de
objeto de acción que no se han llenado mediante cargas útiles de sucesos.
Puede definir como una base de datos
alojada, cualquiera de las bases de datos soportadas (por ejemplo, DB2) para la
que se puede definir una conexión de datos. La base de datos alojada debe ser
accesible para Event Designer y para el servidor de ejecución de
suceso.
Procedimiento
1.En la vista Explorador de suceso,
pulse con el botón derecho del ratón Nuevo > Conexión
de datos. Se abre el asistente de Conexión de datos.
2.Nombre de origen
de datos JNDI :
Ingrese el nombre JNDI de la fuente de datos WebSphere Application
Server que se utiliza por el colector de datos y el conector de JDBC.
3.Controlador
JDBC: Seleccione el controlador que desee
utilizar:
- DB2 Linux,
Unix y Windows
- DB2 z/OS
- SQL Server
- Oracle
- Derby
v Configuración
de conexión BD con NetBeans:
Si eres un programador y desarrollas
tus aplicaciones en Java seguramente necesitarás conectar una base de datos
tipo MySQL 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.
Crear y probar una conexión: Dentro de la sección de Runtime o Tiempo
de ejecución > Databases o Bases de
datos >Drivers da un clic derecho sobre MySQL
(Connector/J driver) y selecciona Connect Usingo Conectar
usando... para que aparezca la pantalla de configuración de la
conexión.
Implementar el código:
Hasta aquí ya hemos establecido la
conexión a la base de datos y probado su funcionamiento desde el NetBeans, sin
embargo, nos hace falta implementar el código directamente en una aplicación.
Para este ejemplo crearemos una clase de nombre Conexion que
se podrá reutilizar las veces que sea necesario.
v Definición de
JDBC, Tipos y Aplicaciones:
Para usar JDBC con un sistema gestor de base de datos en particular, es necesario disponer del driver JDBC apropiado que haga de intermediario entre
ésta y JDBC.
1.1 ¿Qué es JDBC?
JDBC es el API para la ejecución de sentencias SQL. (Como punto de interés JDB
es una marca registrada y no un acrónimo, no obstante
a menudo es conocido
como “Java Database Connectivity”).
Consiste en un conjunto de clases e interfases escritas en el lenguaje de programación Java.
1.1.1 ¿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.
1.1.2 JDBC es un API de bajo nivel y una base para API’s de alto nivel.
JDBC es una interfase
de bajo nivel, lo que quiere
decir que se usa para ‘invocar’ o llamar a comandos
SQL directamente. En esta función trabaja muy bien y es más
fácil de usar que otros API’s de conexión a bases de datos.
1.1.3 JDBC
frente a ODBC y otros API’s
En este punto, el ODBC de Microsoft
(Open Database Connectvity), es probablemente el API
más extendido para el acceso a bases de datos relacionales.
Ofrece.
En resumen, el API JDBC es el interfase natural de Java para las abstracciones y conceptos básicos de SQL. JDBC retiene las características básicas de diseño de
ODBC; de hecho, ambos interfaces están basados en el X/Open SQL CLI (Call
Level Interface).
1.1.4 Modelos en dos y tres pisos.
El API JDBC soporta los modelos en dos y tres pisos de acceso a base de datos. En
el modelo de dos-pisos, un applet Java o
una aplicación habla directamente con
la base de datos. Esto requiere un driver JDBC que pueda comunicar con el gestor
de base de datos particular al que se pretende
accede.
1.1.5 SQL Conforme
SQL es el lenguaje estándar para el acceso
a las bases de datos
relacionales. Una de las áreas de
dificultad es que aunque muchas DBMS’s (Data Base Management
Systems) usan un formato estándar de SQL para
la funcionalidad básica,
estos no conforman la sintaxis más recientemente definidas
o semánticas para funcionalidades más avanzadas.
Una forma en que el API JDBC trata este problema es permitir que cualquier
cadena de búsqueda se pase al driver subyacente del DBMS.
1.Tipos de drivers
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.
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.
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.
4.- driver puro Java y
nativo-protocolo.. Este tipo de driver convierte llamadas JDBC en el protocolo de la red
usado por DBMS directamente.
Uso de JDBC en apliaciones java:
Una conexión a bases de datos Java (JDBC) es un controlador de bases de
datos que permite la conexión mediante programación a una base de datos. Debe
utilizar la conexión como un puente entre la aplicación y la base de datos
real.
1.
Para establecer
un nombre de origen de datos
16.
Haga
clic en Inicio, elija Panel de control, seleccione Herramientas administrativas y, a continuación, haga clic en Orígenes de datos (ODBC).
17.
En
la pantalla Herramientas administrativas, seleccione Orígenes de datos.
18.
En
la página Administrador de orígenes de datos ODBC, haga
clic en la ficha DSN de sistema y haga clic en Agregar.
19.
En
la página Crear nuevo origen de datos , seleccione Controlador de Microsoft Access (*.mdb) y haga clic en Finalizar.
4. Summary:
I.JDBC
1. Content:
Data Access Layer, added:
About this task
You must define all data sources
for business object fields used in event rules. You must also define all data
sources used to fill the object fields of action that have not been filled by
payloads events.
You can define as a hosted
database, any of the supported databases (eg DB2) for which you can define a
data connection. The hosted database should be accessible to Event Designer and
the server running event.
Process
1. In the event Explorer view,
press the right mouse button New> Data Connection. the Data Connection
Wizard opens.
2. Name JNDI data source: Enter
the JNDI name of the data source WebSphere Application Server that is used by
the data collector and JDBC connector.
3.Controlador JDBC: Select the
driver you want to use:
or DB2 Linux, Unix and Windows
or DB2 z / OS
or SQL Server
or Oracle
or Derby
BD Configuration connection
with NetBeans:
If you're a programmer and you
develop your applications in Java certainly you need to connect a MySQL
database data type this environment someday, well, if you need it now, here's a
step by step explanation of how to connect both tools.
Create and test a connection:
Within the section Runtime or Runtime> Databases or Databases> Drivers
gives a right click on MySQL (Connector / J driver) and select Connect Usingo
Connect using ... to display the screen connection configuration.
Implementing the code:
So far we have already
established the connection to the database and proven performance from
NetBeans, however, we need to implement the code directly into an application.
For this example we will create a connection class name can be reused as many
times as necessary.
Defining JDBC, Types and
Applications:
To use JDBC with a management
system database in particular, you need the appropriate JDBC driver that makes
an intermediary between it and JDBC.
1.1 What is JDBC?
JDBC
is the API for executing SQL statements. (As a point of interest JDB
It is a registered trademark and
not an acronym, however it is often known as "Java Database
Connectivity"). It consists of a set of classes and interfaces written in
the Java programming language.
1.1.1 What makes JDBC?
JDBC
just do these three things possible:
• Establishes a connection to
the database.
• Send SQL statements
• Process the results.
1.1.2 JDBC is a low-level API
and a base for high-level API's.
JDBC
is a low-level interface, which means that is used to 'invoke' or call SQL
commands directly. This function works very well and is easier to use than
other API's connection to databases.
1.1.3 JDBC and ODBC against
other APIs
At
this point, the Microsoft ODBC (Open Database connectvity), is probably the
most widespread for access to relational databases API. Offers.
In summary, the JDBC API is a
natural Java interface for abstractions and basics of SQL. JDBC retains the
basic design features of ODBC; in fact, both interfaces are based on the X /
Open SQL CLI (Call Level Interface).
1.1.4 Models in two and three
floors.
The
JDBC API supports two models and three floors of database access. In the
two-story model, a Java applet or application talks directly with
the database. This requires a
JDBC driver that can communicate with the manager
of particular database that is
to access.
As SQL 1.1.5
SQL is the standard language for
access to relational databases. One area of difficulty is that although many
DBMSs (Data Base Management Systems) use a standard format of SQL for basic
functionality, they do not make the most recently defined semantic syntax or
for more advanced features. One way the JDBC API deals with this problem is to
allow any search string is passed to the underlying DBMS driver.
JDBC driver 1.Tipos
The drivers that are likely to
be classified into one of four categories.
1. JDBC-ODBC bridge over ODBC
driver: Product JavaSoft provides access via ODBC drivers. Note that ODBC
binary code, and in many cases the client code database must be loaded on each
client machine that uses this driver.
2. partially Native Java driver.
This kind of driver converts JDBC calls in client API calls to Oracle, Sybase,
Informix, DB2 and other DBMS.
3. Java native JDBC driver-Net.
This driver translates JDBC calls to the network protocol independent DBMS
which is then translated into the DBMS protocol by the server.
4. pure Java driver and
native-protocol .. This kind of driver converts JDBC calls into the network
protocol used by DBMSs directly.
Using JDBC in java apliaciones:
A connection to Java database
(JDBC) driver is a database that allows connection programmatically to a
database. You must use the connection as a bridge between the application and
the actual database.
1. To establish a data source
name
2. Click Start, click Control
Panel, select Administrative Tools, and then click Data Sources (ODBC).
3. In the Administrative Tools
screen, select Data Sources.
4. In the Admin page of ODBC
data sources, click the System DSN tab and click Add.
5. On the Create New Data
Source, select Microsoft Access Driver (* .mdb) and click Finish
5. Recomendaciones:
Ø El diseño y
desarrollo de las nuevas aplicaciones de JDBC conduce a la minimización del
ingreso de datos por parte del usuario; además el lenguaje de desarrollo que se
utiliza.
Ø Esta
orientado a facilitar la ejecución en cualquier Sistema Operativo, ya que se
ajusta a los estándares reconocidos, que permite la flexibilidad de los
cambios.
Ø 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.
6. Conclusiones:
Ø Los JDBC es
una especificación formada por una colección de interfaces y clases abstractas,
que deben implementar todos los fabricantes de drivers que quieran realizar una
implementación de su driver 100% Java pero compatible con JDBC.
Ø Los drivers
JDBC y ODBC 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 Universidad desee implementar en un futuro, orientados con
este fin.
Ø Los JDBC
definen ocho interfaces para operaciones con base de Datos.
7. Apreciación del
Equipo:
Ø
JDBC 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.
8. Glosario de
Términos:
1. Compilar:
Reunir en un solo texto extractos o fragmentos de otras obras ya publicadas
2. Interface:
Intervalo entre dos fases sucesivas, especialmente referido a las fases de la
división cellular.
3. Cláusulas:
Cada una de las disposiciones o condiciones de un contrato, ley, tratado, etc.
4. Sintaxis:
Forma correcta en que deben estar dispuestos los símbolos que componen una
instrucción ejecutable por el ordenador.
5. Credencial:
Documento que permite tomar posesión de su plaza a un empleado.
6. Abstracción:
Consideración aislada de las cualidades esenciales de un objeto, o del mismo
objeto en su pura esencia o noción.
7. Remota:
Distante en el espacio o en el tiempo.
8. Conglomerado:
Masa compacta de materiales unidos artificialmente.
9. Divergencia:
separación progresiva de dos o más líneas o superficies.
10. Cerciorarse:
asegurar la verdad de una cosa.
9. Bibliografía o
Linkografía:
