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.

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.
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
-- phpMyAdmin SQL Dump
-- version 4.5.5.1
-- http://www.phpmyadmin.net
--
-- Servidor: 127.0.0.1
-- Tiempo de generación: 12-06-2017 a las 00:26:33
-- Versión del servidor: 5.7.11
-- Versión de PHP: 5.6.19

SET SQL_MODE = "NO_AUTO_VALUE_ON_ZERO";

SET time_zone = "+00:00";

/*!40101 SET
@OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET
@OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
/*!40101 SET
@OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
/*!40101 SET NAMES utf8mb4 */;

--
-- Base de datos: `javaweb_crud`
--

-- --------------------------------------------------------

--
-- Estructura de tabla para la tabla `articulos`
--

CREATE TABLE `articulos` (

`id` int(10) NOT NULL,
`codigo` varchar(30) COLLATE utf8_spanish2_ci NOT NULL,
`nombre` varchar(50) COLLATE utf8_spanish2_ci NOT NULL,
 `descripcion` varchar(50) COLLATE utf8_spanish2_ci NOT NULL,
`existencia` double NOT NULL,
`precio` double NOT NULL
) ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_spanish2_ci;

--
-- Volcado de datos para la tabla `articulos`
--

INSERT INTO `articulos` (`id`, `codigo`, `nombre`, `descripcion`, `existencia`,

`precio`) VALUES
(5, 'EC001', 'ESFERO ROJO', 'ESFERO BORRABLE', 40, 0.65),
(4, 'EC002', 'ESFERO NEGRO', 'ESFERO BORRABLE', 30, 0.65),
(6, 'FA001', 'FOLDER ARCHIVADOR AZ OFICIO', 'FOLDER CARTÓN', 10,
2.79),
(7, 'SM001', 'SOBRE MANILA ', 'SOBRE MANILA OFICIO', 15, 0.1);

--
-- Índices para tablas volcadas
--

--
-- Indices de la tabla `articulos`
--
ALTER TABLE `articulos`
ADD PRIMARY KEY (`id`);

--
-- AUTO_INCREMENT de las tablas volcadas
--

--
-- AUTO_INCREMENT de la tabla `articulos`
--
ALTER TABLE `articulos`
MODIFY `id` int(10) NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=8;
/*!40101 SET
CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
/*!40101 SET
CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
/*!40101 SET
COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;

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>).
Dependencias añadidas al proyecto JSP y Servlets
XHTML

1   <dependencies>
2     <dependency>
3         <groupId>javax.servlet</groupId>
4         <artifactId>javax.servlet-api</artifactId>
5         <version>3.1.0</version>
6         <scope>provided</scope>
7     </dependency>
8     <dependency>
9         <groupId>javax.servlet.jsp</groupId>
10         <artifactId>javax.servlet.jsp-api</artifactId>
11         <version>2.3.1</version>
12         <scope>provided</scope>
13     </dependency>
14     <dependency>
15         <groupId>jstl</groupId>
16         <artifactId>jstl</artifactId>
17         <version>1.2</version>
18     </dependency>
19     <dependency>
20         <groupId>mysql</groupId>
21         <artifactId>mysql-connector-java</artifactId>
22         <version>5.1.30</version>
23     </dependency>
24 </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.
Archivo web.xml proyecto JSP y Servlet
XHTML

<?xml version="1.0" encoding="UTF-8"?>

1 <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
2 xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
3 http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
4   <display-name>CRUD Artículos con JSP y Servlet </display-name>
5   <context-param>
6     <param-name>jdbcURL</param-name>
7     <param-value>jdbc:mysql://localhost:3306/javaweb_crud</param-value>
8   </context-param>
9   <context-param>
10     <param-name>jdbcUsername</param-name>
11     <param-value>root</param-value>
12   </context-param>
13   <context-param>
14     <param-name>jdbcPassword</param-name>
15     <param-value></param-value>
16   </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.
Clase de conexión proyecto JSP y Servlets
Java

1 package com.ecodeup.articulos.model;
2  
3 import java.sql.Connection;
4 import java.sql.DriverManager;
5 import java.sql.SQLException;
6  
7 /*
8 * @autor: Elivar Largo
9 * @web: www.ecodeup.com
10 */
11  
12 public class Conexion {
13     private Connection jdbcConnection;
14     private String jdbcURL;
15     private String jdbcUsername;
16     private String jdbcPassword;
17     
18     public Conexion(String jdbcURL, String jdbcUsername, String jdbcPassword) {
19 this.jdbcURL = jdbcURL;
20 this.jdbcUsername = jdbcUsername;
21 this.jdbcPassword = jdbcPassword;
22 }
23  
24 public void conectar() throws SQLException {
25         if (jdbcConnection == null || jdbcConnection.isClosed()) {
26             try {
27                 Class.forName("com.mysql.jdbc.Driver");
28             } catch (ClassNotFoundException e) {
29                 throw new SQLException(e);
30             }
31             jdbcConnection = DriverManager.getConnection(
32                                         jdbcURL, jdbcUsername, jdbcPassword);
33         }
34     }
35     
36     public void desconectar() throws SQLException {
37         if (jdbcConnection != null && !jdbcConnection.isClosed()) {
38             jdbcConnection.close();
39         }
40     }
41  
42 public Connection getJdbcConnection() {
43 return jdbcConnection;
44 }  
45  
46 }

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
Clase para modelo
Java

1 package com.ecodeup.articulos.model;
2  
3 /*
4 * @autor: Elivar Largo
5 * @ web: www.ecodeup.com
6 */
7  
8 public class Articulo {
9 private int id;
10 private String codigo;
11 private String nombre;
12 private String descripcion;
13 private double existencia;
14 private double precio;
15
16 public Articulo(int id, String codigo, String nombre, String descripcion, double existencia,
17 double precio) {
18 this.id = id;
19 this.codigo = codigo;
20 this.nombre = nombre;
21 this.descripcion = descripcion;
22 this.existencia = existencia;
23 this.precio = precio;
24 }
25 //getters y setters
26 public int getId() {
27 return id;
28 }
29
 public void setId(int id) {
30 this.id = id;
31 }
32 public String getCodigo() {
33 return codigo;
34 }
35 public void setCodigo(String codigo) {
36 this.codigo = codigo;
37 }
38 public String getNombre() {
39 return nombre;
40 }
41 public void setNombre(String nombre) {
42 this.nombre = nombre;
43 }
44 public String getDescripcion() {
45 return descripcion;
46 }
47 public void setDescripcion(String descripcion) {
48 this.descripcion = descripcion;
49 }
50 public double getExistencia() {
51 return existencia;
52 }
53 public void setExistencia(double existencia) {
54 this.existencia = existencia;
55 }
56 public double getPrecio() {
57 return precio;
58 }
59 public void setPrecio(double precio) {
60 this.precio = precio;
61 }
}

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.
Clase CRUD tabla articulos
Java

1 package com.ecodeup.articulos.dao;
2  
3 import java.sql.Connection;
4 import java.sql.PreparedStatement;
5 import java.sql.ResultSet;
6 import java.sql.SQLException;
7 import java.sql.Statement;
8 import java.util.ArrayList;
9 import java.util.List;
10  
11 import com.ecodeup.articulos.model.Articulo;
12 import com.ecodeup.articulos.model.Conexion;
13  
14 /*
15 * @autor: Elivar Largo
16 * @web: www.ecodeup.com
17 */
18  
19 public class ArticuloDAO {
20 private Conexion con;
21 private Connection connection;
22  
23 public ArticuloDAO(String jdbcURL, String jdbcUsername, String jdbcPassword) throws
24 SQLException {
25 System.out.println(jdbcURL);
26 con = new Conexion(jdbcURL, jdbcUsername, jdbcPassword);
27 }
28  
29 // insertar artículo
30 public boolean insertar(Articulo articulo) throws SQLException {
31 String sql = "INSERT INTO articulos (id, codigo, nombre, descripcion, existencia,
32 precio) VALUES (?, ?, ?,?,?,?)";
33 System.out.println(articulo.getDescripcion());
34 con.conectar();
35 connection = con.getJdbcConnection();
36 PreparedStatement statement = connection.prepareStatement(sql);
37 statement.setString(1, null);
38 statement.setString(2, articulo.getCodigo());
39 statement.setString(3, articulo.getNombre());
40 statement.setString(4, articulo.getDescripcion());
41 statement.setDouble(5, articulo.getExistencia());
42 statement.setDouble(6, articulo.getPrecio());
43  
44 boolean rowInserted = statement.executeUpdate() > 0;
45 statement.close();
46 con.desconectar();
47 return rowInserted;
48 }
49  
50 // listar todos los productos
51 public List<Articulo> listarArticulos() throws SQLException {
52  
53 List<Articulo> listaArticulos = new ArrayList<Articulo>();
54 String sql = "SELECT * FROM articulos";
55 con.conectar();
56 connection = con.getJdbcConnection();
57 Statement statement = connection.createStatement();
58 ResultSet resulSet = statement.executeQuery(sql);
59  
60 while (resulSet.next()) {
61 int id = resulSet.getInt("id");
62 String codigo = resulSet.getString("codigo");
63 String nombre = resulSet.getString("nombre");
64 String descripcion = resulSet.getString("descripcion");
65 Double existencia = resulSet.getDouble("existencia");
66 Double precio = resulSet.getDouble("precio");
67 Articulo articulo = new Articulo(id, codigo, nombre, descripcion, existencia,
68 precio);
69 listaArticulos.add(articulo);
70 }
71 con.desconectar();
72 return listaArticulos;
73 }
  
// obtener por id
public Articulo obtenerPorId(int id) throws SQLException {
74 Articulo articulo = null;
75  
76 String sql = "SELECT * FROM articulos WHERE id= ? ";
77 con.conectar();
78 connection = con.getJdbcConnection();
79 PreparedStatement statement = connection.prepareStatement(sql);
80 statement.setInt(1, id);
81  
82 ResultSet res = statement.executeQuery();
83 if (res.next()) {
84 articulo = new Articulo(res.getInt("id"), res.getString("codigo"),
85 res.getString("nombre"),
86 res.getString("descripcion"), res.getDouble("existencia"),
87 res.getDouble("precio"));
88 }
89 res.close();
90 con.desconectar();
91  
92 return articulo;
93 }
94  
95 // actualizar
96 public boolean actualizar(Articulo articulo) throws SQLException {
97 boolean rowActualizar = false;
98 String sql = "UPDATE articulos SET
99 codigo=?,nombre=?,descripcion=?,existencia=?, precio=? WHERE id=?";
100 con.conectar();
101 connection = con.getJdbcConnection();
102 PreparedStatement statement = connection.prepareStatement(sql);
103 statement.setString(1, articulo.getCodigo());
104 statement.setString(2, articulo.getNombre());
105 statement.setString(3, articulo.getDescripcion());
106 statement.setDouble(4, articulo.getExistencia());
107 System.out.println(articulo.getPrecio());
108 statement.setDouble(5, articulo.getPrecio());
109 statement.setInt(6, articulo.getId());
110  
111 rowActualizar = statement.executeUpdate() > 0;
112 statement.close();
113 con.desconectar();
114 return rowActualizar;
115 }
116
117 //eliminar
118 public boolean eliminar(Articulo articulo) throws SQLException {
119 boolean rowEliminar = false;
120 String sql = "DELETE FROM articulos WHERE ID=?";
121 con.conectar();
122 connection = con.getJdbcConnection();
123 PreparedStatement statement = connection.prepareStatement(sql);
124 statement.setInt(1, articulo.getId());
125  
126 rowEliminar = statement.executeUpdate() > 0;
127 statement.close();
128 con.desconectar();
129  
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.
Servlet AdminProducto y controller de la aplicación
Java

1 package com.ecodeup.articulo.controller;
2  
3 import java.io.IOException;
4 import java.sql.SQLException;
5 import java.util.List;
6  
7 import javax.servlet.RequestDispatcher;
8 import javax.servlet.ServletException;
9 import javax.servlet.annotation.WebServlet;
10 import javax.servlet.http.HttpServlet;
11 import javax.servlet.http.HttpServletRequest;
12 import javax.servlet.http.HttpServletResponse;
13  
14 import com.ecodeup.articulos.dao.ArticuloDAO;
15 import com.ecodeup.articulos.model.Articulo;
16  
17 /**
18 * Servlet implementation class AdminArticulo
19 */
20 @WebServlet("/adminArticulo")
21 public class AdminArticulo extends HttpServlet {
22 private static final long serialVersionUID = 1L;
23 ArticuloDAO articuloDAO;
24  
25 public void init() {
26 String jdbcURL = getServletContext().getInitParameter("jdbcURL");
27 String jdbcUsername = getServletContext().getInitParameter("jdbcUsername");
28 String jdbcPassword = getServletContext().getInitParameter("jdbcPassword");
29 try {
30  
31 articuloDAO = new ArticuloDAO(jdbcURL, jdbcUsername, jdbcPassword);
32 } catch (Exception e) {
33 // TODO: handle exception
34 }
35 }
36  
37 /**
38 * @see HttpServlet#HttpServlet()
39 */
40 public AdminArticulo() {
41 super();
42 // TODO Auto-generated constructor stub
43 }
 44  
45 /**
46 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse
47 *      response)
48 */
49 protected void doGet(HttpServletRequest request, HttpServletResponse response)
50 throws ServletException, IOException {
51 System.out.println("Hola Servlet..");
52 String action = request.getParameter("action");
53 System.out.println(action);
54 try {
55 switch (action) {
56 case "index":
57 index(request, response);
58 break;
59 case "nuevo":
60 nuevo(request, response);
61 break;
62 case "register":
63 System.out.println("entro");
64 registrar(request, response);
65 break;
66 case "mostrar":
67 mostrar(request, response);
68 break;
69 case "showedit":
70 showEditar(request, response);
71 break;
72 case "editar":
73 editar(request, response);
74 break;
75 case "eliminar":
76 eliminar(request, response);
77 break;
78 default:
79 break;
80 }
81 } catch (SQLException e) {
82 e.getStackTrace();
83 }
84
85
86
87 }
88  
89 /**
90 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse
91 *      response)
92 */
93 protected void doPost(HttpServletRequest request, HttpServletResponse response)
94 throws ServletException, IOException {
95 System.out.println("Hola Servlet..");
96 doGet(request, response);
97 }
98
99 private void index (HttpServletRequest request, HttpServletResponse response) throws
100 SQLException, ServletException, IOException{
101 //mostrar(request, response);
102 RequestDispatcher dispatcher= request.getRequestDispatcher("index.jsp");
103 dispatcher.forward(request, response);
104 }
105  
106 private void registrar(HttpServletRequest request, HttpServletResponse response) throws
107 ServletException, IOException, SQLException {
108 Articulo articulo = new Articulo(0, request.getParameter("codigo"),
109 request.getParameter("nombre"), request.getParameter("descripcion"),
110 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 =
111 request.getRequestDispatcher("/vista/register.jsp");
112 dispatcher.forward(request, response);
113 }
114
115
116
117 private void mostrar(HttpServletRequest request, HttpServletResponse response) throws
118 SQLException, IOException , ServletException{
119 RequestDispatcher dispatcher =
120 request.getRequestDispatcher("/vista/mostrar.jsp");
121 List<Articulo> listaArticulos= articuloDAO.listarArticulos();
122 request.setAttribute("lista", listaArticulos);
123 dispatcher.forward(request, response);
124 }
125
126 private void showEditar(HttpServletRequest request, HttpServletResponse response) throws
127 ServletException, IOException, SQLException {
128 Articulo articulo =
129 articuloDAO.obtenerPorId(Integer.parseInt(request.getParameter("id")));
130 request.setAttribute("articulo", articulo);
131
132
RequestDispatcher dispatcher = request.getRequestDispatcher("/vista/editar.jsp");
133
dispatcher.forward(request, response);
134
}
135
136
137 private void editar(HttpServletRequest request, HttpServletResponse response) throws
138 SQLException, ServletException, IOException{
139 Articulo articulo = new Articulo(Integer.parseInt(request.getParameter("id")),
140 request.getParameter("codigo"), request.getParameter("nombre"),
141 request.getParameter("descripcion"), Double.parseDouble(request.getParameter("existencia")),
142 Double.parseDouble(request.getParameter("precio")));
143 articuloDAO.actualizar(articulo);
144 index(request, response);
145 }
146
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.
Página JSP mostrar Artículos
XHTML

1 <%@ page language="java" contentType="text/html; charset=ISO-8859-1"

2     pageEncoding="ISO-8859-1"%>
3     
4   <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
5 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
6 "http://www.w3.org/TR/html4/loose.dtd">
7 <html>
8 <head>
9 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
10 <title>Administrar Artículos</title>
11 </head>
12 <body>
13 <h1>Lista  Artículos</h1>
14 <table>
15 <tr>
16 <td><a href="adminArticulo?action=index" >Ir al menú</a> </td>
17 </tr>
18 </table>
19
20 <table border="1" width="100%">
21 <tr>
22 <td> ID</td>
23 <td> CODIGO</td>
24 <td> NOMBRE</td>
25 <td>DESCRPICION</td>
26 <td>EXISTENCIA</td>
27 <td>PRECIO</td>
28 <td colspan=2>ACCIONES</td>
29 </tr>
30 <c:forEach var="articulo" items="${lista}">
31 <tr>
32 <td><c:out value="${articulo.id}"/></td>
33
 <td><c:out value="${articulo.codigo}"/></td>
<td><c:out value="${articulo.nombre}"/></td>
34 <td><c:out value="${articulo.descripcion}"/></td>
35 <td><c:out value="${articulo.existencia}"/></td>
36 <td><c:out value="${articulo.precio}"/></td>
37 <td><a href="adminArticulo?action=showedit&id=<c:out value="$
38 {articulo.id}" />">Editar</a></td>
39 <td><a href="adminArticulo?action=eliminar&id=<c:out value="$
40 {articulo.id}"/>">Eliminar</a> </td>
41 </tr>
42 </c:forEach>
43 </table>
44
</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.