+ +
Por el experto: Ing. Ubaldo Acosta
[Link]
Crear una aplicación para poner en práctica la integración de los
frameworks Struts + Spring + JPA. Al finalizar deberemos observar lo
siguiente:
[Link]
Mostrar el listado de personas utilizando Struts + Spring + JPA. Para ello necesitamos
integrar las 3 tecnologías descritas.
[Link]
Vamos a utilizar Maven para crear el proyecto Java Web. El proyecto se llamará
Struts2SpringJpaBasico. Este proyecto integrará las 3 tecnologías: Struts + Spring + JPA.
Empecemos con nuestro ejercicio:
[Link]
Creamos nuestro ejercicio llamado Struts2SpringJpaBasico:
[Link]
•Creamos un nuevo proyecto Java Maven de tipo Web Application:
[Link]
•Creamos un nuevo proyecto Java Maven:
[Link]
•Creamos un nuevo proyecto Java Maven:
[Link]
•El archivo [Link] de maven administra las librerías Java vamos a
utilizar. Agregaremos todas las librerías necesarias para integrar las
tecnologías descritas:
[Link]
Archivo [Link]: Clic para ver el
archivo
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="[Link] xmlns:xsi="[Link]
xsi:schemaLocation="[Link] [Link]
<modelVersion>4.0.0</modelVersion>
<groupId>[Link]</groupId>
<artifactId>Struts2SpringJpaBasico</artifactId>
<version>1.0</version>
<packaging>war</packaging>
<name>Struts2SpringJpaBasico</name>
<properties>
<[Link]>UTF-8</[Link]>
<[Link]>[Link]</[Link]>
</properties>
<dependencies>
<dependency>
<groupId>javax</groupId>
<artifactId>javaee-web-api</artifactId>
<version>8.0</version>
<scope>provided</scope>
</dependency> [Link]
Archivo [Link]: Clic para ver el
archivo
<dependency>
<groupId>[Link]</groupId>
<artifactId>struts2-core</artifactId>
<version>[Link]</version>
</dependency>
<dependency>
<groupId>[Link].log4j</groupId>
<artifactId>log4j-api</artifactId>
<version>2.10.0</version>
</dependency>
<dependency>
<groupId>[Link].log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.10.0</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>struts2-convention-plugin</artifactId>
<version>[Link]</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>asm</artifactId>
<version>6.0</version>
</dependency> [Link]
Archivo [Link]: Clic para ver el
archivo
<!--Spring-->
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-core</artifactId>
<version>${[Link]}</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-context</artifactId>
<version>${[Link]}</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-test</artifactId>
<version>${[Link]}</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-orm</artifactId>
<version>${[Link]}</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-web</artifactId>
<version>${[Link]}</version>
</dependency>
[Link]
Archivo [Link]: Clic para ver el
archivo
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${[Link]}</version>
</dependency>
<!--Struts 2 y Spring integracion-->
<dependency>
<groupId>[Link]</groupId>
<artifactId>struts2-spring-plugin</artifactId>
<version>[Link]</version>
</dependency>
<!-- MySql -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.42</version>
</dependency>
</dependencies>
[Link]
Archivo [Link]: Clic para ver el
archivo
<build>
<plugins>
<plugin>
<groupId>[Link]</groupId>
<artifactId>maven-war-plugin</artifactId>
<version>2.3</version>
<configuration>
<failOnMissingWebXml>false</failOnMissingWebXml>
</configuration>
</plugin>
<plugin>
<groupId>[Link]</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.7.0</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
[Link]
•Antes de hacer Clean & Build del proyecto para que descargue las librerías si fuera necesario, verificamos que el
servidor de Glassfish no esté iniciado ya que puede haber problemas para hacer el proceso de Clean & build si el
servidor está iniciado.
[Link]
•Para que se descarguen las nuevas librerías si fuera necesario, hacemos Clean & Build al proyecto. Si por alguna razón
este proceso falla, se debe desactivar cualquier software como antivirus, Windows defender o firewall durante este
proceso para que no se impida la descarga de archivos .jar de Java. Una vez terminado se pueden volver a activar estos
servicios. Este proceso puede demorar varios minutos dependiendo de su velocidad de internet:
[Link]
•Siya no fue necesario descargar ninguna librería debido a que podría ya tener todas descargadas, el proceso es más
rápido. Al final deberemos observar lo siguiente:
[Link]
Vamos a crear a continuación el archivo [Link]
Este archivo es el que nos permite configurar la tecnología de JPA (Java Persistence API).
Veamos como queda nuestro archivo [Link].
[Link]
•Creamos el archivo [Link] y lo agregamos a la carpeta siguiente según se
muestra:
[Link]
•El nombre del archivo es web, no es necesario agregar la extensión, la agrega en
automático el IDE ya que es un documento de tipo XML. Por último proporcionamos la
ruta:
[Link]
•Seleccionamos el tipo indicado y damos click en finalizar.
[Link]
Archivo [Link]: Clic para ver el
archivo
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="[Link]
xmlns:xsi="[Link]
xsi:schemaLocation="[Link]
[Link]
version="2.2">
<persistence-unit name="PersistenceUnit" transaction-type="JTA">
<provider>[Link]</provider>
<jta-data-source>jdbc/PersonaDb</jta-data-source>
<properties>
<property name="[Link]" value="FINE"/>
<property name="[Link]" value="true"/>
</properties>
</persistence-unit>
</persistence>
[Link]
Vamos a crear a continuación el archivo [Link]
Este archivo es el que nos permite configurar el framework de Spring.
Veamos como queda nuestro archivo [Link]
[Link]
•Creamos el archivo [Link] y lo agregamos a la carpeta siguiente según
se muestra:
[Link]
•El nombre del archivo es web, no es necesario agregar la extensión, la agrega en
automático el IDE ya que es un documento de tipo XML. Por último proporcionamos la
ruta:
[Link]
•Seleccionamos el tipo indicado y damos click en finalizar.
[Link]
Archivo [Link]: Clic para ver el
archivo
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="[Link]
xmlns:xsi="[Link]
xmlns:context="[Link]
xmlns:p="[Link]
xmlns:tx="[Link]
xmlns:jee="[Link]
xsi:schemaLocation="
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
<context:component-scan base-package="[Link]" />
<context:component-scan base-package="[Link]" />
[Link]
Archivo [Link]: Clic para ver el
archivo
<!-- Obtiene el entity manager inyectado en la fabrica de Spring -->
<bean class="[Link]" />
<bean id="transactionManager" class="[Link]" />
<!--Nombre que mapea con la Unidad de Persistencia en el archivo [Link]-->
<jee:jndi-lookup id="entityManagerFactory" jndi-name="persistence/PersistenceUnit" />
<!-- Detecta @Transactional -->
<tx:annotation-driven transaction-manager="transactionManager" />
</beans>
[Link]
Vamos a crear a continuación el archivo [Link]
Este archivo es el que nos permite unir una aplicación Java Web con el framework de Struts,
configurando el filtro de Struts en el archivo [Link].
Además, también nos permite integrar el framework de Spring con nuestra aplicación web por
medio de la configuración de un listener de Spring.
Nuestro archivo [Link] también nos permite configurar el nombre JNDI para la conexión a base
de datos que utilizaremos con JPA vía JTA.
Normalmente deberíamos usar la última versión del namespace de JavaEE, pero por problemas
con compatibilidad con Spring, usaremos la versión 3.1 del namespace.
Veamos como queda nuestro archivo [Link].
[Link]
•Creamos el archivo [Link] y lo agregamos a la carpeta WEB-INF según se muestra:
[Link]
•El nombre del archivo es web, no es necesario agregar la extensión, la agrega en
automático el IDE ya que es un documento de tipo XML. Por último proporcionamos la
ruta:
[Link]
•Seleccionamos el tipo indicado y damos click en finalizar.
[Link]
Archivo [Link]: Clic para ver el
archivo
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="[Link] xmlns:xsi="[Link]
xsi:schemaLocation="[Link] [Link]
version="3.1">
<!-- Integracion con Struts Framework-->
<filter>
<filter-name>struts2</filter-name>
<filter-class>[Link]</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!-- integracion con Spring Framework-->
<listener>
<listener-class>
[Link]
</listener-class>
</listener>
<!-- nombre utilizado en el archivo [Link] de Spring y JPA-->
<persistence-unit-ref>
<persistence-unit-ref-name>persistence/PersistenceUnit</persistence-unit-ref-name>
<persistence-unit-name>PersistenceUnit</persistence-unit-name>
</persistence-unit-ref>
</web-app>
[Link]
La clase de entidad [Link] que vamos a crear a continuación es la clase que va a ser
utilizada por la tecnología JPA para representar un registro de la tabla de persona de la base de
datos.
Vamos a utilizar anotaciones de JPA donde sea necesario para personalizar la clase [Link]
y así pueda representar exactamente a los registros de la tabla persona de la base de datos.
A este tipo de clase también se les conoce como clase de dominio.
Veamos como queda nuestra clase [Link]
[Link]
•Creamos la clase [Link]:
[Link]
•Creamos la clase [Link]:
[Link]
Archivo [Link]: Clic para ver el archivo
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
@Entity
public class Persona implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = [Link])
@Column(name = "id_persona")
private Long idPersona;
private String nombre;
@Column(name = "apellido_paterno")
private String apellidoPaterno;
[Link]
Archivo [Link]: Clic para ver el archivo
@Column(name = "apellido_materno")
private String apellidoMaterno;
private String email;
public Persona() {
}
public Persona(Long idPersona) {
[Link] = idPersona;
}
public Long getIdPersona() {
return idPersona;
}
public void setIdPersona(Long idPersona) {
[Link] = idPersona;
}
public String getNombre() {
return nombre;
}
[Link]
Archivo [Link]: Clic para ver el archivo
public void setNombre(String nombre) {
[Link] = nombre;
}
public String getApellidoPaterno() {
return apellidoPaterno;
}
public void setApellidoPaterno(String apellidoPaterno) {
[Link] = apellidoPaterno;
}
public String getApellidoMaterno() {
return apellidoMaterno;
}
public void setApellidoMaterno(String apellidoMaterno) {
[Link] = apellidoMaterno;
}
public String getEmail() {
return email;
}
[Link]
Archivo [Link]: Clic para ver el archivo
public void setEmail(String email) {
[Link] = email;
}
@Override
public String toString() {
return "Persona [idPersona=" + idPersona + ", nombre=" + nombre
+ ", apePaterno=" + apellidoPaterno + ", apeMaterno=" + apellidoMaterno
+ ", email=" + email + "]";
}
@Override
public int hashCode() {
int hash = 7;
hash = 79 * hash + [Link]([Link]);
return hash;
}
[Link]
Archivo [Link]: Clic para ver el archivo
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != [Link]()) {
return false;
}
final Persona other = (Persona) obj;
if () {
return false;
}
return true;
}
[Link]
Vamos a crear una interface Java. Recordemos que es una buena práctica programar utilizando
interfaces para separar las capas de nuestra aplicación Java. Así que crearemos una interface y
posteriormente su implementación.
En esta interface aplicaremos el patrón de diseño DAO (Data Access Object), ya que es la
interface que nos permitirá aplicar las operaciones sobre la clase de entidad de Persona, métodos
como listar, agregar, modificar, eliminar objetos de tipo Persona.
El nombre de la interface es [Link], veamos como queda esta interface:
[Link]
•Creamos la interface [Link]:
[Link]
•Creamos la interface [Link]:
[Link]
Archivo [Link]: Clic para ver el archivo
package [Link];
import [Link];
import [Link];
public interface PersonaDao {
void insertPersona(Persona persona);
void updatePersona(Persona persona);
void deletePersona(Persona persona);
Persona findPersonaById(long idPersona);
List<Persona> findAllPersonas();
long contadorPersonas();
Persona getPersonaByEmail(Persona persona);
}
[Link]
Vamos a crear una clase Java llamada [Link] que implemente la interface
[Link] recién creada. Esta clase utilizará la tecnología de Spring y JPA para realizar las
operaciones sobre la base de datos y obtener la conexión a la base de datos, así como la clase de
entidad [Link] para poder comunicarse con la base de datos y realizar las operaciones
descritas por la interface.
Veamos como queda la clase [Link]
[Link]
•Creamos la clase [Link]:
[Link]
•Creamos la clase [Link]:
[Link]
Archivo [Link]: Clic para ver el archivo
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
@Repository
public class PersonaDaoImpl implements PersonaDao {
Logger log = [Link]();
@PersistenceContext
private EntityManager em;
@Override
public void insertPersona(Persona persona) {
// Insertamos nuevo objeto
[Link](persona);
}
[Link]
Archivo [Link]: Clic para ver el archivo
@Override
public void updatePersona(Persona persona) {
// Actualizamos al objeto
[Link](persona);
}
@Override
public void deletePersona(Persona persona) {
[Link]([Link](persona));
}
@Override
public Persona findPersonaById(long idPersona) {
return [Link]([Link], idPersona);
}
@Override
public List<Persona> findAllPersonas() {
String jpql = "SELECT p FROM Persona p";
Query query = [Link](jpql);
//Forzar a ir directamente a la base de datos para refrescar datos
[Link]("[Link]", [Link]);
List<Persona> personas = [Link]();
[Link]("personas:" + personas);
return personas;
}
[Link]
Archivo [Link]: Clic para ver el archivo
@Override
public long contadorPersonas() {
String consulta = "select count(p) from Persona p";
Query q = [Link](consulta);
long contador = (long) [Link]();
return contador;
}
@Override
public Persona getPersonaByEmail(Persona persona) {
String cadena = "%" + [Link]() + "%"; //se usa en el like como caracteres especiales
String consulta = "from Persona p where upper([Link]) like upper(:param1)";
Query q = [Link](consulta);
[Link]("param1", cadena);
return (Persona) [Link]();
}
}
[Link]
Vamos a crear una interface Java [Link]. Recordemos que es una buena práctica
programar utilizando interfaces para separar las capas de nuestra aplicación Java. Así que
crearemos una interface y posteriormente su implementación.
Veamos como queda esta interface [Link]:
[Link]
•Creamos la interface [Link]:
[Link]
•Creamos la interface [Link]:
[Link]
Archivo [Link]: Clic para ver el archivo
package [Link];
import [Link];
import [Link];
public interface PersonaService {
public List<Persona> listarPersonas();
public Persona recuperarPersona(Persona persona);
public void agregarPersona(Persona persona);
public void modificarPersona(Persona persona);
public void eliminarPersona(Persona persona);
public long contarPersonas();
}
[Link]
Vamos a crear una clase Java llamada [Link] que implemente la interface
[Link] recién creada.
Esta clase utilizará la tecnología de Spring para manejar de manera automática el concepto de
transacciones.
Veamos como queda la clase [Link]
[Link]
•Creamos la clase [Link]:
[Link]
•Creamos la clase [Link]:
[Link]
Archivo [Link]: Clic para ver el archivo
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
@Service("personaService")
@Transactional
public class PersonaServiceImpl implements PersonaService {
@Autowired
private PersonaDao personaDao;
@Override
public List<Persona> listarPersonas() {
return [Link]();
}
@Override
public Persona recuperarPersona(Persona persona) {
return [Link]([Link]());
}
[Link]
Archivo [Link]: Clic para ver el archivo
@Override
public void agregarPersona(Persona persona) {
[Link](persona);
}
@Override
public void modificarPersona(Persona persona) {
[Link](persona);
}
@Override
public void eliminarPersona(Persona persona) {
[Link](persona);
}
@Override
public long contarPersonas() {
return [Link]();
}
}
[Link]
La clase [Link] que vamos a crear a continuación va a hacer las veces de
Controlador (Action) y Modelo (Bean).
Vamos a extender de la clase ActionSupport y para sobreescribiremos el método execute.
El modelo lo obtendremos con ayuda de la interface de servicio, el cual inyectaremos con ayuda
de Spring y el plug-in de integración entre Struts y Spring que agregamos al archivo [Link]
Recordemos que debemos respetar las convenciones de Struts2, así que esta clase debe estar
dentro de un paquete que contenga la palabra: struts, struts2, action o actions, además debe
terminar con la palabra Action.
[Link]
•Creamos la clase [Link]:
[Link]
•Creamos la clase [Link]:
[Link]
Archivo [Link]: Clic para ver el archivo
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
public class MostrarPersonaAction extends ActionSupport {
private long contadorPersonas;
Logger log = [Link]([Link]);
@Autowired
private PersonaService personaService;
private List<Persona> personas;
[Link]
Archivo [Link]: Clic para ver el archivo
@Override
public String execute() {
[Link] = [Link]();
[Link] = [Link]();
return SUCCESS;
}
public List<Persona> getPersonas() {
return personas;
}
public void setPersonas(List<Persona> personas) {
[Link] = personas;
}
public long getContadorPersonas() {
return contadorPersonas;
}
public void setContadorPersonas(long contadorPersonas) {
[Link] = contadorPersonas;
}
}
[Link]
Creamos un archivo [Link]. Este archivo tiene los
mensajes que utilizaremos en las páginas JSP de Struts.
Veamos como queda este archivo [Link]
[Link]
•Creamos el archivo [Link] como sigue:
[Link]
•Depositamos el archivo en la carpeta de resources según se muestra:
[Link]
Archivo [Link]: Clic para ver el archivo
[Link]: Personas con Struts 2
[Link]: No. Registros Encontrados
[Link]: Refrescar
[Link]: idPersona
[Link]: Nombre
[Link]: Apellido Paterno
[Link]: Apellido Materno
[Link]: Email
[Link]
En automático el IDE agrega un archivo llamado [Link]. Sin embargo si este
archivo no se crea debemos agregarlo al proyecto a nivel raíz de Web Pages.
El archivo [Link] realmente aún no forma parte del framework de Struts, sin
embargo será el punto de entrada para que se ejecute el framework de Struts, ya
que desde este archivo indicaremos cual es la acción que deseamos que se
ejecute.
En este ejercicio el path que utilizaremos será: mostrar-persona
[Link]
•Modificamos el archivo [Link]. En caso de que este archivo no
exista a nivel raíz de la carpeta Web Pages según se muestra:
[Link]
Archivo [Link]: Clic para ver el archivo
<!DOCTYPE html>
<html>
<head>
<title>Inicio</title>
<meta charset="UTF-8">
</head>
<body>
<a href="mostrar-persona">Ir a mostrar Persona</a>
</body>
</html>
[Link]
Ahora creamos el archivo: [Link]. Recordar que este nombre
corresponde con el path que se va a utilizar para llamar la acción correspondiente
([Link]), así que separamos por un guión medio cada
palabra de la clase de tipo Action.
Además debemos depositar este JSP en la carpeta /WEB-INF/content según
hemos visto en el tema de convenciones de Struts 2.
[Link]
•Creamos el archivo [Link]:
[Link]
•Creamos el archivo [Link] en la ruta mostrada:
[Link]
Archivo [Link]: Clic para ver el archivo
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@taglib prefix="s" uri="/struts-tags" %>
<!DOCTYPE html>
<html>
<head>
<title><s:text name="[Link]" /></title>
</head>
<body>
<h1><s:text name="[Link]" /></h1>
<s:if test="[Link]() > 0">
<div>
<table border="1">
<tr>
<th><s:text name="[Link]" /></th>
<th><s:text name="[Link]" /></th>
<th><s:text name="[Link]" /></th>
<th><s:text name="[Link]" /></th>
<th><s:text name="[Link]" /></th>
</tr>
[Link]
Archivo [Link]: Clic para ver el archivo
<s:iterator value="personas">
<tr>
<td><s:property value="idPersona" /></td>
<td><s:property value="nombre" /></td>
<td><s:property value="apellidoPaterno" /></td>
<td><s:property value="apellidoMaterno" /></td>
<td><s:property value="email" /></td>
</tr>
</s:iterator>
</table>
</div>
</s:if>
<s:form>
<s:submit key="[Link]" name="submit" />
</s:form>
<div><s:text name="[Link]" />: <s:property value="contadorPersonas" /></div>
</body>
</html>
[Link]
Creamos un archivo [Link]. El API de log4j nos permite manejar el log o
bitácora de una aplicación Java de manera más simple.
Este archivo lo depositamos en la ruta de recursos del proyecto maven. Si no se
usa maven entonces el archivo se debe depositar a nivel raíz del src del código
Java.
[Link]
•Creamos el archivo [Link] como sigue:
[Link]
•Depositamos el archivo en la carpeta de resources según se muestra:
[Link]
•Seleccionamos la opción mostrada:
[Link]
Archivo [Link]: Clic para ver el archivo
<?xml version="1.0" encoding="UTF-8"?>
<Configuration>
<Appenders>
<Console name="STDOUT" target="SYSTEM_OUT">
<PatternLayout pattern="(%F:%L) - %m%n"/>
</Console>
</Appenders>
<Loggers>
<Logger name="[Link].xwork2" level="info"/>
<Logger name="[Link].struts2" level="info"/>
<Root level="info">
<AppenderRef ref="STDOUT"/>
</Root>
</Loggers>
</Configuration>
[Link]
•Antes de ejecutar la aplicación, hacemos Clean & Build para
asegurarnos que tenemos todo listo:
[Link]
•Antes de ejecutar la aplicación, hacemos Clean & Build. Observamos
que el proceso se haya ejecutado con éxito (Build Success):
[Link]
•Ejecutamos la aplicación Struts2SpringJpaBasico como sigue:
[Link]
•Ejecutamos la aplicación como sigue:
[Link]
•Deberemos observar el listado de personas como sigue. Los datos
pueden variar dependiendo de la información que tengamos en la tabla
de persona en la base de datos:
[Link]
•Si agregamos más registros, modificamos o eliminamos registros de la tabla de persona, podemos dar
click en el botón de refrescar para ver la nueva información. De momento esta información se puede
agregar directamente en la base de datos o usando el software de MySql Workbench. Una vez
agregada la información damos clic en el botón de Refrescar y veremos el nuevo listado con las
modificaciones hechas:
[Link]
Si por alguna razón falla el ejercicio, se pueden hacer varias cosas para corregirlo:
1) Detener el servidor de Glassfish
2) Hacer un Clean & Build del proyecto para tener la versión más reciente compilada
3) Volver a hacer Run del proyecto (desplegar nuevamente el proyecto en el servidor)
Si lo anterior no funciona, pueden probar cargando el proyecto resuelto el cual es funcional 100% y
descartar problemas de configuración en su ambiente o cualquier otro error de código.
La configuración por convenciones de Struts 2, es muy sensible, de tal manera que todo debe estar escrito tal
como se especificó en el ejercicio, ya que cualquier cambio en los nombres provocará que no se ejecute
correctamente el ejercicio.
La integración con otros frameworks y tecnologías como Spring y JPA también es muy propenso a errores,
así que puedes apoyarte del proyecto resuelto que te entregamos, el cual es 100% funcional, y así apoyarte
en cualquier momento de esta documentación y los proyectos resueltos que te entregamos.
[Link]
Con este ejercicio hemos creado una aplicación que integra las 3 tecnologías como son:
• Struts 2
• Spring Framework
• JPA (Java Persistence API)
El ejercicio tiene un listado de personas, pero es una arquitectura del mundo real, con capas
lógicas, totalmente funcional y para poner en práctica la integración de las 3 tecnologías.
En los siguientes ejercicios aplicaremos las operaciones CRUD (Create-Read-Update-Delete)
para la tabla de persona.
[Link]
Por: Ing. Ubaldo Acosta
[Link]
