Ejemplo Conectando Java con MySql

En esta entrada vamos a tocar uno de los puntos fundamentales en el desarrollo de software, no vamos a entrar en detalles de que es una BD, ni los tipos existentes ni como crearlas entre muchos otros temas en torno a esto, solamente muestro una pequeña aplicación (muy básica) donde veremos de forma fácil como conectarnos a una BD para consultar y registrar información
....además daremos paso a futuras entradas sobre los Patrones de Diseño, ya que en esta aplicaremos los Patrones VO (Value Object) y DAO (DataAccess Objetc).
Requisitos.

• Ambiente de desarrollo (En este caso Eclipse)
• JDK instalado.
• MySql Instalado
• mysql-connector-java-5.0.8-bin (lo pueden bajar desde aquí)
• Conocimientos Basicos de Programación.
• Ganas de Continuar.

En Marcha.
Bueno, vamos a hacer una aplicación simple, la idea de este tutorial es ver como conectarnos a MySql desde Java, por eso no nos preocuparemos tanto en como se presentaran nuestra información, ni los tipos de datos, ni que tan óptimo sea nuestro código, simplemente vamos a crear una base desde donde podamos trabajar.
La Aplicación.
El siguiente diagrama muestra la estructura de nuestra aplicación (Ojo no es un diagrama de clases completo, es mas usado para dar claridad al sistema, por eso no nos enfocaremos en asociaciones, tipos de datos o etc)

Como vemos la aplicación es básica, nos conectaremos a una BD donde tenemos una única tabla y mediante Java vamos a acceder a dicha BD para poder registrar y consultar información, la idea es poder registrar y consultar personas, en la aplicación tendremos un Menú principal con estas opciones.....

La Base de Datos.

Nuestra base de datos solo tendrá la tabla persona con los datos básicos de registro (si se desea se puede dar otro enfoque a la tabla o trabajar con muchas mas), el Script para la creación es el siguiente:

CREATE DATABASE /*!32312 IF NOT EXISTS*/`codejavu` /*!40100 DEFAULT CHARACTER SET latin1 */;
USE `codejavu`;
/*Table structure for table `persona` */
DROP TABLE IF EXISTS `persona`;
CREATE TABLE `persona` (
  `id` int(10) NOT NULL,
  `nombre` varchar(30) default NULL,
  `edad` int(3) default NULL,
  `profesion` varchar(30) default NULL,
  `telefono` decimal(10,0) default NULL,
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
/*Data for the table `persona` */

Empecemos!!!
Para iniciar vamos a crear un proyecto java en Eclipse, por cuestiones de organización crearemos las clases de nuestro diagrama separándolas por paquetes, esto con el fin de tener nuestro proyecto mas estructurado y fácil de entender, así.

Como vemos tenemos un paquete por cada clase, en estos momentos la aplicación es pequeña por lo tanto no nos da problemas de organización, sin embargo a medida que vaya creciendo se hace importante tener nuestras clases agrupadas facilitando así el trabajo futuro y la mantenibilidad de nuestro sistema.
Clase DbConnection.

Esta clase será nuestra cadena de conexion, aquí definiremos los parámetros requeridos para conectarnos a la BD creada anteriormente.

package prueba.connection;
import java.sql.*;
/**
 * Clase que permite conectar con la base de datos
 * @author chenao
 *
 */
public class DbConnection {
   /**Parametros de conexion*/
   static String bd = "codejavu";
   static String login = "root";
   static String password = "";
   static String url = "jdbc:mysql://localhost/"+bd;
   Connection connection = null;
   /** Constructor de DbConnection */
   public DbConnection() {
      try{
         //obtenemos el driver de para mysql
         Class.forName("com.mysql.jdbc.Driver");
         //obtenemos la conexión
         connection = DriverManager.getConnection(url,login,password);
         if (connection!=null){
            System.out.println("Conexión a base de datos "+bd+" OK\n");
         }
      }
      catch(SQLException e){
         System.out.println(e);
      }catch(ClassNotFoundException e){
         System.out.println(e);
      }catch(Exception e){
         System.out.println(e);
      }
   }
   /**Permite retornar la conexión*/
   public Connection getConnection(){
      return connection;
   }
   public void desconectar(){
      connection = null;
   }
}

En la clase estamos aplicando el manejo de excepciones, tema tratado en el articulo anterior, vemos como se tiene contemplada la jerarquía de excepciones pertinente.

Clase PersonaVO.
Esta clase nos permite dar un manejo mucho mas organizado y seguro a nuestra información, en ella estamos aplicando el patrón VO (Value Object) con el cual nos aseguramos que los datos viajen en un solo objeto, evitando no solo el envió de gran cantidad de parámetros sino también un mayor control............Debemos saber que por cada tabla de nuestra BD se tiene que construir su equivalente clase VO.

package prueba.vo;
/**
 * CLase VO con los atributos del campo empleado
 * @author chenao
 *
 */
public class PersonaVO{
 private Integer idPersona;
 private String nombrePersona;
 private Integer edadPersona;
 private String profesionPersona;
 private Integer telefonoPersona;
 /**
  * @return the idPersona
  */
 public Integer getIdPersona() {
  return idPersona;
 }
 /**
  * @param idPersona the idPersona to set
  */
 public void setIdPersona(Integer idPersona) {
  this.idPersona = idPersona;
 }
 /**
  * @return the nombrePersona
  */
 public String getNombrePersona() {
  return nombrePersona;
 }
 /**
  * @param nombrePersona the nombrePersona to set
  */
 public void setNombrePersona(String nombrePersona) {
  this.nombrePersona = nombrePersona;
 }
 /**
  * @return the edadPersona
  */
 public Integer getEdadPersona() {
  return edadPersona;
 }
 /**
  * @param edadPersona the edadPersona to set
  */
 public void setEdadPersona(Integer edadPersona) {
  this.edadPersona = edadPersona;
 }
 /**
  * @return the profesionPersona
  */
 public String getProfesionPersona() {
  return profesionPersona;
 }
 /**
  * @param profesionPersona the profesionPersona to set
  */
 public void setProfesionPersona(String profesionPersona) {
  this.profesionPersona = profesionPersona;
 }
 /**
  * @return the telefonoPersona
  */
 public Integer getTelefonoPersona() {
  return telefonoPersona;
 }
 /**
  * @param telefonoPersona the telefonoPersona to set
  */
 public void setTelefonoPersona(Integer telefonoPersona) {
  this.telefonoPersona = telefonoPersona;
 }
}

Como vemos cada campo de la tabla persona es reflejado en la Clase PersonaVO, tambien aplicamos un poco el concepto de Encapsulación tratado en un articulo anterior mediante la creación de metodos setter y getter por cada dato privado.
Clase PersonaDAO.
Esta clase sera la encargada de gestionar el acceso a los datos, con ella aplicamos un patrón DAO (DataAccess Objetc) no entraremos en detalle (mas adelante se presentara una entrada sobre este Patrón) ya que básicamente necesitamos saber que este patrón nos enseña la forma de obtener información de la BD mediante métodos CRUD (Create, Read, Update y Delete), así que por cada tabla de nuestra BD debemos tener una clase DAO que la represente!!!

package prueba.dao;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import javax.swing.JOptionPane;
import prueba.connection.DbConnection;
import prueba.vo.PersonaVO;
/**
 * Clase que permite el acceso a la base de datos
 * @author chenao
 *
 */
public class PersonaDAO 
{
 /**
  * Permite registrar un empleado
  * @param persona
  */
 public void registrarPersona(PersonaVO persona) 
 {
  DbConnection conex= new DbConnection();
  try {
   Statement estatuto = conex.getConnection().createStatement();
   estatuto.executeUpdate("INSERT INTO persona VALUES ('"+persona.getIdPersona()+"', '"
     +persona.getNombrePersona()+"', '"+persona.getEdadPersona()+"', '"
     +persona.getProfesionPersona()+"', '"+persona.getTelefonoPersona()+"')");
   JOptionPane.showMessageDialog(null, "Se ha registrado Exitosamente","Información",JOptionPane.INFORMATION_MESSAGE);
   estatuto.close();
   conex.desconectar();
   
  } catch (SQLException e) {
            System.out.println(e.getMessage());
   JOptionPane.showMessageDialog(null, "No se Registro la persona");
  }
 }
   
/**
 * permite consultar el empleado asociado al documento enviado
 * como parametro 
 * @param documento 
 * @return
 */
public ArrayList< personavo> consultarPersona(int documento) {
  ArrayList< personavo> miEmpleado = new ArrayList< personavo>();
  DbConnection conex= new DbConnection();
    
  try {
   PreparedStatement consulta = conex.getConnection().prepareStatement("SELECT * FROM persona where id = ? ");
   consulta.setInt(1, documento);
   ResultSet res = consulta.executeQuery();
   
  if(res.next()){
    PersonaVO persona= new PersonaVO();
    persona.setIdPersona(Integer.parseInt(res.getString("id")));
    persona.setNombrePersona(res.getString("nombre"));
    persona.setEdadPersona(Integer.parseInt(res.getString("edad")));
    persona.setProfesionPersona(res.getString("profesion"));
    persona.setTelefonoPersona(Integer.parseInt(res.getString("telefono")));
    miEmpleado.add(persona);
          }
          res.close();
          consulta.close();
          conex.desconectar();
   
  } catch (Exception e) {
   JOptionPane.showMessageDialog(null, "no se pudo consultar la Persona\n"+e);
  }
  return miEmpleado;
 }
/**
 * permite consultar la lista de empleados
 * @return
 */
public ArrayList< personavo> listaDePersonas() {
  ArrayList< personavo> miEmpleado = new ArrayList< personavo>();
  DbConnection conex= new DbConnection();
    
  try {
   PreparedStatement consulta = conex.getConnection().prepareStatement("SELECT * FROM persona");
   ResultSet res = consulta.executeQuery();
   while(res.next()){
    PersonaVO persona= new PersonaVO();
    persona.setIdPersona(Integer.parseInt(res.getString("id")));
    persona.setNombrePersona(res.getString("nombre"));
    persona.setEdadPersona(Integer.parseInt(res.getString("edad")));
    persona.setProfesionPersona(res.getString("profesion"));
    persona.setTelefonoPersona(Integer.parseInt(res.getString("telefono")));
    miEmpleado.add(persona);
          }
          res.close();
          consulta.close();
          conex.desconectar();
   
  } catch (Exception e) {
   JOptionPane.showMessageDialog(null, "no se pudo consultar la Persona\n"+e);
  }
  return miEmpleado;
 }
}

Por cuestiones de tiempo no realizaremos todo el CRUD, tan solo vamos a trabajar con los métodos de registro y consulta (Los métodos de actualización y eliminación serán una buena tarea en casa ;) )
Cada método usa la cadena de conexión creada anteriormente y se enfoca en una tarea en especifico, además en cada uno hacemos uso de un objeto de tipo PersonaVO, mediante el cual asignamos la información de nuestra tabla persona, tanto para el registro como para la consulta de información.

Clase Principal.
En esta clase vamos a hacer el llamado a todos los procesos de nuestra aplicación, tendremos un menú en el cual presentamos todas las opciones del sistema, así mismo se validaran las entradas del usuario para evitar posibles inconsistencias y posteriormente se hace el llamado a la clase DAO que permite ejecutar los procesos de conexión con la BD.

package prueba.principal;
import java.util.ArrayList;
import javax.swing.JOptionPane;
import prueba.dao.PersonaDAO;
import prueba.vo.PersonaVO;
public class Principal {
 PersonaDAO miPersonaDAO;
 /**
  * Método principal, hace el llamado al menú donde se
  * presentan todas las opciones del sistema
  * @param args
  */
 public static void main(String[] args) {
  
  Principal miPrincipal = new Principal();
  miPrincipal.verMenu();
 }
 /**
  * Método que permite presentar las opciones del sistema.
  * solicita el ingreso de un numero y se envia a su 
  * correspondiente proceso
  */
 private void verMenu() {
  
  String textoMenu="Menú Principal\n\n";
  textoMenu+="Ingrese alguna de las opciones del Menú    \n";
  textoMenu+="1. Registrar Persona\n";
  textoMenu+="2. Consultar Persona\n";
  textoMenu+="3. Ver Lista Personas\n";
  textoMenu+="4. Salir.\n\n";
  
  try {
  int seleccion= Integer.parseInt(JOptionPane.showInputDialog(textoMenu));
  defineSeleccion(seleccion);
  } catch (NumberFormatException e) {
   JOptionPane.showMessageDialog(null,"Error en el ingreso de Datos, " +
     "solo se permiten valores númericos","ERROR",JOptionPane.ERROR_MESSAGE);
   verMenu();
  } catch (Exception e) {
   JOptionPane.showMessageDialog(null,"Error en el ingreso de Datos, " +
     "solo se permiten valores númericos","ERROR",JOptionPane.ERROR_MESSAGE);
   verMenu();
  }
 }
 /**
  * Permite determinar que accion ejecutar dependiendo del parametro de 
  * ingreso correspondiente a las opciones del sistema
  * @param seleccion
  */
 private void defineSeleccion(int seleccion) {
  
   System.out.println("Selecciona "+seleccion);
   
   switch (seleccion) {
   case 1:
     registrarPersona();
     verMenu();
    break;
   case 2:
    int doc=Integer.parseInt(JOptionPane.showInputDialog("Ingrese el numero" +
      " de documento de la persona"));
    buscarPersona(doc);
    verMenu();
    break;
   case 3:
    obtenerRegistros();
    verMenu();
    break;
   case 4:
    System.exit(0);
    break;
   default:
    JOptionPane.showMessageDialog(null, "Ingrese un " +
      "numero valido","ADVERTENCIA",JOptionPane.WARNING_MESSAGE);
    verMenu();
    break;
   }
 }
 /**
  * Permite solicitar los datos de la persona a registrar, se solicitan mediante
  * una ventana de ingreso y se almacenan en un arreglo con toda la informacion usando
  * para esto un ciclo for, posteriormente estos datos son almacenados en el
  * atributo correspondiente del objeto persona para ser enviado al metodo de registro
  * en la clase DAO
  */
 private void registrarPersona() {
  miPersonaDAO = new PersonaDAO();
  PersonaVO miPersona=new PersonaVO();
  
  String mensajeIngreso="Ingrese\n\n";
  
  String datosSolicitados[] = {"Documento : ","Nombre : ",
          "Edad: ","Profesión: ","Telefono: "};
  String datosPersona[] = new String[5];
  for (int i = 0; i < datosSolicitados.length; i++) {
   //solicita el ingreso del dato y se almacena en el arreglo de datosPersona
   datosPersona[i]=JOptionPane.showInputDialog(null, mensajeIngreso+
      datosSolicitados[i],"Datos Persona",JOptionPane.INFORMATION_MESSAGE);
   
   System.out.println(datosSolicitados[i]+datosPersona[i]);
  }
  
  miPersona.setIdPersona(Integer.parseInt(datosPersona[0]));
  miPersona.setNombrePersona(datosPersona[1]);
  miPersona.setEdadPersona(Integer.parseInt(datosPersona[2]));
  miPersona.setProfesionPersona(datosPersona[3]);
  miPersona.setTelefonoPersona(Integer.parseInt(datosPersona[4]));
  
  miPersonaDAO.registrarPersona(miPersona);
  
 }
 /**
  * Permite obtener la lista de personas almacenada en la tabla persona
  * si la lista se encuentra vacia quiere decir que no hay personas registradas
  * acto seguido se presenta un mensaje en pantalla, sino se imprime la lista de 
  * todas las personas registradas en la BD
  */
 private void obtenerRegistros() {
  miPersonaDAO = new PersonaDAO();
  PersonaVO miPersona;
  
  //Se obtiene la lista de personas
  ArrayList< personavo> listaPersonas = miPersonaDAO.listaDePersonas();
  //se valida si se obtubo o no informacion
  if (listaPersonas.size()>0) {
   int numeroPersona=0;
   //se recorre la lista de personas asignandose cada posicion en un objeto persona
   for (int i = 0; i < listaPersonas.size(); i++) {
    numeroPersona++;
    miPersona=listaPersonas.get(i);
    System.out.println("****************Persona "+numeroPersona+"**********************");
    System.out.println("Id Persona: "+miPersona.getIdPersona());
    System.out.println("Nombre Persona: "+miPersona.getNombrePersona());
    System.out.println("Edad Persona: "+miPersona.getEdadPersona());
    System.out.println("Profesión Persona: "+miPersona.getProfesionPersona());
    System.out.println("Telefono Persona: "+miPersona.getTelefonoPersona());
    System.out.println("*************************************************\n");
   }
  }else{
   JOptionPane.showMessageDialog(null,"Actualmente no " +
     "existen registros de personas","INFORMACIÓN",JOptionPane.INFORMATION_MESSAGE);
  }
  
 }
 /**
  * Permite la consulta de una persona en especifico mediante el envio de
  * su documento de identidad como parametro, en caso de que no se retorne
  * informacion se presenta un mensaje en pantalla, sino entonces se imprimen los
  * datos de la persona encontrada
  * @param documento
  */
 private void buscarPersona(int documento) {
  miPersonaDAO = new PersonaDAO();
  PersonaVO miPersona;
  ArrayList< personavo> personasEncontrada = miPersonaDAO.consultarPersona(documento);
  //se valida que se encuentre la persona
  if (personasEncontrada.size()>0) {
   //se recorre la lista y se asignan los datos al objeto para imprimir los valores
   for (int i = 0; i < personasEncontrada.size(); i++) {
    miPersona=personasEncontrada.get(i);
    System.out.println("****************Persona*************************");
    System.out.println("Id Persona: "+miPersona.getIdPersona());
    System.out.println("Nombre Persona: "+miPersona.getNombrePersona());
    System.out.println("Edad Persona: "+miPersona.getEdadPersona());
    System.out.println("Profesión Persona: "+miPersona.getProfesionPersona());
    System.out.println("Telefono Persona: "+miPersona.getTelefonoPersona());
    System.out.println("*************************************************\n");
   }
  }else{
   JOptionPane.showMessageDialog(null,"El documento ingresado " +
     "no corresponde a ninguna persona","INFORMACIÓN",JOptionPane.INFORMATION_MESSAGE);
  }
 }
}

Como se ve, tenemos la clase principal dividida en metodos para cada proceso, eso hace que podamos darle un tratamiento individual a cada uno, asi en caso de algun error facilmente podremos identificar en que metodo sucedio....... tambien vemos que en el método verMenu() validamos por medio de bloques try - catch los posibles errores en el ingreso de datos por parte del usuario.
Ejecutando la Aplicación.
Al ejecutar la aplicación se presenta el menú principal donde ingresamos las opciones correspondientes, pero hay que tener presente que previamente debimos haber agregado el mysql-connector al build path del proyecto, sino nos aparecera algo como esto :
Para solucionarlo sobre el proyecto damos clic derecho/configure Build path... , buscamos al jar desde la ruta donde lo descargamos y damos ok

después de esto ya tendremos nuestra aplicación en funcionamiento

Como se mencionó al principio, es una aplicación básica y no nos enfocamos en muchos detalles.........tan solo en la logica de conexión que nos servira como base para futuros desarrollos....Mas adelante continuaremos con otros temas de interes donde aplicaremos los conceptos vistos en esta entrada!!!También te podría Interesar. 

• Manejo de Excepciones en Java
• ¿ String Vrs StringBuffer Vrs StringBuilder ?
• Comparando Fechas En Java
• Integración Continua, Primeros Pasos Con Jenkins
• Leer Archivo Properties en Java
• Tutorial Proyecto Web Con Eclipse
• Instalación del servidor de aplicaciones JBoss
• Instalación Apache ANT

¿Hay algo que quieras anexar o comentar sobre esta entrada?  no dudes en hacerlo....