Spring Boot 使用泛型类型注入 Bean Map

Question

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 }

Answer 1

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);
    }
}

Answer 2

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.