Spring Boot Inject Bean Map with Generic Type

Spring Framework 5

I have an instance of a Database Entity, and I want to use the corrosponding repository for that entity. How do I inject all JPA Repositories mapped by the entity as the key?

For example:

public interface ARepository extends JpaRepository<AEntity, Long> {}
public interface BRepository extends JpaRepository<BEntity, Long> {}

And in my service component:

public class TestService {
  @Autowired
  private Map<Class, JpaRepository<?, ?>> jpaRepositories;

  public <T> List<T> findAll(T entity) {
    Class entityClass = entity.getClass();
    JpaRepository<?, ?> jpaRepository = jpaRepositories.get(entityClass);
    return jpaRepository.findAll();
  }
}

I want jpaRepositories to be injected with these values:

{ AEntity.class, ARepository }, { BEntity.class, BRepository }

That kind of mapping is not available at runtime by default. If you like a hacky approach and REALLY need it, you can create a map like this for JPA repositories:

package com.example.repo;

import java.lang.reflect.Method;
import java.util.Collection;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.aop.framework.AopProxyUtils;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.support.SimpleJpaRepository;
import org.springframework.data.util.ProxyUtils;
import org.springframework.stereotype.Component;
import org.springframework.util.ReflectionUtils;

import lombok.RequiredArgsConstructor;

@Component
@RequiredArgsConstructor
public class AppRunner implements ApplicationRunner {
	private static final Logger log = LoggerFactory.getLogger(AppRunner.class);

	private final Collection<JpaRepository<?, ?>> jpaRepositories;

	@Override
	public void run(ApplicationArguments args) throws Exception {
		Function<JpaRepository<?, ?>, Class<?>> repositoryClass = r -> {
			if (SimpleJpaRepository.class.isAssignableFrom(ProxyUtils.getUserClass(r))) {
				Method method = ReflectionUtils.findMethod(SimpleJpaRepository.class, "getDomainClass");
				ReflectionUtils.makeAccessible(method);
				return (Class<?>) ReflectionUtils.invokeMethod(method, AopProxyUtils.getSingletonTarget(r));
			}
			
			return Void.class;
		};
		Map<Class<?>, JpaRepository<?, ?>> jpaRepositoriesByClass = jpaRepositories.stream().collect(Collectors.toMap(repositoryClass, Function.identity()));
		log.info("{}", jpaRepositoriesByClass);
	}
}

Here's my solution:

@Bean
public Map<Class<?>, JpaRepository<?, ?>> jpaRepositoryMap(
List<JpaRepository<?, ?>> jpaRepositories
) {
return jpaRepositories.stream()
.collect(Collectors.toMap(
jpaRepository -> resolveGenericType(jpaRepository, 0),
Function.identity()
));
}
private Class<?> resolveGenericType(Object object, int index) {
return ResolvableType.forClass(JpaRepository.class, object.getClass())
.getGenerics()[index].resolve();
}

Spring has ResolvableType as a utility to get generic types of classes.