BaseRepository that delegates to spring-data-jpa SimpleJpaRepository. Useful inside java ee 6 cdi container where you don't want to use spring ifrastructure.

BaseRepository.java

public abstract class BaseRepository<T extends Object, ID extends Serializable>
  implements JpaRepository<T, ID>, JpaSpecificationExecutor<T> {

	private @PersistenceContext EntityManager em;
	
	private SimpleJpaRepository<T, ID> target;	
	
	protected EntityManager getEntityManager() {
		return em;
	}

	@Override
	public Long count() {
		return target.count();
	}

	@Override
	public Long count(Specification<T> s) {
		return target.count(s);
	}

	@Override
	public void delete(T t) {
		target.delete(t);
	}

	@Override
	public void delete(Iterable<? extends T> itrbl) {
		target.delete(itrbl);
	}

	@Override
	public void deleteAll() {
		target.deleteAll();
	}

	@Override
	public void deleteInBatch(Iterable<T> itrbl) {
		target.deleteInBatch(itrbl);
	}

	@Override
	public boolean exists(ID id) {
		return target.exists(id);
	}

	@Override
	public List<T> findAll() {
		return target.findAll();
	}

	@Override
	public List<T> findAll(Sort sort) {
		return target.findAll(sort);
	}

	@Override
	public Page<T> findAll(Pageable pgbl) {
		return target.findAll(pgbl);
	}

	@Override
	public List<T> findAll(Specification<T> s) {
		return target.findAll(s);
	}

	@Override
	public Page<T> findAll(Specification<T> s, Pageable pgbl) {
		return target.findAll(s, pgbl);
	}

	@Override
	public T findOne(ID id) {
		return target.findOne(id);
	}

	@Override
	public T findOne(Specification<T> s) {
		return target.findOne(s);
	}

	@Override
	public void flush() {
		target.flush();
	}
	
	@PostConstruct void init() {
		// this is needed to retrieve the Class instance associated with the generic definition T
		ParameterizedType superclass = (ParameterizedType)getClass().getGenericSuperclass();
		Class<T> type = (Class<T>) superclass.getActualTypeArguments()[0];
		target = new SimpleJpaRepository<T, ID>((JpaEntityInformation<T, ID>) JpaClassUtils.getMetadata(type, em), em);
	}
	
	@Override
	public T save(T t) {
		return target.save(t);
	}

	@Override
	public List<T> save(Iterable<? extends T> itrbl) {
		return target.save(itrbl);
	}

	@Override
	public T saveAndFlush(T t) {
		return target.saveAndFlush(t);
	}
	
}