Modelo Vista Controlador en Java y MySQL. Nivel Básico - 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áfica, un usuario podrá listar, añadir, modificar 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 fichero
.jar que se encargará de registrar y emplear el driver adecuado para tal conexión. El fichero se
puede descargar a través del siguiente enlace (en inglés).
Los temas a tratar, son los siguiente:
Creación del proyecto

Codificación de la clase Bd
Codificación de la clase View
Codificación de la clase Controller
Codificació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 fichero 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 fichero mysql-connector-java-5.0.8-bin.jar

Una vez añadido el fichero, 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áfica.
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áfica, 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 fin.
Como se indicó anteriormente, el modelo estará implementado en la base de datos MySQL.
Codificació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 = nu
14
15 //CONSTRUCTOR
16 //Recibe el nombre de la base de datos
17 Bd(String baseDatos){
18 this.servidor="jdbc:mysql://"+this.m
19 this.puerto+"/"+base
20
21 //Registrar el driver
22 try {
23 Class.forName("com.mysql.jdbc.D
24 } catch (ClassNotFoundException e) {
25 System.err.println("ERROR AL REG
26 System.exit(0); //parar la ejecu
27 }
28
29 //Establecer la conexión con el serv
30 try {
31 conexion = DriverManager.getConn
32 this.usuario, this.c
33 } catch (SQLException e) {
34 System.err.println("ERROR AL CON
35 System.exit(0); //parar la ejecu
36 }
37 System.out.println("Conectado a "+ba
38 }
39
40 //Devuelve el objeto Connection que se u
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.
Codificación de la clase View

La clase View se encarga de la generación de la interfaz gráfica 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 definirán como objetos de la clase JLabel.
Los tres cuadros de texto se definirán como objetos de la clase JTextField.
Los tres botones se definirá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
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 fila 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 fila.
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 definición de los eventos.
De forma análoga a la creación de la clase anterior:
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á definida.
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 TAB
35 private JScrollPane scroll; //Panel de
36 protected Object[][] datos; //Cuerpo de
37 protected String[] cabecera; //Cabec
38 protected DefaultTableModel dtm;//Unión
39 protected JTable tabla; //Tabla propiam
40
41 /**************** MÉTODOS *************
42 //CONSTRUCTOR
43 View(){
44 //Métodos de la JFrame
45 setBounds(100, 100, 450, 300);//Def
46 setTitle("GESTIÓN DE CLIENTES - KAD
47 setDefaultCloseOperation(EXIT_ON_CL
48
49 //CREAR EL CONTENEDOR PRINCIPAL Y A
50 contenedor = new JPanel();
51 getContentPane().add(contenedor);
52
53 //INDICAR QUE SE QUIERE USAR SPRING
54 SpringLayout sp = new SpringLayout(
55 contenedor.setLayout(sp);
56
57 //Vamos al lío
58 /**************** BOF ETIQUETAS vv
59 //ETIQUETA NOMBRE
60 lblNombre = new JLabel("Nombre:");
61 contenedor.add(lblNombre); //A
62 sp.putConstraint(SpringLayout.NORTH
63 SpringLayout.NORTH,
64 sp.putConstraint(SpringLayout.WEST,
65 SpringLayout.WEST,
66 //ETIQUETA APELLIDOS
67 lblApellido = new JLabel("Apellidos
68 contenedor.add(lblApellido);
73 //ETIQUETA NIF
74 lblNIF = new JLabel("NIF:");
75 contenedor.add(lblNIF);
80 /**************** EOF ETIQUETAS ^^
81
82 /**************** BOF CUADROS DE T
83 //CUADRO DE TEXTO PARA EL NOMBRE
84 txtNombre = new JTextField();
85 contenedor.add(txtNombre);
90 sp.putConstraint(SpringLayout.EAST,
92 //CUADRO DE TEXTO PARA EL NIF
93 txtApellido = new JTextField();
94 contenedor.add(txtApellido); //a
101 //CUADRO DE TEXTO PARA LOS APELLIDO
102 txtNIF = new JTextField();
103 contenedor.add(txtNIF);
107 /**************** EOF CUADROS DE T
108
109 /**************** BOF TABLA vvvvvv
110 scroll = new JScrollPane();
111 cabecera = new String[] {"ID","N
112 dtm = new DefaultTableModel
113 tabla = new JTable(dtm);
114 scroll.setViewportView(tabla);
115 //y ahora se coloca el scrollpane.
116 contenedor.add(scroll); //añadir al
122 SpringLayout.EAST,
123 sp.putConstraint(SpringLayout.SOUTH
124 SpringLayout.SOUTH,
125 /**************** EOF TABLA ^^^^^^^
126
127 /**************** BOF BOTONES vvvvv
128 //BOTÓN AÑADIR
129 btnAdd = new JButton("Añad
130 contenedor.add(btnAdd);
135 //BOTÓN BORRAR
136 btnDel = new JButton("Borr
137 contenedor.add(btnDel);
142 //BOTÓN MODIFICAR
143 btnUpd = new JButton("Edit
144 contenedor.add(btnUpd);
149 /**************** EOF BOTONES ^^^^^
150
151 //Se hace visible la ventana
152 setVisible(true);
153
154 }
155
156 public void conectaControlador( Contro
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
169 tabla.setSelectionMode(ListSelectio
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

4 sp.putConstraint(SpringLayout.NORTH, txtNombr
5 SpringLayout.NORTH, conte
6 sp.putConstraint(SpringLayout.WEST, txtNombre
7 SpringLayout.WEST, conten
8 sp.putConstraint(SpringLayout.EAST, txtNombre
Por motivos de claridad en el código, se ha omitido la referencia mediante this.
En la primera línea se construye el objeto, definido previamente.
El objeto creado, se añade al contenedor principal.
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, txtNombr
2 SpringLayout.NORTH, conte
A continuación, el lado oeste:
1 sp.putConstraint(SpringLayout.WEST, txtNombre
y por último, el este:
1 sp.putConstraint(SpringLayout.EAST, txtNombre
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á definida 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
Codificación de la clase Controller

La clase Controller se encarga de la comunicación entre la interfaz gráfica 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 codificar 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áfica 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 especificó 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 definido 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 fila de la tabla.
Cuando se pulse sobre una fila, 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 definició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:
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.
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 ActionLi
13 MouseLi
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
24 //Objeto para ejecutar los procedim
25 // en la base de datos
26 CallableStatement cs;
27
28 //COMANDO EJECTUADO
29 String comando = arg0.getActionCom
30
31 //Deberá coincidir con alguno de lo
32 // indicados en setActionCommand i
33 // clase View
34 switch (comando) {
35 case "INSERTAR":
36 try{
37 //Preparar la llamada
38 cs = Bd.getConexion()
39 "{CALL insertar
40 //Indicar qué informaci
41 // procedimiento
42 cs.setString(1,
43 this.view.txtNombre
44 cs.setString(2,
45 this.view.txtApelli
46 cs.setString(3,
47 this.view.txtNIF.ge
48 //Ejecutar el procedimi
49 cs.execute();
50 }catch (SQLException e) {
51 System.err.println("Err
52 }
53
54 break;
55
56 case "BORRAR":
57 //Recoger qué fila se ha pu
58 int filaPulsada = this.view
59 //Si se ha pulsado una fila
60 if(filaPulsada>=0){
61 //Se recoge el id de la
62 int identificador = (
63 try{
64 //Preparar la llama
65 cs = Bd.getConexio
66 "{CALL borrarCl
67 //Indicar qué infor
68 cs.setInt(1, identi
69 //Ejecutar el proce
70 cs.execute();
71 //System.out.printl
72 }catch (SQLException e)
73 System.err.println(
74 }
75 }
76
77 break;
78
79 case "MODIFICAR":
80 //Recoger qué fila se ha pu
81 filaPulsada = this.view.tab
84 //Se recoge el id de la
85 int identificador = (
86 try{
87 //Preparar la llama
88 cs = Bd.getConexio
89 "{CALL modifica
90 //Indicar qué infor
91 cs.setInt(1, identi
92 cs.setString(2,
93 this.view.txtNo
94 cs.setString(3,
95 this.view.txtAp
96 cs.setString(4,
97 this.view.txtNI
98 //Ejecutar el proce
99 cs.execute();
100 //System.out.printl
101 }catch (SQLException e)
102 System.err.println(
103 }
104 }
105 break;
106
107 default:
108 System.err.println("Comando
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
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 ta
126 // en la tabla de la clase View
127 protected void cargarTabla(){
130 //Objeto para recoger los datos dev
131 ResultSet rs;
132 //Objeto para recorrer el resultado
133 // añadirlo a la tabla definida en
134 Vector<Object> fila;
135
136 //Limpiar los datos de la tabla
137 for(int i=this.view.dtm.getRowCount
138 this.view.dtm.removeRow(i-1);
139 }
140
141 //Cargar datos en la tabla
142 try {
144 cs = Bd.getConexion().prepareC
145 "{CALL getClien
146 //Ejecutarla y recoger el resul
147 rs = cs.executeQuery();
148 //Recorrer el resultado
149 while(rs.next()){
150 //Añadir registro a registr
151 fila = new Vector<Object
152 fila.add(rs.getInt("id"));
153 fila.add(rs.getString("nomb
154 fila.add(rs.getString("nif"
155 //Añadir el vector a la tab
156 this.view.dtm.addRow(fila);
157 }
158
159 } catch (SQLException e) {
160 System.err.println("Error al CA
161 }
162 }
163
164 @Override
165 public void mouseClicked(MouseEvent arg
168 //Objeto para recoger los datos dev
169 ResultSet rs;
170
171 //Recoger qué fila se ha pulsadao e
172 int filaPulsada = this.view.tabla.g
175 //Se recoge el id de la fila ma
176 int identificador= (int)this.vi
177 filaPulsada, 0)
178 try{
180 cs = Bd.getConexion().prep
181 "{CALL getClien
182 //Indicar qué información s
183 cs.setInt(1, identificador)
184 //Ejecutar el procedimiento
185 rs = cs.executeQuery();
186 //Cargar los datos devuelto
187 if(rs.next()){
188 this.view.txtNombre.set
189 this.view.txtApellido.s
190 this.view.txtNIF.setTex
191 }
192 //System.out.println(this.v
193 }catch (SQLException e) {
194 System.err.println("Error a
195 }
196 }
197 }
198
199 @Override
200 public void mouseEntered(MouseEvent arg
201 @Override
202 public void mouseExited(MouseEvent arg0
203 @Override
204 public void mousePressed(MouseEvent arg
205 @Override
206 public void mouseReleased(MouseEvent ar
207 }
Nota: No se ha entrado en detalle en el control de la congruencia de los datos. Por ejemplo,

no se verifica que un cliente ya exista en la base de datos antes de insertarlo. Tampoco se
controla la letra de su NIF.
Codificación de la clase Principal

Ya se tienen definidas 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:
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
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
6 new Bd("kadummvc");
7 //Crear un objeto de la clase View
8 View vista = new View();
9 //Crear un objeto de la clase Contro
10 Controller controlador = new Contro
11 //Vincular la vista y el controlado
12 vista.conectaControlador(controlado
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 ìd` int(10) NOT NULL AUTO_INCREMENT,
3 `nombre` varchar(50) DEFAULT NULL,
4 àpellido` varchar(50) DEFAULT NULL,
5 `nif` varchar(10) DEFAULT NULL,
6 PRIMARY KEY (ìd`)
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 identificador del
cliente a eliminar.
getCliente. Recibe un entero como parámetro de entrada. Representa el identificador del
cliente a cargar. Se obtiene el nombre, apellido y NIF de dicho cliente.
getClientes. No recibe parámetros de entrada. Se obtiene el identificador, 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.
modificarCliente. Recibe como parámetro de entrada el identificador del cliente a modificar,
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 CLI
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 CL
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 VARC
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 ficheros
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 especificó 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
especificó 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 reflejará en
la tabla el cliente insertado.
Insertado
Modificar clientes
Para modificar un cliente, se pulsa sobre la fila del registro a modificar. 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 modificació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 fila 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 refleja 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 fichero ejecutable en Eclipse.
Acceder a File > Export…

En el cuadro de diálogo que aparece, desplegar la carpeta Java y marcar Runnable JAR file
Ejecutable runnable
Tras pulsar Next, se mostrará un cuadro de diálogo donde se configura 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 fichero ejecutable.
Crear ejecutable (.jar)
Se pulsa Finish y se obtendrá un fichero .jar ejecutable

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

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

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

Încărcat de

Drepturi de autor:

Formate disponibile

Modelo Vista Controlador en Java y MySQL.

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

Creación del proyecto

Creación del proyecto

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

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

Bd. Se encargará de realizar la conexión al servidor MySQL.

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

Codificación de la clase View

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

Posiciones de los componentes

Tal y como se ha comentado, las posiciones de los componentes se realizarán mediante la

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

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

Componentes NORTH WEST

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

Componentes NORTH WEST EAST

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

Componentes NORTH WEST EAST SOUTH

Por último, para el caso de los botones:

Componentes SOUTH WEST

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

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

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

1 //CUADRO DE TEXTO PARA EL NOMBRE

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

1 txtNombre = new JTextField();

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

Mediante el empleo de la función putConstraint del objeto sp (de la clase SpringLayout) se

A continuación, el lado oeste:

y por último, el este:

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

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

Codificación de la clase Controller

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

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

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

Para ejecutar los procedimientos almacenados, se empleará la

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

Cuando se pulse sobre una fila, se invocará a un procedimiento almacenado de la base de

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

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

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

Se creará la clase Controller:

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

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

Codificación de la clase Principal

El código de esta clase es:

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

Creación del modelo

1 CREATE TABLE `cliente` (

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

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

1 #BORRAR CLIENTE POR ID

Prueba del proyecto MVC

Se realizará la modificación en la base de datos, se limpian los campos de texto y se actualiza

Seleccionar para borrar

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

Acceder a File > Export…

Se pulsa Finish y se obtendrá un fichero .jar ejecutable

S-ar putea să vă placă și