net.osgiliath.module.spring.data.jpa.DelegatingSimpleJpaRepository Maven / Gradle / Ivy

Go to download
package net.osgiliath.module.spring.data.jpa;

import java.io.Serializable;
import java.util.List;
import javax.annotation.PostConstruct;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.metamodel.Metamodel;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Persistable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.support.JpaMetamodelEntityInformation;
import org.springframework.data.jpa.repository.support.JpaPersistableEntityInformation;
import org.springframework.data.jpa.repository.support.SimpleJpaRepository;

/**
 * Delegates the construction of spring-data-jpa repository (blueprint
 * integration needs this.
 * 
 * @author charliemordant
 *
 * @param 
 *          repository Entity type.
 * @param 
 *          entity ID.
 */
@javax.transaction.Transactional
public abstract class DelegatingSimpleJpaRepository
    implements JpaRepository, JpaSpecificationExecutor {
  /**
   * Delegate spring-data-jpa repository.
   */
  protected SimpleJpaRepository delegate;

  @Override
  public Page findAll(Pageable pageable) {

    return delegate.findAll(pageable);
  }

  @Override
  public  S save(S entity) {

    return delegate.save(entity);
  }

  @Override
  public T findOne(ID id) {

    return delegate.findOne(id);
  }

  @Override
  public boolean exists(ID id) {

    return delegate.exists(id);
  }

  @Override
  public long count() {

    return delegate.count();
  }

  @Override
  public void delete(ID id) {
    delegate.delete(id);

  }

  @Override
  public void delete(T entity) {
    delegate.delete(entity);

  }

  @Override
  public void delete(Iterable entities) {
    delegate.delete(entities);

  }

  @Override
  public void deleteAll() {
    delegate.deleteAll();

  }

  @Override
  public T findOne(Specification spec) {
    return delegate.findOne(spec);
  }

  @Override
  public List findAll(Specification spec) {
    return delegate.findAll(spec);
  }

  @Override
  public Page findAll(Specification spec, Pageable pageable) {

    return delegate.findAll(spec, pageable);
  }

  @Override
  public List findAll(Specification spec, Sort sort) {

    return delegate.findAll(spec, sort);
  }

  @Override
  public long count(Specification spec) {
    return delegate.count(spec);
  }

  @Override
  public List findAll() {
    return delegate.findAll();
  }

  @Override
  public List findAll(Sort sort) {

    return delegate.findAll(sort);
  }

  @Override
  public List findAll(Iterable ids) {
    return delegate.findAll(ids);
  }

  @Override
  public  List save(Iterable entities) {
    return delegate.save(entities);
  }

  @Override
  public void flush() {
    delegate.flush();

  }

  @Override
  public  S saveAndFlush(S entity) {
    return delegate.saveAndFlush(entity);
  }

  @Override
  public void deleteInBatch(Iterable entities) {
    delegate.deleteInBatch(entities);
  }

  @Override
  public void deleteAllInBatch() {
    delegate.deleteAllInBatch();

  }

  @Override
  public T getOne(ID id) {
    return delegate.getOne(id);
  }

  /**
   * Instancites a spring data repository: must be called within postconstruct.
   * 
   * @param emf
   *          the {@link EntityManagerFactory}.
   * @param em
   *          the {@link EntityManager}.
   * @param domainClass
   *          the repository class.
   */
  protected void instanciateDelegateRepository(EntityManagerFactory emf,
      EntityManager em, Class domainClass) {
    Metamodel mm = emf.getMetamodel();
    if (Persistable.class.isAssignableFrom(domainClass)) {
      delegate = new TransactionalSimpleJpaRepository(
          new JpaPersistableEntityInformation(domainClass, mm), em);

    } else {
      delegate = new TransactionalSimpleJpaRepository(
          new JpaMetamodelEntityInformation(domainClass, mm), em);

    }
  }

  /**
   * Client must call this annotated with {@link PostConstruct} annotation,
   * should call instanciateDelegateRepository.
   */
  public abstract void postConstruct();
}