Introducción

La idea de este ejemplo es realizar un ejemplo de sistema de inventario con modulo de ventas y ventaOnline en spring mvc. El proyecto lo nombraremos productmarket.

Requisitos

UML

En esta aplicación vamos utilizar 3 actores: Admin,clienteOnline,vendedorCaja.
Creamos el primer diagrama de casos de uso y lo nombramos Admin
spring project
El segundo actor que va interactuar en el sistema es el clienteOnline.
spring project
Nota:Este ejemplo se va realizar de una forma básica ya que sería muy pesado para realizar un producto completo,estaría fuera del alcance de este tutorial.
El tercer actor que es vendedorCaja
spring project
Faltaría un modulo de facturación pero eso sería en futuro no muy lejano.
Esto fue más o menos para analizar que actores interactuan en nuestra aplicación y las funciones que tienen que realizar en el sistema.Faltaría construir los casos de uso pero para que no sea muy exaustivo no los haremos, pasaremos a la bases de datos o dominio del sistema.

Base de datos

Creamos la base datos y las siguiente tablas, el insert es para poder acceder al administrador de nuestro sistema 

CREATE SCHEMA IF NOT EXISTS `productmarketdb` DEFAULT CHARACTER SET utf8 ;
USE `productmarketdb` ;

CREATE TABLE `usuario` (
  `idusuario` int(11) NOT NULL AUTO_INCREMENT,
  `nombreusuario` varchar(450) DEFAULT NULL,
  `usuario` varchar(100) DEFAULT NULL,
  `password` varchar(45) DEFAULT NULL,
  PRIMARY KEY (`idusuario`)
) ENGINE=MyISAM AUTO_INCREMENT=20 DEFAULT CHARSET=utf8;


CREATE TABLE `producto` (
  `idproducto` int(11) NOT NULL AUTO_INCREMENT,
  `idreferencia` int(11) DEFAULT NULL,
  `nombreproducto` varchar(500) NOT NULL,
  `codigobarras` varchar(45) DEFAULT NULL,
  `descripcion` varchar(900) NOT NULL,
  `cantidad` int(11) DEFAULT NULL,
  `precio` decimal(30,2) DEFAULT NULL,
  `imagen` longblob,
  `tipoimagen` varchar(45) DEFAULT NULL,
  `unidad` varchar(45) DEFAULT NULL,
  PRIMARY KEY (`idproducto`)
) ENGINE=MyISAM AUTO_INCREMENT=23 DEFAULT CHARSET=utf8;



CREATE TABLE `pedido` (
  `idpedido` int(11) NOT NULL AUTO_INCREMENT,
  `llave` varchar(250) DEFAULT NULL,
  `nombre` varchar(250) DEFAULT NULL,
  `apellidopat` varchar(250) DEFAULT NULL,
  `apellidomat` varchar(250) DEFAULT NULL,
  `calle` varchar(250) DEFAULT NULL,
  `entrecalles` varchar(450) DEFAULT NULL,
  `colonia` varchar(250) DEFAULT NULL,
  `municipio` varchar(250) DEFAULT NULL,
  `estado` varchar(250) DEFAULT NULL,
  `pais` varchar(250) DEFAULT NULL,
  `codigopostal` varchar(45) DEFAULT NULL,
  `telefono` varchar(25) DEFAULT NULL,
  `email` varchar(250) DEFAULT NULL,
  `fecha` datetime DEFAULT NULL,
  PRIMARY KEY (`idpedido`)
) ENGINE=MyISAM AUTO_INCREMENT=37 DEFAULT CHARSET=utf8;


CREATE TABLE `ventadetalleonline` (
  `idpedido` int(11) NOT NULL,
  `cantidad` int(11) DEFAULT NULL,
  `idproducto` int(11) DEFAULT NULL,
  `costoproducto` decimal(30,2) DEFAULT NULL
) ENGINE=MyISAM DEFAULT CHARSET=utf8;


CREATE TABLE `ventaonline` (
  `idpedido` int(11) NOT NULL,
  `total` decimal(30,2) DEFAULT NULL,
  PRIMARY KEY (`idpedido`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;


CREATE TABLE `venta` (
  `idventa` int(11) NOT NULL AUTO_INCREMENT,
  `llaveventa` varchar(250) DEFAULT NULL,
  `total` decimal(30,2) DEFAULT NULL,
  `fecha` datetime DEFAULT NULL,
  PRIMARY KEY (`idventa`)
) ENGINE=MyISAM AUTO_INCREMENT=47 DEFAULT CHARSET=utf8;


CREATE TABLE `ventadetalle` (
  `idventa` int(11) NOT NULL,
  `cantidad` int(11) DEFAULT NULL,
  `idproducto` int(11) DEFAULT NULL,
  `total` decimal(30,2) DEFAULT NULL
) ENGINE=MyISAM DEFAULT CHARSET=utf8;




INSERT INTO productmarketdb.usuario VALUES (null,'José Martín Lara López','admin','adminmarket');

Descargar archivo sql

El proyecto de software

El proyecto va a quedar con tres modulos war que serán admin,ventaonline y caja. además de un modulo core para la capa de persistencia y la de servicio que interactuará con los tres modulos este será de tipo jar

eclipse maven

Abrimos nuestro IDE eclipse y creamos un proyecto maven
Procedemos a abrir nuestro IDE eclipse y nos vamos al menú y le damos File->New->Maven Project
java project
Seleccionamos Create a simple project (skip archetype selection) y Use default Workspace location y presionamos Next
java project
Ahora llenamos los siguientes datos:
y presionamos finish.Este el nombre de proyecto padre ya que acordamos que lo vamos hacer modular ya que la idea es crear como una especie de aplicación modular a la medida donde la empresa que lo utilice pueda usar el modulo que más le convenga de acuerdo a sus necesidades de negocio en particular, lo unico que será obligatorio es el modulo core ya que trae la persistencia de datos y la capa de servicio.
java project
En el archivo pom.xml escribimos lo siguiente 
  <build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.3</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
			        <verbose>true</verbose>
			        <fork>true</fork>
			        <executable>${JAVA_HOME}/bin/javac</executable>
			        <compilerVersion>1.8</compilerVersion>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-surefire-plugin</artifactId>
		  		<version>2.4.2</version>
		        <configuration>
		          <jvm>${JAVA_HOME}/bin/java</jvm>
		          <forkMode>once</forkMode>
		        </configuration>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-enforcer-plugin</artifactId>
				<version>1.3.1</version>
				<inherited>true</inherited>
				<executions>
					<execution>
						<id>enforce</id>
						<configuration>
							<rules>
								<DependencyConvergence />
								<requireJavaVersion>
									<version>1.8</version>
								</requireJavaVersion>
							</rules>
						</configuration>
						<goals>
							<goal>enforce</goal>
						</goals>
					</execution>
				</executions>
			</plugin>
		</plugins>
		
		
		<pluginManagement>
		    <plugins>
		      <plugin>
		        <groupId>org.eclipse.m2e</groupId>
		        <artifactId>lifecycle-mapping</artifactId>
		        <version>1.0.0</version>
		        <configuration>
		          <lifecycleMappingMetadata>
		            <pluginExecutions>
		              <pluginExecution>
		                <pluginExecutionFilter>
		                  <groupId>org.apache.maven.plugins</groupId>
		                  <artifactId>maven-enforcer-plugin</artifactId>
		                  <versionRange>[1.0.0,)</versionRange>
		                  <goals>
		                    <goal>enforce</goal>
		                  </goals>
		                </pluginExecutionFilter>
		                <action>
		                  <ignore />
		                </action>
		              </pluginExecution>
		            </pluginExecutions>
		          </lifecycleMappingMetadata>
		        </configuration>
		      </plugin>
		    </plugins>
		</pluginManagement>
	</build>

Una vez realizado esta parte en nuestro editor eclipse selecionamos File->New->Other
java project
Destendemos la pestaña que dice Maven y seleccionamos Maven Module y presionamos Next
java project
En la siguiente pantalla seleccionamos Create a simple project (skip archetype selection) , luego en Module name: lo nombramos como productmarket-admin y en Parent project: seleccionamos productmarket y presionamos Next
java project
Llenamos los siguientes datos:
Por último hacemos clic en Finish
java project
Ahora creamos el modulo core donde tendremos nuestra persistencia de datos y servicios, volvemos a selecionar
File->New->Other
java project
Destendemos la pestaña que dice Maven y seleccionamos Maven Module y presionamos Next
java project
En la siguiente pantalla seleccionamos Create a simple project (skip archetype selection) , luego en Module name: lo nombramos como productmarket-core y en Parent project: seleccionamos productmarket y presionamos Next
java project
Llenamos los siguientes datos:
Por último hacemos clic en Finish
java project
Ahora vamos a crear el modulo productmarket-caja File->New->Other. Destendemos la pestaña que dice Maven y seleccionamos Maven Module y presionamos Next
En la siguiente pantalla seleccionamos Create a simple project (skip archetype selection) , luego en Module name: lo nombramos como productmarket-caja y en Parent project: seleccionamos productmarket y presionamos Next
java project
Llenamos los siguientes datos:
Por último hacemos clic en Finish
java project
Ahora vamos a crear el modulo productmarket-ventaonline File->New->Other. Destendemos la pestaña que dice Maven y seleccionamos Maven Module y presionamos Next
En la siguiente pantalla seleccionamos Create a simple project (skip archetype selection) , luego en Module name: lo nombramos como productmarket-ventaonline y en Parent project: seleccionamos productmarket y presionamos Next
java project
Llenamos los siguientes datos:
Por último hacemos clic en Finish
java project
Marca error en los modulos marcados con war lo que debemos hacer es en productmarket-admin destender la carpeta que dice src/main/webapp crear la carpeta WEB-INF
java project
java project
Y sobre esta crear el archivo web.xml
java project
En el archivo web.xml escribimos el siguiente código:
  <web-app version="3.1" xmlns="http://xmlns.jcp.org/xml/ns/javaee" 
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee 
  http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd">

  <display-name>Archetype Created Web Application</display-name>


<servlet>
        <servlet-name>mvc-dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        
        <load-on-startup>1</load-on-startup>
        
        <multipart-config>
        
        <max-file-size>5242880</max-file-size><!--5MB-->
        <max-request-size>20971520</max-request-size><!--20MB-->
        <file-size-threshold>0</file-size-threshold>
    </multipart-config>
         
        
        
    </servlet>  
    
<filter>
  <filter-name>charsetFilter</filter-name>
  <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  <init-param>
  <param-name>encoding</param-name>
  <param-value>UTF-8</param-value>
  </init-param>
 </filter>
 <filter-mapping>
  <filter-name>charsetFilter</filter-name>
  <url-pattern>/*</url-pattern>
 </filter-mapping>    
      
    <servlet-mapping>
        <servlet-name>mvc-dispatcher</servlet-name>
        <url-pattern>*.html</url-pattern>
    </servlet-mapping>  

	
<welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>

   
   
</web-app>

En el modulo productmarket-cajadestendemos la carpeta que dice src/main/webapp crear la carpeta WEB-INF.Sobre la carpeta creada escribimos un archivo llamado web.xml y escribimos el siguiente código
  <web-app version="3.1" xmlns="http://xmlns.jcp.org/xml/ns/javaee" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee 
http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd">
  <display-name>Archetype Created Web Application</display-name>


<servlet>
        <servlet-name>mvc-dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>    
    <servlet-mapping>
        <servlet-name>mvc-dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>  


<filter>
  <filter-name>charsetFilter</filter-name>
  <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  <init-param>
  <param-name>encoding</param-name>
  <param-value>UTF-8</param-value>
  </init-param>
 </filter>
 <filter-mapping>
  <filter-name>charsetFilter</filter-name>
  <url-pattern>/*</url-pattern>
 </filter-mapping>


</web-app>

En el modulo productmarket-ventaonline realizamos la misma operación.Destendemos la carpeta que dice src/main/webapp crear la carpeta WEB-INF.Sobre la carpeta creada escribimos un archivo llamado web.xml y escribimos el siguiente código
  <web-app version="3.1" xmlns="http://xmlns.jcp.org/xml/ns/javaee" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee 
http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd">
  <display-name>Archetype Created Web Application</display-name>


<servlet>
        <servlet-name>mvc-dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>    
   
   
   <filter>
  <filter-name>charsetFilter</filter-name>
  <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  <init-param>
  <param-name>encoding</param-name>
  <param-value>UTF-8</param-value>
  </init-param>
 </filter>
 <filter-mapping>
  <filter-name>charsetFilter</filter-name>
  <url-pattern>/*</url-pattern>
 </filter-mapping>
   
   
   
   
    <servlet-mapping>
        <servlet-name>mvc-dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>  


</web-app>

Ahora nos vamos al modulo padre llamado productmarketHaciendo clic derecho y seleccionamos Run As->Maven clean
java project
y en consola aparece lo siguiente:
java project
De nuevo sobre productmarketHacemos clic derecho y seleccionamos Run As->Maven install
java project
y en consola aparece lo siguiente:
java project
Ahora lo que vamos hacer es instalar los jars nos vamos a productmarket dejando el archivo pom.xml de la siguiente forma: 
  
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.tutosoftware.productmarket</groupId>
  <artifactId>productmarket</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>pom</packaging>
  <name>ProductMarket</name>
  <properties>
		<pmc.version>0.0.1-SNAPSHOT</pmc.version>
		<spring.version>4.3.7.RELEASE</spring.version>
		<hibernate.version>5.2.9.Final</hibernate.version>
		<apachetiles.version>3.0.7</apachetiles.version>
		<mysql.version>5.1.34</mysql.version>
		<jstl.version>1.2</jstl.version>
		<jsp-api.version>2.1</jsp-api.version>
		<servlet-api.version>3.1.0</servlet-api.version>
		<hibernatevalidator.version>5.3.4.Final</hibernatevalidator.version>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>
  <dependencyManagement>
  <dependencies>
  
      <dependency>
				<groupId>com.tutosoftware.productmarket</groupId>
				<artifactId>productmarket-core</artifactId>
				<version>${pmc.version}</version>
			</dependency>
  
  
  
  
  
   <!-- Spring 4 dependencies -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
       
        <dependency>
            <groupId>org.apache.tiles</groupId>
            <artifactId>tiles-core</artifactId>
            <version>${apachetiles.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.tiles</groupId>
            <artifactId>tiles-api</artifactId>
            <version>${apachetiles.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.tiles</groupId>
            <artifactId>tiles-servlet</artifactId>
            <version>${apachetiles.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.tiles</groupId>
            <artifactId>tiles-jsp</artifactId>
            <version>${apachetiles.version}</version>
        </dependency>
       
       
   
       
       
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
       
       <dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-beans</artifactId>
				<version>${spring.version}</version>
			</dependency>
       
       
       
       
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
            <scope>test</scope>
        </dependency>
         <!-- bean validation  dependencies -->
        <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-validator</artifactId>
        <version>${hibernatevalidator.version}</version>
    </dependency>
        
         <!-- Hibernate  dependencies -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        
         <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
          <!-- mysql  dependencie -->
        
        <dependency>
	    <groupId>mysql</groupId>
	    <artifactId>mysql-connector-java</artifactId>
	    <version>${mysql.version}</version>
	   </dependency>
        
         <!-- Servlet and JSP -->
        <dependency>
				<groupId>javax.servlet.jsp</groupId>
				<artifactId>jsp-api</artifactId>
				<version>${jsp-api.version}</version>
				<scope>provided</scope>
			</dependency>
			
			
         <dependency>
	     <groupId>javax.servlet</groupId>
	    <artifactId>javax.servlet-api</artifactId>
	   <version>${servlet-api.version}</version>
        </dependency>
			
			
			
			<dependency>
				<groupId>javax.servlet</groupId>
				<artifactId>jstl</artifactId>
				<version>${jstl.version}</version>
			</dependency>
        
        </dependencies>
  </dependencyManagement>
   <build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.3</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
			        <verbose>true</verbose>
			        <fork>true</fork>
			        <executable>${JAVA_HOME}/bin/javac</executable>
			        <compilerVersion>1.8</compilerVersion>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-surefire-plugin</artifactId>
		  		<version>2.4.2</version>
		        <configuration>
		          <jvm>${JAVA_HOME}/bin/java</jvm>
		          <forkMode>once</forkMode>
		        </configuration>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-enforcer-plugin</artifactId>
				<version>1.3.1</version>
				<inherited>true</inherited>
				<executions>
					<execution>
						<id>enforce</id>
						<configuration>
							<rules>
								<DependencyConvergence />
								<requireJavaVersion>
									<version>1.8</version>
								</requireJavaVersion>
							</rules>
						</configuration>
						<goals>
							<goal>enforce</goal>
						</goals>
					</execution>
				</executions>
			</plugin>
		</plugins>
		
		
		<pluginManagement>
		    <plugins>
		      <plugin>
		        <groupId>org.eclipse.m2e</groupId>
		        <artifactId>lifecycle-mapping</artifactId>
		        <version>1.0.0</version>
		        <configuration>
		          <lifecycleMappingMetadata>
		            <pluginExecutions>
		              <pluginExecution>
		                <pluginExecutionFilter>
		                  <groupId>org.apache.maven.plugins</groupId>
		                  <artifactId>maven-enforcer-plugin</artifactId>
		                  <versionRange>[1.0.0,)</versionRange>
		                  <goals>
		                    <goal>enforce</goal>
		                  </goals>
		                </pluginExecutionFilter>
		                <action>
		                  <ignore />
		                </action>
		              </pluginExecution>
		            </pluginExecutions>
		          </lifecycleMappingMetadata>
		        </configuration>
		      </plugin>
		    </plugins>
		</pluginManagement>
	</build>
   <modules>
   	<module>productmarket-admin</module>
   	<module>productmarket-core</module>
   	<module>productmarket-caja</module>
   	<module>productmarket-ventaonline</module>
   </modules>
</project>

Como se ve en la parte superior del código dejamos los jar de manera centralizada. Todo esto para mantener un control sobre las versiones de los jars a utlizar y si, decidimos cambiar a una versión mayor nada mas cambiamos en el modulo padre.


Ahora vamos a comenzar la codificar nuestro proyecto para iniciar con el sistema comenzaremos con el modulo administrador.Que serán los casos de uso de login.Para iniciar nos vamos al modulo productmarket-core y en el archivo pom.xml agregamos todas las dependencias necesarias para este modulo quedando de la siguiente manera:
 
  <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>com.tutosoftware.productmarket</groupId>
    <artifactId>productmarket</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>productmarket-core</artifactId>
  <name>Productmarket Core</name>
   <dependencies>
      <!-- Spring 4 dependencies -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
        </dependency>
        
        
         <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
        </dependency>
        
        <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-validator</artifactId>
       </dependency>
        
        
         <!-- Hibernate  dependencies -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
        </dependency>
        
        
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
        </dependency>
        
          <!-- mysql  dependencie -->
        
        <dependency>
	    <groupId>mysql</groupId>
	    <artifactId>mysql-connector-java</artifactId>
	   </dependency>
  
  
  </dependencies>
</project>

Como nuestra persistencia de datos va hacer realizada con hibernate vamos a comenzar por crear nuestra plantilla de hibernate util nos posicionamos en nuestro proyecto productmarket-core y en el directorio src/main/java seleccionamos New->Package
java project
y lo nombramos com.tutosoftware.productmarket.util y presionamos Finish
java project
Sobre el paquete com.tutosoftware.productmarket.util vamos a crear la clase HibernateUtil y escribimos el siguiente código:
  package com.tutosoftware.productmarket.util;

import java.io.Serializable;
import java.util.List;

import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

@Repository
public class HibernateUtil {
	
	
	@Autowired
    private SessionFactory sessionFactory;
        
    public <T> Serializable create(final T entity) {
        return sessionFactory.getCurrentSession().save(entity);        
    }
    
    public <T> T update(final T entity) {
        sessionFactory.getCurrentSession().update(entity);   
        return entity;
    }
    
    public <T> void delete(final T entity) {
        sessionFactory.getCurrentSession().delete(entity);
    }

    public <T> void delete(Serializable id, Class<T> entityClass) {
        T entity = fetchById(id, entityClass);
        delete(entity);
    }
    
    @SuppressWarnings("unchecked")  
    public <T> List<T> fetchAll(Class<T> entityClass) {        
        return sessionFactory.getCurrentSession().createQuery(" FROM "+entityClass.getName()).list();        
    }
  
    
    
    
    @SuppressWarnings("unchecked")  
    public <T> List<T> fetchAll(String hql) {        
        return sessionFactory.getCurrentSession().createQuery(hql).list();        
    }
    
    
    
    
    
    public <T> T fetchById(Serializable id, Class<T> entityClass) {
        return (T)sessionFactory.getCurrentSession().get(entityClass, id);
    }
    @SuppressWarnings("unchecked")
    public <T> T fetchByUniqueResult(String hql) {
        return (T)sessionFactory.getCurrentSession().createQuery(hql).uniqueResult();
    }

}

Ahora sobre src/main/java vamos crear el paquete llamado com.tutosoftware.productmarket.entity y en el creamos la clase Usuario y escribimos el siguiente código:
  package com.tutosoftware.productmarket.entity;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;


@Entity
@Table(name="usuario")
public class Usuario implements Serializable {
	
	/**
	 * 
	 */
	private static final long serialVersionUID = 6294359495119986502L;
	
	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Long idUsuario;
	
	@Column
	private String nombreUsuario;
	
	@Column
	private String usuario;
	
	@Column
	private String password;
	
	
	public Usuario(){
		
	}


	public Long getIdUsuario() {
		return idUsuario;
	}


	public void setIdUsuario(Long idUsuario) {
		this.idUsuario = idUsuario;
	}


	public String getNombreUsuario() {
		return nombreUsuario;
	}


	public void setNombreUsuario(String nombreUsuario) {
		this.nombreUsuario = nombreUsuario;
	}


	public String getUsuario() {
		return usuario;
	}


	public void setUsuario(String usuario) {
		this.usuario = usuario;
	}


	public String getPassword() {
		return password;
	}


	public void setPassword(String password) {
		this.password = password;
	}

}

Ahora sobre src/main/java vamos crear nuestros DAO para realizar nuestra transacciones con hibernate. creamos el paquete llamado com.tutosoftware.productmarket.dao creamos una interface llamada LoginDAO y escribimos el siguiente código: 
  package com.tutosoftware.productmarket.dao;

import java.util.List;

import com.tutosoftware.productmarket.entity.Usuario;



public interface LoginDAO {
	
	public Usuario obtenerLogin(Usuario usuario);
    public long agregarUsuarioLogin(Usuario usuario);
    public List<Usuario> obtenerUsuarios();
    public Usuario actualizarUsuario(Usuario usuario);
    public Usuario obtenerUsuario(long id);
    public void eliminarUsuario(long id);

}

Ahora vamos a implementar las interfaces creamos un paquete llamado com.tutosoftware.productmarket.dao.impl sobre este paquete creamos una clase lamada LoginDAOImpl y escribimos el siguiente código: 
  package com.tutosoftware.productmarket.dao.impl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import com.tutosoftware.productmarket.dao.LoginDAO;
import com.tutosoftware.productmarket.entity.Usuario;
import com.tutosoftware.productmarket.util.HibernateUtil;


@Repository
public class LoginDAOImpl implements LoginDAO {
	
	
	 @Autowired
	  private HibernateUtil hibernateUtil;
	 
	 
      public LoginDAOImpl(){
		 
	 }
	 
	

	@Override
	public Usuario obtenerLogin(Usuario usuario) {
		
		
        String hql="from Usuario as u where u.usuario = '"+usuario.getUsuario()+"' and u.password = '"+usuario.getPassword()+"'";
		
		Usuario usuarioResult = hibernateUtil.fetchByUniqueResult(hql);
		// TODO Auto-generated method stub
		return usuarioResult;
	}

	@Override
	public long agregarUsuarioLogin(Usuario usuario) {
		// TODO Auto-generated method stub
		return (Long) hibernateUtil.create(usuario);
	}

	@Override
	public List<Usuario> obtenerUsuarios() {
		// TODO Auto-generated method stub
		return hibernateUtil.fetchAll(Usuario.class);
	}

	@Override
	public Usuario actualizarUsuario(Usuario usuario) {
		// TODO Auto-generated method stub
		return hibernateUtil.update(usuario);
	}

	@Override
	public Usuario obtenerUsuario(long id) {
		// TODO Auto-generated method stub
		return hibernateUtil.fetchById(id,Usuario.class);
	}

	@Override
	public void eliminarUsuario(long id) {
		// TODO Auto-generated method stub
		Usuario usuario = new Usuario();
		usuario.setIdUsuario(id);
		hibernateUtil.delete(usuario);

	}

}

Ahora vamos por nuestra capa de servicio.Primero creamos el paquete llamado com.tutosoftware.productmarket.service posteriormente creamos la interface LoginService y escribimos el siguiente código: 
  
  package com.tutosoftware.productmarket.service;

import java.util.List;

import com.tutosoftware.productmarket.entity.Usuario;

public interface LoginService {
	
	public Usuario obtenerLogin(Usuario usuario);
	public long agregarUsuarioLogin(Usuario usuario);
	public List<Usuario> obtenerUsuarios();
	public Usuario actualizarUsuario(Usuario usuario);
	public Usuario obtenerUsuario(long id);
	public void eliminarUsuario(long id);

}

Ahora por supuesto creamos la implementación nombremos otro paquete llamado com.tutosoftware.productmarket.service.impl en este paquete nombramos la clase llamada LoginServiceImpl y escbribimos el siguiente código: 
  package com.tutosoftware.productmarket.service.impl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.tutosoftware.productmarket.entity.Usuario;
import com.tutosoftware.productmarket.service.LoginService;
import com.tutosoftware.productmarket.dao.LoginDAO;


@Service
@Transactional
public class LoginServiceImpl implements LoginService {
	
	
	@Autowired
	 private LoginDAO loginDAO;
	
	
	 public LoginServiceImpl(){
		 
	 }
	
	

	@Override
	public Usuario obtenerLogin(Usuario usuario) {
		// TODO Auto-generated method stub
		return loginDAO.obtenerLogin(usuario);
	}

	@Override
	public long agregarUsuarioLogin(Usuario usuario) {
		// TODO Auto-generated method stub
		return loginDAO.agregarUsuarioLogin(usuario);
	}

	@Override
	public List<Usuario> obtenerUsuarios() {
		// TODO Auto-generated method stub
		return loginDAO.obtenerUsuarios();
	}

	@Override
	public Usuario actualizarUsuario(Usuario usuario) {
		// TODO Auto-generated method stub
		return loginDAO.actualizarUsuario(usuario);
	}

	@Override
	public Usuario obtenerUsuario(long id) {
		// TODO Auto-generated method stub
		return loginDAO.obtenerUsuario(id);
	}

	@Override
	public void eliminarUsuario(long id) {
		// TODO Auto-generated method stub
		
		loginDAO.eliminarUsuario(id);

	}

}

Así es como quedaría de manera temporal nuestro proyecto productmarket-core
java project
Ahora si vamos a la parte mvc nos posicionamos en el proyecto productmarket-admin y en el archivo pom.xml Escribimos el siguiente código: 
  <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>com.tutosoftware.productmarket</groupId>
    <artifactId>productmarket</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>productmarket-admin</artifactId>
  <packaging>war</packaging>
  <name>Productmarket Admin</name>
  <build>
		<finalName>productmarketadmin</finalName>
		<plugins>	
			<plugin>            
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-war-plugin</artifactId>
				<version>2.3</version>
				<configuration>
					<webXml>src/main/webapp/WEB-INF/web.xml</webXml>
					<webResources>
						<resource>
							<!-- this is relative to the pom.xml directory -->
							<directory>src/main/webapp/WEB-INF</directory>
							<targetPath>WEB-INF</targetPath>
						</resource>
					</webResources>
				</configuration>
			</plugin>
		</plugins>
	</build>
	<dependencies>
	<dependency>
				<groupId>com.tutosoftware.productmarket</groupId>
				<artifactId>productmarket-core</artifactId>
	</dependency>
	
	
	
   <!-- Spring 4 dependencies -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
        </dependency>
         <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-beans</artifactId>
         </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
        </dependency>
        
         <dependency>
            <groupId>org.apache.tiles</groupId>
            <artifactId>tiles-core</artifactId>
       </dependency>
        <dependency>
            <groupId>org.apache.tiles</groupId>
            <artifactId>tiles-api</artifactId>
           </dependency>
        <dependency>
            <groupId>org.apache.tiles</groupId>
            <artifactId>tiles-servlet</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.tiles</groupId>
            <artifactId>tiles-jsp</artifactId>
           </dependency>
        <!-- Hibernate  dependencies -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
        </dependency>
        
        
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
        </dependency>
        
       <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-validator</artifactId>
       </dependency>
        
          <!-- mysql  dependencie -->
        
        <dependency>
	    <groupId>mysql</groupId>
	    <artifactId>mysql-connector-java</artifactId>
	   </dependency>
        
         <!-- Servlet and JSP -->
        <dependency>
				<groupId>javax.servlet.jsp</groupId>
				<artifactId>jsp-api</artifactId>
			</dependency>
			
			
         <dependency>
	     <groupId>javax.servlet</groupId>
	    <artifactId>javax.servlet-api</artifactId>
        </dependency>
			
			
			
			<dependency>
				<groupId>javax.servlet</groupId>
				<artifactId>jstl</artifactId>
			</dependency>
        
        </dependencies>
</project>

El spring mvc que vamos a configurar va hacer de la forma xml nos vamos a src/main/webapp/WEB-INF creamos el archivo mvc-dispatcher-servlet.xml y escribimos el siguiente código: 
  
  
  <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
       http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">


	<!-- Specifying base package of the Components like Controller, Service, 
		DAO -->
	<context:component-scan base-package="com.tutosoftware.productmarket" />
		
	<!-- Getting Database properties -->
	<context:property-placeholder location="classpath:application.properties" />


	
	<!-- Specifying the Resource location to load JS, CSS, Images etc -->
	<mvc:annotation-driven />
	<mvc:resources mapping="/resources/**" location="/resources/" />
    <mvc:resources mapping="/css/**" location="/css/" />
	<mvc:resources mapping="/fonts/**" location="/fonts/" />
	<mvc:resources mapping="/js/**" location="/js/" />
    
	<!-- View Resolver -->
	
	
	
	
	<bean id="multipartResolver" class="org.springframework.web.multipart.support.StandardServletMultipartResolver"/>
	
	
	
   <bean id="viewResolver"
		class="org.springframework.web.servlet.view.UrlBasedViewResolver">
		<property name="viewClass">
			<value>
				org.springframework.web.servlet.view.tiles3.TilesView
			</value>
		</property>
	</bean>
   
      
      
      
   <bean id="tilesConfigurer"
 class="org.springframework.web.servlet.view.tiles3.TilesConfigurer">
 <property name="definitions">
   <list><value>/WEB-INF/views/tiles/tiles.xml</value></list>
 </property>
 </bean>
   
   
	<!-- DataSource -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
		destroy-method="close">
		<property name="driverClass" value="${database.driverClass}" />
		<property name="jdbcUrl" value="${database.url}" />
		<property name="user" value="${database.username}" />
		<property name="password" value="${database.password}" />

		<property name="acquireIncrement" value="${connection.acquireIncrement}" />
		<property name="minPoolSize" value="${connection.minPoolSize}" />
		<property name="maxPoolSize" value="${connection.maxPoolSize}" />
		<property name="maxIdleTime" value="${connection.maxIdleTime}" />
	</bean>

	<!-- Hibernate SessionFactory -->
	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource"></property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">${hibernate.dialect}</prop>
				<prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
				<prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
				<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
			</props>
		</property>
		<property name="packagesToScan" value="com.tutosoftware.productmarket.entity"></property>
	</bean>

	<!-- Transaction -->
	<bean id="transactionManager"
		class="org.springframework.orm.hibernate5.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>
	<tx:annotation-driven transaction-manager="transactionManager" />

</beans>

Nos vamos a al directorio src/main/resources y creamos el archivo application.properties que contendra datos sobre la conexión de nuestra base de datos.Escribimos el siguiente código:
 database.driverClass=com.mysql.jdbc.Driver
database.url=jdbc:mysql://localhost:3306/productmarketdb
database.username=user
database.password=password

#Hibernate related properties
hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
hibernate.hbm2ddl.auto=update
hibernate.show_sql=true
hibernate.format_sql=true

#Connection pool related properties
connection.acquireIncrement=2
connection.minPoolSize=20
connection.maxPoolSize=50
connection.maxIdleTime=600

No olvidar que estamos en el modulo productmarket-admin nos vamos a Java Resources y en src/main/java creamos el paquete com.tutosoftware.productmarket.validation y creamos la clase llamada UsuarioValidation que se utiliza para validar al administrador.Escribimos el siguiente código. 
  package com.tutosoftware.productmarket.validation;

import org.springframework.validation.Errors;
import org.springframework.validation.ValidationUtils;
import org.springframework.validation.Validator;

import com.tutosoftware.productmarket.entity.Usuario;



public class UsuarioValidation implements Validator {

	@Override
	public boolean supports(Class<?> clazz) {
		// TODO Auto-generated method stub
		return Usuario.class.equals(clazz);
	}

	@Override
	public void validate(Object target, Errors errors) {
		// TODO Auto-generated method stub
		
		
		ValidationUtils.rejectIfEmptyOrWhitespace(errors,"nombreUsuario",
				"field.nombreUsuario.required","El nombre del administrador es requerido");
		ValidationUtils.rejectIfEmptyOrWhitespace(errors,"usuario",
				"field.usuario.required","El usuario es requerido");
		ValidationUtils.rejectIfEmptyOrWhitespace(errors,"password",
				"field.password.required","El password es requerido");

	}

}

Ahora en, src/main/java creamos el paquete com.tutosoftware.productmarket.controller y en ese paquete creamos la calse llamada LoginController que tendra todas la acciones de nuestro logggueo en la aplicación.Escribimos el siguiente código:
  package com.tutosoftware.productmarket.controller;

import java.util.List;

import javax.validation.Valid;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.SessionAttributes;
import org.springframework.web.bind.support.SessionStatus;
import org.springframework.web.context.request.WebRequest;
import org.springframework.web.servlet.ModelAndView;

import com.tutosoftware.productmarket.entity.Usuario;
import com.tutosoftware.productmarket.service.LoginService;
import com.tutosoftware.productmarket.validation.UsuarioValidation;



@Controller
@SessionAttributes("userObj")
public class LoginController {
	
	@Autowired
	private LoginService loginService;
	
	public LoginController(){
		
	}
	
    
	@InitBinder
    protected void initBinder(WebDataBinder binder) {
        binder.setValidator(new UsuarioValidation()); // registramos el validador
    }
	
	
	
	
	 @RequestMapping("/login")
	public  ModelAndView loginUser(@ModelAttribute Usuario usuario) {
		
		return new ModelAndView("login");
	}

	 @RequestMapping("/verificarLogin")
	public ModelAndView verificarLogin(ModelMap model,@ModelAttribute Usuario usuario){
		
		if(usuario.getUsuario().trim().length() != 0 &&  usuario.getPassword().trim().length() != 0){
			usuario=loginService.obtenerLogin(usuario);
			if(usuario != null){
				ModelAndView modelo = new ModelAndView("home");
				modelo.addObject("usuario",usuario);
				modelo.addObject("userObj",usuario);
				return modelo;
				
			}else{
				model.put("falla","usuario o password incorrecto");
				return new ModelAndView("login");
			}
			
			
		}else{
			model.put("vacio","falta un dato usuario o password vació");
			return new ModelAndView("login");
			
		}
		
	}
	
	 @RequestMapping("/agregarUsuario")
		public  ModelAndView agregarUsuario(@ModelAttribute Usuario usuario) {
			
			return new ModelAndView("agregarUsuario");
		}
	 
	 
	 @RequestMapping("/guardarUsuario")
		public  ModelAndView guardarUsuario(ModelMap model,@Valid Usuario usuario,BindingResult result) {
			
		// si hay errores volvemos a la vista del formulario
			if ( result.hasErrors() ) {
				return new ModelAndView("agregarUsuario");
			}
		 
			
				 loginService.agregarUsuarioLogin(usuario);
		         
				 	  
			
		          return new ModelAndView("redirect:verUsuarios.html");
		}
	 
	 
	 @RequestMapping("/verUsuarios")
		public  ModelAndView verUsuarios() {
			
		
			
		 
		     List<Usuario> usuarioList = loginService.obtenerUsuarios();
		           
		      
			
			return new ModelAndView("verUsuarios","usuarioList",usuarioList);
		}
	 
	 
	 @RequestMapping("/editarUsuario")
		public  ModelAndView verUsuarios(@RequestParam long id, @ModelAttribute Usuario usuario) {
			
		
			
		 
		     usuario= loginService.obtenerUsuario(id);
		           
		      
			
			return new ModelAndView("modificarUsuario","usuarioObj",usuario);
		}
	 
	 
	 @RequestMapping("/modificarUsuario")
		public  ModelAndView actualizarUsuario(ModelMap model,@Valid Usuario usuario,BindingResult result) {
			
		// si hay errores volvemos a la vista del formulario
			if ( result.hasErrors() ) {
				return new ModelAndView("modificarUsuario");
			}
		  
				 
				 loginService.actualizarUsuario(usuario) ;
	        	
	        	
				
				 return new ModelAndView("redirect:verUsuarios.html");
		}
	 
	 
	 
	 @RequestMapping("/eliminarUsuario")
		public  ModelAndView eliminarUsuario(@RequestParam long id) {
			
		
			
		 
		     loginService.eliminarUsuario(id);
		           
		     
	           
		      
				
				return new ModelAndView("redirect:verUsuarios.html"); 
			
			
		}
	 
	 
	 
	 @RequestMapping("/salir")
		public  ModelAndView salir(@ModelAttribute Usuario usuario, WebRequest request, SessionStatus status) {
		     status.setComplete();
		    request.removeAttribute("userObj", WebRequest.SCOPE_SESSION);
			return new ModelAndView("login");
		}

}

Se viene la parte de la vista de sistema para realizar el administrador vamos a utlizar un framework de plantillas llamado tiles nos vamos al directorio src/main/webapp/WEB-INF y creamos una carpeta lamada views y sobre esta creamos otra carpeta llamada tiles y en esta creamos un archivo de configuración xml llamado tiles.xml y escribimos el siguiente código:
  
  <?xml version="1.0" encoding="UTF-8"?>


<!DOCTYPE tiles-definitions PUBLIC
       "-//Apache Software Foundation//DTD Tiles Configuration 3.0//EN"
       "http://tiles.apache.org/dtds/tiles-config_3_0.dtd">

<tiles-definitions>  
 
   <!-- Base Definition -->
   <definition name="base-definitionlogin" 
       template="/WEB-INF/views/tiles/adminLogin.jsp">  
       <put-attribute name="title" value="" />  
       <put-attribute name="header" value="/WEB-INF/views/tiles/headerLogin.jsp" />  
        <put-attribute name="body" value="" />  
       <put-attribute name="footer" value="/WEB-INF/views/tiles/footer.jsp" />  
   </definition>  
   
   
   
   
   <definition name="base-definition" 
       template="/WEB-INF/views/tiles/admin.jsp">  
       <put-attribute name="title" value="" />  
       <put-attribute name="header" value="/WEB-INF/views/tiles/header.jsp" />  
       <put-attribute name="menu" value="/WEB-INF/views/tiles/menu.jsp" />  
       <put-attribute name="body" value="" />  
       <put-attribute name="footer" value="/WEB-INF/views/tiles/footer.jsp" />  
   </definition>  
 
  <definition name="login" extends="base-definitionlogin">  
       <put-attribute name="title" value="Bienvenido" />  
       <put-attribute name="body" value="/WEB-INF/views/login.jsp" />  
   </definition>  
 
 
 
   <!-- Home Page -->
   <definition name="home" extends="base-definition">  
       <put-attribute name="title" value="Bienvenido" />  
       <put-attribute name="body" value="/WEB-INF/views/home.jsp" />  
   </definition>  

   <!-- Product Page -->
   <definition name="agregarUsuario" extends="base-definition">  
       <put-attribute name="title" value="Agregar usuario" />  
       <put-attribute name="body" value="/WEB-INF/views/agregarUsuario.jsp" />  
   </definition>  
      
       <definition name="verUsuarios" extends="base-definition">  
       <put-attribute name="title" value="Ver usuarios" />  
       <put-attribute name="body" value="/WEB-INF/views/verUsuarios.jsp" />  
   </definition>
      
      <definition name="modificarUsuario" extends="base-definition">  
       <put-attribute name="title" value="Ver usuarios" />  
       <put-attribute name="body" value="/WEB-INF/views/modificarUsuario.jsp" />  
   </definition>
      
     <definition name="agregarProducto" extends="base-definition">  
       <put-attribute name="title" value="Agregar producto" />  
       <put-attribute name="body" value="/WEB-INF/views/agregarProducto.jsp" />  
   </definition> 
   <definition name="verProductos" extends="base-definition">  
       <put-attribute name="title" value="Ver productos" />  
       <put-attribute name="body" value="/WEB-INF/views/verProductos.jsp" />  
   </definition> 
   
   
   <definition name="modificarProducto" extends="base-definition">  
       <put-attribute name="title" value="Actualizar producto" />  
       <put-attribute name="body" value="/WEB-INF/views/modificarProducto.jsp" />  
   </definition>
 
</tiles-definitions>

El archivo tiles tiene dos plantillas una para loguearse y otra que es del admin comenzemos con la plantilla de login nos vamos a la carpeta src/main/WEB-INF/views/tiles y cramos el jsp llamado adminLogin.jps y escribimos el siguiente código.
  <%@ taglib uri="http://tiles.apache.org/tags-tiles" prefix="tiles"%>

<html>
<head>
<meta http-equiv="Content-Type" content="text/html;UTF-8">
<link href="http://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
<link type="text/css" rel="stylesheet" href="css/materialize.min.css"  media="screen,projection"/>
<script type="text/javascript" src="https://code.jquery.com/jquery-2.1.1.min.js"></script>
 <script type="text/javascript" src="js/materialize.min.js"></script>
<title><tiles:getAsString name="title" /></title>
</head>
<body>
        <div class="container">

       <header id="header">
            <tiles:insertAttribute name="header" />
        </header>
     
             
        <section id="site-content">
            <tiles:insertAttribute name="body" />
        </section>
         
        <footer id="footer">
            <tiles:insertAttribute name="footer" />
        </footer>
        
        </div>

</body>
</html>

Creamos el header nos ubicamos en src/main/WEB-INF/views/tiles y creamos el jsp llamado headerLogin.jps Escribmos el siguiente código:
 <div class="row">
<div class="col s12 indigo accent-4 "><h3>Product Market-Administrador</h3></div>


</div>

Ahora vamos con el footer en src/main/WEB-INF/views/tiles creamos footer.jsp y escribimos el código siguiente;
 <div>
  tutosoftware|isc.José Martín Lara López
</div>

Continuamos con la plantilla del admin en src/main/WEB-INF/views/tiles creamos admin.jsp
  <%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
 <%@ page isELIgnored="false" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@ taglib uri="http://tiles.apache.org/tags-tiles" prefix="tiles"%>

<html>
<head>
<meta http-equiv="Content-Type" content="text/html;UTF-8">
<link href="http://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
<link rel="stylesheet" type="text/css" href="css/style.css" />
<link type="text/css" rel="stylesheet" href="css/materialize.min.css"  media="screen,projection"/>
<script type="text/javascript" src="https://code.jquery.com/jquery-2.1.1.min.js"></script>
 <script type="text/javascript" src="js/materialize.min.js"></script>
<title><tiles:getAsString name="title" /></title>
</head>
<body>
       <div class="container">

       <header id="header">
            <tiles:insertAttribute name="header" />
        </header>
     
        <section id="sidemenu">
            <tiles:insertAttribute name="menu" />
        </section>
             
        <section id="site-content">
            <tiles:insertAttribute name="body" />
        </section>
         
        <footer id="footer">
            <tiles:insertAttribute name="footer" />
        </footer>
        
        </div>

</body>
</html>

Ahora creamos el header en src/main/WEB-INF/views/tiles y creamos header.jsp
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<div class="row">
<div class="col s12 indigo accent-4 "><h3>Product Market-Administrador</h3></div>
<c:choose>
 <c:when test="${userObj.nombreUsuario != null}">
        Bienvenido:${userObj.nombreUsuario} 
       
    </c:when>    
    <c:otherwise>
      <c:redirect  url="salir.html"></c:redirect>  
    </c:otherwise>
</c:choose>

</div>

Lo que sigue es el menú en src/main/WEB-INF/views/tiles y creamos menu.jsp
  <nav>
   
    <ul id="menu">
        
       <li><a href="agregarUsuario.html">Agregar Usuario</a></li>
       <li><a href="verUsuarios.html">Ver Usuarios</a></li>
       <li><a href="agregarProducto.html">Agregar Producto</a></li>
       <li><a href="verProductos.html">Ver Productos</a></li>
       <li><a href="salir.html">Salir</a></li>
    </ul>
</nav>

La parte anterior eran las plantillas ahora vienen las vistas empezemos por irnos a src/main/WEB-INF/views y creamos login.jsp para podernos loguear a la aplicación 
 
   <%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>

<form:form modelAttribute="usuario" method="post" action="verificarLogin.html" >

<table>
<tr>
<td>
 <div class="input-field col s5">
<form:input  path="usuario" />  
<label for="usuario">Usuario</label>
</div>
</td>

</tr>
<tr>
<td>
 <div class="input-field col s5">
<form:password  path="password" />  
<label for="password">Password</label>
</div>
</td>

</tr>

<tr>
<td>
<button class="btn waves-effect waves-light" type="submit" name="action">Iniciar sesión
    <i class="material-icons right">send</i>
  </button>

</td>
</tr>

</table>

   <p><span class="red accent-4">${falla}</span></p>
   <p><span class="red accent-4">${vacio}</span></p>
</form:form>

Ahora vamos con home una vez despues de haber accedido a la aplicación nos pasamos a home.jsp en el directorio src/main/WEB-INF/views 
  <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<c:choose>
 <c:when test="${userObj.nombreUsuario != null}">
        <h2>Selecciona en el menú lo quieras realizar</h2>
       
    </c:when>    
    <c:otherwise>
      <c:redirect  url="salir.html"></c:redirect>  
    </c:otherwise>
</c:choose>

Ahora vamos con la pantalla de agregar usuario en src/main/WEB-INF/views creamos agregarUsuario.jsp 
 <%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<c:choose>
 <c:when test="${userObj.nombreUsuario != null}">
<h2>Agregar Usuario</h2>
<style type="text/css">
		
		span.campoConError {
			color: red;
		}
		
	</style>	

<form:form modelAttribute="usuario" method="post" action="guardarUsuario.html" >

<table>
<tr>
<td>
 <div class="input-field col s5">

<form:input  path="nombreUsuario" />   
<label for="nombreUsuario">Nombre de administrador</label>
</div>
</td>

</tr>
<tr>
<td><form:errors path="nombreUsuario" cssClass="campoConError"/></td>
</tr>



<tr>
<td>
 <div class="input-field col s5">
<form:input  path="usuario" />  
<label for="usuario">Usuario</label>
</div>
</td>

</tr>
<tr>
<td><form:errors path="usuario" cssClass="campoConError"/></td>
</tr>
<tr>
<td>
 <div class="input-field col s5">
<form:input  path="password" />   
<label for="password">Password</label>
</div>
</td>

</tr>
<tr>
<td><form:errors path="password" cssClass="campoConError"/></td>
</tr>
<tr>
<td>
<button class="btn waves-effect waves-light" type="submit" name="action">guardarUsuario
    <i class="material-icons right">send</i>
  </button>

</td>
</tr>

</table>
    <p><span class="red accent-4">${insert}</span></p>
  
</form:form>
 </c:when>    
    <c:otherwise>
      <c:redirect  url="salir.html"></c:redirect>  
    </c:otherwise>
</c:choose>

La siguiente vista por realizar es la de ver usuarios en src/main/WEB-INF/views nombramos verUsuarios.jsp 
  <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<c:choose>
 <c:when test="${userObj.nombreUsuario != null}">
 <c:if test="${empty usuarioList}">
                No hay usarios
            </c:if>
            <c:if test="${not empty usuarioList}">  
             <table class="striped">
                    <thead>
                    <tr>
                        <th>Administrador</th>
                        <th>Nombre Usuario</th>
                        <th>Pasword</th>
                        <th>Actualizar</th>
                        <th>Eliminar</th>
                    </tr>
                    </thead>
                    <tbody>
                    <c:forEach items="${usuarioList}" var="usr">
                        <tr>
                            
                            <td><c:out value="${usr.nombreUsuario}"/></td>
                            <td><c:out value="${usr.usuario}"/></td>
                            <td><c:out value="${usr.password}"/></td> 
                            <td><a href="editarUsuario.html?id=<c:out value='${usr.idUsuario}'/> " 
                            class="waves-effect waves-light btn" >Actualizar</a></td>
                            <td><a href="eliminarUsuario.html?id=<c:out value='${usr.idUsuario}'/>"
                            class="waves-effect waves-light btn" >Eliminar</a></td>                          
                        </tr>
                    </c:forEach>
                    </tbody>
                </table>
            
            
       </c:if>
 </c:when>    
    <c:otherwise>
      <c:redirect  url="salir.html"></c:redirect>  
    </c:otherwise>
</c:choose>

Ahora vamos por la pantalla de modificar usuario en src/main/WEB-INF/views creamos modificarUsuario.jsp 
 <%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<c:choose>
 <c:when test="${userObj.nombreUsuario != null}">
<h2>Actualizar Usuario</h2>
<style type="text/css">
		
		span.campoConError {
			color: red;
		}
		
	</style>	

<form:form modelAttribute="usuario" method="post" action="modificarUsuario.html" >

<table>
<tr>
<td>
 <div class="input-field col s5">
 <form:hidden path="idUsuario" value="${usuarioObj.idUsuario}"/>
<form:input  path="nombreUsuario" value="${usuarioObj.nombreUsuario}"/>   
<label for="nombreUsuario">Nombre de administrador</label>
</div>
</td>

</tr>
<tr>
<td><form:errors path="nombreUsuario" cssClass="campoConError"/></td>
</tr>



<tr>
<td>
 <div class="input-field col s5">
<form:input  path="usuario" value="${usuarioObj.usuario}"/>  
<label for="usuario">Usuario</label>
</div>
</td>

</tr>
<tr>
<td><form:errors path="usuario" cssClass="campoConError"/></td>
</tr>
<tr>
<td>
 <div class="input-field col s5">
<form:input  path="password" value="${usuarioObj.password}"/>   
<label for="password">Password</label>
</div>
</td>

</tr>
<tr>
<td><form:errors path="password" cssClass="campoConError"/></td>
</tr>
<tr>
<td>
<button class="btn waves-effect waves-light" type="submit" name="action">actualizarUsuario
    <i class="material-icons right">send</i>
  </button>

</td>
</tr>

</table>
    <p><span class="red accent-4">${insert}</span></p>
  
</form:form>
</c:when>    
    <c:otherwise>
      <c:redirect  url="salir.html"></c:redirect>  
    </c:otherwise>
</c:choose>

Ahora vamos por el index o nuestra pagina de inicio en src/main/webapp creamos index.jsp
 
  <%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>
<!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=UTF-8">
<link href="http://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
<link type="text/css" rel="stylesheet" href="css/materialize.min.css"  media="screen,projection"/>
<script type="text/javascript" src="https://code.jquery.com/jquery-2.1.1.min.js"></script>
 <script type="text/javascript" src="js/materialize.min.js"></script>

<title>Inventario product market</title>
</head>
<body>
 <div class="container">
 <div class="row">
<div class="col s12 indigo accent-4 "><h3>Product Market - Admin</h3></div>
</div>
<ul>
  <li>
  
  <a href="login.html" class="waves-effect waves-light btn">Iniciar sesión</a></li>
</ul>
</div>


</body>
</html>

Ahora para tener nuestra funcionalidad front-end en src/main/webapp creamos las carpetas css para hojas de estilo, fonts para tipos de letra y js para librerias javascript. no olvidar que estamos porbando materialize que la desargamos de http://materializecss.com/ no olvidar que usa jquery. Por ultimo ulizamos el arcihvo style.css que lo pondremos en src/main/webapp/css y escribimos lo siguiente:
 
  @CHARSET "ISO-8859-1";


body {font-family: Verdana, Arial, sans-serif;font-size: 14px;}
fieldset {margin: 25px 0 0 0;padding: 15px;border: 4px solid; }
legend {padding: 8px; font-size: 16px;}
label {float: left; width: 200px;}
label.error { color: #D60404;}
input, select, textarea { float:left; padding: 5px;background: #cccccc; margin:5px 30px 5px 10px;}
.contenido { margin: 0 auto; width: 900px;}
.input {width: 250px;}
.enviar{margin: 20px auto;color: #000;}
.enviar:hover {background: #A4A4A4;}
.clear {clear: both;}

Cansado

Aqui es la parte donde nuestro esfuerzo empieza a rendir frutos corremos la aplicación con tomcat y lo que aparece es lo siguiente:
java project
Iniciamos sesión:
java project
Nos logueamos:
java project
Damos iniciar se sesión sin poner datos para validar:
java project
Nos loggueamos corectamente, nota no olvidar hacer un insert en la tabla usario para poder ingresar.
java project
una vez que metemos password y usuario correctamente nos pararece lo siguiente:
java project
Ahora agregamos un usuario:
java project
Vemos que el administrador juan perex a sido registrado:
java project
Ahora actualizamos un usuario:
java project
y por ultimo eliminamos un usuario.Como puedes ver puedes interactuar con la aplicación.

Producto

Ahora vamos con los productos de nuestro inventario.
      
Siguiente