20/10/2016 CoDejaVu: Ejemplo Conectando Java con MySql
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 (Data Access Objetc).
Requisitos.
Ambiente de desarrollo (En este caso Eclipse)
JDK instalado.
MySql Instalado
mysqlconnectorjava5.0.8bin (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)
[Link] 1/13
20/10/2016 CoDejaVu: Ejemplo Conectando Java con MySql
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:
1 CREATE DATABASE /*!32312 IF NOT EXISTS*/`codejavu` /*!40100 DEFAULT CHARACTE
2
3 USE `codejavu`;
4
5 /*Table structure for table `persona` */
6
7 DROP TABLE IF EXISTS `persona`;
8
9 CREATE TABLE `persona` (
10 `id` int(10) NOT NULL,
11 `nombre` varchar(30) default NULL,
12 `edad` int(3) default NULL,
13 `profesion` varchar(30) default NULL,
14 `telefono` decimal(10,0) default NULL,
15 PRIMARY KEY (`id`)
16 ) ENGINE=InnoDB DEFAULT CHARSET=latin1;
17
18 /*Data for the table `persona` */
Empecemos!!!
Para iniciar vamos a crear un proyecto java en Eclipse, por cuestiones de
[Link] 2/13
20/10/2016 CoDejaVu: Ejemplo Conectando Java con MySql
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.
1 package [Link];
2 import [Link].*;
3
4 /**
5 * Clase que permite conectar con la base de datos
6 * @author chenao
7 *
8 */
9 public class DbConnection {
10 /**Parametros de conexion*/
11 static String bd = "codejavu";
12 static String login = "root";
13 static String password = "";
14 static String url = "jdbc:mysql://localhost/"+bd;
15
16 Connection connection = null;
17
18 /** Constructor de DbConnection */
19 public DbConnection() {
20 try{
21 //obtenemos el driver de para mysql
22 [Link]("[Link]");
23 //obtenemos la conexión
24 connection = [Link](url,login,password);
25
26 if (connection!=null){
[Link] 3/13
20/10/2016 CoDejaVu: Ejemplo Conectando Java con MySql
26 if (connection!=null){
27 [Link]("Conexión a base de datos "+bd+" OK\n");
28 }
29 }
30 catch(SQLException e){
31 [Link](e);
32 }catch(ClassNotFoundException e){
33 [Link](e);
34 }catch(Exception e){
35 [Link](e);
36 }
37 }
38 /**Permite retornar la conexión*/
39 public Connection getConnection(){
40 return connection;
41 }
42
43 public void desconectar(){
44 connection = null;
45 }
46 }
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.
1 package [Link];
2
3
4 /**
5 * CLase VO con los atributos del campo empleado
6 * @author chenao
7 *
8 */
9 public class PersonaVO{
10
11 private Integer idPersona;
12 private String nombrePersona;
13 private Integer edadPersona;
14 private String profesionPersona;
15 private Integer telefonoPersona;
16
[Link] 4/13
20/10/2016 CoDejaVu: Ejemplo Conectando Java con MySql
16
17 /**
18 * @return the idPersona
19 */
20 public Integer getIdPersona() {
21 return idPersona;
22 }
23 /**
24 * @param idPersona the idPersona to set
25 */
26 public void setIdPersona(Integer idPersona) {
27 [Link] = idPersona;
28 }
29 /**
30 * @return the nombrePersona
31 */
32 public String getNombrePersona() {
33 return nombrePersona;
34 }
35 /**
36 * @param nombrePersona the nombrePersona to set
37 */
38 public void setNombrePersona(String nombrePersona) {
39 [Link] = nombrePersona;
40 }
41 /**
42 * @return the edadPersona
43 */
44 public Integer getEdadPersona() {
45 return edadPersona;
46 }
47 /**
48 * @param edadPersona the edadPersona to set
49 */
50 public void setEdadPersona(Integer edadPersona) {
51 [Link] = edadPersona;
52 }
53 /**
54 * @return the profesionPersona
55 */
56 public String getProfesionPersona() {
57 return profesionPersona;
58 }
59 /**
60 * @param profesionPersona the profesionPersona to set
61 */
62 public void setProfesionPersona(String profesionPersona) {
63 [Link] = profesionPersona;
64 }
65 /**
66 * @return the telefonoPersona
67 */
68 public Integer getTelefonoPersona() {
69 return telefonoPersona;
70 }
71 /**
72 * @param telefonoPersona the telefonoPersona to set
73 */
74 public void setTelefonoPersona(Integer telefonoPersona) {
[Link] 5/13
20/10/2016 CoDejaVu: Ejemplo Conectando Java con MySql
74 public void setTelefonoPersona(Integer telefonoPersona) {
75 [Link] = telefonoPersona;
76 }
77 }
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 (Data Access 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
mediantemétodos CRUD (Create, Read, Update y Delete), así que por cada tabla de
nuestra BD debemos tener una clase DAO que la represente!!!
1 package [Link];
2
3 import [Link];
4 import [Link];
5 import [Link];
6 import [Link];
7 import [Link];
8 import [Link];
9 import [Link];
10 import [Link];
11
12
13 /**
14 * Clase que permite el acceso a la base de datos
15 * @author chenao
16 *
17 */
18 public class PersonaDAO
19 {
20
21 /**
22 * Permite registrar un empleado
23 * @param persona
24 */
25 public void registrarPersona(PersonaVO persona)
26 {
27 DbConnection conex= new DbConnection();
28 try {
29 Statement estatuto = [Link]().createStatement();
30 [Link]("INSERT INTO persona VALUES ('"+[Link]
31 +[Link]()+"', '"+[Link]()+"', '"
32 +[Link]()+"', '"+[Link]()+
33 [Link](null,
[Link] "Se ha registrado Exitosamente"
6/13
20/10/2016 CoDejaVu: Ejemplo Conectando Java con MySql
33 [Link](null, "Se ha registrado Exitosamente"
34 [Link]();
35 [Link]();
36
37 } catch (SQLException e) {
38 [Link]([Link]());
39 [Link](null, "No se Registro la persona");
40 }
41 }
42
43 /**
44 * permite consultar el empleado asociado al documento enviado
45 * como parametro
46 * @param documento
47 * @return
48 */
49 public ArrayList< personavo> consultarPersona(int documento) {
50 ArrayList< personavo> miEmpleado = new ArrayList< personavo>();
51 DbConnection conex= new DbConnection();
52
53 try {
54 PreparedStatement consulta = [Link]().prepareStatement(
55 [Link](1, documento);
56 ResultSet res = [Link]();
57
58 if([Link]()){
59 PersonaVO persona= new PersonaVO();
60 [Link]([Link]([Link]("id")));
61 [Link]([Link]("nombre"));
62 [Link]([Link]([Link]("edad")));
63 [Link]([Link]("profesion"));
64 [Link]([Link]([Link]("telefono"
65 [Link](persona);
66 }
67 [Link]();
68 [Link]();
69 [Link]();
70
71 } catch (Exception e) {
72 [Link](null, "no se pudo consultar la Persona\n"
73 }
74 return miEmpleado;
75 }
76
77 /**
78 * permite consultar la lista de empleados
79 * @return
80 */
81 public ArrayList< personavo> listaDePersonas() {
82 ArrayList< personavo> miEmpleado = new ArrayList< personavo>();
83 DbConnection conex= new DbConnection();
84
85 try {
86 PreparedStatement consulta = [Link]().prepareStatement(
87 ResultSet res = [Link]();
88 while([Link]()){
89 PersonaVO persona= new PersonaVO();
90 [Link]([Link]([Link]("id")));
91 [Link]([Link]("nombre"));
[Link] 7/13
20/10/2016 CoDejaVu: Ejemplo Conectando Java con MySql
91 [Link]([Link]("nombre"));
92 [Link]([Link]([Link]("edad")));
93 [Link]([Link]("profesion"));
94 [Link]([Link]([Link]("telefono"
95 [Link](persona);
96 }
97 [Link]();
98 [Link]();
99 [Link]();
100
101 } catch (Exception e) {
102 [Link](null, "no se pudo consultar la Persona\n"
103 }
104 return miEmpleado;
105 }
106
107 }
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.
1 package [Link];
2
3 import [Link];
4 import [Link];
5 import [Link];
6 import [Link];
7
8
9 public class Principal {
10
11 PersonaDAO miPersonaDAO;
12
13 /**
14 * Método principal, hace el llamado al menú donde se
15 * presentan todas las opciones del sistema
16 * @param args
17 */
18 public static void main(String[]
[Link] args) { 8/13
20/10/2016 CoDejaVu: Ejemplo Conectando Java con MySql
18 public static void main(String[] args) {
19
20 Principal miPrincipal = new Principal();
21 [Link]();
22 }
23
24 /**
25 * Método que permite presentar las opciones del sistema.
26 * solicita el ingreso de un numero y se envia a su
27 * correspondiente proceso
28 */
29 private void verMenu() {
30
31 String textoMenu="Menú Principal\n\n";
32 textoMenu+="Ingrese alguna de las opciones del Menú \n";
33 textoMenu+="1. Registrar Persona\n";
34 textoMenu+="2. Consultar Persona\n";
35 textoMenu+="3. Ver Lista Personas\n";
36 textoMenu+="4. Salir.\n\n";
37
38 try {
39 int seleccion= [Link]([Link](textoMenu));
40 defineSeleccion(seleccion);
41 } catch (NumberFormatException e) {
42 [Link](null,"Error en el ingreso de Datos, "
43 "solo se permiten valores númericos","ERROR",JOptionPane.ERROR_MESSAGE
44 verMenu();
45 } catch (Exception e) {
46 [Link](null,"Error en el ingreso de Datos, "
47 "solo se permiten valores númericos","ERROR",JOptionPane.ERROR_MESSAGE
48 verMenu();
49 }
50 }
51
52 /**
53 * Permite determinar que accion ejecutar dependiendo del parametro de
54 * ingreso correspondiente a las opciones del sistema
55 * @param seleccion
56 */
57 private void defineSeleccion(int seleccion) {
58
59 [Link]("Selecciona "+seleccion);
60
61 switch (seleccion) {
62 case 1:
63 registrarPersona();
64 verMenu();
65 break;
66 case 2:
67 int doc=[Link]([Link]("Ingrese el numero
68 " de documento de la persona"));
69 buscarPersona(doc);
70 verMenu();
71 break;
72 case 3:
73 obtenerRegistros();
74 verMenu();
75 break;
76 case 4:
[Link] 9/13
20/10/2016 CoDejaVu: Ejemplo Conectando Java con MySql
76 case 4:
77 [Link](0);
78 break;
79 default:
80 [Link](null, "Ingrese un " +
81 "numero valido","ADVERTENCIA",JOptionPane.WARNING_MESSAGE);
82 verMenu();
83 break;
84 }
85 }
86
87 /**
88 * Permite solicitar los datos de la persona a registrar, se solicitan med
89 * una ventana de ingreso y se almacenan en un arreglo con toda la informa
90 * para esto un ciclo for, posteriormente estos datos son almacenados en e
91 * atributo correspondiente del objeto persona para ser enviado al metodo
92 * en la clase DAO
93 */
94 private void registrarPersona() {
95 miPersonaDAO = new PersonaDAO();
96 PersonaVO miPersona=new PersonaVO();
97
98 String mensajeIngreso="Ingrese\n\n";
99
100 String datosSolicitados[] = {"Documento : ","Nombre : ",
101 "Edad: ","Profesión: ","Telefono: "};
102 String datosPersona[] = new String[5];
103 for (int i = 0; i < [Link]; i++) {
104 //solicita el ingreso del dato y se almacena en el arreglo de datosPerso
105 datosPersona[i]=[Link](null, mensajeIngreso+
106 datosSolicitados[i],"Datos Persona",JOptionPane.INFORMATION_MESSAGE);
107
108 [Link](datosSolicitados[i]+datosPersona[i]);
109 }
110
111 [Link]([Link](datosPersona[0]));
112 [Link](datosPersona[1]);
113 [Link]([Link](datosPersona[2]));
114 [Link](datosPersona[3]);
115 [Link]([Link](datosPersona[4]));
116
117 [Link](miPersona);
118
119 }
120
121 /**
122 * Permite obtener la lista de personas almacenada en la tabla persona
123 * si la lista se encuentra vacia quiere decir que no hay personas registr
124 * acto seguido se presenta un mensaje en pantalla, sino se imprime la lis
125 * todas las personas registradas en la BD
126 */
127 private void obtenerRegistros() {
128 miPersonaDAO = new PersonaDAO();
129 PersonaVO miPersona;
130
131 //Se obtiene la lista de personas
132 ArrayList< personavo> listaPersonas = [Link]();
133 //se valida si se obtubo o no informacion
134 if ([Link]()>0) {
[Link] 10/13
20/10/2016 CoDejaVu: Ejemplo Conectando Java con MySql
134 if ([Link]()>0) {
135 int numeroPersona=0;
136 //se recorre la lista de personas asignandose cada posicion en un objeto
137 for (int i = 0; i < [Link](); i++) {
138 numeroPersona++;
139 miPersona=[Link](i);
140 [Link]("****************Persona "+numeroPersona+"**********
141 [Link]("Id Persona: "+[Link]());
142 [Link]("Nombre Persona: "+[Link]());
143 [Link]("Edad Persona: "+[Link]());
144 [Link]("Profesión Persona: "+[Link](
145 [Link]("Telefono Persona: "+[Link]())
146 [Link]("*************************************************\n
147 }
148 }else{
149 [Link](null,"Actualmente no " +
150 "existen registros de personas","INFORMACIÓN",JOptionPane.INFORMATION_
151 }
152
153 }
154
155 /**
156 * Permite la consulta de una persona en especifico mediante el envio de
157 * su documento de identidad como parametro, en caso de que no se retorne
158 * informacion se presenta un mensaje en pantalla, sino entonces se imprim
159 * datos de la persona encontrada
160 * @param documento
161 */
162 private void buscarPersona(int documento) {
163 miPersonaDAO = new PersonaDAO();
164 PersonaVO miPersona;
165 ArrayList< personavo> personasEncontrada = [Link](
166 //se valida que se encuentre la persona
167 if ([Link]()>0) {
168 //se recorre la lista y se asignan los datos al objeto para imprimir los
169 for (int i = 0; i < [Link](); i++) {
170 miPersona=[Link](i);
171 [Link]("****************Persona*************************"
172 [Link]("Id Persona: "+[Link]());
173 [Link]("Nombre Persona: "+[Link]());
174 [Link]("Edad Persona: "+[Link]());
175 [Link]("Profesión Persona: "+[Link](
176 [Link]("Telefono Persona: "+[Link]())
177 [Link]("*************************************************\n
178 }
179 }else{
180 [Link](null,"El documento ingresado " +
181 "no corresponde a ninguna persona","INFORMACIÓN",[Link]
182 }
183 }
184 }
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
[Link] 11/13
20/10/2016 CoDejaVu: Ejemplo Conectando Java con MySql
vemos que en el método verMenu() validamos por medio de bloques try
catchlos 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 mysqlconnector 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
[Link] 12/13
20/10/2016 CoDejaVu: Ejemplo Conectando Java con MySql
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....
[Link] 13/13
