Ampliación del Modelo Vista Controlador en Java y

MySQL
15 octubre, 2015 ◆
4 comentarios

En este artículo ampliaremos el tutorial (enlace al tutorial) que muestra paso a paso cómo
construir una aplicación en Java usando el patrón Modelo Vista Controlador (MVC) ya que ha
habido varias consultas y peticiones al respecto.

La ampliación consiste en añadir la posibilidad de filtrar en la gestión de clientes. De este

modo, se permite buscar un cliente en concreto mediante su id, nombre o apellido.

Este artículo parte del ejemplo del tutorial Modelo Vista Controlador en Java y MySQL, nivel
básico. A él vamos a añadirle la opción de búsqueda de modo que el resultado final será el
mostrado en la siguiente imagen:
 Filtrar clientes – MVC

Para ello:

1. En la Vista se realizará una modificación para contemplar el JLabel, JTextField y JButton.

2. En el Controlador se añadirá la escucha del botón Buscar. Y se sobrecargará el
método cargarTabla con un parámetro de entrada.
3. En la base de datos se añadirá un nuevo procedimiento almacenado para realizar la
búsqueda de un cliente.

Vista
Como se ha comentado en el anterior artículo, en este fichero se lleva a cabo el diseño de la
ventana de nuestra aplicación.

Se definen tres nuevas propiedades:

JLabel para la etiqueta Buscar.

JTextField donde se introducirá el identificador, nombre o apellido a buscar.
JButton para realizar la búsqueda.

En el constructor se crean dichas propiedades y se añaden al contenedor siguiendo la misma

filosofía empleada de SpringLayout.

Por último, en el método conectaControlador se añade actionListener y actionCommand al

botón para que desencadene una acción en el controlador.

El nuevo código quedaría tal y como se muestra a continuación:

 1 package kadumMVC;
2 public class View extends JFrame {
3     private static final long serialVersionU
4     //ETIQUETAS
5     [...]
6     private JLabel lblBuscar;
7      
8     //CUADROS DE TEXTO
9     [...]
10     protected JTextField txtBuscar;
11      
12     //BOTONES
13     [...]
14     protected JButton btnBuscar;
15     [...]
16      
17     /**************** MÉTODOS **************
18     //CONSTRUCTOR
19     View(){
20     [...]
21         //etiqueta buscar
22         lblBuscar = new JLabel("Buscar:");
23         contenedor.add(lblBuscar);
24         sp.putConstraint(SpringLayout.NORTH
25         sp.putConstraint(SpringLayout.WEST,
26         /**************** EOF ETIQUETAS  ^^^
27          
28          
29         /**************** BOF CUADROS DE  TE
30     [...]
31         //cuadro de texto para buscar
32         txtBuscar    = new JTextField();
33         contenedor.add(txtBuscar);          
34         sp.putConstraint(SpringLayout.NORTH
35         sp.putConstraint(SpringLayout.WEST,
36         sp.putConstraint(SpringLayout.EAST,
37         /**************** EOF CUADROS DE  TE
38     [...]
39  
40         /**************** BOF BOTONES vvvvvv
41     [...]
42         //boton buscar
43         btnBuscar        = new JButton("Busc
44         contenedor.add(btnBuscar);
45         sp.putConstraint(SpringLayout.SOUTH
46         sp.putConstraint(SpringLayout.WEST,
47         /**************** EOF BOTONES ^^^^^^
48          
49         //Se hace visible la ventana
50         setVisible(true);
51     }
52      
53     public void conectaControlador(  Control
54     [...]
55         btnBuscar.addActionListener(c);
56         btnBuscar.setActionCommand("BUSCAR")
57          
 58         tabla.addMouseListener(c);
59         tabla.setSelectionMode(ListSelection
60     }
61 }

Controlador
En el método actionPerformed, se tiene un switch para cada comando ejectuado
(INSERTAR, BORRAR y MODIFICAR). El método concluye con una llamada a cargarTabla().

La idea que se lleva a cabo es añadir una nueva opción al switch para contemplar el
comando BUSCAR.

Al final del método, si se pulsa sobre el botón buscar, en lugar de llamar al método
cargarTabla(), sin parámetros, se llamará a ese método pero con un parámetro de entrada,
de modo que se deberá sobrecargar cargarTabla(String buscar). El parámetro de entrada
con el cual se llama será la información que se escriba en el JTextField.

El método sobrecargado se encargará de llamar al procedimiento

almacenado filtrarCliente que se describe posteriormente.

El código resultante es:

1 package kadumMVC;
2  
3 [...]
4  
5 public class Controller implements ActionLis
6     @Override
7     public void actionPerformed(ActionEvent
8 [...]
9         //Se almacena la informacion a busca
10         String buscar = "";
11          
12 [...]
13         switch (comando) {
14             case "INSERTAR":
15 [...]
16             break;
17              
18             case "BORRAR":
19 [...]
20             break;
21  
22             case "MODIFICAR":
23 [...]
24             case "BUSCAR":
25                 //Obtener el valor buscado
26                 buscar    = this.view.txtBus
27             break;
28              
29             default:
30                 System.err.println("Comando
31             break;
32         }
33          
34          
35         //limpiar el formulario
36         limpia();
37          
38         //Se añade la condición para cargar
39         if(comando!="BUSCAR"){    //Carga no
40             cargarTabla();
41         }else{    //Cargar la tabla con crit
42             cargarTabla(buscar);
43         }
44     }
45  
46     //Método para limpiar los campos de la v
47     private void limpia(){
48         this.view.txtNombre.setText("");
49         this.view.txtApellido.setText("");
50         this.view.txtNIF.setText("");
51         //Limpiamos el nuevo campo de texto
52         this.view.txtBuscar.setText("");
53  
54     }
55      
56     //No se modifica nada
57     protected void cargarTabla(){
58 [...]
59     }
60  
61 /* SOBRECARGA DEL MÉTODO PARA OBTENER SOLO L
62 protected void cargarTabla(String buscar){
63         CallableStatement cs;
64         ResultSet rs;
65         Vector<Object> fila;
66          
67         for(int i=this.view.dtm.getRowCount
68             this.view.dtm.removeRow(i-1);
69         }
70          
71          
72         //Cargar datos en la tabla CON LOS C
73         try {
74             //Preparar la llamada
75             cs    = Bd.getConexion().prepare
76             cs.setString(1, buscar);
77              
78             //Ejecutarla y recoger el result
79             rs    = cs.executeQuery();
80             //Recorrer el resultado
81             while(rs.next()){
82                 //Añadir registro a registro
83                 fila    = new Vector<Object>
 84                 fila.add(rs.getInt("id"));
85                 fila.add(rs.getString("nomb
86                 fila.add(rs.getString("nif")
87                 //Añadir el vector a la tabl
88                 this.view.dtm.addRow(fila);
89             }
90              
91              
92         } catch (SQLException e) {
93             System.err.println("Error al CAR
94         }
95     }
96 [...]
97      
98 }

Procedimiento almacenado
Cuando se pulsa el botón buscar, el controlador llama al procedimiento
almacenado filtrarCliente. Este método debe devolver el id, nombre y NIF de los clientes que
coincidan con el parámetro de búsqueda.

Recordamos que se deben devolver esos 3 campos porque son los que se muestran en nuestra
tabla.

El procedimiento en nuestra base de datos MySQL será:

1 DELIMITER $$
2 DROP PROCEDURE IF EXISTS filtrarCliente$$
3 CREATE PROCEDURE filtrarCliente(buscar VARCH
4 BEGIN
5     SELECT id, nombre, nif
6     FROM cliente
7     WHERE cliente.id= buscar
8     OR cliente.nombre LIKE CONCAT('%',busca
9     OR cliente.apellido LIKE CONCAT('%',busc
10      
11 END
12 $$

Donde se observa que recibe un parámetro de entrada que se utiliza en el WHERE de la

condición para obtener los clientes cuyo id, nombre o apellido coincidan con dicho parámetro.

MVC Resultado
Tras realizar estas ampliaciones se podrán realizar búsquedas sobre los clientes almacenados.
En la siguiente captura de pantalla se realiza la búsqueda del cliente con identificador igual a 2.
 Buscar cliente por id

Tras pulsar el botón Buscar, se carga en la tabla los clientes que coinciden con la búsqueda.

Resultado de la búsqueda

Al pulsar sobre el cliente que nos interesa, se cargarán sus datos en los diferentes JTextField
por lo que se podrá llevar a cabo su modificación o eliminación.
 Seleccionar cliente buscado

Espero que esta ampliación de la funcionalidad de la aplicación sirva para afianzar los
conceptos explicados sobre modelo vista controlador y emplearla como base para mejorar
vuestro modelo con más funcionalidades.