Introducción
Lo que necesitamos para ver como se aplica hibernete en un proyecto de software lo
primero que debemos realizar es el dominio de la base de datos y posteriormente realizar el
mapeo, para la persistencia de datos,
una vez realizado esto, procedemos a seleccionar nuestro framework favorito o
simplemente un jsp o servelt, según sea la decisión que tomemos, para que el usario interactue
con la aplicación. En este ejemplo se realizará la búsqueda e inserción de registros.
Requisitos
Base de datos
Lo primero que debemos realizar es crear la tabla cancion sobre la cuál
vamos a trabajar abrimos nuestro MySQL Workbench y creamos la siguiente tabla:
idcancion |
INT |
nombrecancion |
VARCHAR(250) |
artista |
VARCHAR(250) |
album |
VARCHAR(250) |
nombrearchivo |
VARCHAR(250) |
rutaarchivo |
VARCHAR(450) |
![hibernate project](../img/hibernate1.jpg)
CREATE TABLE `pruebadb`.`cancion` (
`idcancion` INT NOT NULL AUTO_INCREMENT,
`nombrecancion` VARCHAR(250) NOT NULL,
`artista` VARCHAR(250) NOT NULL,
`album` VARCHAR(250) NULL,
`nombrearchivo` VARCHAR(250) NOT NULL,
`rutaarchivo` VARCHAR(450) NOT NULL,
PRIMARY KEY (`idcancion`))
ENGINE = MyISAM
DEFAULT CHARACTER SET = utf8;
El proyecto de software
Vamos a crear una aplicación que administre nuestro archivos mp3 esto lo
vamos a desarrollar con struts2 para parte del cliente y por supuesto
hibernate.
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](../img/jsf3.jpg)
Dejamos los valores por default y presionamos Next
![maven project](../img/struts23.jpg)
En Catalogseleccionamos All Catalogs y en Artifact Id eligimos maven-archetype-webapp y presionamos Next
Llenamos con los siguientes datos:
- Group Id: com.tutosoftware esto significa la estructura de nuestros paquetes.Nota:Se puede cambiar.
- Artifact Id: MusicManager es el nombre de nuestro proyecto
- Version: dejar el predeterminado selecionado
- Package: dejar el valor por default
Posteriormente presionamos Finish
![hibernate project](../img/hibernate2.jpg)
Control de versiones
Hasta aquí llegamos a la parte donde se formo el esqueleto para el proyecto
pero nuestra visión debe ir un poco mas allá porque, este un tutorial de hibernate
se va crear la versión 1 pero que pasa si un futuro no muy lejano queremos agregar
una capa de servicio con spring entonces se partiría de la versión 1 que tendríamos
agregada en el visualsvnserver.
Lo primero debemos realizar es instalar visualsvnserver una vez instalado creamos
un usuario hacemos clic derecho Users y seleccionamos Create User ...
![hibernate project](../img/hibernate3.jpg)
Creamos nuestro usuario y password y presionamos ok
![hibernate project](../img/hibernate4.jpg)
Volvamos a nuestro IDE eclipse y nos vamos al menú que se llama Help->Install New Software...
![eclipse project](../img/eclipse11.jpg)
En la parte que dice Work withseleccionamos Mars - http://download.eclipse.org/releases/mars y en buscar
escribimos subversive
![eclipse project](../img/eclipse12.jpg)
Seleccionamos las siguientes opciones:
- Subversive Revision Graph(Optional)
- Subversive SVN Integration for the Mylyn Project (Optional)
- Subversive SVN JDT Ignore Extensions (Optional)
- Subversive SVN Team Provider
Y presionamos Next
![eclipse project](../img/eclipse13.jpg)
Volvemos a presionar Next
Aceptamos los terminos y presionamos Finish
![eclipse project](../img/eclipse14.jpg)
Le damos en ok que continue con la instalación
![eclipse project](../img/eclipse15.jpg)
Nos pregunta que reiniciemos eclipse le damos en Yes
![eclipse project](../img/eclipse16.jpg)
Ahora lo que sigue a continuación es instalar el conector nos vamos a nuestro
ambiente de trabajo y seleccionamos Window->Open Perspective->Other ..
![eclipse project](../img/eclipse17.jpg)
Seleccionamos SVN Repository Exploring y presionamos OK
![eclipse project](../img/eclipse18.jpg)
Seleccionamos todos los conectores y presionamos Finish
![eclipse project](../img/eclipse19.jpg)
Presionamos Next
![eclipse project](../img/eclipse20.jpg)
Volvemos a presionar Next
![eclipse project](../img/eclipse21.jpg)
Aceptamos los términos y presionamos Finish
![eclipse project](../img/eclipse22.jpg)
Presionamos Ok
![eclipse project](../img/eclipse23.jpg)
Reiniciamos eclipse
![eclipse project](../img/eclipse16.jpg)
Por último nos vamos al menú Windows->Preferences
![eclipse project](../img/eclipse24.jpg)
Destendemos los opción que dice Team y selecionamos SVN posteriormente nos vamos
a la pestaña que dice SVN Connector y selecionamos la versión SVNKit 1.8 presionamos Apply
y posteriormente Ok
![eclipse project](../img/eclipse25.jpg)
Volvamos a nuestro visualSNVserver para crear un repositorio vació que posteriormente será llenado
por el equipo de programación con un cliente de visualsvn server.Nos vamos a la parte que dice Repositories->Create New Repository...
![hibernate project](../img/hibernate5.jpg)
Seleccionamos el tipo de repositorio y presionamos siguiente.
![hibernate project](../img/hibernate6.jpg)
Nombramos nuestro repositorio como MusicManager y presionamos Siguiente
![hibernate project](../img/hibernate7.jpg)
Le decimos que creamos un repositororio vació y hacemos clic en siguiente.
![hibernate project](../img/hibernate8.jpg)
Por defecto, a nadie se le permite acceder a este Repositorio, descentralizaremos la autoridad posteriormente.
selecionamos Nobody has access y presionamos Create
![hibernate project](../img/hibernate9.jpg)
Presionamos Finish
![hibernate project](../img/hibernate10.jpg)
Hacemos clic derecho sobre MusicManager y seleccionamos Properties
![hibernate project](../img/hibernate11.jpg)
En las pestaña que dice Security vamos agregar los permisos para un usuario.Hacemos clic en Add...
![hibernate project](../img/hibernate12.jpg)
Seleccionamos el usuario y presionamos Ok
![hibernate project](../img/hibernate13.jpg)
Seleccionamos Aplicar y posteriormente Aceptar
![hibernate project](../img/hibernate14.jpg)
Copiamos la URL.Hacemos clic derecho sobre MusicManager->Copy URL to Clipboard
![hibernate project](../img/hibernate15.jpg)
Volvamos a eclipse y selecionamos el proyecto MusicManager que vamos a compartir en el repositorio.Seleccionamos Team->Share Project...
![hibernate project](../img/hibernate16.jpg)
Seleccionamos el tipo de repostirio en este caso es SVN y presionamos Next
![hibernate project](../img/hibernate17.jpg)
Ahora lo primero es pegar la url , posterriormente meter usuario y password luego selecionamos
Save authenticacion (Could trigger secure storage login) y presionamos Next
![hibernate project](../img/hibernate18.jpg)
Seleccionamos Trust Always
![hibernate project](../img/hibernate19.jpg)
Aparece un cuadro dialogo le damos OK.Posteriormente le damos en Next
![hibernate project](../img/hibernate20.jpg)
Presionamos Finish
![hibernate project](../img/hibernate21.jpg)
Ahora escribimos un comentario y presionamos OK
![hibernate project](../img/hibernate22.jpg)
Seleccionamos Yes
![hibernate project](../img/hibernate23.jpg)
![hibernate project](../img/hibernate24.jpg)
Maven eclipse
Ahora volvamos al proyecto en eclipse y vamos a cargar todas las dependencias necesarias para poder
compilar nuestro proyecto, el archivo pom.xml nos queda 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/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.tutosoftware</groupId>
<artifactId>MusicManager</artifactId>
<packaging>war</packaging>
<version>0.0.1-SNAPSHOT</version>
<name>MusicManager Maven Webapp</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>org.apache.struts</groupId>
<artifactId>struts2-core</artifactId>
<version>2.5.2</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>javax.servlet.jsp-api</artifactId>
<version>2.3.1</version>
<scope>provided</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-core -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>5.2.4.Final</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.34</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<finalName>MusicManager</finalName>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.3</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
Ahora vemos que tenemos un problema nos vamos a nuestro
proyecto y le damos clic derecho donde dice
Maven->Update Project.. y presionamos OK
![Login Test](../img/jsf6.jpg)
Sobre MusicManager/src/main creamos la carpeta java y presionamos Finish
En la carpeta src/main/java creamos un paquete llamado com.tutosoftware.musicmanager.model
![hibernate project](../img/hibernate25.jpg)
sobre com.tutosoftware.musicmanager.model vamos crear la clase llamada Cancion que sera el dominio o la tabla que vamos a mapear y escribimos
el siguiente código
package com.tutosoftware.musicmanager.model;
public class Cancion {
private Long idCancion;
private String nombreCancion;
private String artista;
private String album;
private String nombreArchivo;
private String rutaArchivo;
public Cancion(){
}
public Cancion(String nombreCancion,String artista,String album,String nombreArchivo,
String rutaArchivo){
this.nombreCancion=nombreCancion;
this.artista=artista;
this.album=album;
this.nombreArchivo=nombreArchivo;
this.rutaArchivo=rutaArchivo;
}
public Long getIdCancion() {
return idCancion;
}
public void setIdCancion(Long idCancion) {
this.idCancion = idCancion;
}
public String getNombreCancion() {
return nombreCancion;
}
public void setNombreCancion(String nombreCancion) {
this.nombreCancion = nombreCancion;
}
public String getArtista() {
return artista;
}
public void setArtista(String artista) {
this.artista = artista;
}
public String getAlbum() {
return album;
}
public void setAlbum(String album) {
this.album = album;
}
public String getNombreArchivo() {
return nombreArchivo;
}
public void setNombreArchivo(String nombreArchivo) {
this.nombreArchivo = nombreArchivo;
}
public String getRutaArchivo() {
return rutaArchivo;
}
public void setRutaArchivo(String rutaArchivo) {
this.rutaArchivo = rutaArchivo;
}
}
A continuación nos vamos con la conexión de hibernate nos ubicamos en src/main/resources y creamos el archivo hibernate.cfg.xml y escribimos lo
siguiente:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.password">lara</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/pruebadb</property>
<property name="hibernate.connection.username">admin</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
<property name="hibernate.cache.provider_class">org.hibernate.cache.HashtableCacheProvider</property>
<property name="hibernate.transaction.factory_class">org.hibernate.transaction.JDBCTransactionFactory</property>
<property name="hibernate.current_session_context_class">thread</property>
<property name="hibernate.show_sql">false</property>
<property name="hibernate.hbm2ddl.auto">update</property>
<mapping resource="com/tutosoftware/musicmanager/model/Cancion.hbm.xml"/>
</session-factory>
</hibernate-configuration>
Ahora sobre src/main/resources creamos la carpeta com
![hibernate project](../img/hibernate26.jpg)
y sobre la carpeta com creamos la carpeta tutosoftware
y sobre tutosoftware creamos la carpeta musicmanager
y sobre musicmanager creamos la carpeta model
ahora en src/main/resources en la carpeta com/tutosoftware/musicmanager/model creamos el archivo
Cancion.hbm.xml ya que este ejemplo se realizara el mapeo con xml posteriormente en otro ejemplo lo
realizaremos con anotaciones.Escribimos el siguiente código
<?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.tutosoftware.musicmanager.model.Cancion" table="CANCION">
<id name="idCancion" type="java.lang.Long">
<column name="IDCANCION"></column>
<generator class="identity"></generator>
</id>
<property name="nombreCancion" type="string" column="NOMBRECANCION" not-null="true"></property>
<property name="artista" type="string" column="ARTISTA" not-null="true"></property>
<property name="album" type="string" column="ALBUM"></property>
<property name="nombreArchivo" type="string" column="NOMBREARCHIVO" not-null="true"></property>
<property name="rutaArchivo" type="string" column="RUTAARCHIVO" not-null="true"></property>
</class>
</hibernate-mapping>
en src/main/java creamos el paquete com.tutosoftware.musicmanager.util
en el paquete com.tutosoftware.musicmanager.util creamos la clase HibernateSession que será la encargada de mandar la factoria
y escribimos el siguiente código:
package com.tutosoftware.musicmanager.util;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import com.tutosoftware.musicmanager.model.Cancion;
public class HibernateSession {
private static final SessionFactory sessionFactory = buildSessionFactory();
private static Session session;
private static SessionFactory buildSessionFactory(){
Configuration configuration = new Configuration();
configuration.configure();
configuration.addClass(Cancion.class);
ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder()
.applySettings(configuration.getProperties())
.build();
SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
return sessionFactory;
}
public static SessionFactory getSessionFactory(){
return sessionFactory;
}
public static Session getSession(){
if(null == session){
session = sessionFactory.openSession();
}
return session;
}
}
El siguiente paso es crear en src/main/java el paquete com.tutosoftware.musicmanager.dao
En el paquete com.tutosoftware.musicmanager.dao creamos la interfaz CancionDAO todo esto para
la inyeccción de depedencias con otros frameworks.Hacemos clic derecho sobre el paquete y selecionamos
New->Interface
![hibernate project](../img/hibernate27.jpg)
![hibernate project](../img/hibernate28.jpg)
Escribimos el siguiente código:
package com.tutosoftware.musicmanager.dao;
import java.util.List;
import com.tutosoftware.musicmanager.model.Cancion;
public interface CancionDAO {
public List<Cancion> obtenerCanciones();
public void guardarCancion(Cancion cancion);
//public void actualizarCancion();
//public void borrarCancion();
}
creamos el paquete com.tutosoftware.musicmanager.dao.impl
sobre el paquete com.tutosoftware.musicmanager.dao.impl creamos la clase CancionDAOImpl
![hibernate project](../img/hibernate29.jpg)
y escribimos el siguiente código:
package com.tutosoftware.musicmanager.dao.impl;
import java.util.List;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import com.tutosoftware.musicmanager.util.HibernateSession;
import com.tutosoftware.musicmanager.dao.CancionDAO;
import com.tutosoftware.musicmanager.model.Cancion;
public class CancionDAOImpl implements CancionDAO {
@SuppressWarnings({ "unchecked", "deprecation" })
@Override
public List<Cancion> obtenerCanciones() {
// TODO Auto-generated method stub
SessionFactory sessionFactory = HibernateSession.getSessionFactory();
Session session = sessionFactory.openSession();
session.beginTransaction();
List<Cancion> canciones = session.createQuery("from Cancion").list();
session.getTransaction().commit();
session.close();
return canciones;
}
@Override
public void guardarCancion(Cancion cancion) {
// TODO Auto-generated method stub
SessionFactory sessionFactory = HibernateSession.getSessionFactory();
Session session = sessionFactory.openSession();
session.beginTransaction();
session.save(cancion);
session.getTransaction().commit();
session.close();
}
}
Lo que sigue es crear el paquete com.tutosoftware.musicmanager.action
Creamos el prime action en la clase llamada MusicaAction la cuál se encargara
de subir el mp3 con fileupload y una vez subido realizara el insert en mysql con
hibernate y posteriormente nos mostarará el resultado.Escribimos el siguiente
código:
package com.tutosoftware.musicmanager.action;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import javax.servlet.ServletContext;
import org.apache.commons.io.FileUtils;
import org.apache.struts2.util.ServletContextAware;
import com.opensymphony.xwork2.ActionSupport;
import com.tutosoftware.musicmanager.dao.CancionDAO;
import com.tutosoftware.musicmanager.dao.impl.CancionDAOImpl;
import com.tutosoftware.musicmanager.model.Cancion;
public class MusicaAction extends ActionSupport implements ServletContextAware{
private static final long serialVersionUID = 1L;
private String nombreCancion;
private String artista;
private String album;
private File fileUpload;
private String fileUploadContentType;
private String fileUploadFileName;
private ServletContext servletContext;
//private String destPath;
Cancion cancion = new Cancion();
CancionDAO cancionDAO = new CancionDAOImpl();
List<Cancion> listCancion = new ArrayList<Cancion>();
@Override
public String execute() throws Exception {
try {
//Ruta en raíz donde subira el mp3
String filePath = servletContext.getRealPath("/").concat("musica");
System.out.println("Image location:" + filePath);
File fileToCreate = new File(filePath, this.fileUploadFileName);
FileUtils.copyFile(this.fileUpload, fileToCreate);
} catch (Exception e) {
e.printStackTrace();
return INPUT;
}
cancion.setNombreCancion(nombreCancion);
cancion.setArtista(artista);
cancion.setAlbum(album);
cancion.setNombreArchivo(fileUploadFileName);
cancion.setRutaArchivo("/musica/");
cancionDAO.guardarCancion(cancion);
listCancion = cancionDAO.obtenerCanciones();
return ActionSupport.SUCCESS;
}
@Override
public void validate() {
if (null == nombreCancion || nombreCancion.length() == 0)
addActionError(getText("error.nombrecancion.requerido"));
if (null == artista || artista.length() == 0)
addActionError(getText("error.artista.requerido"));
if (null == fileUploadFileName)
addActionError(getText("error.nombrearchivo.requerido"));
}
public String getNombreCancion() {
return nombreCancion;
}
public void setNombreCancion(String nombreCancion) {
this.nombreCancion = nombreCancion;
}
public String getArtista() {
return artista;
}
public void setArtista(String artista) {
this.artista = artista;
}
public String getAlbum() {
return album;
}
public void setAlbum(String album) {
this.album = album;
}
public File getFileUpload() {
return fileUpload;
}
public void setFileUpload(File fileUpload) {
this.fileUpload = fileUpload;
}
public String getFileUploadContentType() {
return fileUploadContentType;
}
public void setFileUploadContentType(String fileUploadContentType) {
this.fileUploadContentType = fileUploadContentType;
}
public String getFileUploadFileName() {
return fileUploadFileName;
}
public void setFileUploadFileName(String fileUploadFileName) {
this.fileUploadFileName = fileUploadFileName;
}
public List<Cancion> getListCancion() {
return listCancion;
}
public void setListCancion(List<Cancion> listCancion) {
this.listCancion = listCancion;
}
public void setServletContext(ServletContext context) {
servletContext=context;
}
}
en el paquete com.tutosoftware.musicmanager.action creamos el segundo action llamado ListarMusicaAction
que nos devolverá una lista de los mp3 disponibles.Escribimos el siguiente código:
package com.tutosoftware.musicmanager.action;
import java.util.ArrayList;
import java.util.List;
import com.opensymphony.xwork2.ActionSupport;
import com.tutosoftware.musicmanager.dao.CancionDAO;
import com.tutosoftware.musicmanager.dao.impl.CancionDAOImpl;
import com.tutosoftware.musicmanager.model.Cancion;
public class ListarMusicaAction extends ActionSupport {
private static final long serialVersionUID = 1L;
CancionDAO cancionDAO = new CancionDAOImpl();
List<Cancion> listCancion = new ArrayList<Cancion>();
@Override
public String execute() throws Exception {
listCancion = cancionDAO.obtenerCanciones();
return ActionSupport.SUCCESS;
}
public List<Cancion> getListCancion() {
return listCancion;
}
public void setListCancion(List<Cancion> listCancion) {
this.listCancion = listCancion;
}
}
Ahora modificamos el index.jsp y escribimos lo siguiente:
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Music Manager</title>
<s:head/>
</head>
<body>
<h2>Music Manager</h2>
<s:if test="hasActionErrors()">
<div id="campoError">
<s:actionerror/>
</div>
</s:if>
<s:form action="musicaAction" method="post" enctype="multipart/form-data">
<s:textfield name="nombreCancion" label="Nombre Canción"> </s:textfield>
<s:textfield name="artista" label="Artista"> </s:textfield>
<s:textfield name="album" label="Albúm"> </s:textfield>
<s:file name="fileUpload" label="Seleccionar un archivo" size="40" />
<s:submit value="enviar" name="submit" />
<s:token />
</s:form>
<s:a href="listarMusicaAction.action">ConsultarArchivos</s:a>
</body>
</html>
en webapp cramos la carpeta llamada jsp
dentro de la carpeta jsp creamos el archivo upload.jsp y escribimos el siguiente
código:
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Music Manager</title>
</head>
<body>
<s:if test="listCancion.size() > 0">
<table style="border: solid;">
<tr>
<th>Id canción</th>
<th>Nombre de la canción</th>
<th>Artista</th>
<th>Albúm</th>
<th>Audio</th>
</tr>
<s:iterator value="listCancion" var="cancion">
<tr>
<td><s:property value="idCancion" /></td>
<td><s:property value="nombreCancion" /></td>
<td><s:property value="artista" /></td>
<td><s:property value="album" /></td>
<td>
<audio id="audio-1" controls="controls">
<source src="<s:url value='%{rutaArchivo}%{nombreArchivo}'/>"/>
</audio>
</td>
</tr>
</s:iterator>
</table>
</s:if>
<a href="index.jsp">Regresar</a>
</body>
</html>
En webapp creamos la carpeta musica ya que ahí es donde se subiran los mp3s
en src/main/resources creamos el archivo ApplicationResources.properties aquí
donde apreceran los errores de la vista.Escribimos el siguiente código:
error.nombrecancion.requerido = Nombre de la canción requerido!
error.artista.requerido = Nombre del artista requerido!
error.nombrearchivo.requerido = Archivo requerido!
struts.messages.error.content.type.not.allowed = Solo aceptamos archivos de audio
de la misna forma en src/main/resources creamos el archivo struts.xml y escribimos el
siguiente código:
<?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>
<constant name="struts.enable.DynamicMethodInvocation" value="false"></constant>
<constant name="struts.devMode" value="true"></constant>
<constant name="struts.custom.i18n.resources" value="ApplicationResources"></constant>
<constant name="struts.multipart.maxSize" value="104857600" />
<package name="default" namespace="/" extends="struts-default">
<action name="">
<result>index.jsp</result>
</action>
<action name="musicaAction" class="com.tutosoftware.musicmanager.action.MusicaAction">
<interceptor-ref name="token"></interceptor-ref>
<result name="error">index.jsp</result>
<result name="input">index.jsp</result>
<result name="success" >/jsp/upload.jsp</result>
<result name="invalid.token">index.jsp</result>
<interceptor-ref name="defaultStack">
<param name="fileUpload.maximumSize">10485760</param>
<param name="fileUpload.allowedTypes">audio/mpeg,audio/mp3</param>
</interceptor-ref>
</action>
<action name="listarMusicaAction" class="com.tutosoftware.musicmanager.action.ListarMusicaAction">
<result name="success">/jsp/upload.jsp</result>
</action>
</package>
</struts>
Modificamos el archivo web.xml y escribimos lo siguiente:
<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>
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
En caso de que no te deje pasar de la versión 2.3 a 3.1 del web.xml lo hay es posicionarse
en la carpeta .settings de tu proyecto:
![java project](../img/java42.jpg)
Modificamos el archivo org.eclipse.wst.common.project.facet.core.xml
la línea <installed facet="jst.web" version="2.3"/> por
<installed facet="jst.web" version="3.1"/> no olvidar que modificamos el web.xml
quedandonos el archivo de la siguiente manera:
<?xml version="1.0" encoding="UTF-8"?>
<faceted-project>
<fixed facet="wst.jsdt.web"/>
<installed facet="jst.web" version="3.1"/>
<installed facet="wst.jsdt.web" version="1.0"/>
<installed facet="java" version="1.8"/>
</faceted-project>
Luego damos un Maven->Update Project.. y listo.
Ahora hacemos clic derecho sobre nuestro proyecto y selecionamos Run As->Run on Server
![java project](../img/java35.jpg)
y presionamos Finish
![java project](../img/java36.jpg)
La aplicación la abrimos con nuestro explorador desde la dirección http://localhost:8080/MusicManager/
![hibernate project](../img/hibernate30.jpg)
Intentamos enviar un registro sin llenar los datos
![hibernate project](../img/hibernate31.jpg)
Llenamos los datos y damos enviar
![hibernate project](../img/hibernate32.jpg)
Este el resultado que nos arroja
![hibernate project](../img/hibernate33.jpg)
Seleccionamos regresar y probamos Consultar archivos
![hibernate project](../img/hibernate34.jpg)
Vista en google chrome
![hibernate project](../img/hibernate35.jpg)
Vista en internet explorer
![hibernate project](../img/hibernate36.jpg)
Una vez probada nuestra aplicación nos posicionamos en el proyecto y hacemos
clic derecho y seleccionamos Team->Commit para subir los cambios nuestro controlador de versiones
![hibernate project](../img/hibernate37.jpg)
Hacemos un comentario y presionamos ok
![hibernate project](../img/hibernate38.jpg)
Conclusión
Como podemos ver se llego al objetivo que era realizar un ejemplo de hibernate
pero me encontre con unos cambios sobre todo en la parte de mapeo ya que la parte del
session factory al que agregar la clase configuration.addClass(Cancion.class);
sino marca error y otro fue esta deprecado el método list() de consulta falta ver
como se solucionar este problema con la versión 5.2.4,además de poner un controlador de versiones
esto es para tratar de semajar a un desarrollo de software real donde se tiene que controlar
los cambios y la parte del cliente que es struts2 con fileupload que tine validaciones con interceptores
para tamaño de archivo,tipo de archivo y evitar replicación de registros con token
además de visualizar los mp3 que subimos y poder usarlos.Como punto final cada
vez que se muestre un ejemplo sera un poco mas robusto hasta casi llegar a una infrastructura y
así ir evolucionando poco a poco.
Referencias
Aquí dejo algunos links de donde saque información para este ejemplo:
Descargar código fuente
descargar código
importar el proyecto maven a eclipse
Hay que importar el proyecto a eclipse y no olvidar que se esta realizado en java 1.8.
Como importar un proyecto a eclipse