Package org.hibernate.reactive.mutiny

Interface Mutiny.SessionFactory

All Superinterfaces:
AutoCloseable
Enclosing interface:
Mutiny
public static interface Mutiny.SessionFactory extends AutoCloseable
Factory for reactive sessions.

A Mutiny.SessionFactory may be obtained from an instance of EntityManagerFactory as follows: 

 Mutiny.SessionFactory sessionFactory =
                        createEntityManagerFactory("example")
                                .unwrap(Mutiny.SessionFactory.class);

Here, configuration properties must be specified in persistence.xml.

Alternatively, a Mutiny.SessionFactory may be obtained via programmatic configuration of Hibernate using: 

 Configuration configuration = new Configuration();
 ...
 Mutiny.SessionFactory sessionFactory =
                configuration.buildSessionFactory(
                        new ReactiveServiceRegistryBuilder()
                                .applySettings( configuration.getProperties() )
                                .build()
                )
                .unwrap(Mutiny.SessionFactory.class);

  • Method Details

    • createSession

      @Incubating Mutiny.Session createSession()
      Obtain a new reactive session, the main interaction point between the user's program and Hibernate Reactive.

      The underlying database connection is obtained lazily when the returned Mutiny.Session needs to access the database.

      The client must close the session using Mutiny.Closeable.close().

    • createSession

      @Incubating Mutiny.Session createSession(String tenantId)
      Obtain a new reactive session.

      The underlying database connection is obtained lazily when the returned Mutiny.Session needs to access the database.

      The client must close the session using Mutiny.Closeable.close().

      Parameters:
      tenantId - the id of the tenant

    • createStatelessSession

      @Incubating Mutiny.StatelessSession createStatelessSession()
      Obtain a new reactive stateless session.

      The underlying database connection is obtained lazily when the returned Mutiny.StatelessSession needs to access the database.

      The client must close the session using Mutiny.Closeable.close().

    • createStatelessSession

      @Incubating Mutiny.StatelessSession createStatelessSession(String tenantId)
      Obtain a new reactive stateless session.

      The underlying database connection is obtained lazily when the returned Mutiny.StatelessSession needs to access the database.

      The client must close the session using Mutiny.Closeable.close().

      Parameters:
      tenantId - the id of the tenant

    • openSession

      io.smallrye.mutiny.Uni<Mutiny.Session> openSession()
      Obtain a new reactive session Uni, the main interaction point between the user's program and Hibernate Reactive.

      When the Uni completes successfully it returns a newly created session.

      The client must explicitly close the session by calling Mutiny.Closeable.close().

      See Also:

    • openSession

      io.smallrye.mutiny.Uni<Mutiny.Session> openSession(String tenantId)
      Obtain a new reactive session Uni for a specified tenant.

      When the Uni completes successfully it returns a newly created session.

      The client must explicitly close the session by calling Mutiny.Closeable.close().

      Parameters:
      tenantId - the id of the tenant
      See Also:

    • openStatelessSession

      io.smallrye.mutiny.Uni<Mutiny.StatelessSession> openStatelessSession()
      Obtain a reactive stateless session Uni.

      When the Uni completes successfully it returns a newly created session.

      The client must explicitly close the session by calling Mutiny.StatelessSession.close().

      See Also:

    • openStatelessSession

      io.smallrye.mutiny.Uni<Mutiny.StatelessSession> openStatelessSession(String tenantId)
      Obtain a reactive stateless session Uni.

      When the Uni completes successfully it returns a newly created session.

      The client must explicitly close the session by calling Mutiny.StatelessSession.close().

      Parameters:
      tenantId - the id of the tenant
      See Also:

    • withSession

      <T> io.smallrye.mutiny.Uni<T> withSession(Function<Mutiny.Session,io.smallrye.mutiny.Uni<T>> work)
      Perform work using a reactive session.

    • If there is already a session associated with the current reactive stream, then the work will be executed using that session.
    • Otherwise, if there is no session associated with the current stream, a new session will be created.

      The session will be closed automatically, but must be flushed explicitly if necessary.

      • Parameters:
      work - a function which accepts the session and returns the result of the work as a Uni.

    • withSession

      <T> io.smallrye.mutiny.Uni<T> withSession(String tenantId, Function<Mutiny.Session,io.smallrye.mutiny.Uni<T>> work)
      Perform work using a reactive session for a specified tenant.

    • If there is already a session associated with the current reactive stream, and the given tenant, then the work will be executed using that session.
    • Otherwise, a new session will be created.

      The session will be closed automatically, but must be flushed explicitly if necessary.

      • Parameters:
      tenantId - the id of the tenant
      work - a function which accepts the session and returns the result of the work as a Uni.

    • withTransaction

      <T> io.smallrye.mutiny.Uni<T> withTransaction(BiFunction<Mutiny.Session,Mutiny.Transaction,io.smallrye.mutiny.Uni<T>> work)
      Perform work using a reactive session within an associated transaction.

    • If there is already a session associated with the current reactive stream, then the work will be executed using that session.
    • Otherwise, if there is no session associated with the current stream, a new session will be created.

      The session will be flushed and closed automatically, and the transaction committed automatically.

      • Parameters:
      work - a function which accepts the session and transaction and returns the result of the work as a Uni.
      See Also:

    • withTransaction

      default <T> io.smallrye.mutiny.Uni<T> withTransaction(Function<Mutiny.Session,io.smallrye.mutiny.Uni<T>> work)
      Perform work using a reactive session within an associated transaction.

    • If there is already a session associated with the current reactive stream, then the work will be executed using that session.
    • Otherwise, if there is no session associated with the current stream, a new session will be created.

      The session will be flushed and closed automatically, and the transaction committed automatically.

      • Parameters:
      work - a function which accepts the session and returns the result of the work as a Uni.
      See Also:

    • withStatelessTransaction

      default <T> io.smallrye.mutiny.Uni<T> withStatelessTransaction(Function<Mutiny.StatelessSession,io.smallrye.mutiny.Uni<T>> work)
      Perform work using a reactive session within an associated transaction.

    • If there is already a stateless session associated with the current reactive stream, then the work will be executed using that session.
    • Otherwise, if there is no stateless session associated with the current stream, a new stateless session will be created.

      The session will be closed automatically and the transaction committed automatically.

      • Parameters:
      work - a function which accepts the stateless session and returns the result of the work as a Uni.
      See Also:

    • withStatelessTransaction

      <T> io.smallrye.mutiny.Uni<T> withStatelessTransaction(BiFunction<Mutiny.StatelessSession,Mutiny.Transaction,io.smallrye.mutiny.Uni<T>> work)
      Perform work using a reactive session within an associated transaction.

    • If there is already a stateless session associated with the current reactive stream, then the work will be executed using that session.
    • Otherwise, if there is no stateless session associated with the current stream, a new stateless session will be created.

      The session will be closed automatically and the transaction committed automatically.

      • Parameters:
      work - a function which accepts the stateless session and returns the result of the work as a Uni.
      See Also:

    • withStatelessSession

      <T> io.smallrye.mutiny.Uni<T> withStatelessSession(Function<Mutiny.StatelessSession,io.smallrye.mutiny.Uni<T>> work)
      Perform work using a stateless session.

    • If there is already a stateless session associated with the current reactive stream, then the work will be executed using that session.
    • Otherwise, if there is no stateless session associated with the current stream, a new stateless session will be created.

      The session will be closed automatically.

      • Parameters:
      work - a function which accepts the session and returns the result of the work as a Uni.

    • withStatelessSession

      <T> io.smallrye.mutiny.Uni<T> withStatelessSession(String tenantId, Function<Mutiny.StatelessSession,io.smallrye.mutiny.Uni<T>> work)
      Perform work using a stateless session.

    • If there is already a stateless session associated with the current reactive stream and given tenant id, then the work will be executed using that session.
    • Otherwise, if there is no stateless session associated with the current stream and given tenant id, a new stateless session will be created.

      The session will be closed automatically.

      • Parameters:
      tenantId - the id of the tenant
      work - a function which accepts the session and returns the result of the work as a Uni.

    • withTransaction

      <T> io.smallrye.mutiny.Uni<T> withTransaction(String tenantId, BiFunction<Mutiny.Session,Mutiny.Transaction,io.smallrye.mutiny.Uni<T>> work)
      Perform work using a reactive session for the tenant with the specified tenant id within an associated transaction.

    • If there is already a session associated with the current reactive stream and given tenant id, then the work will be executed using that session.
    • Otherwise, if there is no session associated with the current stream and given tenant id, a new stateless session will be created.

      The session will be flushed and closed automatically, and the transaction committed automatically.

      • Parameters:
      tenantId - the id of the tenant
      work - a function which accepts the session and returns the result of the work as a Uni.
      See Also:

    • withStatelessTransaction

      <T> io.smallrye.mutiny.Uni<T> withStatelessTransaction(String tenantId, BiFunction<Mutiny.StatelessSession,Mutiny.Transaction,io.smallrye.mutiny.Uni<T>> work)
      Perform work using a reactive session for the tenant with the specified tenant id within an associated transaction.

    • If there is already a stateless session associated with the current reactive stream and given tenant id, then the work will be executed using that session.
    • Otherwise, if there is no stateless session associated with the current stream and given tenant id, a new stateless session will be created.

      The session will be closed automatically and the transaction committed automatically.

      • Parameters:
      tenantId - the id of the tenant
      work - a function which accepts the stateless session and returns the result of the work as a Uni.
      See Also:

    • getCriteriaBuilder

      HibernateCriteriaBuilder getCriteriaBuilder()
      Returns:
      an instance of CriteriaBuilder for creating criteria queries.

    • getMetamodel

      Metamodel getMetamodel()
      Obtain the JPA Metamodel for the persistence unit.

    • getCache

      Cache getCache()
      Obtain the Cache object for managing the second-level cache.

    • getStatistics

      Statistics getStatistics()
      Obtain the Statistics object exposing factory-level metrics.

    • getCurrentSession

      Mutiny.Session getCurrentSession()
      Return the current instance of Mutiny.Session, if any. A current session exists only when this method is called from within an invocation of withSession(Function) or withTransaction(Function).
      Returns:
      the current instance, if any, or null
      Since:
      3.0

    • getCurrentStatelessSession

      Mutiny.StatelessSession getCurrentStatelessSession()
      Return the current instance of Mutiny.Session, if any. A current session exists only when this method is called from within an invocation of withStatelessSession(Function) or withStatelessTransaction(Function).
      Returns:
      the current instance, if any, or null
      Since:
      3.0

    • close

      void close()
      Destroy the session factory and clean up its connection pool.
      Specified by:
      close in interface AutoCloseable

    • isOpen

      boolean isOpen()
      Returns:
      false if close() has been called