@Service
public class FactoryRepository {
    
    @Autowired
    private ApplicationContext appContext;
    
    @Autowired 
    @PersistenceContext(unitName="entityManagerFactory")
    private EntityManager entityManager;  
    
    
    private RepositoryFactorySupport support;
    
    @PostConstruct
    public void init() {
          support = new JpaRepositoryFactory(entityManager);
    } 
   
    public  AbstractRepository getRepositoryByClassName(String className) {
        String[] beanNames = appContext.getBeanNamesForType(AbstractRepository.class);
        for (String beanName : beanNames) {
            if(beanName.startsWith(className.toLowerCase())){
                Object bean = appContext.getBean(beanName);
                support.getRepository(bean.getClass());
            }
        }

        return null;
    }
}

/**
 * 
 */
@SuppressWarnings("unchecked")
@NoRepositoryBean
public class GenericRepositoryImpl<T, ID extends Serializable>
        extends SimpleJpaRepository<T, ID> implements AbstractRepository<T, ID>, Serializable {

    private static final long serialVersionUID = 1L;

    private final JpaEntityInformation<T, ?> entityInformation;
    private final EntityManager em;
   // private final DefaultPersistenceProvider provider;

    private Class<?> springDataRepositoryInterface;

    public Class<?> getSpringDataRepositoryInterface() {
        return springDataRepositoryInterface;
    }

    public void setSpringDataRepositoryInterface(
            Class<?> springDataRepositoryInterface) {
        this.springDataRepositoryInterface = springDataRepositoryInterface;
    }

    /**
     * Creates a new {@link SimpleJpaRepository} to manage objects of the given
     * {@link JpaEntityInformation}.
     *
     * @param entityInformation
     * @param entityManager
     */
    public GenericRepositoryImpl(JpaEntityInformation<T, ?> entityInformation, EntityManager entityManager, Class<?> springDataRepositoryInterface) {
        super(entityInformation, entityManager);
        this.entityInformation = entityInformation;
        this.em = entityManager;
      //  this.provider = DefaultPersistenceProvider.fromEntityManager(entityManager);
        this.springDataRepositoryInterface = springDataRepositoryInterface;
    }

    /**
     * Creates a new {@link SimpleJpaRepository} to manage objects of the given
     * domain type.
     *
     * @param domainClass
     * @param em
     */
    public GenericRepositoryImpl(Class<T> domainClass, EntityManager em) {
        this(JpaEntityInformationSupport.getMetadata(domainClass, em), em, null);
    }

    public <S extends T> S save(S entity) {
        if (this.entityInformation.isNew(entity)) {
            this.em.persist(entity);
            flush();
            return entity;
        }
        entity = this.em.merge(entity);
        flush();
        return entity;
    }

    public T saveWithoutFlush(T entity) {
        return super.save(entity);
    }

    public List<T> saveWithoutFlush(Iterable<? extends T> entities) {
        List<T> result = new ArrayList<T>();
        if (entities == null) {
            return result;
        }

        for (T entity : entities) {
            result.add(saveWithoutFlush(entity));
        }
        return result;
    }
}

@Controller
@RequestMapping(value = "/rest/api")
public class RestController {

    @Autowired
    FactoryService service;

    @RequestMapping(method = RequestMethod.GET,
            produces = {MediaType.APPLICATION_JSON_VALUE},
            value = "/{clazz}/{id}")
    public ResponseEntity<String> id(@PathVariable("clazz") String clazz, @PathVariable(value = "id") Long id) {

        AbstractService ss = service.getServiceByClassName(clazz);
        Object au = ss.findOne(id);
        System.out.println(au);
        Result<Object> re = ResultFactory.getResult(au);

        HttpHeaders headers = new HttpHeaders();
        headers.add("Content-type", "application/json;charset=UTF-8");
        return new ResponseEntity<>(re.toString(), headers, HttpStatus.OK);
    }

    /**
     * http://www.youtube.com/watch?v=wylViAqNiRA 
     * TODO получение объекта по его
     * классу и внесение изменений в базу
     *
     * @param id
     * @return
     */
    @RequestMapping(method = RequestMethod.POST, value = "/{id}")
    @ResponseBody
    public ResponseEntity<String> post(@PathVariable("id") Long id) {
        //User u = userService.findOne(id);

        // Result<User> re = ResultFactory.getResult(u);
        return new ResponseEntity<>(" ", HttpStatus.OK);
    }

    @RequestMapping(method = RequestMethod.GET,
            produces = {MediaType.APPLICATION_JSON_VALUE},
            value = "/{clazz}/findall")
    @ResponseStatus(HttpStatus.FOUND)
    @ResponseBody
    /**
     * автоматически преобразуется в json через jackson
     */
    public List<User> findAll(
            @PathVariable("clazz") String clazz
            //@PathVariable("method") String method
    ) throws NoSuchMethodException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        
       
        AbstractService ss = service.getServiceByClassName(clazz);
        //Class noparams[] = {};
        //Method imethod =  ss.getClass().getDeclaredMethod(method, noparams);
       //  return (List<User>) imethod.invoke(ss, null);

        
        return ss.findAll();

    }

    
    
 
}

@NoRepositoryBean
public interface AbstractRepository<T , ID extends Serializable>  extends JpaRepository<T, ID>,JpaSpecificationExecutor<T>{
    
}

public interface RefBook0Repository extends CrudRepository<RefBook0, Long> {

@NoRepositoryBean
public interface AbstractRepository<T , ID extends Serializable> extends JpaRepository<T, ID>,JpaSpecificationExecutor<T>{
}

public interface UserRepository extends AbstractRepository<User, Long>{
User findOneByLogin(String login);
}