Even though I’ve been working with Hibernate for 3 years now, I’ve only just run into this issue – most likely because in past projects we’ve used POJO generations and now, for the first time in a real life project, I’m using the Schema Export tool.

It turns out that, for some odd reason, when creating foreign keys for OneToMany / ManyToOne relationships, Hibernate completely ignore the @Cascade annotations or the cascade keyword of the join annotation.

For instance, consider the following model:

@Entity
public class Cat {

 @Id
 @GeneratedValue
 @Column
 private Long id;

 @Column
 private String name;

 @OneToMany(mappedBy = "parent", cascade = {CascadeType.ALL})
 @ForeignKey(name = "FK_KITTEN_PARENT")
 private List kittens = new ArrayList();

}

@Entity
public class Kitten {

 @Id
 @Column
 @GeneratedValue
 private Long id;

 @ManyToOne(cascade = CascadeType.ALL)
 private Cat parent;

 @Column
 private String name;
}

The resulting DDL for these two classes will be:

create table Cat (id bigint not null auto_increment, name varchar(255), primary key (id)) ENGINE=InnoDB

create table Kitten (id bigint not null auto_increment, name varchar(255), parent_id bigint, primary key (id)) ENGINE=InnoDB

alter table Kitten add index FK_KITTEN_PARENT (parent_id), add constraint FK_KITTEN_PARENT foreign key (parent_id) references Cat (id)

This behavior does not seem to be documented anywhere. The Hibernate guys seem to think it’s natural for people to assume that the CascadeType and @Cascade definitions are not translated into DDL. What Hibernate does, instead of generating DDL, is automatically deleting the children (Kittens, in our case) of a deleted parent, when you use the Criteria API. And what if you happen to use HQL? tough.

Fortunately, there IS a solution. It involves using the not-so-well documented annotation (or XML attribute) @OnDelete on the parent (Cat, in our case) side of the association, thus:

@Entity
public class Cat {

@Id
@GeneratedValue
@Column
private Long id;

@Column
private String name;

@OneToMany(mappedBy = "parent", cascade = {CascadeType.ALL})
@ForeignKey(name = "FK_KITTEN_PARENT")
@OnDelete(action = OnDeleteAction.CASCADE)
private List<Kitten> kittens = new ArrayList<Kitten>();

This ensures that the foreign key is created with the appropriate on delete cascade clause and allowing you to safely delete your parent entities not worrying about any children that refer to them.

Again this is going to be somewhat of a beginner’s view similar to my previous posts.  The last couple weeks I’ve been trying to expand my knowledge into more than just straight Java.  I’ve been integrating the Spring framework into my projects for a while and I’ve become addicted to using it.  I’m even focusing most of my web projects on Spring MVC, but there were some things I still wanted to improve on.  Enter Hibernate.  So far, most of my projects have all been using straight JDBC, which is fine for small projects, but as you get into larger and modular projects, straight JDBC shows it’s limitations.

To familiarize myself with Hibernate, I started with the tutorial at Hibernate’s website.  Having assimilated the basics pretty easily, I moved on to Hibernate Annotations because the less XML configuration I have to write, the better.  Hibernate Annotations does allow you to use both Annotations and the XML mapping file strategy if your needs require it.  The initial tutorial walks you through an Event manager type application.  One of the classes you create is a utility class named HibernateUtil which is responsible for creating your Hibernate SessionFactory.

In the XML mapping version, you would have something like this:

package com.mycompany;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {

	private static Log log = LogFactory.getLog ( HibernateUtil.class );
	private static final SessionFactory sessionFactory = buildSessionFactory();

	private static SessionFactory buildSessionFactory() {
		SessionFactory sessionFactory = null;

		try {
			sessionFactory = new Configuration().configure().buildSessionFactory();
		} catch ( Throwable e ) {
			if ( log.isErrorEnabled() ) {
				log.error ( "Initial SessionFactory creation failed.", e );
				throw new ExceptionInInitializerError ( e );
			}
		}

		return sessionFactory;
	}

	public static SessionFactory getSessionFactory() {
		return sessionFactory;
	}

}

Modifying it for Annotation based mapping was pretty simple.  I won’t list the changes you need to make to your persisted object class since that’s easy enough to achieve following the tutorial, but to change the way the SessionFactory instance is created, you simply need to use the AnnotationConfiguration class instead of Configuration.

sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();

My first attempt had resulted in an Exception about not being able to determine the SQL dialect. The reason for that was because instead of calling configure() on AnnotationConfiguration() first, I was just calling buildSessionFactory() from AnnotationConfiguration().  Since my dialect is defined in hibernate.cfg.xml, I have to call configure() on AnnotationConfiguration() before calling buildSessionFactory().

So for anybody wanting to learn the basics of Hibernate and take advantage of the Annotation based mapping all within an hour, I highly suggest you follow the online tutorial at Hibernate’s website first, and then follow it up with a look at section 2.2.1 of the free available chapter from Manning to get your feet wet with Hibernate Annotations.

My next step will be using Hibernate in a Spring project.

Benipal Technologies
Location: Bangalore
Experience: 4-6 Years
Education: Graduates, MCA, M.Sc
Skills: JAVA J2EE, XML, STRUTS, HIBERNATE, SOAP,
WALK IN INTERVIEWS ON SATURDAY, NOV 21 from 12pm – 5 pm and SUNDAY, NOV 22 from 12 pm – 5 pm.

DESIRED CANDIDATE PROFILE:

Must have a Bachelors degree with any specialization. Preference will be given to M.Sc and MCA degrees. Excellent spoken engish is an absolute must with good presentation skills.

Ability to perform under pressure will be a critical factor.

Contact Details:

Benipal Technologies

28 5th Block 4th B Cross Koramangala Industrial Layout Bangalore, India 560095

Tel: 080-3026-8000

Here’s a small tip I found out while troubleshooting why my JVM was exiting in the middle of optimizing my index.

I created a utility class to create and close FullTextSessions for me that also created and committed a transaction at the same time for convenience throughout my code. But this meant that the optimize() method returned while Lucene was still working, thus leaving my index locked even after the JVM exited:

FullTextSession s = Search.getFullTextSession(factory.openSession());
s.beginTransaction();
s.getSearchFactory().optimize();
s.getTransaction().commit();
s.close();

To get the method to block until the optimization work is completed, do not create a transaction:

FullTextSession s = Search.getFullTextSession(factory.openSession());
s.getSearchFactory().optimize();
s.close();

Cum sa accesezi corect un managed-bean programatic gasesti aici , sper sa nu dispara pagina si sa am timp sa o adaug pe plogul meu (care de asemenea sper sa nu pateasca nimic);

Alte informatii despre hibernate si JSF, cum sa faci o aplicatie jsf si Hibernate in netBeans, tutorial oficial NetBeans aici, foarte interesant si util.

Totorial Hibernate in eclipse intuitiv gasiti aici .

Acelas exemplu oferit de catre JDeveloper gasiti aici . JDeveloper este un IDE dezvoltat de catre cei de la Oracle.

O alta idee de aplicatie JSF si Hibernate gasiti si aici .

Un tutorial interesant despre Hibernate gasiti aici .

Informatii interesanta despre cum sa golesti o tabela in Hibernate gasesti aici.

Un site interesant despre maparile Hibernate gasiti aici . Mi se pare foarte util pt a intelege mai usor si a dezvolta mai rapid o aplicatie.

O versiune unor probleme care implica hibernate si JSF vor fi adaugate mai tarziu pe acest blog.

I’ve really been so quiet these days. (And I am sure no one really misses me here in this blog. Hehehe. But if in case there are some people following me here, let me just share that I am a bit busy helping the family move from my place to our very own home in the province.

You see, I was lucky enough to secure a loan a year ago, and now, the house and lot is ready for occupancy. Yeah!

For now, I just wish you all enjoyed the Pacquaio-Cotto match. Sana lang knockout no?

I will be back soon.

To test if I my mappings are correct, I use the following Java Application which uses SchemaExport. It gives me the SQL-statements and executes them against a database.
To protect the production database, you can either set the second parameter of create() to false and/or change the connection string to a test database.
configuration.setProperty(Environment.URL, "jdbc:mysql://localhost/test");


package starter;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.cfg.Environment;
import org.hibernate.tool.hbm2ddl.SchemaExport;

public class SchemaTester {

    public static void main(String[] args) throws ClassNotFoundException {
        AnnotationConfiguration configuration = new AnnotationConfiguration();

        List<Class> classes = findClasses(new File("src/domain"), "domain");
        for (Class clazz : classes) {
            configuration.addAnnotatedClass(clazz);
        }

        configuration.configure();
        configuration.setProperty(Environment.URL, "jdbc:mysql://localhost/test");

        SchemaExport schemaExport = new SchemaExport(configuration);
        schemaExport.create(true, true);
        // schemaExport.execute(true, false, false, true); // to see just create statements
    }

    private static List<Class> findClasses(File directory, String packageName)
                                                                throws ClassNotFoundException  {
        List<Class> classes = new ArrayList<Class>();
        if (!directory.exists()) {
            return classes;
        }
        File[] files = directory.listFiles();
        for (File file : files) {
            System.out.println(file);
            if (file.isDirectory()) {
                if(!file.getName().contains(".")) {
                    classes.addAll(findClasses(file, packageName + "." + file.getName()));
                }
            } else if (file.getName().endsWith(".java")) {
                String javaName = file.getName().substring(0, file.getName().length() - ".java".length());
                classes.add(Class.forName(packageName + '.' + javaName));
            }
        }
        return classes;
    }
}

Resources

• Chapter 1. Setting up an annotations project
• Get all classes within a package

Today I had to change a hibernate query constructed with the criteria API to a SQL query. The result looked like:

String sqlQuery = "select count(*) ...";
Session dbSession = getSession();
SQLQuery crit = dbSession.createSQLQuery(sqlQuery);
crit.setCacheable(true);
return (Integer) crit.uniqueResult();

The former query was cached and the new one should be too. But I got the following exception:

java.lang.ClassCastException: java.math.BigDecimal
at org.hibernate.cache.StandardQueryCache.put(StandardQueryCache.java:83)

The following post from hibernate forum helped me to find a solution. The exception is gone after adding the result as a scalar. And the working query looks like:

String sqlQuery = "select count(*) as result ...";
Session dbSession = getSession();
SQLQuery crit = dbSession.createSQLQuery(sqlQuery);
crit.addScalar("result", Hibernate.INTEGER);
crit.setCacheable(true);
return (Integer) crit.uniqueResult();

Tym razem pokazuję jak radzić sobie z nieodpowiednimi ustawieniami operacji kaskadowych, jak działa ten mechanizm, oraz jak z niego korzystać.

Operacje kaskadowe w Hibernate

PS. Może w końcu zacznę umieszczać treść artykułów bezpośrednio na stronie, ale jak na razie toporny interfejs  edycji wpisów skutecznie mnie zniecęca.

Recently we had a story which involved improving one of our data models. The table for the model had grown quite wide and we wanted to improve normalization and performance. We wanted to move a few columns from our original table (Listing) to a new table with the primary key of the new table (ListingLocation) also being a foreign key to the primary key of the original table, our one-to-one relationship. I will try to detail how we accomplished this change using a simplified example. Source code is linked at the bottom of this post.

Here is the entity relationship diagram of the old, single table structure:

And here is the entity relationship diagram of the new, two table structure:

As you can see, it is a very simple example of a very common relationship in the database. However, what we found when implementing this in Hibernate was not a simple as I had hoped.

To get started here is the SQL used to represent our new tables:

CREATE TABLE Listing
(
id BIGINT(20) NOT NULL AUTO_INCREMENT,
price DECIMAL(10,2),
PRIMARY KEY (id)
) TYPE = INNODB;

CREATE TABLE ListingLocation
(
listingID BIGINT(20) NOT NULL,
address VARCHAR(255),
PRIMARY KEY(listingID),
INDEX (listingID),
FOREIGN KEY (listingID) REFERENCES Listing (id)
) TYPE = INNODB;


I’ve used MySQL for this example because it is free and easy to setup. InnoDB table types have been because they allow foreign keys, which is crucial to this example.

Our old Listing entity was pretty basic; it looked something like this (imports & getters/setters excluded):

@Entity
@Table
public class Listing implements Serializable {
@Id
@GeneratedValue
private long id;
@Column(columnDefinition= "DECIMAL(10,2)")
private double price;
private String address;
...

In this case, creating a new instance of Listing and persisting it is very easy. When we split the entities, it becomes a little more complicated. Here is what our entities looked like after being split:

@Entity
@Table
public class Listing implements Serializable {
@Id
@GeneratedValue
private long id;
@Column(columnDefinition= "DECIMAL(10,2)")
private double price;
@OneToOne
@PrimaryKeyJoinColumn
private ListingLocation listingLocation;
...

and

@Entity
@Table
public class ListingLocation implements Serializable {
@Id
@Column(name = "listingID")
private Long id;
private String address;
...


The differences are not large, but there are a couple important points to note:

• Adding ListingLocation to Listing with @OneToOne & @PrimaryKeyJoinColumn annotations tells Hibernate the Listing has a one-to-one mapping with ListingLocation by using the Primary Key as the join column.
• Adding @Id & @Column(name = “listingID”) annotations to our id field in ListingLocation tells Hibernate that id is, well, an ID, but that column should not be called “id” in the DB, but “listingID” as that will help an observer see the relationship quickly without looking closely at the schema. Also, it is good to note that the @GeneratedValue is not on “id” in ListingLocation as it is in Listing as we want to specify exactly what goes in that field.

The biggest gripe I have with using the one-to-one relationship is that we can no longer save Listing only. Our REAL Listing entity is far more complex with several relationships, but this was the first one-to-one relationship with Hibernate. Previously we could do something like:

Listing listing = new Listing();
listing.setPrice(price);
listing.setAddress(address);
listing.setFoo(foo); // where foo is a @OneToMany annotated entity
...
session.save(listing);

Now, we must save Listing and ListingLocation separately like this:

ListingLocation listingLocation = new ListingLocation();
listingLocation.setAddress(address);
Listing listing = new Listing();
listing.setPrice(price);
listing.setListingLocation(listingLocation);
...
session.save(listing);
if (listing.getListingLocation() != null) {
listing.getListingLocation().setId(listing.getId());
session.save(listing.getListingLocation()); // save ListingLocation
}


I guess I’m just a bit spoiled, but I was hoping that this would bit more automatic, as it is with the one-to-many/many-to-one relationships.

I have written a small app that uses these two entities and inserts a row into each table, the link is available at the bottom of this post. The config (hibernate.cfg.xml) expects that you have MySQL running on 127.0.0.1 with a DB named ‘OneToOneDemo’ with a user named ‘root’ and a password of ‘password’; I have included the SQL (Setup-OneToOneDemo.sql) to setup the DB. Just extract the contents of the archive, navigate to the project directory, and from the command line/terminal run:

mvn clean compile exec:java -Dexec.mainClass=com.point2.onetoonedemo.App -e


You should see the following output:

@OneToOne @PrimaryKeyJoinColumn Hibernate Demo
----------------------------------------------
...
Hibernate:
insert into Listing (price) values (?)

Hibernate:
insert into ListingLocation (address, listingID) values (?, ?)
Saved listing ID: 1


Download Source Code (12 KB .ZIP)

If you have any questions, comments, or suggestions on how to do better accomplish one-to-one Hibernate mappings, I would love to hear about them. If you have any problems getting the code to compile and/or run, please let me know and I will make the necessary changes. Everything should just work, providing you modify the hibernate config or setup your DB. I had a difficult time finding complete and recent documentation on this subject so I hope this post and the maven project will help.

By: Damien Gabrielson

In this article I am  showing how to apply Hibernate annotations to develop real-world applications. With the combination of Hibernate annotation and Spring MVC, developers can drastically reduce the time at the configuration level. No more artless mapping files, no more klutzy XDoclet tags – life becomes so easy! This article describes a step-by-step procedure of how to build, deploy, and run a J2EE-based Web application using the above-mentioned technologies.

Sun is shining! I put on my bright orange, stylish coat and went out for a walk,… and to get the mail.

    I was surprised that there were still a few crickets, and frogs chirping away in the trees and dried grass. I nearly stepped on a few stray grasshoppers. With the weather in the upper twenties last night, they should all have hibernated for the winter, or laid their eggs, larvae, nymphs or pupae.

     The bees and wasps have died off. Well, at least the males and the workers. The females crawl into someplace safe, at least they hope so, until spring.

     All my beautiful Monarchs have flown off to far away places to return again in spring.

     I have been trying to vacuum up and squish all the Japanese beetles and box elders that have been invading my house for the past month. I know that no matter how vigilant I am at removing them, some will have crawled in-between the siding, or find places under the tiles. Others have gotten inside the house hoping to hold out for spring.

     In the middle of winter when the sun beats down on the roof, I will find a fly or a beetle that has a death wish by drowning my morning coffee.

    Some caterpillars hibernate, like the woolly bear caterpillar.  That little bugger is not fun to pick up; I try to avoid it altogether. But, every year I make a mistake and touch it, either with my toes, or while grabbing a hand full of weeds. The sharp, stinging sensation is not a pleasant experience, and they seem to be everywhere in the late summer, early fall.

     I try not to disturbed any insects as they settle in for the winter; except for the ones in my house. The others, the ones in rotting logs and in the wooded area hidden under leaves, I leave them be. In spring I want to see them flying and diving around flowers. I want the bees to pollinate my flowers. I want to hear the summer songs of the crickets and cicadas and katydids.

    For now, as I clean up around the outside of the house. Putting away my rakes, and watering hoses. I hope that all of nature can survive the snows and freezing temperatures.

    That reminds me I need a pair of winter gloves.

What’s with this weather? What’s with my body? I’m freezing! Where are the curtains I ordered (in September)? I want my curtains so that I can shut out the weather. I want to cocoon myself in a centrally heated, thick (heavily interlined) curtained house. No, hang on. Scratch that. Actually I want to hibernate. Yes, that would be better. Why can’t humans hibernate? Avoid the cold and the damp altogether, avoid S.A.D. syndrome, avoid over-eating starch because it temporarily makes you feel better but leaves you feeling and looking like a little human butterball by the Spring.

Wake me up when it’s Spring, would you?

Photo from the Daily Mail online

What’s with this weather?  What’s with my body?  I’m freezing!   Where are the curtains I ordered (in September)?  I want my curtains so that I can shut out the weather. I want to cocoon myself in a centrally heated, thick (heavily interlined) curtained house. No, hang on.  Scratch that.  Actually I want to hibernate. Yes, that would be better. Why can’t humans hibernate?  Avoid the cold and the damp altogether, avoid S.A.D. syndrome, avoid over-eating starch because it temporarily makes you feel better but leaves you feeling and looking like a little human butterball by the Spring. 

Wake me up when it’s Spring, would you?

Photo from the Daily Mail online

O Criteria é uma API do Hibernate que facilita muito quando precisamos montar uma query complexa com filtros opcionais. Adicionar restrições ou criar joins com esta API é muito mais simples de gerenciar do que concatenando Strings, como faríamos ao trabalhar com SQL puro.

Apesar das vantagens, o Criteria também tem alguns problemas. O último que encontrei foi ao tentar fazer 2 joins entre as mesmas 2 tabelas. No meu caso, eu tinha no banco as tabelas projeto e historico. A segunda tabela é populada através de uma trigger no banco: sempre que o status do projeto muda, a tabela historico registra o status anterior do projeto com data/hora da mudança. Eu precisava fazer uma query que buscasse um projeto com status “iniciado” num determinado período de datas e com status “finalizado” em outro período. Inicialmente, pensei simplesmente em criar 2 joins entre as tabelas, cada um com um alias diferente e filtrando pelas datas específicas:

Criteria criteria = getSession().createCriteria(Projeto.class);

// Primeiro join
criteria.createCriteria("historicoList", "historicoIniciado", Criteria.LEFT_JOIN)
        .add(Restrictions.eq("historicoIniciado.status", Status.INICIADO.value()))
        .add(Restrictions.ge("historicoIniciado.data", dataIniciadoDe))
        .add(Restrictions.le("historicoIniciado.data", dataIniciadoAte));

// Segundo join
criteria.createCriteria("historicoList", "historicoFinalizado", Criteria.LEFT_JOIN)
        .add(Restrictions.eq("historicoFinalizado.status", Status.FINALIZADO.value()))
        .add(Restrictions.ge("historicoFinalizado.data", dataFinalizadoDe))
        .add(Restrictions.le("historicoFinalizado.data", dataFinalizadoAte));

O código acima, apesar de semelhante ao que eu já havia criado para adicionar outros filtros à query de projetos, fazendo joins com outras tabelas, não funcionava. Tentei retirar um dos joins com a tabela historico e funcionou. Ou seja, o problema estava na criação do segundo join com as mesmas tabelas, mesmo utilizando aliases diferentes. Ao pesquisar este problema, descobri que não é um bug. Na verdade, o Criteria não suporta múltiplos joins para a mesma associação.

Sendo assim, a solução que encontrei para este problema foi criar uma subquery para a tabela historico, utilizando um DetachedCriteria:

DetachedCriteria historicoCriteria = DetachedCriteria.forClass(Historico.class, "historicoIniciado")
        .setProjection(Projections.distinct(Projections.property("projeto")))
        .add(Restrictions.eq("historicoIniciado.status", Status.INICIADO.value()));
        .add(Restrictions.ge("historicoIniciado.data", dataIniciadoDe));
        .add(Restrictions.le("historicoIniciado.data", dataIniciadoAte));
criteria.add(Subqueries.propertyIn("id", historicoCriteria));

Desta forma, apenas um dos joins precisa ser substituído por uma subquery. O outro join pode ser mantido sem problemas.

Sumber : http://www.developersbook.com

Hibernate Vs. iBatis?
Hibernate or iBatis or both ? Which is better?
Which one to use and when?

These are the few questions that continuously get asked in most of forums.
What’s really difference between two and really more importantly when should I use one over the other. Its pretty interesting question because there are major differences between iBatis and Hibernate.

Within in the java persistence there is no one size, fits all solution. So, in this case Hibernate which is a de facto standard is used in lot of places.

Let us consider a scenario where Hibernate work great for initial model. Now Suddenly if you are using stored procedures, well we can do it in Hibernate but its little difficult; ok we map those, all of sudden we got some reporting type of queries, those don’t have keys have group bys; with some difficulty here we can use name queries and stuff like that, but now starts getting more complicated, we have complex joins, yes you can do in hibernate, but we can’t do with average developer. We have sql that just doesn’t work.

So these are some of the complexities. One of the other things I find is, if am looking at an application that doesn’t work very well with an ORM, aside from these considerations of using stored procedures, already using SQL, complex joins. In other words, Hibernate works very well if your data model is well in sync with object model, because ORM solutions like Hibernate map object to tables. However, let’s suppose data model is not in sync with object model, in this case you have do lot of additional coding and complexities are entering into your application, start coming the beyond the benefits of ORM. So, again all of sudden you are noticing that the flow is gone; our application is becoming very very complex and developers can’t maintain the code.

This is where the model starts breaking down. One size does not fit all. So this is where I like to use iBatis; as the alternative solution for these type of situations, iBatis maps results sets to objects, so no need to care about table structures. This works very well for stored procedures, works very well for reporting applications, etc,.

Now the question is , does it work well for simple CRUD applications? Well, it works because what we have to write is sql. Then why not use Hibernate for that?

You can start see Some of the decision criteria that comes into play. So one of the other follow on questions that typically get is , can I use both? That’s really interesting question! because the answer is sure.

But,such a thing will never ever exists is java persistence world. However we can kind of use both to create this little hybrid. So think of this kind scenario, we have very large application where Hibernate is working very well for it, but we have a reporting piece that just is a real nag , its query only , so we can do is, we can use iBatis to pull up the queries for reporting piece and still use Hibernate for all the operational stuff and updates. This model actually works well, it doesn’t break the transactional model, and it doesn’t affect any of the primary & secondary caches with a Hibernate. It’s a good solution.

• Use iBatis if
  • You want to create your own SQL’s and are willing to maintain them
  • your environment is driven by relational data model
  • you have to work existing and complex schema’s
• Use Hibernate if
  • your environment is driven by object model and wants generates SQL automatically

The message is,

• One size does not fit all the java persistence and the important to know there are other solutions besides the traditional ORMs, and that would be iBatis.
• Both the solutions work well, given their specific domain.
• Look for the opportunity where you can use both.

h

Olá turma. Hoje eu vou postar no meu blog uma apresentação que fiz sobre o framework de persistência de dados java, Hibernate. É uma apresentação de introdução ao framework e creio que tenha ficado bem simples e de fácil entendimento. Clique neste link para fazer o donwload.

Obrigado e até mais.

PS1: Ah, FeedBacks são sempre bem vindos.

PS2: Caso você encontre o link quebrado, me mande um e-mail: fabiozoroastro@gmail.com

Jest to pierwszy z serii artykułów, które chciałbym poświęcić narzędziu Hibernate. Staram się w nim odpowiedzieć na pytanie jak konfigurować mapowanie tabel bazodanowych na obiekty, a w szczególności – czy dany związek między encjami powinien być gorliwy czy leniwy.

hibernate-automatyczne-pobieranie-obiektow

PS: nadchodząca wersja 3.5 ma, według zapowiedzi zespołu Hibernate (https://www.hibernate.org/357.html#A8), wprowadzić "profile pobierania danych", czyli możliwość definiowania wielu wersji ustawień pobierania obiektów, które można przeglądać w czasie wykonania aplikacji i wybierać ten najbardziej odpowedni do sytuacji. Postaram się zaktualizować artykuł po tym, gdy wersja 3.5 ujrzy światło dzienne.

I was a bit confused about the differences between HQL outer join v.s. join fetch, its applications and type of behind the scene SQL generated.  Hopefully the following example can clarify these concepts somewhat.   Suppose there is a simple parent child relationship between an entity “artist” and “address”.

<set table="ADDRESS">

Scenario 1: No JOIN on collection expressed in HQL, collection mapping has lazy=false

The HQL:

SELECT artist

from Artist as artist

Result: Address table loaded via a separate query, hibernate loads the “address” entity due to the lazy=false mapping to “address”

Scenario 2: No JOIN on collection expressed in HQL, mapping has lazy=true

The mapping:

The HQL:

SELECT artist

from Artist as artist

Result: Address object not loaded, lazy initialization exception when trying to access address object

Scenario 3: OUTER JOIN in HQL

This is where things start to get confusing for me, in HQL there is a LEFT JOIN as well as a LEFT JOIN FETCH keyword.

from Artist as artist

LEFT JOIN artist.address

The underlying SQL is as expecte, joining both the artist and address tables and returning everything

Result: returns artist and address as a list of object array, the “artist” entity is located at index 0, “address” entity is at index 1.

List<Object[]> list = artistDAO.findAll();

System.out.println("got artist size: " + list.size());

for(Object[] result : list)

{

Artist artistResult = (Artist)result[0];

Address addressResult = (Address)result[1];

System.out.println("got address: " + addressResult.getAddress());

}

Note that “address” is mapped as an association of “artist”, whether THAT gets loaded depends on the fetching plan (lazy or not lazy)

Scenario 4: OUTER JOIN in HQL, with projection

The HQL

SELECT artist from Artist as artist

LEFT JOIN artist.address

The underlying SQL shows that a join is performed, but only the columns from the “artist” table is returned

Result: Due to the projection to only return “artist”, the resulting SQL joins with “address” but doesn’t return it, so the “address” children entity doesn’t get initialized!!

At first I thought by joining “address” I would get “artist” with “address” association fully loaded, but all I am doing is joining the two entities, and then wasting the join by returning only “artist”.

The correct way to have “address” loaded would have been to use an EAGER FETCH such as scenario 5 expressed below.

The useful thing to do with the outer join this way would have been a restriction, such as

SELECT artist from Artist as artist

LEFT JOIN artist.address as address<strong> </strong>

WHERE address.streetName like ‘%elm street%’

Scenario 5: LEFT JOIN WITH EAGER FETCH in HQL

The LEFT JOIN FETCH key word in HQL essentially overrides fetching strategy from mapping and eagerly fetches the associations.  The difference between this and a LEFT JOIN is that the association is fully initialized and accessible from the parent object.

from Artist as artist

LEFT JOIN FETCH artist.address

Note the underlying SQL is exactly the same as scenario 4, but the way hibernate returns the objects are different (list of “artist” object, as supposed to a list of object array).