BaseEntityService (OmniPersistence 0.4 API)

java.lang.Object
- org.omnifaces.persistence.service.BaseEntityService<I,E>

Type Parameters:

I - The generic ID type, usually Long.

E - The generic base entity type.
```
public abstract class BaseEntityService<I extends Comparable<I> & Serializable,E extends BaseEntity<I>>
extends Object
```
Base entity service. Let your Stateless service classes extend from this. Ideally, you would not anymore have the need to inject the EntityManager in your service class and it would suffice to just delegate all persistence actions to methods of this abstract class.
You only need to let your entities extend from one of the following mapped super classes:
Logging

BaseEntityService uses JULI Logger for logging.
- Level.WARNING will log unparseable or illegal criteria values. The BaseEntityService will skip them and continue.
- Level.FINE will log computed type mapping (the actual values of I and E type paramters), and any discovered ElementCollection and OneToMany mappings of the entity. This is internally used in order to be able to build proper queries to perform a search inside a ElementCollection or OneToMany field.
- Level.FINER will log the getPage(Page, boolean) arguments, the set parameter values and the full query result.
See Also:

BaseEntity, Page, Criteria

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected static interface`	`BaseEntityService.MappedQueryBuilder<T>` Functional interface to fine-grain a JPA criteria query for any of `getPage(Page, boolean)` methods taking a specific result type, such as an entity subclass (DTO).
`protected static interface`	`BaseEntityService.QueryBuilder<E>` Functional interface to fine-grain a JPA criteria query for any of `getPage(Page, boolean)` methods.

Constructor Summary

Constructors
Constructor and Description

BaseEntityService()
The constructor initializes the type mapping.

Constructors
Constructor and Description
`BaseEntityService()` The constructor initializes the type mapping.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected Consumer<javax.persistence.EntityManager>`	`afterPage()` Here you can in your DTO subclass define the callback method which needs to be invoked after any of `getPage(Page, boolean)` methods is called.
`protected Consumer<javax.persistence.EntityManager>`	`beforePage()` Here you can in your DTO subclass define the callback method which needs to be invoked before any of `getPage(Page, boolean)` methods is called.
`protected long`	`countForeignKeyReferencesTo(E entity)` Returns count of all foreign key references to given entity.
`protected javax.persistence.Query`	`createNamedQuery(String name)` Create an instance of `Query` for executing a Java Persistence Query Language statement identified by the given name, usually to perform an INSERT, UPDATE or DELETE.
`protected javax.persistence.TypedQuery<E>`	`createNamedTypedQuery(String name)` Create an instance of `TypedQuery` for executing a Java Persistence Query Language statement identified by the given name, usually to perform a SELECT.
`void`	`delete(E entity)` Delete given entity.
`void`	`delete(Iterable<E> entities)` Delete given entities.
`protected E`	`fetchLazyBlobs(E entity)` Fetch all lazy blobs of given entity.
`protected E`	`fetchLazyCollections(E entity, Function<E,Collection<?>>... getters)` Fetch lazy collections of given entity on given getters.
`protected E`	`fetchLazyMaps(E entity, Function<E,Map<?,?>>... getters)` Fetch lazy maps of given entity on given getters.
`Optional<E>`	`findById(I id)` Find entity by given ID.
`List<E>`	`getAll()` Get all entities.
`E`	`getById(I id)` Get entity by given ID.
`static BaseEntityService<?,?>`	`getCurrentInstance()` Returns the currently active `BaseEntityService` from the `SessionContext`.
`Database`	`getDatabase()` Returns the SQL database being used.
`protected javax.persistence.EntityManager`	`getEntityManager()` Returns the entity manager being used.
`javax.persistence.metamodel.EntityType<? extends BaseEntity>`	`getMetamodel(Class<? extends BaseEntity> type)` Returns the metamodel of given base entity.
`org.omnifaces.utils.collection.PartialResultList<E>`	`getPage(Page page, boolean count)` Returns a partial result list based on given `Page`.
`protected org.omnifaces.utils.collection.PartialResultList<E>`	`getPage(Page page, boolean count, BaseEntityService.QueryBuilder<E> queryBuilder)` Returns a partial result list based on given `Page` and `BaseEntityService.QueryBuilder`.
`protected org.omnifaces.utils.collection.PartialResultList<E>`	`getPage(Page page, boolean count, boolean cacheable)` Returns a partial result list based on given `Page`.
`protected org.omnifaces.utils.collection.PartialResultList<E>`	`getPage(Page page, boolean count, boolean cacheable, BaseEntityService.QueryBuilder<E> queryBuilder)` Returns a partial result list based on given `Page`, entity type and `BaseEntityService.QueryBuilder`.
`protected <T extends E> org.omnifaces.utils.collection.PartialResultList<T>`	`getPage(Page page, boolean count, boolean cacheable, Class<T> resultType, BaseEntityService.MappedQueryBuilder<T> queryBuilder)` Returns a partial result list based on given `Page`, entity type and `BaseEntityService.QueryBuilder`.
`protected <T extends E> org.omnifaces.utils.collection.PartialResultList<T>`	`getPage(Page page, boolean count, Class<T> resultType, BaseEntityService.MappedQueryBuilder<T> mappedQueryBuilder)` Returns a partial result list based on given `Page`, result type and `BaseEntityService.MappedQueryBuilder`.
`Provider`	`getProvider()` Returns the JPA provider being used.
`protected E`	`manage(E entity)` Make given entity managed.
`protected Consumer<javax.persistence.TypedQuery<?>>`	`onPage(Page page, boolean cacheable)` Here you can in your DTO subclass define the callback method which needs to be invoked when any query involved in `getPage(Page, boolean)` is about to be executed.
`I`	`persist(E entity)` Persist given entity.
`void`	`reset(E entity)` Reset given entity.
`E`	`save(E entity)` Save given entity.
`E`	`update(E entity)` Update given entity.
`List<E>`	`update(Iterable<E> entities)` Update given entities.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - BaseEntityService
```
public BaseEntityService()
```
    The constructor initializes the type mapping. The I and E will be resolved to a concrete Class<?>.
- Method Detail
  - getProvider
```
public Provider getProvider()
```
    Returns the JPA provider being used. Normally, you don't need to override this. This is automatically determined based on getEntityManager().
    
    Returns:
    
    The JPA provider being used.
  - getDatabase
```
public Database getDatabase()
```
    Returns the SQL database being used. Normally, you don't need to override this. This is automatically determined based on getEntityManager().
    
    Returns:
    
    The SQL database being used.
  - getMetamodel
```
public javax.persistence.metamodel.EntityType<? extends BaseEntity> getMetamodel(Class<? extends BaseEntity> type)
```
    Returns the metamodel of given base entity.
    
    Returns:
    
    The metamodel of given base entity.
  - getEntityManager
```
protected javax.persistence.EntityManager getEntityManager()
```
    Returns the entity manager being used. When you have only one persistence unit, then you don't need to override this. When you have multiple persistence units, then you need to extend the BaseEntityService like below wherein you supply the persistence unit specific entity manager and then let all your service classes extend from it instead.
```
 public abstract class YourBaseEntityService<E extends BaseEntity<Long>> extends BaseEntityService<Long, E> {

     @PersistenceContext(unitName = "yourPersistenceUnitName")
     private EntityManager entityManager;

     @Override
     public EntityManager getEntityManager() {
         return entityManager;
     }

 }
 
```
    Returns:
    
    The entity manager being used.
  - createNamedTypedQuery
```
protected javax.persistence.TypedQuery<E> createNamedTypedQuery(String name)
```
    Create an instance of TypedQuery for executing a Java Persistence Query Language statement identified by the given name, usually to perform a SELECT.
    
    Parameters:
    
    name - The name of the Java Persistence Query Language statement defined in metadata, which can be either a NamedQuery or a <persistence-unit><mapping-file>.
    
    Returns:
    
    An instance of TypedQuery for executing a Java Persistence Query Language statement identified by the given name, usually to perform a SELECT.
  - createNamedQuery
```
protected javax.persistence.Query createNamedQuery(String name)
```
    Create an instance of Query for executing a Java Persistence Query Language statement identified by the given name, usually to perform an INSERT, UPDATE or DELETE.
    
    Parameters:
    
    name - The name of the Java Persistence Query Language statement defined in metadata, which can be either a NamedQuery or a <persistence-unit><mapping-file>.
    
    Returns:
    
    An instance of Query for executing a Java Persistence Query Language statement identified by the given name, usually to perform an INSERT, UPDATE or DELETE.
  - findById
```
public Optional<E> findById(I id)
```
    Find entity by given ID.
    
    Parameters:
    
    id - Entity ID to find entity for.
    
    Returns:
    
    Found entity, if any.
  - getById
```
public E getById(I id)
```
    Get entity by given ID.
    
    Parameters:
    
    id - Entity ID to get entity by.
    
    Returns:
    
    Found entity, or null if there is none.
  - getAll
```
public List<E> getAll()
```
    Get all entities. The default ordering is by ID, descending.
    
    Returns:
    
    All entities.
  - persist
```
public I persist(E entity)
```
    Persist given entity.
    
    Parameters:
    
    entity - Entity to persist.
    
    Returns:
    
    Entity ID.
    
    Throws:
    
    IllegalEntityStateException - When entity has an ID.
  - update
```
public E update(E entity)
```
    Update given entity.
    
    Parameters:
    
    entity - Entity to update.
    
    Returns:
    
    Updated entity.
    
    Throws:
    
    IllegalEntityStateException - When entity has no ID.
  - update
```
public List<E> update(Iterable<E> entities)
```
    Update given entities.
    
    Parameters:
    
    entities - Entities to update.
    
    Returns:
    
    Updated entities.
    
    Throws:
    
    IllegalEntityStateException - When at least one entity has no ID.
  - save
```
public E save(E entity)
```
    Save given entity. This will automatically determine based on presence of entity ID whether to persist(BaseEntity) or to update(BaseEntity).
    
    Parameters:
    
    entity - Entity to save.
    
    Returns:
    
    Saved entity.
  - reset
```
public void reset(E entity)
```
    Reset given entity. This will discard any changes in given entity. The given entity must be unmanaged/detached. The actual intent of this method is to have the opportunity to completely reset the state of a given entity which might have been edited in the client, without changing the reference. This is generally useful when the entity is in turn held in some collection and you'd rather not manually remove and reinsert it in the collection.
    
    Parameters:
    
    entity - Entity to reset.
    
    Throws:
    
    IllegalEntityStateException - When entity has no ID.
    
    javax.persistence.EntityNotFoundException - When entity has in meanwhile been deleted.
  - delete
```
public void delete(E entity)
```
    Delete given entity.
    
    Parameters:
    
    entity - Entity to delete.
    
    Throws:
    
    NonDeletableEntityException - When entity has NonDeletable annotation set.
    
    IllegalEntityStateException - When entity has no ID.
    
    javax.persistence.EntityNotFoundException - When entity has in meanwhile been deleted.
  - delete
```
public void delete(Iterable<E> entities)
```
    Delete given entities.
    
    Parameters:
    
    entities - Entities to delete.
    
    Throws:
    
    NonDeletableEntityException - When at least one entity has NonDeletable annotation set.
    
    IllegalEntityStateException - When at least one entity has no ID.
    
    javax.persistence.EntityNotFoundException - When at least one entity has in meanwhile been deleted.
  - manage
```
protected E manage(E entity)
```
    Make given entity managed. NOTE: This will discard any changes in the given entity! This is particularly useful in case you intend to make sure that you have the most recent version at hands.
    
    Parameters:
    
    entity - Entity to manage.
    
    Returns:
    
    The managed entity.
    
    Throws:
    
    IllegalEntityStateException - When entity has no ID.
    
    javax.persistence.EntityNotFoundException - When entity has in meanwhile been deleted.
  - countForeignKeyReferencesTo
```
protected long countForeignKeyReferencesTo(E entity)
```
    Returns count of all foreign key references to given entity. This is particularly useful in case you intend to check if the given entity is still referenced elsewhere in database.
    
    Parameters:
    
    entity - Entity to count all foreign key references for.
    
    Returns:
    
    Count of all foreign key references to given entity.
  - fetchLazyCollections
```
protected E fetchLazyCollections(E entity,
                                 Function<E,Collection<?>>... getters)
```
    Fetch lazy collections of given entity on given getters. If no getters are supplied, then it will fetch every single PluralAttribute not of type PluralAttribute.CollectionType.MAP. Note that the implementation does for simplicitly not check if those are actually lazy or eager.
    
    Parameters:
    
    entity - Entity instance to fetch lazy collections on.
    
    getters - Getters of those lazy collections.
    
    Returns:
    
    The same entity, useful if you want to continue using it immediately.
  - fetchLazyMaps
```
protected E fetchLazyMaps(E entity,
                          Function<E,Map<?,?>>... getters)
```
    Fetch lazy maps of given entity on given getters. If no getters are supplied, then it will fetch every single PluralAttribute of type PluralAttribute.CollectionType.MAP. Note that the implementation does for simplicitly not check if those are actually lazy or eager.
    
    Parameters:
    
    entity - Entity instance to fetch lazy maps on.
    
    getters - Getters of those lazy collections.
    
    Returns:
    
    The same entity, useful if you want to continue using it immediately.
  - fetchLazyBlobs
```
protected E fetchLazyBlobs(E entity)
```
    Fetch all lazy blobs of given entity. Note that the implementation does for simplicitly not check if those are actually lazy or eager.
    
    Parameters:
    
    entity - Entity instance to fetch all blobs on.
    
    Returns:
    
    The same entity, useful if you want to continue using it immediately.
  - beforePage
```
protected Consumer<javax.persistence.EntityManager> beforePage()
```
    Here you can in your DTO subclass define the callback method which needs to be invoked before any of getPage(Page, boolean) methods is called. For example, to set a vendor specific EntityManager hint. The default implementation returns a no-op callback.
    
    Returns:
    
    The callback method which is invoked before any of getPage(Page, boolean) methods is called.
  - onPage
```
protected Consumer<javax.persistence.TypedQuery<?>> onPage(Page page,
                                                           boolean cacheable)
```
    Here you can in your DTO subclass define the callback method which needs to be invoked when any query involved in getPage(Page, boolean) is about to be executed. For example, to set a vendor specific Query hint. The default implementation sets the Hibernate cacheable and cacheRegion hints.
    
    Parameters:
    
    page - The page on which this query is based.
    
    cacheable - Whether the results should be cacheable.
    
    Returns:
    
    The callback method which is invoked when any query involved in getPage(Page, boolean) is about to be executed.
  - afterPage
```
protected Consumer<javax.persistence.EntityManager> afterPage()
```
    Here you can in your DTO subclass define the callback method which needs to be invoked after any of getPage(Page, boolean) methods is called. For example, to remove a vendor specific EntityManager hint. The default implementation returns a no-op callback.
    
    Returns:
    
    The callback method which is invoked after any of getPage(Page, boolean) methods is called.
  - getPage
```
public org.omnifaces.utils.collection.PartialResultList<E> getPage(Page page,
                                                                   boolean count)
```
    Returns a partial result list based on given Page. This will by default cache the results.
    
    Parameters:
    
    page - The page to return a partial result list for.
    
    count - Whether to run the COUNT(id) query to estimate total number of results. This will be available by PartialResultList.getEstimatedTotalNumberOfResults().
    
    Returns:
    
    A partial result list based on given Page.
  - getPage
```
protected org.omnifaces.utils.collection.PartialResultList<E> getPage(Page page,
                                                                      boolean count,
                                                                      boolean cacheable)
```
    Returns a partial result list based on given Page.
    
    Parameters:
    
    page - The page to return a partial result list for.
    
    count - Whether to run the COUNT(id) query to estimate total number of results. This will be available by PartialResultList.getEstimatedTotalNumberOfResults().
    
    cacheable - Whether the results should be cacheable.
    
    Returns:
    
    A partial result list based on given Page.
  - getPage
```
protected org.omnifaces.utils.collection.PartialResultList<E> getPage(Page page,
                                                                      boolean count,
                                                                      BaseEntityService.QueryBuilder<E> queryBuilder)
```
    Returns a partial result list based on given Page and BaseEntityService.QueryBuilder. This will by default cache the results.
    
    Parameters:
    
    page - The page to return a partial result list for.
    
    count - Whether to run the COUNT(id) query to estimate total number of results. This will be available by PartialResultList.getEstimatedTotalNumberOfResults().
    
    queryBuilder - This allows fine-graining the JPA criteria query.
    
    Returns:
    
    A partial result list based on given Page and BaseEntityService.QueryBuilder.
  - getPage
```
protected org.omnifaces.utils.collection.PartialResultList<E> getPage(Page page,
                                                                      boolean count,
                                                                      boolean cacheable,
                                                                      BaseEntityService.QueryBuilder<E> queryBuilder)
```
    Returns a partial result list based on given Page, entity type and BaseEntityService.QueryBuilder.
    
    Parameters:
    
    page - The page to return a partial result list for.
    
    count - Whether to run the COUNT(id) query to estimate total number of results. This will be available by PartialResultList.getEstimatedTotalNumberOfResults().
    
    cacheable - Whether the results should be cacheable.
    
    queryBuilder - This allows fine-graining the JPA criteria query.
    
    Returns:
    
    A partial result list based on given Page and BaseEntityService.QueryBuilder.
  - getPage
```
protected <T extends E> org.omnifaces.utils.collection.PartialResultList<T> getPage(Page page,
                                                                                    boolean count,
                                                                                    Class<T> resultType,
                                                                                    BaseEntityService.MappedQueryBuilder<T> mappedQueryBuilder)
```
    Returns a partial result list based on given Page, result type and BaseEntityService.MappedQueryBuilder. This will by default cache the results.
    
    Type Parameters:
    
    T - The generic type of the entity or a DTO subclass thereof.
    
    Parameters:
    
    page - The page to return a partial result list for.
    
    count - Whether to run the COUNT(id) query to estimate total number of results. This will be available by PartialResultList.getEstimatedTotalNumberOfResults().
    
    resultType - The result type which can be the entity type itself or a DTO subclass thereof.
    
    mappedQueryBuilder - This allows fine-graining the JPA criteria query and must return a mapping of getters-paths.
    
    Returns:
    
    A partial result list based on given Page and BaseEntityService.MappedQueryBuilder.
    
    Throws:
    
    IllegalArgumentException - When the result type does not equal entity type and mapping is empty.
  - getPage
```
protected <T extends E> org.omnifaces.utils.collection.PartialResultList<T> getPage(Page page,
                                                                                    boolean count,
                                                                                    boolean cacheable,
                                                                                    Class<T> resultType,
                                                                                    BaseEntityService.MappedQueryBuilder<T> queryBuilder)
```
    Returns a partial result list based on given Page, entity type and BaseEntityService.QueryBuilder.
    
    Type Parameters:
    
    T - The generic type of the entity or a DTO subclass thereof.
    
    Parameters:
    
    page - The page to return a partial result list for.
    
    count - Whether to run the COUNT(id) query to estimate total number of results. This will be available by PartialResultList.getEstimatedTotalNumberOfResults().
    
    cacheable - Whether the results should be cacheable.
    
    resultType - The result type which can be the entity type itself or a DTO subclass thereof.
    
    queryBuilder - This allows fine-graining the JPA criteria query and must return a mapping of getters-paths when result type does not equal entity type.
    
    Returns:
    
    A partial result list based on given Page and BaseEntityService.MappedQueryBuilder.
    
    Throws:
    
    IllegalArgumentException - When the result type does not equal entity type and mapping is empty.
  - getCurrentInstance
```
public static BaseEntityService<?,?> getCurrentInstance()
```
    Returns the currently active BaseEntityService from the SessionContext.
    
    Returns:
    
    The currently active BaseEntityService from the SessionContext.
    
    Throws:
    
    IllegalStateException - if there is none, which can happen if this method is called outside EJB context, or when currently invoked EJB service is not an instance of BaseEntityService.

Class BaseEntityService<I extends Comparable<I> & Serializable,E extends BaseEntity<I>>

Logging

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

BaseEntityService

Method Detail

getProvider

getDatabase

getMetamodel

getEntityManager

createNamedTypedQuery

createNamedQuery

findById

getById

getAll

persist

update

update

save

reset

delete

delete

manage

countForeignKeyReferencesTo

fetchLazyCollections

fetchLazyMaps

fetchLazyBlobs

beforePage

onPage

afterPage

getPage

getPage

getPage

getPage

getPage

getPage

getCurrentInstance