Vamos a realizar una aplicación para gestionar el alta, baja y actualización de una lista de clientes utilizando el lenguaje Java para su realización y con persistencia de datos mediante MySQL.
Para realizar la aplicación se ha utilizado el IDE Eclipse con el pluging de WindowBuldier para la realización de los elementos de la interfaz gráfica.
Se ha utilizado el patrón de MVC para la estructura de la clase y los patrones de diseño DAO y el modelo Singleton para la capa de persistencia.
La aplicación consta de las siguientes clases:
Inicio: Clase controladora con el main que contiene el código para lanzar la aplicación.
Altas: Clase del paquete Vista, con los elementos de la interfaz.
Clientes: Clase del modelo de datos, donde se define la estructura del cliente.
DaoCliente: Clase con los métodos de persistencia para la gestión de la información en la BD. Siguiendo el modelo Singleton.
Descripción de las clases y métodos más importantes.
Vista
Para realizar la interfaz se ha utilizado el plugin para Eclipse windowBuldier, con el cual se ha ido incorporando los paneles y elementos para interactuar con el usuario.
La interfaz esta compuesta principalmente de elementos Text Field además de un combobox y una tabla.
TextField:
La inserción de los Tex Fields se ha realizado con el pluging, donde se ha cambiado el nombre (variable) del elemento y se ha puesto un label para identificarlo.
Combo
La realización del combo se ha realizado insertando el elemento e incorporando los elementos en el Array del código.
Tabla
En el caso de la tabla se ha realizado un método para poder reutilizar el código cada vez que se modifican los datos al realizar una actualización, inserción o borrado de un elemento.
Para las acciones nos encontramos con tres botones:
Guardar
Como podemos observar en el código anterior, el evento del botón hace una llamada al método de guardado en la misma clase.
En la función vemos como realiza tanto el guardado como la actualización según sea el caso. Para ello diferencia la acción mediante la comprobación del ID. En el caso de la actualización primero se selecciona un elemento de la lista mostrada en la tabla, con la cual se obtiene el Id del elemento seleccionado. Esto se produce al hacer click en un elemento de la lista mostrada y capturando el evento.
Que realiza la llamada al método de llenar campos, con el cual partiendo del Id del objeto seleccionado obtiene el dato almacenado en la fila seleccionado y rellena con los datos obtenidos de la base de datos cada campo del formulario.
Para el botón de borrado llamamos al método delete realizado en la clase Cliente para borrar el registro enviando el id del elemento.
Cada vez que se borra, actualiza o se inserta un cliente, debemos vaciar los datos del formulario, por lo que tenemos el método limpiar campos que es ejecutado cada vez que se realiza alguna de estas acciones.
Modelo
En el modelo de la aplicación intervienen tres elementos, la clase clientes que define la estructura de un cliente, la Clase DaoClientes que contiene los métodos de manipulación en la base de datos y la propia base de datos.
Base de datos:
La base de datos consta de una sola tabla con los valores de los campos de cada atributo de cliente. No se han respetado todas las formas normales de entidad relación para no hacer la practica demasiado grande.
La clase Cliente consta de los atributos y los métodos de inserción, actualización, borrado y listado de elementos para realizar el CRUD de los datos.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 |
package modelo; import java.sql.SQLException; import java.util.ArrayList; import java.util.List; public class Cliente { private int id; private String dni; private String nombre; private String apellidos; private String nombreVia; private int numero; private int piso; private String puerta; private String cp; private String provincia; private String poblacion; private String pais; private int tipoVia; /** * Constructor Cliente Vacio */ public Cliente() { } /** * Constructor con parametros * * @param id * @param dni * @param nombre * @param apellidos * @param nombreVia * @param numero * @param piso * @param puerta * @param cp * @param provincia * @param poblacion * @param pais * @param tipoVia */ public Cliente(int id, String dni, String nombre, String apellidos, String nombreVia, int numero, int piso, String puerta, String cp, String provincia, String poblacion, String pais, int tipoVia) { this.id = id; this.dni = dni; this.nombre = nombre; this.apellidos = apellidos; this.nombreVia = nombreVia; this.numero = numero; this.piso = piso; this.puerta = puerta; this.cp = cp; this.provincia = provincia; this.poblacion = poblacion; this.pais = pais; this.tipoVia = tipoVia; } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getDni() { return dni; } public void setDni(String dni) { this.dni = dni; } public String getNombre() { return nombre; } public void setNombre(String nombre) { this.nombre = nombre; } public String getApellidos() { return apellidos; } public void setApellidos(String apellidos) { this.apellidos = apellidos; } public String getNombreVia() { return nombreVia; } public void setNombreVia(String nombreVia) { this.nombreVia = nombreVia; } public int getNumero() { return numero; } public void setNumero(int numero) { this.numero = numero; } public int getPiso() { return piso; } public void setPiso(int piso) { this.piso = piso; } public String getPuerta() { return puerta; } public void setPuerta(String puerta) { this.puerta = puerta; } public String getCp() { return cp; } public void setCp(String cp) { this.cp = cp; } public String getProvincia() { return provincia; } public void setProvincia(String provincia) { this.provincia = provincia; } public String getPoblacion() { return poblacion; } public void setPoblacion(String poblacion) { this.poblacion = poblacion; } public String getPais() { return pais; } public void setPais(String pais) { this.pais = pais; } public int getTipoVia() { return tipoVia; } public void setTipoVia(int tipoVia) { this.tipoVia = tipoVia; } /** * Metodo de inserción de cliente. Envia los datos del objeto al metodo de la clase DAO de insertar. * @throws SQLException */ public void insertar() throws SQLException { DaoCliente.getInstance().insert(this); } /** * Metodo de actualización de cliente. Envia los datos del objeto al metodo de la clase DAO de actualizar. * @throws SQLException */ public void update() throws SQLException { DaoCliente.getInstance().update(this); } /** * Metodo de Borrado de cliente. Envia el id del objeto actual al metodo de la clase DAO de borrado. * @throws SQLException */ public void delete(int id) throws SQLException { DaoCliente.getInstance().delete(id); } /** * Metodo para obtener la lista de clientes obtenidos de la base de datos mediante el metodo obtener de la clase DAO * @return * @throws SQLException */ public List<Cliente> obtenerLista() throws SQLException{ List<Cliente> lista = DaoCliente.getInstance().obtenerLista(); return lista; } } |
Siguiendo el modelo Singleton y para facilitar el cambio de la capa de persistencia, esta capa solo realiza las llamadas a la clase DAO correspondiente que es la que realizara las operaciones con la base de datos.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 |
package modelo; import java.sql.Connection; import java.sql.Date; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.util.ArrayList; import java.util.List; public class DaoCliente { private Connection con = null; private static DaoCliente instance = null; private DaoCliente() throws SQLException { con = DBConnection.getConnection(); } public static DaoCliente getInstance() throws SQLException { if (instance == null) instance = new DaoCliente(); return instance; } /** * * Metodo que inserta mediante el conector JDBC los datos de un cliente en la Base de datos * * @param t * @throws SQLException */ public void insert(Cliente t) throws SQLException { PreparedStatement ps = con.prepareStatement( "INSERT INTO clientes(dni, nombre, apellidos, nombreVia, numero, piso, puerta, cp, provincia, poblacion, pais, tipoVia) VALUES (?, ?, ?, ?, ?, ?, ?, ?,?,?,?,?)"); ps.setString(1, t.getDni()); ps.setString(2, t.getNombre()); ps.setString(3, t.getApellidos()); ps.setString(4, t.getNombreVia()); ps.setInt(5, t.getNumero()); ps.setInt(6, t.getPiso()); ps.setString(7,t.getPuerta()); ps.setString(8,t.getCp()); ps.setString(9,t.getProvincia()); ps.setString(10,t.getPoblacion()); ps.setString(11,t.getPais()); ps.setInt(12, t.getTipoVia()); ps.executeUpdate(); ps.close(); } /** * Metodo que acutaliza los datos de un cliente mediante el id almacenado del mismo. * @param t * @throws SQLException */ public void update(Cliente t) throws SQLException { if (t.getId() != 0) { PreparedStatement ps = con.prepareStatement( "UPDATE clientes SET dni = ?, nombre = ?, apellidos = ?, nombreVia = ?, numero = ?, piso = ?, puerta = ?, cp = ?, provincia = ?, poblacion = ?, pais = ?, tipoVia = ? WHERE id = ?"); ps.setString(1, t.getDni()); ps.setString(2, t.getNombre()); ps.setString(3, t.getApellidos()); ps.setString(4, t.getNombreVia()); ps.setInt(5, t.getNumero()); ps.setInt(6, t.getPiso()); ps.setString(7,t.getPuerta()); ps.setString(8,t.getCp()); ps.setString(9,t.getProvincia()); ps.setString(10,t.getPoblacion()); ps.setString(11,t.getPais()); ps.setInt(12, t.getTipoVia()); ps.setInt(13, t.getId()); ps.executeUpdate(); ps.close(); } } /** * Metodo que retorna la lista de clientes almacenados en la base de datos. * @return * @throws SQLException */ public List<Cliente> obtenerLista() throws SQLException { PreparedStatement ps = con.prepareStatement("SELECT * FROM clientes"); ResultSet rs = ps.executeQuery(); List<Cliente> result = null; while (rs.next()) { if (result == null) result = new ArrayList<>(); result.add(new Cliente(rs.getInt("id"), rs.getString("dni"),rs.getString("nombre"), rs.getString("apellidos"), rs.getString("nombreVia"), rs.getInt("numero"), rs.getInt("piso"), rs.getString("puerta"), rs.getString("cp"), rs.getString("provincia"), rs.getString("poblacion"),rs.getString("pais"), rs.getInt("tipoVia"))); } rs.close(); ps.close(); return result; } /* * Metodo que obtiene los datos de un cliente por medio de la identificación del ID */ public Cliente obtenerPorId(int id) throws SQLException { PreparedStatement ps = con.prepareStatement("SELECT * FROM clientes WHERE id = ?"); ps.setInt(1, id); ResultSet rs = ps.executeQuery(); Cliente result = null; if (rs.next()) { result = new Cliente(rs.getInt("id"), rs.getString("dni"),rs.getString("nombre"), rs.getString("apellidos"), rs.getString("nombreVia"), rs.getInt("numero"), rs.getInt("piso"), rs.getString("puerta"), rs.getString("cp"), rs.getString("provincia"), rs.getString("poblacion"),rs.getString("pais"), rs.getInt("tipoVia")); } rs.close(); ps.close(); return result; } /** * Metodo para borrar un cliente de la base de datos proporciandole el id del mismo. * @param id * @throws SQLException */ public void delete(int id) throws SQLException { if (id <= 0) return; PreparedStatement ps = con.prepareStatement("DELETE FROM Clientes WHERE id = ?"); ps.setInt(1, id); ps.executeUpdate(); ps.close(); } } |
Podemos observar como cada uno de los métodos realiza una llamada a los métodos de la clase estática DaoClientes.
En esta clase es donde se construye las sentencias SQL para la manipulación de los datos. Podemos observar como en el constructor de la clase utilizamos el patrón singleton para realizar la conexión llamando a la clase DBConnection.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 |
package modelo; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.util.Properties; public class DBConnection { private static final String JDBC_URL = "jdbc:mysql://localhost:3306/GestionClientesEjercicio"; private static Connection instance = null; private DBConnection() { } /** * Medoto que permite la llamada estatica por los metodos del resto de clases, utilizando el patron Singleton * @return * @throws SQLException */ public static Connection getConnection() throws SQLException { if (instance == null) { Properties props = new Properties(); props.put("user", "root"); props.put("password", "root"); instance = DriverManager.getConnection(JDBC_URL, props); } return instance; } } |
Junto a este documento se incluyen los siguientes recursos.
- Proyecto Eclipse con todo el código del programa. Descargar
- Compilación JAR del proyecto para su ejecución. AplicacionClientes.jar
- Script SQL de la base de datos. baseDeDatos.sql
- Documentación en JAVADOC. Documentación