<?xml version='1.0' encoding='UTF-8'?><rss xmlns:atom="http://www.w3.org/2005/Atom" xmlns:openSearch="http://a9.com/-/spec/opensearchrss/1.0/" xmlns:blogger="http://schemas.google.com/blogger/2008" xmlns:georss="http://www.georss.org/georss" xmlns:gd="http://schemas.google.com/g/2005" xmlns:thr="http://purl.org/syndication/thread/1.0" version="2.0"><channel><atom:id>tag:blogger.com,1999:blog-3127563630788798649</atom:id><lastBuildDate>Fri, 24 Jul 2026 06:06:28 +0000</lastBuildDate><category>Hibernate</category><category>HQL</category><category>Java</category><category>DAO</category><category>Annotations</category><category>Spring</category><category>Ant</category><category>Cache</category><category>Criteria</category><category>DataAccessException</category><category>First Level Cache</category><category>Hibernate Criteria</category><category>HibernateDaoSupport</category><category>HibernateTemplate</category><category>IoC</category><category>SQL</category><category>Second Level Cache</category><category>Struts</category><category>equals</category><category>getHibernateTemplate</category><category>getSession</category><category>hashCode</category><category>ADO</category><category>API de Java</category><category>Analisis de Riesgos</category><category>AnnotationSessionFactoryBean</category><category>Apache</category><category>Apache Commons Lang</category><category>Array Java</category><category>ArrayList</category><category>Arrays Java</category><category>Arrays en Java</category><category>AuditInterceptor</category><category>Buenas Prácticas</category><category>Capa de Datos</category><category>Capa de Presentación</category><category>Colecciones en Java</category><category>Collection Framework</category><category>Configuration</category><category>Criteria Query</category><category>Criteria.Spring</category><category>DefaultLoadEventListener</category><category>EHCache</category><category>ETL</category><category>EmptyInterceptor</category><category>Fetch</category><category>Filter</category><category>Framework</category><category>Group By</category><category>HashMap Java</category><category>HashMap en Java</category><category>HashSet</category><category>Hibernate Annotations</category><category>Hibernate Mapping</category><category>Hibernate Query Language</category><category>Hibernate Session</category><category>Hibernate con Spring</category><category>HibernateEntityManager</category><category>HibernateException</category><category>ICD</category><category>Incialización de Arrays</category><category>Interceptor</category><category>Interface Control Document</category><category>JPA</category><category>Java Array</category><category>Java Arrays</category><category>Java Persistence API</category><category>Java StringBuffer</category><category>Job Schedule</category><category>Job Scheduling</category><category>Join</category><category>Lazy Loading</category><category>LazyInitializationException</category><category>LinkedList</category><category>List</category><category>MVC</category><category>Map</category><category>Mapeo Hibernate</category><category>Microsoft ActiveX Data Object</category><category>Modelo Vista Controlador</category><category>OLAP</category><category>ORM</category><category>OpenSymphony</category><category>Order By</category><category>OutOfMemoryError</category><category>Plan de Calidad</category><category>Plan de Proyecto</category><category>Quartz</category><category>Quartz Java</category><category>Queue</category><category>RuntimeException</category><category>Select</category><category>Session</category><category>Set</category><category>Spring Framework</category><category>Spring Hibernate</category><category>Spring Quartz</category><category>StringBuffer Java</category><category>StringBuffer en Java</category><category>Struts 2</category><category>Struts Tags</category><category>Struts Tiles</category><category>Subconsultas</category><category>Transacciones</category><category>Transaction</category><category>TreeSet</category><category>advice</category><category>aop</category><category>aspect</category><category>aspect oriented programming</category><category>aspecto</category><category>bases de datos relacionales</category><category>cache en Hibernate</category><category>cierre de proyecto</category><category>colecciones de objetos</category><category>compareTo</category><category>constraints</category><category>contains</category><category>cron</category><category>cronjob</category><category>ejemplo</category><category>entrySet</category><category>evaluar el rendimiento</category><category>evaluar la performance</category><category>gestión de proyectos</category><category>hash</category><category>hbm.xml</category><category>implementar un ETL</category><category>integrar hibernate con spring</category><category>introduction</category><category>iterator</category><category>jointpoint</category><category>keySet</category><category>kick off de un proyecto</category><category>length array java</category><category>openSession</category><category>pagina web</category><category>patron</category><category>poc</category><category>point of contact</category><category>pointcut</category><category>proceso batch</category><category>procesos ETL</category><category>programación orientada a aspectos</category><category>proxy</category><category>punto de cruce</category><category>puntos de corte</category><category>reglas de negocio</category><category>reunion de kick off</category><category>reuniones de seguimiento</category><category>servlet</category><category>sessionFactory</category><category>sistemas legacy</category><category>stored procedure</category><category>struts-config</category><category>target</category><category>triggers</category><category>weaving</category><title>Java en Castellano, Hibernate Framework, Struts Framework, Spring Framework y mucho más!!</title><description>Estabas buscando el significado de Hibernate Framework?? de Struts Framework?? Spring Framework?? Java Collections?? &#xa;Empieza a investigar este blog.&#xa;&#xa;BIENVENIDO!!</description><link>http://javaencastellano-hibernate.blogspot.com/</link><managingEditor>noreply@blogger.com (Julian)</managingEditor><generator>Blogger</generator><openSearch:totalResults>38</openSearch:totalResults><openSearch:startIndex>1</openSearch:startIndex><openSearch:itemsPerPage>25</openSearch:itemsPerPage><item><guid isPermaLink="false">tag:blogger.com,1999:blog-3127563630788798649.post-3939646314213508331</guid><pubDate>Wed, 29 May 2013 02:32:00 +0000</pubDate><atom:updated>2013-05-28T23:32:58.593-03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">Fetch</category><category domain="http://www.blogger.com/atom/ns#">Hibernate</category><category domain="http://www.blogger.com/atom/ns#">Lazy Loading</category><title>Hibernate Fetch y Lazy Loading</title><atom:summary type="text">

Hibernate (http://www.hibernate.org/) es una potente herramienta de persistencia que nos permite mapear clases en una base de datos relacional.



En este tutorial vamos a ver como se comportan ciertas relaciones, y como podemos optimizar las consultas a la base de datos. No pretende ser una guía detallada, sino una introducción a las características de Hibernate en este sentido.




Esta fuera</atom:summary><link>http://javaencastellano-hibernate.blogspot.com/2013/05/hibernate-fetch-y-lazy-loading.html</link><author>noreply@blogger.com (Julian)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-3127563630788798649.post-3068548008630152010</guid><pubDate>Wed, 29 May 2013 02:25:00 +0000</pubDate><atom:updated>2013-05-28T23:25:39.547-03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">Buenas Prácticas</category><category domain="http://www.blogger.com/atom/ns#">Hibernate</category><title>Hibernate: Buenas Prácticas</title><atom:summary type="text">


Pero el uso de un ORM también puede causar problemas si no tenemos en cuenta unas ciertas buenas prácticas.&amp;nbsp;

Escriba las clases detalladas y mapéelas utilizando&amp;nbsp;:




Utilice una clase&amp;nbsp;Dirección&amp;nbsp;para encapsular&amp;nbsp;calle,&amp;nbsp;distrito,&amp;nbsp;estado,&amp;nbsp;código postal. Esto promueve la reutilización de código y simplifica la refabricación.



Declare las propiedades </atom:summary><link>http://javaencastellano-hibernate.blogspot.com/2013/05/hibernate-buenas-practicas.html</link><author>noreply@blogger.com (Julian)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-3127563630788798649.post-3497601731016407508</guid><pubDate>Wed, 29 May 2013 02:20:00 +0000</pubDate><atom:updated>2013-05-28T23:20:20.829-03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">Ant</category><category domain="http://www.blogger.com/atom/ns#">Hibernate</category><title>Hibernate + Ant</title><atom:summary type="text">

Puede llamar a&amp;nbsp;SchemaExport&amp;nbsp;desde su script de construcción de Ant:




&amp;lt;target&amp;nbsp;name=&quot;schemaexport&quot;&amp;gt;
&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;lt;taskdef&amp;nbsp;name=&quot;schemaexport&quot;
&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;classname=&quot;org.hibernate.tool.hbm2ddl.SchemaExportTask&quot;
&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;classpathref=&quot;class.path&quot;/&amp;gt;
&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;
&amp;nbsp;</atom:summary><link>http://javaencastellano-hibernate.blogspot.com/2013/05/hibernate-ant.html</link><author>noreply@blogger.com (Julian)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-3127563630788798649.post-227174900538911015</guid><pubDate>Wed, 29 May 2013 02:18:00 +0000</pubDate><atom:updated>2013-05-28T23:18:03.159-03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">Filter</category><category domain="http://www.blogger.com/atom/ns#">Hibernate</category><title>Hibernate Filters</title><atom:summary type="text">

Hibernate3 proporciona un nuevo enfoque innovador para manejar datos con reglas de &quot;visibilidad&quot;. Unfiltro Hibernate&amp;nbsp;es un filtro global, con nombre y parametrizado que puede ser habilitado o deshabilitado para una sesión de Hibernate especifica.




Filtros de Hibernate

Hibernate3 tiene la habilidad de predefinir criterios de filtros y unir esos filtros tanto a nivel de clase como de </atom:summary><link>http://javaencastellano-hibernate.blogspot.com/2013/05/hibernate-filters.html</link><author>noreply@blogger.com (Julian)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-3127563630788798649.post-5034911727043624597</guid><pubDate>Wed, 29 May 2013 02:14:00 +0000</pubDate><atom:updated>2013-05-28T23:14:03.214-03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">Hibernate</category><category domain="http://www.blogger.com/atom/ns#">HQL</category><category domain="http://www.blogger.com/atom/ns#">Select</category><category domain="http://www.blogger.com/atom/ns#">Subconsultas</category><title>Hibernate HQL Sub Select (Subconsultas)</title><atom:summary type="text">

Para bases de datos que soportan subconsultas, Hibernate soporta subconsultas dentro de consultas. Una subconsulta se debe encerrar entre paréntesis (frecuentemente por una llamada a una función de agregación SQL). Incluso se permiten subconsultas correlacionadas (subconsultas que se refieren a un alias en la consulta exterior).



from Cat as fatcat
where fatcat.weight 
&amp;gt; (
    select avg(</atom:summary><link>http://javaencastellano-hibernate.blogspot.com/2013/05/hibernate-hql-sub-select-subconsultas.html</link><author>noreply@blogger.com (Julian)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-3127563630788798649.post-5824808288488713737</guid><pubDate>Wed, 29 May 2013 02:12:00 +0000</pubDate><atom:updated>2013-05-28T23:12:32.822-03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">Group By</category><category domain="http://www.blogger.com/atom/ns#">Hibernate</category><category domain="http://www.blogger.com/atom/ns#">HQL</category><title>Hibernate HQL Group By</title><atom:summary type="text">

Una consulta que retorna valores agregados se puede agrupar por cualquier propiedad de una clase retornada o componentes:



select cat.color, sum(cat.weight), count(cat)
from Cat cat
group by cat.color
select foo.id, avg(name), max(name)
from Foo foo join foo.names name
group by foo.id



Se permite también una cláusula&amp;nbsp;having.


select cat.color, sum(cat.weight), count(cat)
from Cat cat
</atom:summary><link>http://javaencastellano-hibernate.blogspot.com/2013/05/hibernate-hql-group-by.html</link><author>noreply@blogger.com (Julian)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-3127563630788798649.post-8477417529117913388</guid><pubDate>Wed, 29 May 2013 02:11:00 +0000</pubDate><atom:updated>2013-05-28T23:11:23.762-03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">Hibernate</category><category domain="http://www.blogger.com/atom/ns#">HQL</category><category domain="http://www.blogger.com/atom/ns#">Order By</category><title>Hibernate HQL Order By</title><atom:summary type="text">

La lista retornada por una consulta se puede ordenar por cualquier propiedad de una clase retornada o componentes:



from DomesticCat cat
order by cat.name asc, cat.weight desc, cat.birthdate



Los&amp;nbsp;asc&amp;nbsp;o&amp;nbsp;desc&amp;nbsp;opcionales indican ordenamiento ascendente o descendente respectivamente.

</atom:summary><link>http://javaencastellano-hibernate.blogspot.com/2013/05/hibernate-hql-order-by.html</link><author>noreply@blogger.com (Julian)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-3127563630788798649.post-2320790236454968806</guid><pubDate>Wed, 29 May 2013 02:10:00 +0000</pubDate><atom:updated>2013-05-28T23:10:19.064-03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">Hibernate</category><category domain="http://www.blogger.com/atom/ns#">HQL</category><category domain="http://www.blogger.com/atom/ns#">Join</category><title>Hibernate HQL Join</title><atom:summary type="text">

También puede asignar alias a entidades asociadas o a elementos de una colección de valores utilizando una&amp;nbsp;join. 
Por ejemplo:


from Cat as cat
    inner join cat.mate as mate
    left outer join cat.kittens as kitten
from Cat as cat left join cat.mate.kittens as kittens
from Formula form full join form.parameter param



Los tipos de uniones soportadas se tomaron prestados de ANSI SQL


</atom:summary><link>http://javaencastellano-hibernate.blogspot.com/2013/05/hibernate-hql-join.html</link><author>noreply@blogger.com (Julian)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-3127563630788798649.post-3687028744270313091</guid><pubDate>Wed, 29 May 2013 02:07:00 +0000</pubDate><atom:updated>2013-05-28T23:07:48.237-03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">Hibernate</category><category domain="http://www.blogger.com/atom/ns#">HQL</category><title>Ejemplos de HQL</title><atom:summary type="text">


Las consultas de Hibernate pueden ser bastante potentes y complejas. De hecho, el poder del lenguaje de consulta es uno de las fortalezas principales de Hibernate. He aquí algunos ejemplos de consultas muy similares a las consultas de proyectos recientes. Note que la mayoría de las consultas que escribirá son mucho más simples que los siguientes ejemplos.




La siguiente consulta retorna el </atom:summary><link>http://javaencastellano-hibernate.blogspot.com/2013/05/ejemplos-de-hql.html</link><author>noreply@blogger.com (Julian)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-3127563630788798649.post-8940406053123188716</guid><pubDate>Wed, 29 May 2013 01:57:00 +0000</pubDate><atom:updated>2013-05-28T22:57:02.098-03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">AuditInterceptor</category><category domain="http://www.blogger.com/atom/ns#">Configuration</category><category domain="http://www.blogger.com/atom/ns#">DefaultLoadEventListener</category><category domain="http://www.blogger.com/atom/ns#">EmptyInterceptor</category><category domain="http://www.blogger.com/atom/ns#">Interceptor</category><category domain="http://www.blogger.com/atom/ns#">Transaction</category><title>Interceptores y Eventos en Hibernate</title><atom:summary type="text">


Es útil para la aplicación reaccionar a ciertos eventos que ocurren dentro de Hibernate. Esto permite la implementación de funcionalidades genéricas y la extensión de la funcionalidad de Hibernate.




1. Interceptores

La interfaz&amp;nbsp;Interceptor&amp;nbsp;brinda callbacks desde la sesión a la aplicación, permitiendole a ésta última inspeccionar y/o manipular las propiedades de un objeto </atom:summary><link>http://javaencastellano-hibernate.blogspot.com/2013/05/interceptores-y-eventos-en-hibernate.html</link><author>noreply@blogger.com (Julian)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-3127563630788798649.post-5574940700814422548</guid><pubDate>Wed, 29 May 2013 01:51:00 +0000</pubDate><atom:updated>2013-05-28T22:51:02.037-03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">Criteria</category><category domain="http://www.blogger.com/atom/ns#">Hibernate</category><category domain="http://www.blogger.com/atom/ns#">Hibernate Criteria</category><title>Hibernate Criteria</title><atom:summary type="text">

Acompaña a Hibernate una API de consultas por criterios intuitiva y extensible.








1. Creando una instancia de&amp;nbsp;Criteria



La interface&amp;nbsp;org.hibernate.Criteria&amp;nbsp;representa una consulta contra una clase persistente en particular. LaSession&amp;nbsp;es una fábrica de instancias de&amp;nbsp;Criteria.

Criteria crit = sess.createCriteria(Cat.class);
crit.setMaxResults(50);
List cats = </atom:summary><link>http://javaencastellano-hibernate.blogspot.com/2013/05/hibernate-criteria.html</link><author>noreply@blogger.com (Julian)</author><thr:total>2</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-3127563630788798649.post-2167154630972181533</guid><pubDate>Wed, 29 May 2013 01:38:00 +0000</pubDate><atom:updated>2013-05-28T22:38:43.617-03:00</atom:updated><title>¿Qué es Hibernate?</title><atom:summary type="text">
Cuando comenzamos a estudiar Java escuchamos nombrar este Framework de Java y en repetidas ocasiones nos preguntamos para qué sirve o por qué utilizarlo. En esta nota encontrarás respuestas a algunos de esos interrogantes.


“Hibernate es una herramienta de Mapeo objeto-relacional (ORM) para la plataforma Java (y disponible también para .Net con el nombre de NHibernate) que facilita el mapeo de </atom:summary><link>http://javaencastellano-hibernate.blogspot.com/2013/05/que-es-hibernate.html</link><author>noreply@blogger.com (Julian)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-3127563630788798649.post-5575307466785503273</guid><pubDate>Wed, 29 May 2013 01:28:00 +0000</pubDate><atom:updated>2013-05-28T22:28:58.812-03:00</atom:updated><title>Hibernate Mapping: Testear mapeos </title><atom:summary type="text">

Revolviendo la web por ahí me encuentro con un muy&amp;nbsp;pequeño ejemplo&amp;nbsp;de cómo, con pocas líneas, testear todos los mapeos de&amp;nbsp;Hibernate&amp;nbsp;de una aplicación. El test comprueba que sintácticamente estén bien escritos todos los mapeos, que las columnas mapeadas existan y se puedan asignar a atributos de los objetos. Para hacer uso se utiliza el API de&amp;nbsp;Hibernate&amp;nbsp;para pedirle</atom:summary><link>http://javaencastellano-hibernate.blogspot.com/2013/05/hibernate-mapping-testear-mapeos.html</link><author>noreply@blogger.com (Julian)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-3127563630788798649.post-8244998105156444319</guid><pubDate>Wed, 29 May 2013 01:00:00 +0000</pubDate><atom:updated>2013-05-28T22:01:30.466-03:00</atom:updated><title>Hibernate HQL con Eficiencia</title><atom:summary type="text">

Hibernate&amp;nbsp;provee varias formas de ejecutar un mismo Query HQL, devolviendo los resultados de distintas maneras. La interfaz que se utiliza para la ejecución de queries es precisamente&amp;nbsp;org.hibernate.Query&amp;nbsp;que provee 3 metodos para obtener los resultados de un Query:&amp;nbsp;list(),&amp;nbsp;iterate()&amp;nbsp;y&amp;nbsp;scroll().


Se analizarán los dos primeros en cuanto a eficiencia y </atom:summary><link>http://javaencastellano-hibernate.blogspot.com/2013/05/hibernate-varias-formas-de-ejecutar-un.html</link><author>noreply@blogger.com (Julian)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-3127563630788798649.post-1108259515561629154</guid><pubDate>Wed, 29 May 2013 00:59:00 +0000</pubDate><atom:updated>2013-05-28T21:59:29.936-03:00</atom:updated><title>Hibernate 3.3</title><atom:summary type="text">

Después de muchos meses de trabajo ya se puede&amp;nbsp;descargar Hibernate 3.3 GA, la nueva versión del ORM más utilizado para Java. Entre las&amp;nbsp;novedades&amp;nbsp;más destacadas frente a la versión 3.2 anterior:

Migración a un sistema de construcción con Maven.
División del proyecto en varios módulos jar (al estilo de módulos Maven), lo que facilita el ver y administrar las dependencias.
Rediseño</atom:summary><link>http://javaencastellano-hibernate.blogspot.com/2013/05/hibernate-33_28.html</link><author>noreply@blogger.com (Julian)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-3127563630788798649.post-5223174190156054203</guid><pubDate>Wed, 29 May 2013 00:14:00 +0000</pubDate><atom:updated>2013-05-28T21:14:18.691-03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">Criteria.Spring</category><category domain="http://www.blogger.com/atom/ns#">Hibernate</category><category domain="http://www.blogger.com/atom/ns#">Hibernate Criteria</category><title>Hibernate Criteria + Spring</title><atom:summary type="text">



Hibernate&amp;nbsp;Criteria&amp;nbsp;es una API que nos facilita las consultas (no las inserciones) a la base de datos. La ventaja fundamental de esta API es que nos permite tratar la composición de la consulta de una forma totalmente orientada a objetos. Es decir, no compone la consulta a través de una cadena insertada por nosotros mismos, sino que la compone la propia API a través de unas </atom:summary><link>http://javaencastellano-hibernate.blogspot.com/2013/05/hibernate-criteria-spring.html</link><author>noreply@blogger.com (Julian)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-3127563630788798649.post-8319188540535062480</guid><pubDate>Tue, 28 May 2013 23:39:00 +0000</pubDate><atom:updated>2013-05-28T20:39:33.330-03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">Annotations</category><category domain="http://www.blogger.com/atom/ns#">Hibernate</category><category domain="http://www.blogger.com/atom/ns#">Hibernate Annotations</category><category domain="http://www.blogger.com/atom/ns#">HibernateEntityManager</category><title>Hibernate Annotations</title><atom:summary type="text">

Uno de los problemas mas frecuentes al trabajar con Hibernate, es la generación de los mapping files. (archivos .hbm.xml). Hay varias opciones para generarlos, desde escribirlos a mano hasta usar varios de los generadores automáticos. La manera mas usual es usar&amp;nbsp;Xdoclet, algo que a mi particularmente nunca me gustó, ya que agrega un paso mas a la compilación, obligándome a usar Ant todo el</atom:summary><link>http://javaencastellano-hibernate.blogspot.com/2013/05/hibernate-annotations.html</link><author>noreply@blogger.com (Julian)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-3127563630788798649.post-7635770409286917013</guid><pubDate>Tue, 28 May 2013 23:34:00 +0000</pubDate><atom:updated>2013-05-28T20:51:11.569-03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">hbm.xml</category><category domain="http://www.blogger.com/atom/ns#">Hibernate Mapping</category><category domain="http://www.blogger.com/atom/ns#">Mapeo Hibernate</category><title>Mapeo en Hibernate (hbm.xml)</title><atom:summary type="text">



Para generar un mapeo de un objeto Java a Hibernate debemos contar con el Bean inicial.

La version java de la clase Person seria algo asi:



package org.hibernate.tutorial.domain;

public class Person {

&amp;nbsp; &amp;nbsp; private Long id;

&amp;nbsp; &amp;nbsp; private int age;

&amp;nbsp; &amp;nbsp; private String firstname;

&amp;nbsp; &amp;nbsp; private String lastname;

&amp;nbsp; &amp;nbsp; public Person() {}

&amp;nbsp; &amp;</atom:summary><link>http://javaencastellano-hibernate.blogspot.com/2013/05/mapeo-en-hibernate-hbmxml.html</link><author>noreply@blogger.com (Julian)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-3127563630788798649.post-621915498427466905</guid><pubDate>Tue, 21 Sep 2010 00:22:00 +0000</pubDate><atom:updated>2013-05-28T20:51:54.175-03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">Annotations</category><category domain="http://www.blogger.com/atom/ns#">AnnotationSessionFactoryBean</category><category domain="http://www.blogger.com/atom/ns#">DAO</category><category domain="http://www.blogger.com/atom/ns#">ejemplo</category><category domain="http://www.blogger.com/atom/ns#">getHibernateTemplate</category><category domain="http://www.blogger.com/atom/ns#">getSession</category><category domain="http://www.blogger.com/atom/ns#">Hibernate</category><category domain="http://www.blogger.com/atom/ns#">HibernateDaoSupport</category><category domain="http://www.blogger.com/atom/ns#">integrar hibernate con spring</category><category domain="http://www.blogger.com/atom/ns#">IoC</category><category domain="http://www.blogger.com/atom/ns#">Spring</category><title>Hibernate + Spring + Annotations</title><atom:summary type="text">
&lt;!--[if gte mso 9]&gt;
 
  Normal
  0
  21
  
   
   
   
   
  
  MicrosoftInternetExplorer4
 
&lt;![endif]--&gt;&lt;!--[if !mso]&gt;

st1\:*{behavior:url(#ieooui) }

&lt;![endif]--&gt;&lt;!--[if gte mso 10]&gt;

 /* Style Definitions */
 table.MsoNormalTable
 {mso-style-name:&quot;Tabla normal&quot;;
 mso-tstyle-rowband-size:0;
 mso-tstyle-colband-size:0;
 mso-style-noshow:yes;
 mso-style-parent:&quot;&quot;;
 mso-padding-alt:0cm 5.4pt 0cm</atom:summary><link>http://javaencastellano-hibernate.blogspot.com/2010/09/hibernate-spring-annotations.html</link><author>noreply@blogger.com (Julian)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-3127563630788798649.post-6171663152245352124</guid><pubDate>Thu, 22 Jul 2010 19:10:00 +0000</pubDate><atom:updated>2013-05-28T20:52:03.218-03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">DataAccessException</category><category domain="http://www.blogger.com/atom/ns#">HibernateException</category><category domain="http://www.blogger.com/atom/ns#">HibernateTemplate</category><category domain="http://www.blogger.com/atom/ns#">LazyInitializationException</category><category domain="http://www.blogger.com/atom/ns#">Session</category><category domain="http://www.blogger.com/atom/ns#">Spring Hibernate</category><title>Spring Hibernate: HibernateTemplate Class</title><atom:summary type="text">
Hablando del HibernateTemplate, la implementación de Hibernate según Spring, surge siempre la misma pregunta entre la gente que no lo utiliza asiduamente: ¿De que me pierdo si no lo uso?


Si consultamos la documentación de Spring Hibernate encontramos que dice que HibernateTemplate es una clase que provee muchas de las funcionalidades de la interfaz Session de Hibernate, adicionando algunos </atom:summary><link>http://javaencastellano-hibernate.blogspot.com/2010/07/spring-hibernate-hibernatetemplate.html</link><author>noreply@blogger.com (Julian)</author><thr:total>1</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-3127563630788798649.post-8947800827394789140</guid><pubDate>Mon, 14 Jun 2010 18:29:00 +0000</pubDate><atom:updated>2013-05-28T20:52:11.182-03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">bases de datos relacionales</category><category domain="http://www.blogger.com/atom/ns#">constraints</category><category domain="http://www.blogger.com/atom/ns#">ETL</category><category domain="http://www.blogger.com/atom/ns#">ICD</category><category domain="http://www.blogger.com/atom/ns#">implementar un ETL</category><category domain="http://www.blogger.com/atom/ns#">Interface Control Document</category><category domain="http://www.blogger.com/atom/ns#">OLAP</category><category domain="http://www.blogger.com/atom/ns#">procesos ETL</category><category domain="http://www.blogger.com/atom/ns#">reglas de negocio</category><category domain="http://www.blogger.com/atom/ns#">sistemas legacy</category><category domain="http://www.blogger.com/atom/ns#">triggers</category><title>Procesos ETL (Extract, Transform and Load)</title><atom:summary type="text">
ETL son las siglas en inglés que representan Extract, Transform and 
Load (Extraer, Transformar, Cargar). Este proceso permite a una 
organización mover datos desde diferentes fuentes, transformarlos y 
arreglarlos a medida, y guardarlos en otra base de datos o en otro 
sistema para su posterior utilización por el negocio.


Los
 procesos ETL también se pueden 
utilizar para integrar sistemas </atom:summary><link>http://javaencastellano-hibernate.blogspot.com/2010/06/procesos-etl-extract-transform-and-load.html</link><author>noreply@blogger.com (Julian)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-3127563630788798649.post-7231957087738357641</guid><pubDate>Mon, 14 Jun 2010 18:28:00 +0000</pubDate><atom:updated>2013-05-28T20:52:18.326-03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">cron</category><category domain="http://www.blogger.com/atom/ns#">cronjob</category><category domain="http://www.blogger.com/atom/ns#">Java</category><category domain="http://www.blogger.com/atom/ns#">Job Schedule</category><category domain="http://www.blogger.com/atom/ns#">Job Scheduling</category><category domain="http://www.blogger.com/atom/ns#">OpenSymphony</category><category domain="http://www.blogger.com/atom/ns#">proceso batch</category><category domain="http://www.blogger.com/atom/ns#">Quartz</category><category domain="http://www.blogger.com/atom/ns#">Quartz Java</category><category domain="http://www.blogger.com/atom/ns#">Spring Quartz</category><title>Introdución a Quartz Job Scheduling Framework</title><atom:summary type="text">

Siempre existe la necesidad de hacer un proceso batch que ejecute 
una tarea programada. ¿Con que 
tecnología Java open-source lo 
puedo hacer?


Hoy les mostraremos un framework open-source que nació para 
facilitar la creación y gestión Trabajos
 Programados (job scheduling):
 Quartz Job Scheduling Framework de OpenSymphony.

Ofrece una gran 
flexibilidad sin sacrificar la simplicidad. Puede </atom:summary><link>http://javaencastellano-hibernate.blogspot.com/2010/06/introducion-quartz-job-scheduling.html</link><author>noreply@blogger.com (Julian)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-3127563630788798649.post-3526826688674731601</guid><pubDate>Mon, 14 Jun 2010 18:28:00 +0000</pubDate><atom:updated>2013-05-28T20:52:26.038-03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">Apache</category><category domain="http://www.blogger.com/atom/ns#">Capa de Datos</category><category domain="http://www.blogger.com/atom/ns#">Capa de Presentación</category><category domain="http://www.blogger.com/atom/ns#">Framework</category><category domain="http://www.blogger.com/atom/ns#">IoC</category><category domain="http://www.blogger.com/atom/ns#">Java</category><category domain="http://www.blogger.com/atom/ns#">Modelo Vista Controlador</category><category domain="http://www.blogger.com/atom/ns#">MVC</category><category domain="http://www.blogger.com/atom/ns#">pagina web</category><category domain="http://www.blogger.com/atom/ns#">patron</category><category domain="http://www.blogger.com/atom/ns#">servlet</category><category domain="http://www.blogger.com/atom/ns#">Spring</category><category domain="http://www.blogger.com/atom/ns#">Struts</category><category domain="http://www.blogger.com/atom/ns#">Struts 2</category><category domain="http://www.blogger.com/atom/ns#">Struts Tags</category><category domain="http://www.blogger.com/atom/ns#">Struts Tiles</category><category domain="http://www.blogger.com/atom/ns#">struts-config</category><title>Introdución a Apache Struts Framework</title><atom:summary type="text">
Siempre que queramos diseñar una aplicación web de gran calibre nos 
enfrentaremos al problema de organizar los módulos de manera que no nos 
quede ni una gran jsp con código java embebido (feo, feo…) ni un gran 
servlet que centraliza todo el sistema (también es feo, feo…). Entonces…
 ¿Cómo hacemos que nuestra aplicación web no sea un chiquero? ¿Cómo 
hacemos para organizarnos bien y dividir </atom:summary><link>http://javaencastellano-hibernate.blogspot.com/2010/06/introducion-apache-struts-framework.html</link><author>noreply@blogger.com (Julian)</author><thr:total>1</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-3127563630788798649.post-4364374350076598406</guid><pubDate>Mon, 14 Jun 2010 18:27:00 +0000</pubDate><atom:updated>2013-05-28T20:52:34.703-03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">Analisis de Riesgos</category><category domain="http://www.blogger.com/atom/ns#">cierre de proyecto</category><category domain="http://www.blogger.com/atom/ns#">gestión de proyectos</category><category domain="http://www.blogger.com/atom/ns#">kick off de un proyecto</category><category domain="http://www.blogger.com/atom/ns#">Plan de Calidad</category><category domain="http://www.blogger.com/atom/ns#">Plan de Proyecto</category><category domain="http://www.blogger.com/atom/ns#">poc</category><category domain="http://www.blogger.com/atom/ns#">point of contact</category><category domain="http://www.blogger.com/atom/ns#">reunion de kick off</category><category domain="http://www.blogger.com/atom/ns#">reuniones de seguimiento</category><title>Kick Off de un Proyecto</title><atom:summary type="text">
Que es el Kick Off de un Proyecto?
En la 
gestión de proyectos se está haciendo cada vez mas común, tanto como 
importante, los conceptos de &quot;Kick off&quot; y el cierre del proyecto, tanto 
es así que pasaron de ser simples reuniones por buenas prácticas a 
marcar a dos de los momentos más importantes del proyecto.


Era
 común que se pensara que estas reuniones eran una verdadera pérdida de 
tiempo </atom:summary><link>http://javaencastellano-hibernate.blogspot.com/2010/06/kick-off-de-un-proyecto.html</link><author>noreply@blogger.com (Julian)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-3127563630788798649.post-9174293586580522226</guid><pubDate>Mon, 14 Jun 2010 18:26:00 +0000</pubDate><atom:updated>2013-05-28T20:52:41.684-03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">advice</category><category domain="http://www.blogger.com/atom/ns#">aop</category><category domain="http://www.blogger.com/atom/ns#">aspect</category><category domain="http://www.blogger.com/atom/ns#">aspect oriented programming</category><category domain="http://www.blogger.com/atom/ns#">aspecto</category><category domain="http://www.blogger.com/atom/ns#">introduction</category><category domain="http://www.blogger.com/atom/ns#">jointpoint</category><category domain="http://www.blogger.com/atom/ns#">pointcut</category><category domain="http://www.blogger.com/atom/ns#">programación orientada a aspectos</category><category domain="http://www.blogger.com/atom/ns#">proxy</category><category domain="http://www.blogger.com/atom/ns#">punto de cruce</category><category domain="http://www.blogger.com/atom/ns#">puntos de corte</category><category domain="http://www.blogger.com/atom/ns#">target</category><category domain="http://www.blogger.com/atom/ns#">weaving</category><title>Programación Orientada a Aspectos (AOP , Aspect-Oriented Programming)</title><atom:summary type="text">
Que es Programación Orientada a Aspectos o 
Aspect-Oriented Programming (AOP)?
La Programación
 Orientada a Aspectos o Aspect-Oriented Programming (AOP)
 es un paradigma de programación que ayuda a conseguir una 
modularización de las aplicaciones y una separación de los conceptos de 
un sistema mucho más óptimas.
 

La Programación 
Orientada a Aspectos o Aspect-Oriented Programming encapsula 
</atom:summary><link>http://javaencastellano-hibernate.blogspot.com/2010/06/programacion-orientada-aspectos-aop.html</link><author>noreply@blogger.com (Julian)</author><thr:total>0</thr:total></item></channel></rss>