Beginning Hibernate: For Hibernate 5

In Dec 2011, Hibernate Core 4.0.0 Final was released. This includes new features such as multi-tenancy support, introduction of ServiceRegistry (a major change in how Hibernate builds and manages "services"), better session opening from SessionFactory, improved integration via org.hibernate.integrator.spi.Integrator and auto discovery, internationalization support, message codes in logging, and a more distinction between the API, SPI or implementation classes.[5]

Beginning Hibernate: For Hibernate 5

The org.hibernate.Session interface[12] represents a Hibernate session, i.e., the main point of the manipulation performed on the database entities. The latter activities include (among the other things) managing the persistence state (transient, persisted, detached[clarification needed]) of the objects, fetching the persisted ones from the database and the management of the transaction demarcation[clarification needed].

There are plenty of applications in production that use the Hibernate framework exclusively without JPA. That is why I figured it would also be helpful to provide an example hibernate.cfg.xml for MySQL 8 using classes found in Hibernate 5 distributions.

There are a number of different dialects that could potentially be specified in the hibernate.cfg.xml for MySQL The correct dialect to choose depends upon the MySQL version in use and the type of database engine in play, like MyISAM or InnoDB. If a developer fails to choose the correct dialect, it will result in unpredictable Hibernate query results at runtime.

A thread-safe (and immutable) representation of the mapping of the application domain model to a database.Acts as a factory for org.hibernate.Session instances. The EntityManagerFactory is the JPA equivalent of a SessionFactory and basically those two converge into the same SessionFactory implementation.

Behind the scenes, the Hibernate Session wraps a JDBC java.sql.Connection and acts as a factory for org.hibernate.Transaction instances.It maintains a generally "repeatable read" persistence context (first level cache) of the application domain model.

Hibernate understands both the Java and JDBC representations of application data.The ability to read/write this data from/to the database is the function of a Hibernate type.A type, in this usage, is an implementation of the org.hibernate.type.Type interface.This Hibernate type also describes various aspects of behavior of the Java type such as how to check for equality, how to clone values, etc.

Historically Hibernate defined just a single org.hibernate.cfg.NamingStrategy. That singularNamingStrategy contract actually combined the separate concerns that are now modeled individuallyas ImplicitNamingStrategy and PhysicalNamingStrategy.

When an entity does not explicitly name the database table that it maps to, we needto implicitly determine that table name. Or when a particular attribute does not explicitly namethe database column that it maps to, we need to implicitly determine that column name. There areexamples of the role of the org.hibernate.boot.model.naming.ImplicitNamingStrategy contract todetermine a logical name when the mapping did not provide an explicit name.

There are multiple ways to specify the ImplicitNamingStrategy to use. First, applications can specifythe implementation using the hibernate.implicit_naming_strategy configuration setting which accepts:

for org.hibernate.boot.model.naming.ImplicitNamingStrategyLegacyJpaImpl - compliant with the legacy NamingStrategy developed for JPA 1.0, which was unfortunately unclear in many respects regarding implicit naming rules

for org.hibernate.boot.model.naming.ImplicitNamingStrategyComponentPathImpl - mostly follows ImplicitNamingStrategyJpaCompliantImpl rules, except that it uses the full composite paths, as opposed to just the ending property part

Secondly, applications and integrations can leverage org.hibernate.boot.MetadataBuilder#applyImplicitNamingStrategyto specify the ImplicitNamingStrategy to use. SeeBootstrap for additional details on bootstrapping.

There are multiple ways to specify the PhysicalNamingStrategy to use. First, applications can specifythe implementation using the hibernate.physical_naming_strategy configuration setting which accepts:

To use these hibernate-spatial types, you must add the hibernate-spatial dependency to your classpath and use a org.hibernate.spatial.SpatialDialect implementation.See Spatial for more details about spatial types.

These mappings are managed by a service inside Hibernate called the org.hibernate.type.BasicTypeRegistry, which essentially maintains a map of org.hibernate.type.BasicType (a org.hibernate.type.Type specialization) instances keyed by a name.That is the purpose of the "BasicTypeRegistry key(s)" column in the previous tables.

We said before that a Hibernate type is not a Java type, nor a SQL type, but that it understands both and performs the marshalling between them.But looking at the basic type mappings from the previous examples,how did Hibernate know to use its org.hibernate.type.StringType for mapping for java.lang.String attributes,or its org.hibernate.type.IntegerType for mapping java.lang.Integer attributes?

The answer lies in a service inside Hibernate called the org.hibernate.type.BasicTypeRegistry, which essentially maintains a map of org.hibernate.type.BasicType (a org.hibernate.type.Type specialization) instances keyed by a name.

If you application and database are entirely nationalized you may instead want to enable nationalized character data as the default.You can do this via the hibernate.use_nationalized_character_data setting or by calling MetadataBuilder#enableGlobalNationalizedCharacterDataSupport during bootstrap.

However, as explained in this article, this is not always practical especially for front-end nodes.For this reason, Hibernate offers the hibernate.jdbc.time_zone configuration property which can be configured:

With this configuration property in place, Hibernate is going to call the PreparedStatement.setTimestamp(int parameterIndex, java.sql.Timestamp, Calendar cal) orPreparedStatement.setTime(int parameterIndex, java.sql.Time x, Calendar cal), where the java.util.Calendar references the time zone provided via the hibernate.jdbc.time_zone property.

This is the default strategy since Hibernate 5.0. For older versions, this strategy is enabled through the hibernate.id.new_generator_mappings configuration property .When using this strategy, AUTO always resolves to SequenceStyleGenerator.If the underlying database supports sequences, then a SEQUENCE generator is used. Otherwise, a TABLE generator is going to be used instead.

This is a legacy mechanism that was used by Hibernate prior to version 5.0 or when the hibernate.id.new_generator_mappings configuration property is false.The legacy strategy maps AUTO to the native generator strategy which uses the Dialect#getNativeIdentifierGeneratorStrategy to resolve the actual identifier generator (e.g. identity or sequence).

For implementing database sequence-based identifier value generation Hibernate makes use of its org.hibernate.id.enhanced.SequenceStyleGenerator id generator.It is important to note that SequenceStyleGenerator is capable of working against databases that do not support sequences by switching to a table as the underlying backing.This gives Hibernate a huge degree of portability across databases while still maintaining consistent id generation behavior (versus say choosing between SEQUENCE and IDENTITY).This backing storage is completely transparent to the user.

For implementing identifier value generation based on IDENTITY columns,Hibernate makes use of its org.hibernate.id.IdentityGenerator id generator which expects the identifier to generated by INSERT into the table.IdentityGenerator understands 3 different ways that the INSERT-generated value might be retrieved:

Hibernate achieves table-based identifier generation based on its org.hibernate.id.enhanced.TableGenerator which defines a table capable of holding multiple named value segments for any number of entities.

UUIDGenerator supports pluggable strategies for exactly how the UUID is generated.These strategies are defined by the org.hibernate.id.UUIDGenerationStrategy contract.The default strategy is a version 4 (random) strategy according to IETF RFC 4122.Hibernate does ship with an alternative strategy which is a RFC 4122 version 1 (time-based) strategy (using ip address rather than mac address).

When using a bidirectional @OneToOne association, Hibernate enforces the unique constraint upon fetching the child-side.If there are more than one children associated with the same parent, Hibernate will throw a org.hibernate.exception.ConstraintViolationException.Continuing the previous example, when adding another PhoneDetails, Hibernate validates the uniqueness constraint when reloading the Phone object.

Hibernate uses its own collection implementations which are enriched with lazy-loading, caching or state change detection semantics.For this reason, persistent collections must be declared as an interface type.The actual interface might be java.util.Collection, java.util.List, java.util.Set, java.util.Map, java.util.SortedSet, java.util.SortedMap or even other object types (meaning you will have to write an implementation of org.hibernate.usertype.UserCollectionType).

Actually, we are concerned with building 2 different ServiceRegistries.First is the org.hibernate.boot.registry.BootstrapServiceRegistry.The BootstrapServiceRegistry is intended to hold services that Hibernate needs at both bootstrap and run time.This boils down to 3 services:

The second ServiceRegistry is the org.hibernate.boot.registry.StandardServiceRegistry.You will almost always need to configure the StandardServiceRegistry, which is done through org.hibernate.boot.registry.StandardServiceRegistryBuilder:

The main use cases for an org.hibernate.integrator.spi.Integrator right now are registering event listeners and providing services (see org.hibernate.integrator.spi.ServiceContributingIntegrator).With 5.0 we plan on expanding that to allow altering the metamodel describing the mapping between object and relational models. 041b061a72