Seize the deal!
You missed out!
Imagine having a tool that can automatically detect JPA and Hibernate performance issues. Hypersistence Optimizer is that tool!
20 years of Hibernate and counting.
On the 23rd of May 2001, Gavin King launched the first version of Hibernate. Twenty years later, Hibernate is one the most successful Java data access frameworks, having millions of developers using it on a per-daily basis.
Getting involved with the Hibernate project has been one of the best investments I have ever made. Next, I’m going to share my journey to celebrate this awesome anniversary.
It was 2004 when I started working on my graduate thesis, and since it was a .NET project, I started reading about NHibernate, a brand new open-source project that was mirroring a very famous Java project at the time, called Hibernate.
After reading both the NHibernate and Hibernate docs, I was already sold. The documentation was very well written, and the data access API was both simple and powerful. So, I chose NHibernate, even if the available version was just a Beta release, 0.8.4.
Adopting NHibernate was fairly simple, and the data access logic was looking much better than its ADO.NET counterpart.
Before I graduated, I got hired as a software developer on a Java-based project that was using J2EE. The data access layer was not using Entity Beans due to their infamous performance issues, so it was using JDBC instead.
I had to implement a transaction handling mechanism in order to make sure that multiple DAO methods are enlisted in the same database transaction. Nowadays, this is just a matter of adding a
@Transactional annotation, but 20 years ago, it was a great deal of work to achieve that.
Mid-project, the project manager said we had to add support for Oracle as well. The data access layer consisted of thousands of SQL Server-specific statements, so adding support for Oracle took weeks. Having used NHibernate previously, I started to miss both its convenience and the built-in database portability.
In 2008, I joined a new team that was using Spring and Hibernate, and the project template had been generated with the Matt Raible‘s AppFuse. Leaving J2EE behind was so easy! Spring and Hibernate worked so well together, and the project was a complete success.
Having to use Hibernate on a daily basis allowed me to learn more about it. So, I started reading the Java Persistence with Hibernate book, written by Christian Bauer, a long-time Hibernate committer, and Gavin King, the father of Hibernate. With 880 pages, the book was one of the biggest technical books I had read before. But it was all worth it.
By reading the documentation and the Java Persistence with Hibernate book, I got to know how to use Hibernate properly.
Until 2015, when I quit my software architect job, every Java project we developed used Spring and Hibernate. From small projects to one of the largest real estate platforms in Finland, Spring and Hibernate had been a success story to us.
In 2013, I started this blog, and all this time, I managed to write over 400 articles about Hibernate, JPA, and database systems.
Blogging works both ways. Not only that you can share your knowledge with others, but writing down your thought is a great way to deepen your understanding of a given topic.
While previously I was only reading StackOverflow answers, in May 2014, I started answering Hibernate questions, and, to my surprise, I started to like doing that. Nowadays, my StackOverflow account shows me that I answered over 1600 questions.
After a while, the Hibernate team noticed my involvement in the project and made me an offer to work as a Developer Advocate for the Hibernate project.
During the three years I worked on The Hibernate project, I managed to rewrite the User Guide, add several performance tuning options, integrate countless Pull Requests, revived the Hibernate forum, and spoke about it at various software conferences. Here’s an article which I wrote to celebrate my 3 year Hibernate anniversary.
While working as a software developer, I noticed that, on every project I worked on, some of my colleagues were struggling with database performance issues, no matter what framework they were using.
And, because my articles and StackOverflow answers were very well received, I started thinking about writing a book about Java data access performance tuning. And that’s how my High-Performance Java Persistence book was born.
Five years later, High-Performance Java Persistence is an Amazon ⭐⭐⭐⭐⭐ best-seller with over 63 reviews.
In the autumn of 2018, I started the Hibernate Types open-source project, which provides support for various database-specific column types, like JSON, ARRAY, Range, HStore, Inet. Nowadays, the Hibernate Types project gets over 850k monthly downloads.
After I quit working for Red Hat, I started working on Hypersistence Optimizer, a tool that helps you analyze your Hibernate mappings, configurations, as well as queries and
EntityManager usage, and tell you what changes you need to make to speed up your data access layer.
Two years later, and Hypersistence Optimizer is a life-saver for hundreds of companies using it on aper-daily basis.
Hibernate has a very bright future. Being the default data access layer option for any Spring Boot or Quarkus project, Hibernate adoption grows larger and larger with every new project that gets started.
While the 5.5 branch aims to add support for Jakarta EE, the 6.0 version is going to provide a new query parser and many performance optimizations. So, I’m looking forward to the next 20 years of Hibernate.