Cómo crear un CRUD en Java Web con JSP y Servlet
Hola que tal, bienvenido a este nuevo artículo, en donde aprenderás cómo crear un CRUD en Java Web con JSP y Servlet.
Para este ejercicio usaremos Maven para la gestión de librerías, aclarar también que si bien es cierto que el CRUD es de una sola tabla, el tutorial es muy práctico ya que te da las bases para que tu continúes de forma autodidacta aplicando esos conocimientos en un proyecto más grande.
Que necesitas?
Tener instalado Java 8, descargar Eclipse Neon y configurado con Apache Tomcat, si no tienes instalado nada de lo anterior, puedes hacerlo revisando estos tutoriales: Instalar Java 8, Consola VS IDE, Integrar Apache en Eclipse.
Tener instalado MySQL con algún entorno para poder administrarlos bien sea phpMyadmin o MySQL Workbench, si no tienes instalado, puedes revisar estos tutoriales: Instalar MySQL y MySQL WORKBENCH en Windows 10 o bien Cómo instalar WampServer en Windows 10.
Hoja de ruta de lo que vamos hacer
Crear la base de datos con la tabla artículos.
Crear el proyecto Web.
Convertir el proyecto Web a Maven y configurar el archivo pom.xml.
Definir la conexión a la base de datos usando el archivo web.xml
Crear el modelo para la tabla artículos.
Crear la clase DAO (métodos CRUD) y Controlador.
Crear las Vistas.
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.
De momento dejo una vista previa de como va quedar la vista principal de proyecto.
Crear la base de datos y la tabla artículos
Para crear la base de datos junto con la tabla, bien puedes hacerlo de forma gráfica o usar el siguiente script Descarga Script. La tabla artículos tiene 5 campos (id, codigo, nombre, descripcion, existencia, precio) que hacen referencia al artículo, la clave primaria es el campo id y es un campo auto numérico.
Recuerda que antes de ejecutar el script para crear la tabla, debes crear la base de datos y esta debe llamarse javaweb_crud.
Estructura completa del Proyecto
Esta es la estructura del proyecto que debe quedar al final del tutorial y que la iré explicando en el transcurso del mismo.
Crear el Web Dynamic Project
Como la idea de este artículo es aprender un poco de Java Web con JSP y Servlet vamos a crear un proyecto Web Dynamic Project, como se muestra en la siguiente imagen.
Si no lo encuentras en en esa opción, pincha al final en la opción Other->Web->Dynamic Web Project, lo siguiente es darle el nombre el proyecto y crearlo.
Es importante que en el proyecto, la versión de Servlet sea la 3.1 y que esté atado al contenedor de Servlet Apache Tomcat.
Finalmente el proyecto quedaría como se muestra a continuación.
Convertir el Proyecto a Maven
La idea de usar Maven en un proyecto es poder gestionar el uso de librerías que va utilizar la aplicación, por lo que ya no tenemos que descargar los .jar, sino que Maven lo hará por nosotros, sólo bastará con indicarle en el archivo pom.xml, las librerías que vayamos a usar. En las siguientes imágenes, te muestro paso a paso como hacerlo, primero debes dar click derecho sobre el proyecto y luego seguir la imagen.
Te va pedir algunos datos con respeto al proyecto Maven.
Ahora la vista del proyecto quedará de la siguiente manera, el archivo pom.xml es donde añadiremos las dependencias del proyecto, que son las librerías que vamos a usar.
Finalmente se añade las dependencias al archivo pom.xml (jstl, jsp, servlet y MySQL) de manera que traiga las librerías desde su repositorio (las dependencias deben estar entre la etiqueta <description> y <build>).
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
<dependencies> <dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>3.1.0</version> <scope>provided</scope> </dependency> <dependency> <groupId>javax.servlet.jsp</groupId> <artifactId>javax.servlet.jsp-api</artifactId> <version>2.3.1</version> <scope>provided</scope> </dependency> <dependency> <groupId>jstl</groupId> <artifactId>jstl</artifactId> <version>1.2</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.30</version> </dependency> </dependencies> |
Una vez agregadas las dependencias debemos actualizar el proyecto de manera que los cambios surjan efectos.
Te va indicar que proyecto se va actualizar y le das OK. Al actualizar el proyecto se descargarán automáticamente las librerías a utilizar de modo que ahora el proyecto quedará como en la siguiente imagen.
Crear el archivo web.xml
Con la versión anterior a la 3.1 (Servlet) este archivo se generaba automáticamente, puesto que ahí se mapeaba todo lo referente a la configuración de los Servlets, con la versión 3.1 todo se lo hace con anotaciones dentro del mismo Servlet. Pues bien, dicho lo anterior, es necesario crear el archivo web.xml ya que vamos a cargar ahí las configuraciones para el acceso a la base de datos, hacemos esto por se una buena práctica, en cuanto a seguridades se refiere.
Como te mencionaba, aquí vamos a cargar tanto la URL de conexión, así como el usuario y la clave, de tal manera que en las clases donde se acceda a la conexión sólo llamaremos a los atributos del archivo web.xml, la configuración del archivo debe quedar como sigue, no olvides que debes cambiar tu usuario y clave para entrar a MySQL.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1"> <display-name>CRUD Artículos con JSP y Servlet </display-name> <context-param> <param-name>jdbcURL</param-name> <param-value>jdbc:mysql://localhost:3306/javaweb_crud</param-value> </context-param> <context-param> <param-name>jdbcUsername</param-name> <param-value>root</param-value> </context-param> <context-param> <param-name>jdbcPassword</param-name> <param-value></param-value> </context-param> </web-app> |
Crear la clase para la conexión
La clase para la conexión queda de la siguiente manera, básicamente lo que se hace es crear la conexión con los parámetros pasados desde el archivo web.xml, la clase contiene dos métodos, uno para conectar y otro para desconectar, se añade también el acceso a la variable de la conexión jdbcConnection, de manera que se la pueda obtener desde cualquier parte del DAO, la clase debe estar dentro del paquete com.ecodeup.articulos.model.
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.
|
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 |
package com.ecodeup.articulos.model; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; /* * @autor: Elivar Largo * @web: www.ecodeup.com */ public class Conexion { private Connection jdbcConnection; private String jdbcURL; private String jdbcUsername; private String jdbcPassword; public Conexion(String jdbcURL, String jdbcUsername, String jdbcPassword) { this.jdbcURL = jdbcURL; this.jdbcUsername = jdbcUsername; this.jdbcPassword = jdbcPassword; } public void conectar() throws SQLException { if (jdbcConnection == null || jdbcConnection.isClosed()) { try { Class.forName("com.mysql.jdbc.Driver"); } catch (ClassNotFoundException e) { throw new SQLException(e); } jdbcConnection = DriverManager.getConnection( jdbcURL, jdbcUsername, jdbcPassword); } } public void desconectar() throws SQLException { if (jdbcConnection != null && !jdbcConnection.isClosed()) { jdbcConnection.close(); } } public Connection getJdbcConnection() { return jdbcConnection; } } |
Crear la clase Articulo para el modelo
Esta clase contiene los atributos para mapear el objeto hacia la tabla de la base de datos y debe estar dentro del paquete com.ecodeup.articulos.model
|
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 |
package com.ecodeup.articulos.model; /* * @autor: Elivar Largo * @ web: www.ecodeup.com */ public class Articulo { private int id; private String codigo; private String nombre; private String descripcion; private double existencia; private double precio; public Articulo(int id, String codigo, String nombre, String descripcion, double existencia, double precio) { this.id = id; this.codigo = codigo; this.nombre = nombre; this.descripcion = descripcion; this.existencia = existencia; this.precio = precio; } //getters y setters public int getId() { return id; } public void setId(int id) { this.id = id; } public String getCodigo() { return codigo; } public void setCodigo(String codigo) { this.codigo = codigo; } public String getNombre() { return nombre; } public void setNombre(String nombre) { this.nombre = nombre; } public String getDescripcion() { return descripcion; } public void setDescripcion(String descripcion) { this.descripcion = descripcion; } public double getExistencia() { return existencia; } public void setExistencia(double existencia) { this.existencia = existencia; } public double getPrecio() { return precio; } public void setPrecio(double precio) { this.precio = precio; } } |
Crear la clase lo métodos CRUD para la tabla artículos
Esta clase contiene todos los métodos CRUD para la tabla artículos y está organizada de la siguiente manera, esta clase debe estar dentro del paquete com.ecodeup.articulos.dao.
|
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 |
package com.ecodeup.articulos.dao; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; import java.util.ArrayList; import java.util.List; import com.ecodeup.articulos.model.Articulo; import com.ecodeup.articulos.model.Conexion; /* * @autor: Elivar Largo * @web: www.ecodeup.com */ public class ArticuloDAO { private Conexion con; private Connection connection; public ArticuloDAO(String jdbcURL, String jdbcUsername, String jdbcPassword) throws SQLException { System.out.println(jdbcURL); con = new Conexion(jdbcURL, jdbcUsername, jdbcPassword); } // insertar artículo public boolean insertar(Articulo articulo) throws SQLException { String sql = "INSERT INTO articulos (id, codigo, nombre, descripcion, existencia, precio) VALUES (?, ?, ?,?,?,?)"; System.out.println(articulo.getDescripcion()); con.conectar(); connection = con.getJdbcConnection(); PreparedStatement statement = connection.prepareStatement(sql); statement.setString(1, null); statement.setString(2, articulo.getCodigo()); statement.setString(3, articulo.getNombre()); statement.setString(4, articulo.getDescripcion()); statement.setDouble(5, articulo.getExistencia()); statement.setDouble(6, articulo.getPrecio()); boolean rowInserted = statement.executeUpdate() > 0; statement.close(); con.desconectar(); return rowInserted; } // listar todos los productos public List<Articulo> listarArticulos() throws SQLException { List<Articulo> listaArticulos = new ArrayList<Articulo>(); String sql = "SELECT * FROM articulos"; con.conectar(); connection = con.getJdbcConnection(); Statement statement = connection.createStatement(); ResultSet resulSet = statement.executeQuery(sql); while (resulSet.next()) { int id = resulSet.getInt("id"); String codigo = resulSet.getString("codigo"); String nombre = resulSet.getString("nombre"); String descripcion = resulSet.getString("descripcion"); Double existencia = resulSet.getDouble("existencia"); Double precio = resulSet.getDouble("precio"); Articulo articulo = new Articulo(id, codigo, nombre, descripcion, existencia, precio); listaArticulos.add(articulo); } con.desconectar(); return listaArticulos; } // obtener por id public Articulo obtenerPorId(int id) throws SQLException { Articulo articulo = null; String sql = "SELECT * FROM articulos WHERE id= ? "; con.conectar(); connection = con.getJdbcConnection(); PreparedStatement statement = connection.prepareStatement(sql); statement.setInt(1, id); ResultSet res = statement.executeQuery(); if (res.next()) { articulo = new Articulo(res.getInt("id"), res.getString("codigo"), res.getString("nombre"), res.getString("descripcion"), res.getDouble("existencia"), res.getDouble("precio")); } res.close(); con.desconectar(); return articulo; } // actualizar public boolean actualizar(Articulo articulo) throws SQLException { boolean rowActualizar = false; String sql = "UPDATE articulos SET codigo=?,nombre=?,descripcion=?,existencia=?, precio=? WHERE id=?"; con.conectar(); connection = con.getJdbcConnection(); PreparedStatement statement = connection.prepareStatement(sql); statement.setString(1, articulo.getCodigo()); statement.setString(2, articulo.getNombre()); statement.setString(3, articulo.getDescripcion()); statement.setDouble(4, articulo.getExistencia()); System.out.println(articulo.getPrecio()); statement.setDouble(5, articulo.getPrecio()); statement.setInt(6, articulo.getId()); rowActualizar = statement.executeUpdate() > 0; statement.close(); con.desconectar(); return rowActualizar; } //eliminar public boolean eliminar(Articulo articulo) throws SQLException { boolean rowEliminar = false; String sql = "DELETE FROM articulos WHERE ID=?"; con.conectar(); connection = con.getJdbcConnection(); PreparedStatement statement = connection.prepareStatement(sql); statement.setInt(1, articulo.getId()); rowEliminar = statement.executeUpdate() > 0; statement.close(); con.desconectar(); return rowEliminar; } } |
Crear el Servlet que sirve de controlador
El Servlet se llama AdminArticulo, y se encuentra dentro del paquete com.ecodeup.articulos.controller.
En el Servlet manejamos todas las peticiones como por ejemplo para crear un nuevo artículo, actualizar y eliminar.
|
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 |
package com.ecodeup.articulo.controller; import java.io.IOException; import java.sql.SQLException; import java.util.List; import javax.servlet.RequestDispatcher; import javax.servlet.ServletException; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import com.ecodeup.articulos.dao.ArticuloDAO; import com.ecodeup.articulos.model.Articulo; /** * Servlet implementation class AdminArticulo */ @WebServlet("/adminArticulo") public class AdminArticulo extends HttpServlet { private static final long serialVersionUID = 1L; ArticuloDAO articuloDAO; public void init() { String jdbcURL = getServletContext().getInitParameter("jdbcURL"); String jdbcUsername = getServletContext().getInitParameter("jdbcUsername"); String jdbcPassword = getServletContext().getInitParameter("jdbcPassword"); try { articuloDAO = new ArticuloDAO(jdbcURL, jdbcUsername, jdbcPassword); } catch (Exception e) { // TODO: handle exception } } /** * @see HttpServlet#HttpServlet() */ public AdminArticulo() { super(); // TODO Auto-generated constructor stub } /** * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse * response) */ protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { System.out.println("Hola Servlet.."); String action = request.getParameter("action"); System.out.println(action); try { switch (action) { case "index": index(request, response); break; case "nuevo": nuevo(request, response); break; case "register": System.out.println("entro"); registrar(request, response); break; case "mostrar": mostrar(request, response); break; case "showedit": showEditar(request, response); break; case "editar": editar(request, response); break; case "eliminar": eliminar(request, response); break; default: break; } } catch (SQLException e) { e.getStackTrace(); } } /** * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse * response) */ protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { System.out.println("Hola Servlet.."); doGet(request, response); } private void index (HttpServletRequest request, HttpServletResponse response) throws SQLException, ServletException, IOException{ //mostrar(request, response); RequestDispatcher dispatcher= request.getRequestDispatcher("index.jsp"); dispatcher.forward(request, response); } private void registrar(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException, SQLException { Articulo articulo = new Articulo(0, request.getParameter("codigo"), request.getParameter("nombre"), request.getParameter("descripcion"), Double.parseDouble(request.getParameter("cantidad")), Double.parseDouble(request.getParameter("precio"))); articuloDAO.insertar(articulo); RequestDispatcher dispatcher = request.getRequestDispatcher("index.jsp"); dispatcher.forward(request, response); } private void nuevo(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException, SQLException { RequestDispatcher dispatcher = request.getRequestDispatcher("/vista/register.jsp"); dispatcher.forward(request, response); } private void mostrar(HttpServletRequest request, HttpServletResponse response) throws SQLException, IOException , ServletException{ RequestDispatcher dispatcher = request.getRequestDispatcher("/vista/mostrar.jsp"); List<Articulo> listaArticulos= articuloDAO.listarArticulos(); request.setAttribute("lista", listaArticulos); dispatcher.forward(request, response); } private void showEditar(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException, SQLException { Articulo articulo = articuloDAO.obtenerPorId(Integer.parseInt(request.getParameter("id"))); request.setAttribute("articulo", articulo); RequestDispatcher dispatcher = request.getRequestDispatcher("/vista/editar.jsp"); dispatcher.forward(request, response); } private void editar(HttpServletRequest request, HttpServletResponse response) throws SQLException, ServletException, IOException{ Articulo articulo = new Articulo(Integer.parseInt(request.getParameter("id")), request.getParameter("codigo"), request.getParameter("nombre"), request.getParameter("descripcion"), Double.parseDouble(request.getParameter("existencia")), Double.parseDouble(request.getParameter("precio"))); articuloDAO.actualizar(articulo); index(request, response); } private void eliminar(HttpServletRequest request, HttpServletResponse response) throws SQLException, ServletException, IOException{ Articulo articulo = articuloDAO.obtenerPorId(Integer.parseInt(request.getParameter("id"))); articuloDAO.eliminar(articulo); RequestDispatcher dispatcher = request.getRequestDispatcher("index.jsp"); dispatcher.forward(request, response); } } |
Crear las vistas para el ejemplo
Las vistas son simples archivos con extensión .jsp, en las cuales usamos JSTL (Java Server Pages Tag Library) que no son más que etiquetas y que nos permiten manipular o embeber código java dentro de una pagína JSP.
Para poder hacer uso de estas etiquetas, se debe incluir una declaración en el inicio de la página JSP donde vayamos a usarlas (línea 4), en este caso pongo como ejemplo la página mostrar.jsp que está dentro de la carpeta vista y que muestra todos los artículos, finalmente recordar que (a excepción de la página index.jsp) las páginas JSP están dentro de la carpeta 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 44 |
<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%> <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>Administrar Artículos</title> </head> <body> <h1>Lista Artículos</h1> <table> <tr> <td><a href="adminArticulo?action=index" >Ir al menú</a> </td> </tr> </table> <table border="1" width="100%"> <tr> <td> ID</td> <td> CODIGO</td> <td> NOMBRE</td> <td>DESCRPICION</td> <td>EXISTENCIA</td> <td>PRECIO</td> <td colspan=2>ACCIONES</td> </tr> <c:forEach var="articulo" items="${lista}"> <tr> <td><c:out value="${articulo.id}"/></td> <td><c:out value="${articulo.codigo}"/></td> <td><c:out value="${articulo.nombre}"/></td> <td><c:out value="${articulo.descripcion}"/></td> <td><c:out value="${articulo.existencia}"/></td> <td><c:out value="${articulo.precio}"/></td> <td><a href="adminArticulo?action=showedit&id=<c:out value="${articulo.id}" />">Editar</a></td> <td><a href="adminArticulo?action=eliminar&id=<c:out value="${articulo.id}"/>">Eliminar</a> </td> </tr> </c:forEach> </table> </body> </html> |
Las demás vistas, index.jsp, register.jsp y editar.jsp las puedes descargar del proyecto completo, del siguiente enlace Descargar Proyecto Completo.
Finalmente te dejo una imagen de como se muestran los artículos ingresados junto con sus respectivas acciones, tanto de editar como de eliminar.
Espero haya sido de ayuda, si tienes alguna pregunta, la puedes hacer en la parte de comentarios, nos vemos en la próxima entrada.
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.
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 este y otros temas:
- Curso de Programación Java Web, con JSP, Servlet y JPA,
- CÓMO CREAR UN CRUD EN JAVA WEB CON JSP Y SERVLET,
- Integrar Bootstrap en un proyecto Java Web usando Java 8.
Elivar Largo
Full Stack Developer, JavaScript, PHP, Java, Spring, Laravel, Vuejs, Blogger, aprendiendo y compartiendo conocimientos. Cursos de Programación Web en: https://programacionfullstack.com/
Cargando ...
Gracias por compartir, oye puedes hacer un tutorial donde expliques lo mismo solo que utilizando las vistas o mejor utilizando PrimeFaces y JasperReport 😀
Hola Fernando, lo tendré en cuenta para los próximos artículos.
Hola, muy hermoso ese codigo y entendi por etapas que es lo que debo hacer, no lo he probado posiblemente funciones, la cuestion es la siguiente no tengo ni idea para que sirve cada linea de codigo, o porque se utilizan ciertas funciones asi. Podes decirme donde aprender como manejar todas estas variables y metodos?
Hola Andrés, gracias por tu comentario, puedes descargar el proyecto en el enlace que está al final y probar, te debería funcionar perfectamente. Si quieres aprender más a fondo y a detalle puedes revisar este enlace Aprende programación Web con JSP y Servlet
Saludos…
buen dia, un excelente tutorial, pero no tengo idea donde crear el archivo web.xml, antemano muchas gracias y exitos.
Hola ervin, el archivo web.xml se crea dentro de la carpeta WEB-INF, te puedes guiar por la imagen que está al inicio del artículo. Saludos
Excelente sitio WEB Elivar, felicidades la verdad es entiendible, hay cosas que no son tan comprensibles para alguien que va iniciando, pero es que la misma logica y metodologia te obligan a complementar la busqueda, sobre todo practicar una y otra vez, asi como leer y analizar paso por paso de los codigos ejemplos que nos brindas, muchas gracias !!!!
Que tal Oscar, gracias por tu comentario y me alegro mucho que te haya servido, comentarios como estos son los que inspiran a seguir publicando. Saludos
Gracias por el articulo y el codigo. Todo funciona a la primera y correctamente.
Muy completo todo.
Hola, disculpa al momento de ejecutar la aplicación, no me muestra nada, no se si hay algún paso adicional para ello?
Hola Daya, revisa que el Tomcat este levantado, puedes ver la consola y revisar si está ejecutándose. Revisa que estés ubicada en el proyecto que deseas ejecutar, puede también intentar ejecutarlo directamente desde servlet creado y no desde el proyecto, click derecho en servlet y ejecutar.
hola muy buen articulo, solo que se pueden duplicar un mismo usuario ya que son id diferentes habria una forma de validar un saludo
Hola edw2121, si se lo puede validar, lo más rápido en este caso es a través de código, antes de insertar se debería consultar usando (sentencias sql) si el usuario existe enviar un mensaje de usuario duplicado, caso contrario insertar
excelente sitio, solo tengo una duda, en el mostrar.jsp en la linea 29 cuando haces el forEach, la var=”articulo” de done lo optienes o a donde haces el llamado de esa variable ??
saludos
Gracias Luis, articulo es la variable que se declara para obtener y mostrar cada objecto al recorrer la lista, no precisamente debe llamarse artículo puede llamarse de cualquier nombre sin embargo le puse ese nombre para que haga referencia a lo se está obteniendo de la lista que son artículos.
Hola Elivar, primero felicitarte por tus cursos y videos.
No me permite descargar tu script para generar la DB por problemas de seguridad.Podrias subirlo d e nuevo?
Hola Alex déjame tu correo para enviarte el zip del proyecto
hola me envías el zip del proyecto por favor
Lo puedes descargar del artículo al final. Saludos
Me gusto las etapas de como le hiciste, aunque hay algunas cosas que no entiendo muy bien ya que apenas estoy iniciando en el desarrollo. Sin embargo esta excelente. Solo una cosa cuando le doy en mostrar pues no muestra nada, y ademas al insertar el registro me nada como id = 0; No se si algo esta mal aunque ya revice no encuentro que puede estar mal.
Hola, debería funcionarte intenta hacer una impresión de los datos por consola para ver si cuando ejecutas el método mostrar obtienes los datos de la consulta desde la base de datos.
hola por favor envíame el zip del proyecto ingenierojosecastillo@hotmail.com
La descarga del proyecto la encuentras al final en un enlace donde dice: Descarga del Proyecto Completo
Hola amigo muy util tu infofrmacion. No tienes un proyecto de java aplicacion web pero con store procedures? Sería de gran ayuda.
Hola, de momento no pero en los próximos artículos o videos trataré este tema.
Hola, disculpa nos basamos en tu ejemplo y nos ha sido de mucha utilidad, solo que no nos permite insertar desde eclipse solo si lo hacemos manualmente en mysql. Quisiera como hiciste la conexion de eclipse a mysql y cuales son los campos de la base de datos? porque la tabla la creamos pero no sabemos si este correcta.
Hola, para la conexión se usa el archivo web.xml y usando la clase Conexion.java que se muestra en el desarrollo del tutorial, en el constructor del ArticuloDAO es donde se hace la conexión pero usando los archivos anteriormente mencionados.
El script de la DB está al inicio del articulo, si lees un poco más a fondo lo puedes encontrar y descargar. Los campos de la tabla también los puedes identificar al momento de hacer el INSERT en la claseArticuloDAO.
Elivar, muy buenas tardes, mi nombre es Guillermo Cárdenas tengo una empresa de desarrollo de Aplicacioenes y estamos desarrollando con (JAVA, MySql en Eclipse) todo cliente/servidor y me han solicitado pasarlo a WEB, he mirado su modelo y experiencia y quisiera concertar una reunión para explorar su apoyo a este nuevo proyecto.
Ojala nos podamos contactar. Cordial Saludo
Guillermo
311 513 1223 Colombia
Excelente Elivar! Muchas gracias por la información, me has sacado de muchas dudas. Seguiré leyendo todos tus artículos.