KADUM

Modelo Vista Controlador en Java y MySQL. Nivel Básico

 18 noviembre, 2014 ◆  16 comentarios

Conoces los fundamentos de la programación orientada a objetos y has trabajado con bases de
datos. También has implementado interfaces para interactuar con los usuarios de tus aplicaciones.
Pero hasta ahora lo has hecho sin separar metodológicamente cada uno de estos componentes. Si
quieres ir un paso más allá y mejorar en arquitectura software, has llegado al lugar adecuado.
En este ejemplo se tratarán las directrices básicas para afrontar metodología MVC (Modelo – Vista
– Controlador), un modelo maduro que ha demostrado su validez a lo largo de los años en todo tipo
de aplicaciones y sobre multitud de lenguajes y plataformas de desarrollo.
En concreto, en esta guía rápida se empleará como base de datos MySQL y como lenguaje de
programación, Java.

Supuesto Práctico
Se tendrá una base de datos con una tabla donde se almacenará la información de los clientes de
nuestro negocio. Desde una interfaz grá ca, un usuario podrá listar, añadir, modi car o eliminar los
diversos clientes.

La información a almacenar de los clientes será: nombre, apellidos y NIF

Tanto la vista como el controlador estarán implementados en Java mediante Eclipse. Sin embargo,
debido a su simplicidad, el modelo se implementará en MySQL. Se hará uso de procesos
almacenados (stored procedures) en la base de datos.

Debido a que el proyecto Java accederá a una base de datos MySQL, se debe usar un chero .jar que
se encargará de registrar y emplear el driver adecuado para tal conexión. El chero se puede
descargar a través del siguiente enlace (en inglés).
Los temas a tratar, son los siguiente:

 Creación del proyecto

 Codi cación de la clase Bd
 Codi cación de la clase View
 Codi cación de la clase Controller
 Codi cación de la clase Principal
 Creación del modelo
 Prueba del proyecto MVC
 Creación de un ejecutable

Creación del proyecto

Se llevará a cabo la creación de un proyecto Java en Eclipse

 Una vez abierto Eclipse, se debe acceder a File > New > Java Proyect
 En el cuadro de diálogo que aparece, se indica el Project name kadumMVC y se selecciona
JavaSE-1.7 como execution enviroment JRE.
 Crear proyecto KadumMVC

 Se pulsa sobre el botón Next para añadir el chero mysql-connector-java-5.0.8-bin.jar que

previamente se ha debido descargar.
 En el cuadro de diálogo, se selecciona la pestaña Libraries y se pulsa el botón Add External JARs.
 Crear Proyecto – Add jar

 Se busca y se selecciona el chero mysql-connector-java-5.0.8-bin.jar

 Una vez añadido el chero, se pulsa Finish

Una vez creado el proyecto, se procederá a la construcción de las diversas clases que compondrán
nuestro proyecto. En los siguientes apartados, se describirá cómo llevar a cabo esta tarea. Las clases
que se construirán serán:
  Bd. Se encargará de realizar la conexión al servidor MySQL.
 View. Se encargará de la creación de la interfaz grá ca.
 Principal. Contendrá la función main que se encargará de la creación de los objetos necesarios y
de la ejecución de los diversos métodos.
 Controller. Se encargará de recoger los eventos desencadenados por la interfaz grá ca, se los
comunicará a nuestro modelo y actualizará si fuere necesario la interfaz. Como se puede comprobar,
actúa como intermediario entre la vista y el modelo.

Puesto que el modelo se tratará de forma diferente, no se generará ninguna clase para tal n. Como
se indicó anteriormente, el modelo estará implementado en la base de datos MySQL.

Codi cación de la clase Bd

La clase Bd se encargará de realizar la conexión a nuestro servidor. Se tendrán dos métodos, el
constructor y un método que devolverá un objeto de la clase Connection. Dicho objeto se empleará
en la clase Controller.

 Dentro del proyecto creado, se accede al menú File > New > Class
 En el cuadro de diálogo que aparece, tras escribir el nombre de la clase Bd, se pulsa sobre el
botón Finish.
 Clase Bd

 El código de la clase será el siguiente:

1 package kadumMVC;
2
3 import java.sql.Connection;
4 import java.sql.DriverManager;
5 import java.sql.SQLException;
6
7 public class Bd {
8 private String maquina = "localhost";
9 private String usuario = "root";
10 private String clave = "";
11 private int puerto = 3306;
12 private String servidor = "";
 13 private static Connection conexion = null;
14
15 //CONSTRUCTOR
16 //Recibe el nombre de la base de datos
17 Bd(String baseDatos){
18 this.servidor="jdbc:mysql://"+this.maquina+":"+
19 this.puerto+"/"+baseDatos;
20
21 //Registrar el driver
22 try {
23 Class.forName("com.mysql.jdbc.Driver");
24 } catch (ClassNotFoundException e) {
25 System.err.println("ERROR AL REGISTRAR EL DRIVER");
26 System.exit(0); //parar la ejecución
27 }
28
29 //Establecer la conexión con el servidor
30 try {
31 conexion = DriverManager.getConnection(this.servidor,
32 this.usuario, this.clave);
33 } catch (SQLException e) {
34 System.err.println("ERROR AL CONECTAR CON EL SERVIDOR");
35 System.exit(0); //parar la ejecución
36 }
37 System.out.println("Conectado a "+baseDatos);
38 }
39
40 //Devuelve el objeto Connection que se usará en la clase Controlle
41 public static Connection getConexion() {
42 return conexion;
43 }
44
45 }

Se observa que se realizará la conexión a localhost a través del puerto 3306, mediante el usuario
root, el cual no tiene contraseña. En el momento de la creación de un objeto de la clase Bd, se le
indicará el nombre de la base de datos a la que se desea conectar.

Codi cación de la clase View

La clase View se encarga de la generación de la interfaz grá ca de la aplicación. La clase View
extenderá la clase JFrame. Para llevar a la creación de los distintos componentes de la interfaz, se
hará uso de la librería javax.swing. La colocación de los componentes se implementará mediante la
clase SpringLayout
El resultado que se obtendrá será la generación de una ventana como la mostrada a continuación,
donde el usuario podrá ver la relación de clientes almacenados en la base de datos. Tendrá la
posibilidad de añadir nuevos clientes o editar o borrar clientes existentes.
 Ventana Inicial

Componentes

Los componentes que se emplearán son los mostrados en la imagen siguiente:

Componentes

Todos los componentes irán colocados sobre un objeto JPanel.

Las tres etiquetas se de nirán como objetos de la clase JLabel.
Los tres cuadros de texto se de nirán como objetos de la clase JTextField.
Los tres botones se de nirán como objetos de la clase JButton.
Para la construcción de la tabla, se emplearán varios elementos:

 Un objeto JScrollPane.
 En el interior del objeto JScrollPane, se colocará un objeto de la clase JTable, el cual representa la
tabla propiamente dicha.
 La tabla se construirá a partir de un elemento JDefaultTableModel, el cual unirá la cabecera de
la tabla con el cuerpo de la tabla propiamente dicho.
 Para la cabecera de la tabla, se empleará un array de cadenas de caracteres – String[].
 Para el cuerpo propiamente dicho, se empleará una matriz de Object – Object[][].

Posiciones de los componentes

Tal y como se ha comentado, las posiciones de los componentes se realizarán mediante la función
putConstraint() de la clase SpringLayout.
Dicha función recibe 5 parámetros:

putConstraint(lado, delComponente, separado, delLado, deOtroComponente)

 Los dos primeros parámetros (lado, delComponente) hacen referencia a uno de los 4 lados de un
componente en concreto.
 El tercer parámetro (separado) indica la separación en píxeles que se desea tener respecto a… Es
aquí donde entran en función el cuarto y quinto parámetro.
 Los dos últimos parámetros (delLado, deOtroComponente), indican respecto a qué lado de qué
componente se desea realizar la separación indicada.

El valor para los parámetros 1 y 4 podrán ser NORTH, SOUTH, EAST, WEST.
El valor para la separación podrá ser positivo o negativo. Cuando el 4 parámetro sea SOUTH o
WEST, en nuestro caso, las cantidades serán negativas, ya que se toma como referencia el
contenedor.
Para más información de la función putConstraint, visitar el enlace siguiente en inglés:

Por simplicidad, todos los componentes se separarán una cantidad de píxeles en función del
contenedor principal.
 Posición – JLabels

Se observa la separación de las tres etiquetas respecto al contenedor principal.

Componentes NORTH WEST

Etiqueta para el nombre 10 px 10 px
Etiqueta para los apellidos 50 px 10 px
Etiqueta para el NIF 90 px 10 px

Para el caso de los cuadros de texto, las separaciones serán:

Componentes NORTH WEST EAST

Cuadro de texto para el nombre 10 px 100 px 300 px
Cuadro de texto para los apellidos 50 px 100 px 300 px
Cuadro de texto para el NIF 90 px 100 px 300 px

Para el JScrollPane (que contendrá en su interior la tabla)

Componentes NORTH WEST EAST SOUTH

JScrollPane 120 px 10 px -10 px -50 px

Por último, para el caso de los botones:

Componentes SOUTH WEST

Botón Añadir -10 px 60 px
Botón Borrar -10 px 190 px
 Componentes SOUTH WEST
Botón Editar -10 px 310 px

Eventos

La interfaz debe comunicarse con el futuro controlador (clase Controller) cuando el usuario pulse
sobre los botones Añadir, Borrar o Editar, además de cuando pulse sobre una la de la tabla.

Para los botones se empleará el método addActionListener. Para que el controlador pueda
distinguir qué botón se ha pulsado, también se empleará el método setActionCommand.
Para la tabla se usará el método addMouseListener. El controlador actuará cuando se haga click
sobre una la.

Se observa que no se añadirán las acciones a realizar, simplemente cuándo se realizan.

Código

Se está en disposición para la creación de la clase View.

En el constructor se crearán los componentes de la interfaz y en el método conectaControlador, la
de nición de los eventos.
De forma análoga a la creación de la clase anterior:

 Dentro del proyecto creado, se accede al menú File > New > Class
 En el cuadro de diálogo que aparece, tras escribir el nombre de la clase View, se seleccionará la
superclass.
 Se debe pulsar sobre el botón Browser asociado a Superclass. En el cuadro de diálogo que
aparece, se escribe JFrame y se selecciona la sugerencia aportada por Eclipse.
 Por último, se pulsa sobre el botón Finish.
 Clave View

El código de la clase será el siguiente.

Si se copia el código, se observa que el parámetro de entrada del método conectaControlador genera
un error, ya que la clase Controller aún no está de nida.

1 package kadumMVC;
2
3 import javax.swing.JFrame;
4 import javax.swing.JPanel;
5 import javax.swing.SpringLayout;
6 import javax.swing.JLabel;
7 import javax.swing.JTextField;
8 import javax.swing.JButton;
9 import javax.swing.JScrollPane;
10 import javax.swing.table.DefaultTableModel;
11 import javax.swing.JTable;
12
13 public class View extends JFrame {
14
15 /**************** ATRIBUTOS ***************************/
16 //CONTENEDOR PRINCIPAL
17 private JPanel contenedor;
18
19 //DEFINICIÓN DE LAS ETIQUETAS
20 private JLabel lblNombre;
21 private JLabel lblApellido;
22 private JLabel lblNIF;
23
24 //DEFINICIÓN DE LOS CUADROS DE TEXTO
25 protected JTextField txtNombre;
26 protected JTextField txtApellido;
27 protected JTextField txtNIF;
28
29 //DEFINICIÓN DE LOS BOTONES
30 protected JButton btnAdd;
31 protected JButton btnDel;
32 protected JButton btnUpd;
33
34 //DEFINICIÓN DE LOS OBJETOS PARA LA TABLA
35 private JScrollPane scroll; //Panel de scroll que contiene la ta
36 protected Object[][] datos; //Cuerpo de la tabla
37 protected String[] cabecera; //Cabecera de la tabla
38 protected DefaultTableModel dtm;//Unión de la cabecera y la tabl
39 protected JTable tabla; //Tabla propiamente dicha
40
41 /**************** MÉTODOS ***************************/
42 //CONSTRUCTOR
43 View(){
44 //Métodos de la JFrame
45 setBounds(100, 100, 450, 300);//Definir las dimensiones de l
46 setTitle("GESTIÓN DE CLIENTES - KADUM"); //Barra de títul
47 setDefaultCloseOperation(EXIT_ON_CLOSE); //Acción al puls
48
49 //CREAR EL CONTENEDOR PRINCIPAL Y AÑADIRLO A LA VENTANA
50 contenedor = new JPanel();
51 getContentPane().add(contenedor);
52
53 //INDICAR QUE SE QUIERE USAR SPRINGLAYOUT
54 SpringLayout sp = new SpringLayout();
55 contenedor.setLayout(sp);
56
57 //Vamos al lío
58 /**************** BOF ETIQUETAS vvvvvvvvvvvvvvvv **/
59 //ETIQUETA NOMBRE
60 lblNombre = new JLabel("Nombre:"); //Crear el objeto
61 contenedor.add(lblNombre); //Añadirlo al contenedor
62 sp.putConstraint(SpringLayout.NORTH, lblNombre, 10,
63 SpringLayout.NORTH, contenedor);
64 sp.putConstraint(SpringLayout.WEST, lblNombre, 10,
65 SpringLayout.WEST, contenedor);
66 //ETIQUETA APELLIDOS
 67 lblApellido = new JLabel("Apellidos:");
68 contenedor.add(lblApellido);
69 sp.putConstraint(SpringLayout.NORTH, lblApellido, 50,
70 SpringLayout.NORTH, contenedor);
71 sp.putConstraint(SpringLayout.WEST, lblApellido, 10,
72 SpringLayout.WEST, contenedor);
73 //ETIQUETA NIF
74 lblNIF = new JLabel("NIF:");
75 contenedor.add(lblNIF);
76 sp.putConstraint(SpringLayout.NORTH, lblNIF, 90,
77 SpringLayout.NORTH, contenedor);
78 sp.putConstraint(SpringLayout.WEST, lblNIF, 10,
79 SpringLayout.WEST, contenedor);
80 /**************** EOF ETIQUETAS ^^^^^^^^^^^^^^^^ **/
81
82 /**************** BOF CUADROS DE TEXTO vvvvvvvvv **/
83 //CUADRO DE TEXTO PARA EL NOMBRE
84 txtNombre = new JTextField();
85 contenedor.add(txtNombre);
86 sp.putConstraint(SpringLayout.NORTH, txtNombre, 10,
87 SpringLayout.NORTH, contenedor);
88 sp.putConstraint(SpringLayout.WEST, txtNombre, 100,
89 SpringLayout.WEST, contenedor);
90 sp.putConstraint(SpringLayout.EAST, txtNombre, 300,
91 SpringLayout.WEST, contenedor);
92 //CUADRO DE TEXTO PARA EL NIF
93 txtApellido = new JTextField();
94 contenedor.add(txtApellido); //añadir al contenedor
95 sp.putConstraint(SpringLayout.NORTH, txtApellido, 50,
96 SpringLayout.NORTH, contenedor);
97 sp.putConstraint(SpringLayout.WEST, txtApellido, 100,
98 SpringLayout.WEST, contenedor);
99 sp.putConstraint(SpringLayout.EAST, txtApellido, 300,
100 SpringLayout.WEST, contenedor);
101 //CUADRO DE TEXTO PARA LOS APELLIDOS
102 txtNIF = new JTextField();
103 contenedor.add(txtNIF);
104 sp.putConstraint(SpringLayout.NORTH, txtNIF, 90, SpringLayou
105 sp.putConstraint(SpringLayout.WEST, txtNIF, 100, SpringLayou
106 sp.putConstraint(SpringLayout.EAST, txtNIF, 300, SpringLayou
107 /**************** EOF CUADROS DE TEXTO ^^^^^^^^^ **/
108
109 /**************** BOF TABLA vvvvvvvvvvvvvvvvvvvv **/
110 scroll = new JScrollPane();
111 cabecera = new String[] {"ID","NOMBRE","NIF"};
112 dtm = new DefaultTableModel(datos,cabecera);
113 tabla = new JTable(dtm);
114 scroll.setViewportView(tabla);
115 //y ahora se coloca el scrollpane...
116 contenedor.add(scroll); //añadir al contenedor
117 sp.putConstraint(SpringLayout.NORTH, scroll, 120,
118 SpringLayout.NORTH, contenedor);
119 sp.putConstraint(SpringLayout.WEST, scroll, 10,
120 SpringLayout.WEST, contenedor);
121 sp.putConstraint(SpringLayout.EAST, scroll, -10,
122 SpringLayout.EAST, contenedor);
123 sp.putConstraint(SpringLayout.SOUTH, scroll, -50,
 124 SpringLayout.SOUTH, contenedor);
125 /**************** EOF TABLA ^^^^^^^^^^^^^^^^^^^^ **/
126
127 /**************** BOF BOTONES vvvvvvvvvvvvvvvvvv **/
128 //BOTÓN AÑADIR
129 btnAdd = new JButton("Añadir");
130 contenedor.add(btnAdd);
131 sp.putConstraint(SpringLayout.SOUTH, btnAdd, -10,
132 SpringLayout.SOUTH, contenedor);//colocarlo
133 sp.putConstraint(SpringLayout.WEST, btnAdd, 60,
134 SpringLayout.WEST, contenedor);
135 //BOTÓN BORRAR
136 btnDel = new JButton("Borrar");
137 contenedor.add(btnDel);
138 sp.putConstraint(SpringLayout.SOUTH, btnDel, -10,
139 SpringLayout.SOUTH, contenedor);
140 sp.putConstraint(SpringLayout.WEST, btnDel, 190,
141 SpringLayout.WEST, contenedor);
142 //BOTÓN MODIFICAR
143 btnUpd = new JButton("Editar");
144 contenedor.add(btnUpd);
145 sp.putConstraint(SpringLayout.SOUTH, btnUpd, -10,
146 SpringLayout.SOUTH, contenedor);
147 sp.putConstraint(SpringLayout.WEST, btnUpd, 310,
148 SpringLayout.WEST, contenedor);
149 /**************** EOF BOTONES ^^^^^^^^^^^^^^^^^^^^ **/
150
151 //Se hace visible la ventana
152 setVisible(true);
153
154 }
155
156 public void conectaControlador( Controller c ){
157
158 btnAdd.addActionListener(c);
159 btnAdd.setActionCommand("INSERTAR");
160
161 btnDel.addActionListener(c);
162 btnDel.setActionCommand("BORRAR");
163
164 btnUpd.addActionListener(c);
165 btnUpd.setActionCommand("MODIFICAR");
166
167 tabla.addMouseListener(c);
168 //sólo se permite pulsar una fila a la vez.
169 tabla.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
170 }
171 }

Se observa que en el constructor, los objetos que se construyen siguen cierto patrón. A modo de
detalle, nos centramos en la construcción del cuadro de texto para el nombre:

1 //CUADRO DE TEXTO PARA EL NOMBRE

2 txtNombre = new JTextField();
3 contenedor.add(txtNombre);
 4 sp.putConstraint(SpringLayout.NORTH, txtNombre, 10,
5 SpringLayout.NORTH, contenedor);
6 sp.putConstraint(SpringLayout.WEST, txtNombre, 100,
7 SpringLayout.WEST, contenedor);
8 sp.putConstraint(SpringLayout.EAST, txtNombre, 300,
9 SpringLayout.WEST, contenedor);

Por motivos de claridad en el código, se ha omitido la referencia mediante this.

En la primera línea se construye el objeto, de nido previamente.

1 txtNombre = new JTextField();

El objeto creado, se añade al contenedor principal.

1 contenedor.add(txtNombre);

Mediante el empleo de la función putConstraint del objeto sp (de la clase SpringLayout) se posiciona
el objeto txtNombre en el contenedor.
Primero se posiciona el lado norte:

1 sp.putConstraint(SpringLayout.NORTH, txtNombre, 10,

2 SpringLayout.NORTH, contenedor);

A continuación, el lado oeste:

1 sp.putConstraint(SpringLayout.WEST, txtNombre, 100,

2 SpringLayout.WEST, contenedor);

y por último, el este:

1 sp.putConstraint(SpringLayout.EAST, txtNombre, 300,

2 SpringLayout.WEST, contenedor);

Puede resultar curioso que primero se añade al contenedor principal y posteriormente, se

posiciona. Se obtendría el mismo resultado si tras la construcción del objeto, se posicionara y por
último, se añadiera al contenedor.

En el método conectaControlador, se indica que al pulsar los botones se desea que se realice una
acción, que vendrá de nida en la clase Controller.

Para que Controller sepa qué botón se ha pulsado, se emplea el método setActionCommand.

 Para el botón añadir, se le asocia el comando INSERTAR

 Para borrar, se le asocia BORRAR
 Para editar, MODIFICAR
 

Codi cación de la clase Controller

La clase Controller se encarga de la comunicación entre la interfaz grá ca y la base de datos, el
modelo.

Cuando el usuario interactúe con la Vista, desencadenará la ejecución de ciertos eventos que serán
recogidos por el Controlador y lanzados al Modelo. Cuando el modelo devuelva la información, se
actualizará la interfaz. Por ese motivo, la clase controlador tendrá un objeto de la clase View.

Puesto que debe codi car eventos de ratón y de acción, la clase implementará dos interfaces de
Java, así se simulará la herencia múltiple en Java. Las interfaces que se implementarán serán:
ActionListener, MouseListener

Nota: No se debe confundir el concepto de interfaz de Java (se podría considerar como una clase
abstracta) con la idea de interfaz grá ca de usuario (cuya creación se ha llevado a cabo en el
apartado anterior).

Cuando se realice la implementación de la interfaz ActionListener, se tendrá que sobrescribir

obligatoriamente el método actionPerformed.

Al realizar la implementación de la interfaz MouseListener, se tendrán que sobrescribir

obligatoriamente varios métodos: mouseClicked, mouseEntered, mouseExited, mousePressed y
mouseReleased. En nuestro caso, sólo se añadirá código en el primer método, sin embargo, la
declaración del resto de métodos es obligatoria.

actionPerformed

Este método se ejecutará cuando el usuario pulse sobre alguno de los tres botones de la Ventana,
tal y como se especi có en el método conectaControlador de la clase View.
En función del comando que se ejecute:

 INSERTAR
 BORRAR
 MODIFICAR

Se llamará a un procedimiento almacenado en la base de datos. Se ha decidido implementar el

modelo como procedimientos almacenados en la base de datos.
Para ejecutar los procedimientos almacenados, se empleará la interfaz CallableStatement dentro de
java.sql

Se usará el método prepareCall para invocar a los procedimientos almacenados. Dicho

procedimiento pertenece a la interfaz Connection. Se obtendrá un objeto de dicha interfaz mediante
la invocación al método estático getConexion de nido en nuestra clase Bd.

Cada vez que el usuario pulse un botón, se limpiarán los cuadros de texto de la ventana (método
limpia) y se volcarán los datos existentes en la tabla de clientes en el objeto JTable creado en la clase
View (método cargaTabla).

mouseClicked

Este método se ejecutará cuando el usuario pulse sobre una la de la tabla.

Cuando se pulse sobre una la, se invocará a un procedimiento almacenado de la base de datos que
obtiene el nombre, apellido y NIF del cliente marcado y cargará los datos en los cuadros de texto de
la ventana.

Para obtener la información devuelta por el procedimiento almacenado, se hará uso de la interfaz
ResultSet.

El resto de métodos cuya de nición es obligatoria al implementar la interfaz MouseListener, no

contendrán código alguno.

Código

En el constructor se realizará la vinculación entre el controlador y la ventana. A continuación, se

invocará el método cargaTabla, el cual se encarga de añadir la información de la base de datos a la
ventana.

Se creará la clase Controller:

 Dentro del proyecto creado, se accede al menú File > New > Class
 En el cuadro de diálogo que aparece, tras escribir el nombre de la clase Controller, se
seleccionarán las interfaces a implementar.
 Se debe pulsar sobre el botón Add asociado a Interfaces. En el cuadro de diálogo que aparece, se
buscarán y añadirán ActionListener y MouseListener.
 Por último, se pulsa sobre el botón Finish.
 Clase Controller

El código de la clase será el siguiente.

1 package kadumMVC;
2
3 import java.awt.event.ActionEvent;
4 import java.awt.event.ActionListener;
5 import java.awt.event.MouseEvent;
6 import java.awt.event.MouseListener;
7 import java.sql.CallableStatement;
8 import java.sql.ResultSet;
9 import java.sql.SQLException;
10 import java.util.Vector;
11
12 public class Controller implements ActionListener,
13 MouseListener {
14 private View view;
15
16 //CONSTRUCTOR
17 Controller( View view ){
18 this.view = view;
19 cargarTabla();
20 }
21
22 @Override
23 public void actionPerformed(ActionEvent arg0) {
24 //Objeto para ejecutar los procedimientos almacenados
25 // en la base de datos
26 CallableStatement cs;
27
28 //COMANDO EJECTUADO
29 String comando = arg0.getActionCommand();
30
31 //Deberá coincidir con alguno de los parámetros
32 // indicados en setActionCommand invocado en la
33 // clase View
34 switch (comando) {
35 case "INSERTAR":
36 try{
37 //Preparar la llamada
38 cs = Bd.getConexion().prepareCall(
39 "{CALL insertarCliente(?,?,?)}");
40 //Indicar qué información se pasa al
41 // procedimiento
42 cs.setString(1,
43 this.view.txtNombre.getText());
44 cs.setString(2,
45 this.view.txtApellido.getText());
46 cs.setString(3,
47 this.view.txtNIF.getText());
48 //Ejecutar el procedimiento
49 cs.execute();
50 }catch (SQLException e) {
51 System.err.println("Error en la INSERCIÓN");
52 }
53
54 break;
55
56 case "BORRAR":
57 //Recoger qué fila se ha pulsado
58 int filaPulsada = this.view.tabla.getSelectedRow();
59 //Si se ha pulsado una fila
60 if(filaPulsada>=0){
61 //Se recoge el id de la fila marcada
62 int identificador = (int)this.view.dtm.getValu
63 try{
64 //Preparar la llamada
65 cs = Bd.getConexion().prepareCall(
66 "{CALL borrarCliente(?)}");
67 //Indicar qué información se pasa al procedi
68 cs.setInt(1, identificador);
69 //Ejecutar el procedimiento
 70 cs.execute();
71 //System.out.println(this.view.dtm.getValueA
72 }catch (SQLException e) {
73 System.err.println("Error en el BORRADO");
74 }
75 }
76
77 break;
78
79 case "MODIFICAR":
80 //Recoger qué fila se ha pulsadao en la tabla
81 filaPulsada = this.view.tabla.getSelectedRow();
82 //Si se ha pulsado una fila
83 if(filaPulsada>=0){
84 //Se recoge el id de la fila marcada
85 int identificador = (int)this.view.dtm.getValu
86 try{
87 //Preparar la llamada
88 cs = Bd.getConexion().prepareCall(
89 "{CALL modificarCliente(?,?,?,?)}");
90 //Indicar qué información se pasa al procedi
91 cs.setInt(1, identificador);
92 cs.setString(2,
93 this.view.txtNombre.getText());
94 cs.setString(3,
95 this.view.txtApellido.getText());
96 cs.setString(4,
97 this.view.txtNIF.getText());
98 //Ejecutar el procedimiento
99 cs.execute();
100 //System.out.println(this.view.dtm.getValueA
101 }catch (SQLException e) {
102 System.err.println("Error en la MODIFICACION
103 }
104 }
105 break;
106
107 default:
108 System.err.println("Comando no definido");
109 break;
110 }
111 //limpiar el formulario
112 limpia();
113
114 //refrescar la tabla
115 cargarTabla();
116 }
117
118 //Método para limpiar los campos de la ventana
119 private void limpia(){
120 this.view.txtNombre.setText("");
121 this.view.txtApellido.setText("");
122 this.view.txtNIF.setText("");
123 }
124
125 //Método que recarga los datos de la tabla de la base de datos
126 // en la tabla de la clase View
127 protected void cargarTabla(){
128 //Objeto para ejecutar los procedimientos almacenados en la
129 CallableStatement cs;
130 //Objeto para recoger los datos devueltos por el procedimien
131 ResultSet rs;
132 //Objeto para recorrer el resultado del procedimiento almace
133 // añadirlo a la tabla definida en la clase View
134 Vector<Object> fila;
135
136 //Limpiar los datos de la tabla
137 for(int i=this.view.dtm.getRowCount(); i>0; i--){
138 this.view.dtm.removeRow(i-1);
139 }
140
141 //Cargar datos en la tabla
142 try {
143 //Preparar la llamada
144 cs = Bd.getConexion().prepareCall(
145 "{CALL getClientes()}");
146 //Ejecutarla y recoger el resultado
147 rs = cs.executeQuery();
148 //Recorrer el resultado
149 while(rs.next()){
150 //Añadir registro a registro en el vector
151 fila = new Vector<Object>();
152 fila.add(rs.getInt("id"));
153 fila.add(rs.getString("nombre"));
154 fila.add(rs.getString("nif"));
155 //Añadir el vector a la tabla de la clase View
156 this.view.dtm.addRow(fila);
157 }
158
159 } catch (SQLException e) {
160 System.err.println("Error al CARGAR DATOS");
161 }
162 }
163
164 @Override
165 public void mouseClicked(MouseEvent arg0) {
166 //Objeto para ejecutar los procedimientos almacenados en la
167 CallableStatement cs;
168 //Objeto para recoger los datos devueltos por el procedimien
169 ResultSet rs;
170
171 //Recoger qué fila se ha pulsadao en la tabla
172 int filaPulsada = this.view.tabla.getSelectedRow();
173 //Si se ha pulsado una fila
174 if(filaPulsada>=0){
175 //Se recoge el id de la fila marcada
176 int identificador= (int)this.view.dtm.getValueAt(
177 filaPulsada, 0);
178 try{
179 //Preparar la llamada
180 cs = Bd.getConexion().prepareCall(
181 "{CALL getCliente(?)}");
182 //Indicar qué información se pasa al procedimiento
183 cs.setInt(1, identificador);
 184 //Ejecutar el procedimiento
185 rs = cs.executeQuery();
186 //Cargar los datos devueltos en los cuadros de texto
187 if(rs.next()){
188 this.view.txtNombre.setText(rs.getString(1));
189 this.view.txtApellido.setText(rs.getString(2));
190 this.view.txtNIF.setText(rs.getString(3));
191 }
192 //System.out.println(this.view.dtm.getValueAt(filaPu
193 }catch (SQLException e) {
194 System.err.println("Error al CARGAR UN CLIENTE");
195 }
196 }
197 }
198
199 @Override
200 public void mouseEntered(MouseEvent arg0) {}
201 @Override
202 public void mouseExited(MouseEvent arg0) {}
203 @Override
204 public void mousePressed(MouseEvent arg0) {}
205 @Override
206 public void mouseReleased(MouseEvent arg0) {}
207 }

Nota: No se ha entrado en detalle en el control de la congruencia de los datos. Por ejemplo, no se

veri ca que un cliente ya exista en la base de datos antes de insertarlo. Tampoco se controla la
letra de su NIF.

Codi cación de la clase Principal

Ya se tienen de nidas las clases en Java que se usarán; se necesita generar una clase que contenga el
procedimiento main que se encargue de construir los objetos necesarios.

En eclipse:

 Dentro del proyecto creado, se accede al menú File > New > Class
 En el cuadro de diálogo que aparece, tras escribir el nombre de la clase Principal, se marca el
checkbox correspondiente a public static void main
 Por último, se pulsa sobre el botón Finish.
 Clase Principal

El código de esta clase es:

1 package kadumMVC;
2
3 public class Principal {
4 public static void main(String[] args) {
5 //Invocar al constructor de la clase Bd
6 new Bd("kadummvc");
7 //Crear un objeto de la clase View
8 View vista = new View();
9 //Crear un objeto de la clase Controller
10 Controller controlador = new Controller(vista);
11 //Vincular la vista y el controlador
12 vista.conectaControlador(controlador);
 13
14 }
15 }

Como nota, observar que se realiza la vinculación entre la clase Controller y View en dos sentidos.

 En la construcción del objeto controlador, se pasa como parámetro el objeto vista.

 Se invoca a un método de la clase vista, que recibe como parámetro el objeto controlador.

Creación del modelo

El modelo se implementará, no como clases en Java, sino como procedimientos almacenados
(stored procedures) en la base de datos MySQL de nuestro proyecto.

 Se crea la base de datos kadummvc. Como se observa, es el mismo nombre que recibe como
parámetro de entrada la invocación al constructor Bd en la clase Principal.
 Se crea la tabla cliente. Con los campos id, nombre, apellido y NIF

1 CREATE TABLE `cliente` (

2 `id` int(10) NOT NULL AUTO_INCREMENT,
3 `nombre` varchar(50) DEFAULT NULL,
4 `apellido` varchar(50) DEFAULT NULL,
5 `nif` varchar(10) DEFAULT NULL,
6 PRIMARY KEY (`id`)
7 );

 A continuación, se crean los 5 procedimientos almacenados invocados desde la clase Controller:

 borrarCliente. Recibe un entero como parámetro de entrada. Representa el identi cador del
cliente a eliminar.
 getCliente. Recibe un entero como parámetro de entrada. Representa el identi cador del
cliente a cargar. Se obtiene el nombre, apellido y NIF de dicho cliente.
 getClientes. No recibe parámetros de entrada. Se obtiene el identi cador, nombre y NIF de
todos los clientes de la tabla ordenados por nombre.
 insertarCliente. Recibe como parámetros de entrada el nombre, apellido y NIF del cliente a
insertar.
 modi carCliente. Recibe como parámetro de entrada el identi cador del cliente a modi car,
el nuevo nombre, apellido y NIF.

Los códigos de los procedimientos almacenados (stored procs) son:

1 #BORRAR CLIENTE POR ID

2 DELIMITER $$
3 DROP PROCEDURE IF EXISTS borrarCliente$$
4 CREATE PROCEDURE borrarCliente(id INT(10))
5 BEGIN
6 DELETE FROM cliente
 7 WHERE cliente.id = id;
8 END
9 $$
10
11 #OBTENER EL NOMBRE, APELLIDO Y NIF DE UN CLIENTE
12 DELIMITER $$
13 DROP PROCEDURE IF EXISTS getCliente$$
14 CREATE PROCEDURE getCliente(id INT(10))
15 BEGIN
16 SELECT nombre, apellido, nif
17 FROM cliente
18 WHERE cliente.id= id;
19 END
20 $$
21
22 #OBTENER EL ID, NOMBRE Y NIF DE TODOS LOS CLIENTES
23 DELIMITER $$
24 DROP PROCEDURE IF EXISTS getClientes$$
25 CREATE PROCEDURE getClientes()
26 BEGIN
27 SELECT id, nombre, nif
28 FROM cliente
29 ORDER BY nombre;
30 END
31 $$
32
33 #INSERTAR UN CLIENTE
34 DELIMITER $$
35 DROP PROCEDURE IF EXISTS insertarCliente$$
36 CREATE PROCEDURE insertarCliente(nombre VARCHAR(50),
37 apellido VARCHAR(50),
38 nif VARCHAR(10))
39 BEGIN
40 INSERT INTO cliente
41 VALUES(NULL,nombre,apellido,nif);
42 END
43 $$
44
45 #MODIFICAR CLIENTE POR ID
46 DELIMITER $$
47 DROP PROCEDURE IF EXISTS modificarCliente$$
48 CREATE PROCEDURE modificarCliente(id INT(10),
49 nombre VARCHAR(50),
50 apellido VARCHAR(50),
51 nif VARCHAR(10))
52 BEGIN
53 UPDATE cliente
54 SET cliente.nombre = nombre,
55 cliente.apellido= apellido,
56 cliente.nif = nif
57 WHERE cliente.id= id;
58
59 END
60 $$
Una vez compilados los códigos en nuestra base de datos, sólo queda cruzar los dedos (:-) y probar
el proyecto.

Prueba del proyecto MVC

Ya se tienen creadas las clases en Java, la base de datos en MySQL con su tabla y procedimientos
almacenados.

Relación de cheros

Base de Datos

 Se debe acceder en Eclipse a la clase Principal que contiene la función main y ejecutarla,
pulsando la tecla F11.
Se mostrará un mensaje en la consola indicando que se ha conectado a la base de datos kadummvc,
tal y como se especi có en la creación del objeto bd dentro de la clase Principal.
Y aparecerá la ventana en las coordenadas 100, 100 con un tamaño de 450×300 tal y como se
especi có en el constructor de la clase View.

Ejecución

Añadir clientes

 Se rellenan los campos de texto.

 Rellenar campos

 Se pulsa Añadir.
 Se añadirá la información a la base de datos, se limpiarán los campos de texto y se re ejará en la
tabla el cliente insertado.

Insertado

Modi car clientes

 Para modi car un cliente, se pulsa sobre la la del registro a modi car. De esa forma, se cargan
los datos para ese cliente.
 Se reescribe la información correctamente y se pulsa sobre Editar.
 Seleccionar y editar

 Se realizará la modi cación en la base de datos, se limpian los campos de texto y se actualiza la
tabla de la ventana.

Borrar clientes

 Para eliminar un cliente que no sea de nuestro cuento, se pulsa sobre la la del registro a borrar.
Se cargarán sus datos en los cuadros de texto.
 Se pulsa sobre Borrar.
 Seleccionar para borrar

 Se eliminará de la base de datos, se limpian los cuadros de texto y se re eja la eliminación en la

tabla de la ventana.

Borrado

Creación de un ejecutable
Una vez comprobada que la aplicación funciona según lo previsto, se lleva a cabo la construcción del
chero ejecutable en Eclipse.

 Acceder a File > Export…

 En el cuadro de diálogo que aparece, desplegar la carpeta Java y marcar Runnable JAR le
 Ejecutable runnable

 Tras pulsar Next, se mostrará un cuadro de diálogo donde se con gura qué clase es la que
contiene el método main que interesa ejecutar. Dónde se desea almacenar el ejecutable y la opción
de incluir las bibliotecas necesarias en el chero ejecutable.

Crear ejecutable (.jar)

  Se pulsa Finish y se obtendrá un chero .jar ejecutable

Antes de nalizar esta guía básica sobre MVC en Java y MySQL me gustaría, por un lado, agradecer
la paciencia de mis alumnos/as del curso de Programación de Aplicaciones Orientadas a Objetos y
Administración de Bases de Datos, por la tardanza en nalizar este artículo; y por otro lado, si os ha
resultado útil esta guía y deseáis acceder directamente a los archivos que componen la explicación,
te pedimos que te hagas seguidor de nuestro Facebook pulsando sobre la parte izquierda (el icono
de la  F) del siguiente botón:

  

Tags: java ◆ mysql

Volver al blog

 Ant Sig 

Comentarios (16)

N00b dijo:
 16 abril, 2015 a las 6:05 pm

Código fuente disponible para descargar?

Kadum dijo:
16 junio, 2015 a las 3:54 pm

Para acceder al código fuente, debes hacerte seguidor de Kadum desarrollo web en facebook
pulsando sobre el botón que aparece al nal del artículo.
Si no ves el botón, quizás no tengas una versión adecuada del navegador o, lo que es más probable,
emplees extensiones-complementos tipo AdBlockPlus. En este último caso, deberías deshabilitar el
complemento para poder ver el botón.

John dijo:
14 octubre, 2015 a las 5:25 pm

Exelente programa !!
solo tengo una pregunta ?
Como podria hacer un procedimiento para buscar un cliente mediante el id me muestre los datos
para posteriormente modi carlo o eliminarlo..
Espero su pronta respusta..
muchas gracias..
Saludos!!

Jose dijo:
15 octubre, 2015 a las 10:51 am

Hola John:
Muchas gracias por tu comentario. La respuesta a tu pregunta es lo su cientemente
amplia como para responderte creando un nuevo artículo al respecto. En este enlace
puedes ver la ampliación necesaria para ltrar clientes por id.
Espero que te sea de ayuda.

John dijo:
21 febrero, 2016 a las 9:43 am
 Muchas gracias!!!
Me sirvió bastante y justo ahora me encuentro realizando una aplicación
utilizando lo aprendido,nuevamente reitero mis agradecimientos por
compartir sus conocimientos.
Espero y sigan publicando contenido de programación.
Saludos!!

Laura dijo:
22 febrero, 2016 a las 1:22 pm

¡Muchas gracias por leernos!

Si nos sigues en las redes sociales, cuando publicamos
artículos nuevos, los enlazamos. Así podéis estar al día.

Un saludo

jesus dijo:
23 enero, 2016 a las 6:28 pm

Eres un crack hermano muy buen tuto

Jose dijo:
4 febrero, 2016 a las 8:21 pm

Muchas gracias Jesús por tu apoyo.

RaGuAngel dijo:
14 abril, 2016 a las 1:18 am

Muy buen trabajo.

Tengo unas preguntas, ¿como trabajaría el proyecto usando Maven ? ¿El ejemplo corre con la GUI en
Linux Red Hat?

Laura dijo:
15 abril, 2016 a las 6:45 am
 Hola, RaGuAngel:
Gracias por tu comentario. Lamentablemente no podemos ayudarte a responder tus
preguntas porque no hemos trabajado hasta el momento con Maven.

RaGuAngel dijo:
18 abril, 2016 a las 5:16 pm

Gracias Laura, de todas maneras estaré al pendiente del blog para seguir
aprendiendo y seguire investigando como trabajarlo con MAVEN y
cuando le de al clavo, lo comparto en el blog.

Saludos. XD

David dijo:
28 noviembre, 2016 a las 9:08 am

Hola gracias por compartir el tutorial.

Quiero saber como debo de gestionar varias ventanas con MVC,, por ejemplo si tuviera un menu
una ventana principal y quiero que dentro de la misma me muestre diferentes contenidos. Lo debo
de hacer en el controlador de esa ventana principal con el actionListener o lo hago en el main de la
aplicacion,

Uso frame o panel?

Muchas gracias por su ayuda, si tiene algun codigo o link para ver el ejemplo seria perfecto.

Laura dijo:
7 diciembre, 2016 a las 5:12 pm

Hola, David:
Muchas gracias por tu valoración positiva de este tutorial.
Hemos estado entretenidos entregando un proyecto de web multi-idioma y siguiendo el
Joomla days de Granada. A ver si disfrutamos pronto de este evento en Córdoba
El caso, que te respondo algo tarde con ando en que la respuesta te sea útil.

Para continuar con la estructura MVC, lo idóneo es llevar a cabo la gestión de los
elementos del menú en el Controlador que implementa el ActionListener. Si se añadiera
en el main, ya no estariamos haciendo uso de de la metología MVC.
 Respecto al uso de frame o panel para mostrar las distintas pantallas.
Se tendrían varias alternativas pero pasan por tener un único JFrame. Si optaras por
utilizar varios Jframe, en la barra de tareas del sistema operativo se abrirían diversas
ventanas (tantas como JFrame instanciados), por lo que di cultaría la usabilidad. Así
pues:

 Se podría tener un JFrame con distintos JPanel como contenedores.

 O bien, un JFrame con un JDestokPane y varios JInternalFrame donde tener el
contenido.

Nos parece muy interesante tu pregunta, por lo que hemos decidido preparar otro
tutorial donde se explique cómo utilizar las clases JMenuBar, JMenu y JMenuItem para
la generación de un menú integrando distintos JInternalFrame donde mostrar
contenidos diferentes.
Si te interesa el tema, publicaremos en la web y en las redes sociales el enlace cuando
esté terminado, así que te recomendamos que nos sigas.

https://www.facebook.com/kadumweb/
Un saludo

Oscar dijo:
8 junio, 2017 a las 4:48 pm

Hola, buenas días! Excelente ejemplo, muy completo.

Muchas gracias!

Vanessa dijo:
12 octubre, 2017 a las 11:59 pm

Muy completo solo que como soy principiante el java como hago los procedures?

Laura dijo:
11 diciembre, 2017 a las 9:16 am

Hola Vanessa:
En este tutorial, los procedures no se realizan en Java, sino que se desarrolla en MySQL.
Dentro del apartado Creación del modelo, descrito en este tutorial se presenta el
 código fuente para la construcción de los procedimientos almacenados en la base de
datos.
Esperemos que te sea de ayuda.

Ya no se aceptan comentarios.

Buscar

Entradas recientes
 Cómo eliminar los IDs de las URLs en Joomla 3.7
 Descubre las novedades de Joomla 3.7
 Tips & tricks – Ordenar listas mediante Drag & drop
 Consigue gratis espacio extra en Google Drive
 Tablas dinámicas: Teoría y ejercicios resueltos

Etiquetas
auxiliar administrativo ◆ blog ◆ css ◆ drag & drop ◆ Excel ◆ java ◆ joomla ◆ jquery ◆ lista de
comandos ◆ mysql ◆ oposiciones ◆ php ◆ seguridad ◆ SEO ◆ TPV virtual

Categorías
 eCommerce
 Excel
 Gestores de contenido
 Oposiciones
 Programación
 Redes Sociales
 SEO
  Word

Comentarios recientes
 Laura en Modelo Vista Controlador en Java y MySQL. Nivel Básico
 Laura en Ampliación del Modelo Vista Controlador en Java y MySQL
 Laura en Tablas dinámicas: Teoría y ejercicios resueltos
 Ana Gutiérrez en Tablas dinámicas: Teoría y ejercicios resueltos
 Vanessa en Modelo Vista Controlador en Java y MySQL. Nivel Básico

Archivos
 abril 2017
 marzo 2017
 abril 2016
 febrero 2016
 enero 2016
 noviembre 2015
 octubre 2015
 septiembre 2015
 julio 2015
 abril 2015
 febrero 2015
 enero 2015
 diciembre 2014
 noviembre 2014
 octubre 2014
 septiembre 2014
 agosto 2014
 julio 2014
 junio 2014
 Inicio

© Copyright 2014 KADUM - Desarrollo web de calidad para tu negocio