La siguiente pequeña tutoría consiste en mostrar y enseñar
lo que te piden en una entrevista de trabajo, como caso practico para evaluar
el conocimiento que traes como programador.
Básicamente te piden que realices una conexión con una base de datos
ya sea en Oracle, MySQL o Server SQL, e inmediatamente te piden insertar, modificar,
consultar y eliminar datos de algunas tablas.
Bueno, empecemos de una vez, para terminar temprano, pero primero me imagino
que querras ver el código fuente, asi que lo podras descargar de
AQUI.
PRIMER PASO: debemos de declarar algunas variables que nos serán útiles:
private Connection conexion;// Representa la conexión con una BD.
private Statement stmSql;//ejecutar una sentencia SQL
private String sControlador; //Contiene el nombre del controlador.
private String sUsuario;//Contiene el nombre de usuario.
private String sContasenia;//contraseña para el acceso a la BD
private String sURL;//Contiene el url para realizar la conexión
private String sDB;//Nombre de la BD para trabajar
De todas estas variables las mas importantes son la de Connexion , Statement, ya que en estas radican la funcionalidad de la conexión a la BD.
SEGUNDO PASO: crear un constructor sin parámetros, que nos permitirá realizar una conectividad a una BD por default, el constructor de la clase le asignaremos, las rutas y/o parámetros que permitirán la conexión a la BD
public Conexion(){
sControlador = "com.mysql.jdbc.Driver";
sDB = "dbluz";
sUrl = "jdbc:mysql://localhost/"+sDB;
sUsuario = "root";
sContrasenia = "moster03";
}
Observe como la variable sControlador se le asigna el nombre del controlador, en este caso la conexión se realiza con MySQL, el nombre cambia dependiendo
de la BD a conectarse, se puede configurar una conexión especificando
la clase del driver y la URL de la conexión para la base de datos seleccionada.
Abajo tiene un listado con las clases de driver, las URLs de conexión
y los ficheros .jar del driver para las bases de datos más utilizadas:
DB2
Clase Driver : COM.ibm.db2.jdbc.app.DB2Driver
URL de Conexión:: jdbc:db2:<database>
Fichero .jar/.zip: db2java.zip
Sybase
Clase Driver : com.sybase.jdbc2.jdbc.SybDriver
URL de Conexión:
dbc:sybase:Tds:<host>:<port>/<database>
Fichero .jar/.zip: jconn2.jar
Oracle
Clase Driver : oracle.jdbc.driver.OracleDriver
URL de Conexión: jdbc:oracle:thin:@ <host>:<port>:<sid>
Fichero .jar/.zip: classes12.zip
SQLServer
Clase Driver : com.microsoft.jdbc.sqlserver.SQLServerDriver
URL de Conexión: jdbc:microsoft:sqlserver://localhost:1433
Fichero .jar/.zip: mssqlserver.jar, msbase.jar, msutil.jar
PostgreSQL
Clase Driver: org.postgresql.Driver
URL de Conexión: jdbc:postgresql://<server>:<port>/<database>
Fichero .jar/.zip: postgresql.jar
NOTA:
• Los drivers o conectores para la JDBC generalmente son ofrecidos por
las mismas empresas que ofrecen los servicios de las BD, por ejemplo MySQL la
ofrece en el siguiente dominio: http://www.mysql.com/products/connector/j/
TERCER PASO: Crear otro constructor que realice la conexión a la BD,
nótese que dependiendo de la información que le enviemos, este
constructor nos permitirá realizar la conexión con cualquier BD.
public Conexion(String sControlador, String sDB, String sUsuario,
String sContrasenia, String sUrl){
this.sControlador = sControlador;
this.sUsuario = sUsuario;
this.sContrasenia = sContrasenia;
this.sUrl = sUrl+sDB;
}
Dependiendo de la funcionalidad de tu código, tu eliges que tipo de
constructor elegir, si tu sabes que tipo de BD utilizar y no cambia utiliza
la primera, si por el contrario tu necesitas estarte conectando en varias BD
como Oracle o Serverr SQL y no estés creando clases para realizar las
conexiones para cada una te recomiendo la segunda.
CUARTO PASO: el siguiente paso es crear un método que nos permita abrir
la conexión a la BD.
private void vodAbrirConexion(){
try{
Class.forName(sControlador).newInstance();
conexion = DriverManager.getConnection(sUrl,sUsuario,sContrasenia);
stmSql = conexion.createStatement();
System.out.println("Conexion Creada con Exito '_'");
…
…
Este método es muy importante ya que en este crearemos las instancias
correspondientes para realizar la conexión.
Nótese como en el método pasado se invoca al método forName
de Class que devuelve una Clase, especificada con el controlador, garantizando
un objeto de la clase del controlador. En seguida creamos una instancia de la
clase Connection por medio de la clase DriverManager que obtiene la conexión
por medio del método getConnection con los atributos de la url de la
BD, el nombre del usuario de la BD y por ultimo la contraseña del usuario,
que administra la BD, creamos otra instancia de la clase Statement en base a
la instancia Connection antes creada por su método createStatement, esta
instancia de Statement es con la que estaremos interactuando hasta que se cierre
la conexión a la BD para realizar las distintas sentencias SQL. Finalmente
creamos las excepciones que nos permitirán verificar que se halla realizado
con eficacia la conexión.
QUINTO PASO: creamos un método que nos permita cerrar la BD.
public void vCerrarConexion(){
try{
if(stmSql!=null){
stmSql.close();
….
}
if(conexion!=null){
conexion.close();
……
}
}
catch(SQLException eSQL){/*NO HACER NADA*/}
}
Nótese como cerramos tanto el objeto de Statement como el objeto de Connection.
SEXTO PASO: finalmente creamos un método que nos permitirá ejecutar
sentencias SQL, impactando en la BD ya sea para Seleccionar, Borrar, etc.
Como se observa el siguiente método nos permitirá ejecutar sentencias.
private ResultSet rstSetConsulta(String sConsultaSql){
ResultSet rsConsulta = null;
try{
rsConsulta = stmSql.executeQuery(sConsultaSql);
}
….
Observe que esta función nos regresa un objeto de tipo ResultSet, así
como recibir como parámetro una consulta sql, que será procesada
por el método executeQuery, de la clase Statement.
SEPTIMO PASO: Finalmente nos queda crear un método que nos permita ejecutar
actualizaciones en la Base de Datos, ya sea un insert, update o delete.
private void vodModificar(String sIntruccionSQL){
try{
stmSql.executeUpdate(sIntruccionSQL);
…
FINAL. Finalmente nos queda más que jugar con estos métodos y
hacer nuestras consultas o actualizaciones en la base de datos tan complejas
como se nos sea posible en base a nuestros objetivos dentro del sistema.
Si observa en la clase Conexión.java, se crea un método llamado
executaConsulta, que utiliza al método rstSetConsulta, y este realizar
la consulta en especifico, dándole un tratamiento especial a los valores
obtenidos, no importando si es de tipo int, String float, etc, ya que son obtenidos
como Objetos, finalmente son pasados a una variable de tipo StringBuffer, pudiéndose
también pasar en un Vector, una lista, arreglo, etc. Notese que ademas
nos traen los metadatos es decir los nombres de los campos en la Base de datos.
En el main, se realizan las pruebas pertinentes, si observa solo invocamos
a la clase y en esta invocamos metos y/o funciones pasándole solamente
las sentencias SQL, correspondientes y estos se encargan de lo demás,
haciendo la transacción a la BD mas fácil.
