Programación Java SE Operaciones CRUD en Java, utilizando el patrón DAO

Hola que tal, esta vez vamos a crear todas la operaciones CRUD en Java utilizando los Patrones de diseño MVC y DAO, pero bueno te preguntarás que es un CRUD, esta palabra es un acrónimo del habla inglesa que quiere decir create, read, update, delete que en español es crear, leer, actualizar, eliminar y que se refiere a los registros de una base de datos.

Aunque si utilizas algún framework como Spring en Java o Laravel en PHP no deberías preocuparte por esto, ya que el mismo framework lo implementa.

A pesar que como mencioné si utilizas un framework esto ya no tiene mucho sentido aún así me parece interesante el conocer que existe y más si recién estas iniciando a trabajar con base de datos.

QUE VAS A NECESITAR?

Bien, para realizar un CRUD el requisito principal y obligatorio es tener instalado MySQL.

Además, una herramienta gráfica que te permita administrar MySQL, estas pueden ser: phpMyadmin, MySQL Workbench o cualquier otra herramienta similar que tengas instalada.

Sino la tienes y sabes manejar comandos SQL, lo puedes hacer también a través de comandos SQL por consola.

Para este ejemplo voy a utilizar MySQL Workbench ya que tiene una interfaz amigable y aprovechar también que ya la tengo instalada.

Si aún no tienes instalado MySQL puedes revisar este tutorial, dónde también explico algunas cosas básicas como por ejemplo crear una conexión entre otras cosas para la instalación, Aprende a instalar MySQL y MySQL Workbench en Windows 10.

Nota: Si te interesa seguir el tema de programación Web con Java, puedes revisar mi Curso de Programación Java Web, con JSP, Servlet y JPA donde aprenderás paso a paso como desarrollar aplicaciones web con Java.

PASOS GENERALES PARA CREAR UN CRUD EN JAVA

Crear una base de datos y una tabla.
En Eclipse crear un nuevo proyecto Java.
Conectarte a la base de datos a través de JDBC Driver.
Programar los métodos para el CRUD.
Usar los métodos CRUD.

1. CREAR LA BASE DE DATOS

Antes que nada debes crear una base de datos en MySQL llamada ventas con una tabla llamada cliente, con los siguientes campos id, cedula, nombre y apellido, el campo id debe ser autoincrementable.

Puedes acceder al tutorial donde explico Cómo crear una base de datos en MySQL utilizando MySQL Workbench o puedes utilizar cualquier herramienta que desees, lo importante es crear la base de datos, la tabla cliente y sus campos.

Si quieres seguir el tema de programación Web con Java puedes revisar los siguientes enlaces:

2. CREAR UN NUEVO PROYECTO JAVA

Lo siguiente que vas hacer es crear un proyecto en Java, ya que el CRUD lo vamos hacer desde la consola, la estructura del proyecto debe quedar de la siguiente manera, no te preocupes, luego te explicaré como hacerlo.

3. CREAR LA CONEXIÓN A TRAVÉS DE JDBC DRIVER

Una vez creado el proyecto vas hacer la conexión de la aplicación a la base de datos, recuerda que para esto debes descargar el driver de conexión y agregarlo al class path del proyecto.

Si aún no lo tienes o no sabes como hacerlo revisa el siguiente tutorial Cómo conectase a MySQL desde java.

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
package com.connection;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
 
public class Conexion {
	public static Connection conectar() {
		Connection con = null;
		
		String password = "root";
		String usuario = "root";
		String url = "jdbc:mysql://localhost:3306/ventas?user=" + usuario
				+ "&password=" + password;
		try {
			con = DriverManager.getConnection(url);
			if (con != null) {
				System.out.println("Conectado");
			}
		} catch (SQLException e) {
			System.out.println("No se pudo conectar a la base de datos");
			e.printStackTrace();
		}
		return con;
	}
}

4. PROGRAMAR LOS MÉTODOS CRUD

Ahora vamos a programar las operaciones CRUD utilizando el patrón de diseño DAO para la parte del acceso a los datos.

Primero empezamos creando el modelo que es la clase Cliente.java y que es la clase que va mapear los atributos de la tabla cliente en la base de datos ventas.

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
package com.ecodeup.model;
 
public class Cliente {
	private int id;
	
	private String cedula;
	private String nombre;
	private String apellido;
	
	public Cliente() {
	}
	
	public Cliente(String cedula, String nombre, String apellido) {
		this.id = id;
		this.cedula = cedula;
		this.nombre = nombre;
		this.apellido = apellido;
	}
 
	public int getId() {
		return id;
	}
 
	public void setId(int id) {
		this.id = id;
	}
 
	public String getCedula() {
		return cedula;
	}
 
	public void setCedula(String cedula) {
		this.cedula = cedula;
	}
 
	public String getNombre() {
		return nombre;
	}
 
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}
 
	public String getApellido() {
		return apellido;
	}
 
	public void setApellido(String apellido) {
		this.apellido = apellido;
	}
	
	@Override
	public String toString() {
		return this.id+", "+this.cedula+", "+this.nombre+", "+this.apellido;
	}
}

Luego creamos la Interface IClienteDAO.java que registra los métodos CRUD, al ser una interface solo contiene la firma de los métodos.

1
2
3
4
5
6
7
8
9
10
11
12
package com.ecodeup.idao;
 
import java.util.List;
 
import com.ecodeup.model.Cliente;
 
public interface IClienteDao {	
	public boolean registrar(Cliente cliente);
	public List<Cliente> obtener();
	public boolean actualizar(Cliente cliente);
	public boolean eliminar(Cliente cliente);
}

Lo siguiente es crear la implementación de la interface anterior, para esto lo hacemos en la clase ClienteDaoImpl.java, nota que también utilizamos la clase Conexion.java, para la ejecución de comandos SQL.

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
package com.ecodeup.dao;
 
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
 
import com.connection.Conexion;
import com.ecodeup.idao.IClienteDao;
import com.ecodeup.model.Cliente;
 
public class ClienteDaoImpl implements IClienteDao {	
	
	@Override
	public boolean registrar(Cliente cliente) {
		boolean registrar = false;
		
		Statement stm= null;
		Connection con=null;
		
		String sql="INSERT INTO cliente values (NULL,'"+cliente.getCedula()+"','"+cliente.getNombre()+"','"+cliente.getApellido()+"')";
		
		try {			
			con=Conexion.conectar();
			stm= con.createStatement();
			stm.execute(sql);
			registrar=true;
			stm.close();
			con.close();
		} catch (SQLException e) {
			System.out.println("Error: Clase ClienteDaoImple, método registrar");
			e.printStackTrace();
		}
		return registrar;
	}
 
	@Override
	public List<Cliente> obtener() {
		Connection co =null;
		Statement stm= null;
		ResultSet rs=null;
		
		String sql="SELECT * FROM CLIENTE ORDER BY ID";
		
		List<Cliente> listaCliente= new ArrayList<Cliente>();
		
		try {			
			co= Conexion.conectar();
			stm=co.createStatement();
			rs=stm.executeQuery(sql);
			while (rs.next()) {
				Cliente c=new Cliente();
				c.setId(rs.getInt(1));
				c.setCedula(rs.getString(2));
				c.setNombre(rs.getString(3));
				c.setApellido(rs.getString(4));
				listaCliente.add(c);
			}
			stm.close();
			rs.close();
			co.close();
		} catch (SQLException e) {
			System.out.println("Error: Clase ClienteDaoImple, método obtener");
			e.printStackTrace();
		}
		
		return listaCliente;
	}
 
	@Override
	public boolean actualizar(Cliente cliente) {
		Connection connect= null;
		Statement stm= null;
		
		boolean actualizar=false;
				
		String sql="UPDATE CLIENTE SET cedula='"+cliente.getCedula()+"', nombres='"+cliente.getNombre()+"', apellidos='"+cliente.getApellido()+"'" +" WHERE ID="+cliente.getId();
		try {
			connect=Conexion.conectar();
			stm=connect.createStatement();
			stm.execute(sql);
			actualizar=true;
		} catch (SQLException e) {
			System.out.println("Error: Clase ClienteDaoImple, método actualizar");
			e.printStackTrace();
		}		
		return actualizar;
	}
 
	@Override
	public boolean eliminar(Cliente cliente) {
		Connection connect= null;
		Statement stm= null;
		
		boolean eliminar=false;
				
		String sql="DELETE FROM CLIENTE WHERE ID="+cliente.getId();
		try {
			connect=Conexion.conectar();
			stm=connect.createStatement();
			stm.execute(sql);
			eliminar=true;
		} catch (SQLException e) {
			System.out.println("Error: Clase ClienteDaoImple, método eliminar");
			e.printStackTrace();
		}		
		return eliminar;
	}
 
}

APLICANDO EL PATRÓN MODELO VISTA CONTROLADOR.

Una vez creado el acceso a datos los DAO’s vamos a utilizar la arquitectura MVC para poder utilizar los métodos CRUD.

El modelo ya lo habíamos creado anteriormente, así que ahora sólo vamos a crear la vista y luego el controlador.

La vista es el lugar donde se va mostrar los datos del modelo, recuerda que en la arquitectura MVC la vista no interactua directamente con el modelo ni con el acceso a los datos, sino lo hace a través del controlador.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.ecodeup.vista;
 
import java.util.List;
 
import com.ecodeup.model.Cliente;
 
public class ViewCliente {
	public void verCliente(Cliente cliente) {
		System.out.println("Datos del Cliente: "+cliente);
	}
	
	public void verClientes(List<Cliente> clientes) {
		for (Cliente cliente : clientes) {
			System.out.println("Datos del Cliente: "+cliente);
		}		
	}
}

Ahora nos queda crear el controlador que es el encargado de enlazar el acceso a los datos con la vista:

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
package com.ecodeup.controller;
 
import java.util.ArrayList;
import java.util.List;
 
import com.ecodeup.dao.ClienteDaoImpl;
import com.ecodeup.idao.IClienteDao;
import com.ecodeup.model.Cliente;
import com.ecodeup.vista.ViewCliente;
 
public class ControllerCliente {
	
	private ViewCliente vista= new ViewCliente();
	
	public ControllerCliente() {
	}
	
	//llama al DAO para guardar un cliente
	public void registrar(Cliente cliente ) {
		IClienteDao dao= new  ClienteDaoImpl();
		dao.registrar(cliente);
	}
	
	//llama al DAO para actualizar un cliente
	public void actualizar(Cliente cliente) {
		IClienteDao dao= new  ClienteDaoImpl();
		dao.actualizar(cliente);
	}
	
	//llama al DAO para eliminar un cliente
	public void eliminar(Cliente cliente) {
		IClienteDao dao= new  ClienteDaoImpl();
		dao.eliminar(cliente);
	}
	
	//llama al DAO para obtener todos los clientes y luego los muestra en la vista
	public void verClientes(){
		List<Cliente> clientes = new ArrayList<Cliente>();
		IClienteDao dao= new  ClienteDaoImpl();
		clientes=dao.obtener();
		vista.verClientes(clientes);
	}
}

5. DEMO DEL CRUD

Finalmente lo que haremos es crear un demo para ver el funcionamiento de lo que programamos anteriormente.

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
package com.ecodeup.demo;
 
import com.ecodeup.controller.ControllerCliente;
 
import com.ecodeup.model.Cliente;
 
public class CrudJavaDemo {
 
	public static void main(String[] args) {
 
		Cliente cliente = new Cliente("1717213183", "Elivar", "Largo");			
		
		// controlador
		ControllerCliente controller = new ControllerCliente();
 
		// guarda un cliente a través del controlador
		controller.registrar(cliente);
 
		// ver clientes
		controller.verClientes();
 
		// editar un cliente por medio del id
		cliente.setId(1);
		cliente.setNombre("Santiago");
		controller.actualizar(cliente);
 
		// eliminar un cliente por medio del id
		cliente.setId(1);
		controller.eliminar(cliente);
	}
}

Recuerda seguir la estructura del proyecto que vimos en la primera imagen, para que todo funcione correctamente.

Espero que este tutorial te haya servido, nos vemos en la próxima entrada y si tuviste algún problema no dudes en dejarme un comentario.

Buscar este blog

Compartiendo conocimientos