Maven multripoyecto para Struts2,Spring y Hibernate

Para generar esta estructura de proyecto, parto del supuesto que tiene configurado un
repositorio maven local, eclipse ,un servidor de base de datos MySql y un servidor JBoss o
Tomcat.
Con maven se genera una estructura de multiporyectos un pom.xml padre y los n proyectos
hijos con sus respectivos pom.xml que generaran .jar o .war.
Se pretende crear un temple con proyecto padre que contenga dos hijos un proyecto
backend y otro frontend.En el backend se alojaran las clases entidades del proyecto y en el
frontend los action de struts2, beans con spring , y la conexion a la bd y mapeo con
hibernate.
1.Crear dos carpetas una llamada multiproyecto y otra workspace_maven(en esta
importaremos los proyectos creados con maven y son los que se trabajaran desde eclipse)
Desde consola nos situamos en la carpeta multiproyecto:
cd /home/mvega/multiproyecto

2.Dentro de /multiproyecto correr el siguiente comando maven para crear el proyecto padre:
mvn archetype:create -DgroupId=com.template.main -DartifactId=template-main

El resultado es el siguiente:

3.
3.
3.
3.
3.
3.

Dentro de ej. /home/mvega/multiproyecto/template-main , borrar la carpeta src, y en el

archivo pom.xml modificar <packaging>jar</packaging> por
<packaging>pom</packaging>

4.Ingresar al proyecto padre con

cd /home/mvega/multiproyecto/template-main

5.Dentro del proyecto padre correr el mando maven para generar el proyecto backend:
mvn archetype:create -DgroupId=com.template.backend -DartifactId=template-backend

6.Dentro del proyecto padre correr el mando maven para generar el proyecto frontend:
mvn archetype:create -DgroupId=com.template.frontend -DartifactId=template-frontend

7.Dentro del proyecto template-frontend agrega la siguiente linea al pom.xml ,

<packaging>war</packaging>

quedando lo siguiente:
<groupId>com.template.frontend</groupId>
<artifactId>template-frontend</artifactId>
<packaging>war</packaging>

<version>1.0-SNAPSHOT</version>
<name>template-frontend</name>

8.Dentro del proyecto template-frontend agregar dentro del pom.xml la dependencia con el
proyecto template-backend:
<!-- dependency to template-backend project -->
<dependency>
<groupId>com.template.backend</groupId>
<artifactId>template-backend</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>

9.Dentro del proyecto template-frontend crear un archivo vacion web.xml, quedando en el

siguiente path:
template-frontend/src/main/webapp/WEB-INF/web.xml

10.Situarse dentro del proyecto padre tempate-main agregar los modulos y correr el
siguiente comando maven:
<modules>
<module>template-backend</module>
<module>template-frontend</module>
</modules>
mvn clean install

En este punto se tiene un proyecto que genera un .war, este caso seria el proyecto templatefrontend con dependencia de .jar generado por el proyecto template-backend

11.Hacer el proyecto template-frontend de tipo eclipse, importandolos con comando maven:

mvn eclipse:eclipse

Una vez corrido ese comando dentro de eclipse se creara una variable de entorno a maven
M2_REPO que hace referencia ej. /home/mvega/.m2/repository/
12. Hacer el proyecto template-frontend dinamico web para eclipse
mvn eclipse:eclipse -Dwtpversion=1.5

13.Ingresar a Eclipse e importar el proyecto recien creado con maven

File->New Proyect->Import...

Seleccionar la opcion
General->Existing Project into Workspace

Debemos elegir el proyecto template-main que esta dentro del workspace_maven para este
ejemplo, se veran dentro de la vista de packege del eclipse los proyectos template-backend
y template-frontend con sus respectivos archivos pom.xml
14.Hacer proyecto dinamico para Tomcat o Jboss sobre el proyecto template-frotend hacer
click con el boton derecho de mouse elegir Properties->Project Facets presionar el boton
Apply y Ok

Nota:en este punto fijarse la solapa Problem, hacer click boton derecho en los proyectos
template-backend y template-frontend elegir opcion Quick Fix opcion facect ..1.6

Hasta aqui se tiene multiproyectos con maven, un proyecto padre como template-main y dos
proyectos hijos template-backend y template-frontend
Continuando con la creacion de una aplicacion web multiproyecto con struts2,spring y
hibernate, configuraremos las dependencias y archivos de los respectivos frameworks.
15. En el archivo pom.xml del proyecto template-frontend vamos a colocar las dependencias
de struts2,spring y hibernate.
Struts2...
<!-- Struts 2 -->
<dependency>
<groupId>org.apache.struts</groupId>
<artifactId>struts2-core</artifactId>
<version>2.1.8</version>
</dependency>
<!-- Struts 2 + Spring plugins -->
<dependency>
<groupId>org.apache.struts</groupId>
<artifactId>struts2-spring-plugin</artifactId>
<version>2.1.8</version>
</dependency>

MySql...
<!-- MySQL database driver -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.9</version>
</dependency>

Spring...
<!-- Spring framework -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring</artifactId>
<version>2.5.6</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>2.5.6</version>
</dependency>

Hibernate....
<!-- Hibernate core -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate</artifactId>
<version>3.2.7.ga</version>
</dependency>
<!-- Hibernate core library dependency start -->
<dependency>
<groupId>dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>1.6.1</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.1.1</version>
</dependency>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.2.1</version>
</dependency>
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2</version>
</dependency>
<!-- Hibernate core library dependency end -->
<!-- Hibernate query library dependecy start -->
<dependency>
<groupId>antlr</groupId>
<artifactId>antlr</artifactId>
<version>2.7.7</version>
</dependency>

<dependency>
<groupId>javax.transaction</groupId>
<artifactId>jta</artifactId>
<version>1.0.1B</version>
</dependency>
<dependency>
<groupId>javassist</groupId>
<artifactId>javassist</artifactId>
<version>3.4.GA</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>asm</groupId>
<artifactId>asm</artifactId>
<version>3.1</version>
</dependency>
<!-- Hibernate query library dependecy end -->

16. Correr en MySql el siguiente script con esto crearemos una tabla usuario dentro del
schema template:
DROP TABLE IF EXISTS `template`.`usuario`;
CREATE TABLE `template`.`usuario` (
`ID` BIGINT(20) UNSIGNED NOT NULL AUTO_INCREMENT,
`NOMBRE` VARCHAR(45) NOT NULL,
`PASSWORD` VARCHAR(45) NOT NULL,
PRIMARY KEY (`ID`)
) ENGINE=InnoDB AUTO_INCREMENT=17 DEFAULT CHARSET=utf8;
INSERT INTO template.usuario (NOMBRE,PASSWORD)VALUES ('admin','admin');
INSERT INTO template.usuario (NOMBRE,PASSWORD)VALUES ('root','root');
INSERT INTO template.usuario (NOMBRE,PASSWORD)VALUES ('admin','1234');
17.Hibernate configuraremos una entidad Usuario.java en el proyecto template-backend
package com.template.backend.modelo;
import java.io.Serializable;
/**
* @author mvega
*
*/
public class Usuario implements Serializable {
private static final long serialVersionUID = -8261984277322134700L;
private Long id;
private String nombre;
private String password;

//constructor y getters and setters

18.Generamos el jar de template-backend para ser utilizado por el proyecto templatefrontend, en consola ingresamos los siguientes comandos:
cd /home/mvega/workspace_maven/template-backend
mvn clean install -Dmaven.test.skip=true
19.Desde consola ingresamos al proyecto template-frotend, y corremos el siguiente
comando:
mvn eclipse:eclipse
Esto refrescara las referencias de dependencia entre el template-frontend y el templatebackend y las dependencias de struts2,spring y hibernate configuradas en el pom.xml, si no
tenemos los jar automaticamente maven los bajara al repositorio local de la pc.

Dentro de Referend Libreries del proyecto template-frontend se podra ver esto:

Es clase Usuario.java creada en el proyecto template-backend.

20.Dentro del proyecto template-frontend, crearmos el archivo de mapeo Usuario.hbm.xml,

, creamos la siguiente estructura de carpetas resource/hibernate y colocar el archivo
Usuario.hbm.xml con el siguiente contenido:

Usuario.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.template.backend.modelo.Usuario" table="usuario"
catalog="template">
<id name="id" type="java.lang.Long">
<column name="ID" />
<generator class="identity" />
</id>
<property name="nombre" type="string">
<column name="NOMBRE" length="45" not-null="true" />
</property>
<property name="password" type="string">
<column name="PASSWORD" length="45" not-null="true" />
</property>
</class>
</hibernate-mapping>

21.Continuamos dentro del proyecto template-frontend, vamos a crear una interface y su

implementacion para poder conectarnos con la bd en este caso UsuarioDAO.java y
UsuarioDAOImpl.java

UsuarioDAO.java
package com.template.frontend.dao;
/**
* @author mvega
*
*/
public interface UsuarioDAO {
public boolean validarUsuario(String nombre,String password);
}
UsuarioDAOImpl.java
package com.template.frontend.dao.impl;
import org.hibernate.Criteria;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import com.template.backend.modelo.Usuario;
import com.template.frontend.dao.UsuarioDAO;
public class UsuarioDAOImpl extends HibernateDaoSupport implements UsuarioDAO{
public boolean validarUsuario(String nombre,String password) {
boolean usuarioValido = false;
Criteria criteria = this.getSession().createCriteria(Usuario.class);
criteria.add(Restrictions.eq("nombre", nombre));
criteria.add(Restrictions.eq("password", password));
Usuario usuario =(Usuario)criteria.uniqueResult();
if(usuario!=null){
usuarioValido = true;
}
}
}

return usuarioValido;

22.Procedemos a crear la capa BO que sera inyectada al action que recibe los datos del
formulario y es un intermediario en el action y la capa dao.
UsuarioBO.java y UsuarioBOImpl.java

UsuarioBO.java
package com.template.frontend.bo;
/**
* @author mvega
*
*/
public interface UsuarioBO {
public boolean validarUsuario(String nombre, String password);
}
UsuarioBOImpl.java
package com.template.frontend.bo.impl;
import com.template.frontend.bo.UsuarioBO;
import com.template.frontend.dao.UsuarioDAO;
/**
* @author mvega
*
*/
public class UsuarioBOImpl implements UsuarioBO {
private UsuarioDAO usuarioDAO;
public boolean validarUsuario(String nombre, String password) {
password);

boolean usuarioValido = this.usuarioDAO.validarUsuario(nombre,

return usuarioValido;

public void setUsuarioDAO(UsuarioDAO usuarioDAO) {

this.usuarioDAO = usuarioDAO;
}
}

23.En el proyecto template-frontend dentro de webapp creamos una estructura de carpetas

para alojar las paginas login.jsp, login_ok.jsp y login_error.jps, quedando esto de la siguiente
manera:

login.jsp
<%@ page contentType="text/html; charset=UTF-8" %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<head></head>
<body>
<h1>Login al sistema con struts2, spring y hibernate</h1>
<s:form action="Usuario">
<s:textfield name="nombre" label="Nombre:"/>
<s:password name="password" label="Password"/>
<s:submit label="Enviar" name="Enviar"/>
</s:form>
</body>
</html>

login_ok.jsp
<%@ page contentType="text/html; charset=UTF-8" %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<head></head>
<body>
<h1>Login al sistema con struts2, spring y hibernate</h1>
<h4>Bienvenido

<s:property value="nombre"/> !!!</h4>

</body>
</html>

login_error.jsp
<%@ page contentType="text/html; charset=UTF-8" %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<head></head>
<body>
<h1>Login al sistema con struts2, spring y hibernate</h1>
<h4>El usuario o password ingresado es invalido, o no esta registrado en el
sistema!!!</h4>
</body>
</html>

24.Creamos el archivo struts.xml que contiene la deficinion de action y navegabilidad de las

paginas.
Dicho archivo lo colocamos dentro de src/main/resources

struts.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<package name="login" namespace="/Usuario" extends="struts-default">
<action name="Login">
<result>pages/login.jsp</result>
</action>
<action name="Usuario"
class="com.template.frontend.action.UsuarioAction">
<result name="success">pages/login_ok.jsp</result>
<result name="error">pages/login_error.jsp</result>
</action>
</package>
</struts>

25.Creamos el archivo de configuracion de la base de datos database.properties dentro de

la estructura de carpetas WEB-INF/conf/database/properties

database.properties
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/template
jdbc.username=root
jdbc.password=root

26.Crearemos los archivos de configuracion de spring que crearan los bean de conexion a la
base de datos action bo y dao.
Se crea la carpeta spring dentro de WEB-INF/conf/spring en el se alojaran los archivos
action-spring.xml
bo-spring.xml
dao-spring.xml
data-source.xml
hibernate-session-factory.xml

data-source.xml
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<bean
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="location">
<value>WEB-INF/conf/database/properties/database.properties</value>
</property>
</bean>
<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />

<property name="username" value="${jdbc.username}" />

<property name="password" value="${jdbc.password}" />
</bean>
</beans>

hibernate-session-factory.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<!-- Hibernate session factory -->
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref bean="dataSource"/>
</property>
<property name="hibernateProperties">
<props>
<prop
key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
<property name="mappingResources">
<list>
<value>hibernate/Usuario.hbm.xml</value>
</list>
</property>
</bean>
</beans>

dao-spring.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<bean id="usuarioDAO" class="com.template.frontend.dao.impl.UsuarioDAOImpl"
>

<property name="sessionFactory" ref="sessionFactory" />

</bean>

</beans>

bo-spring.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<bean id="usuarioBO" class="com.template.frontend.bo.impl.UsuarioBOImpl" >
<property name="usuarioDAO" ref="usuarioDAO" />
</bean>
</beans>

action-spring.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<bean id="usuarioAction" class="com.template.frontend.action.UsuarioAction">
<property name="usuarioBO" ref="usuarioBO" />
</bean>
</beans>

27.Creamos el archivo de contexto de spring applicationContext.xml que levantara todos

los archivos xml creados con anterioridad, debe esta dentro de WEB-INF

applicationContext.xml
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<!-- Database Configuration -->
<import resource="conf/spring/data-source.xml"/>
<import resource="conf/spring/hibernate-session-factory.xml"/>
<!-- Beans Action Declaration -->
<import resource="conf/spring/action-spring.xml"/>
<!-- Beans BO Declaration -->
<import resource="conf/spring/bo-spring.xml"/>
<!-- Beans DAO Declaration -->
<import resource="conf/spring/dao-spring.xml"/>
</beans>

28.Por ultimo vamos a configurar el servlet de struts y el contecxto de spring dentro del
archivo web.xml
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Template Struts 2 Web Application</display-name>
<!-- Servlet de struts2 -->
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!-- Contexto de spring -->
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
</web-app>

29.Agregar el proyecto dinamico al servidor, en este caso tenemos configurado un servidor

jboss 4.2,pero tambien se puede probar el proyecto en otro servidor como el tomcat, para
ellos sobre el sevidor hacemos boton derecho del mouse Add and Remove.. y seleccionamos
el proyecto template-frontend

30.Corremos el servidor y se desplegara en el la carpeta deploy del server el templatefrontend.war, y accedemos a la aplicacion para ingresar los datos al fomularios a la siguiente
url
http://localhost:8082/template-frontend/Usuario/Login.action
ingresamos :
usaurio:admin
password: admin

Pantalla de login

Pantalla de bienvenida

Para el caso que se ingrese un usuario o password invalido se mostrara la pantalla de error