在JPA存储库中是否存在自动连接任何Spring@组件的方法？

关键是我有一个自定义JPA存储库，它是使用“@EnableJpaRepositories”加载的，但在这个自定义JPA存储库中，我会自动连接另一个用@Component注释的Springbean，但它从来没有填充过，总是带来一个空引用

我了解到JPA存储库确实加入并共享相同的Spring应用程序上下文，因此它无法看到由公共应用程序上下文加载的bean。。。这是真的吗？如果是这样的话，有没有办法将它们粘合起来，并创建自定义存储库来正确地注入我的组件

下面是相关代码：

public class DefaultCrudRepository<T extends IdentifiableEntity> extends    QuerydslJpaRepository<T, BigInteger>
    implements CrudRepository<T> {

private static final EntityPathResolver DEFAULT_ENTITY_PATH_RESOLVER = SimpleEntityPathResolver.INSTANCE;

private JpaEntityInformation<T, BigInteger> jpaEntityInformation;
private EntityManager entityManager;
private EntityPath<T> path;
private PathBuilder<T> builder;
private Querydsl querydsl;

@Autowired
private SortComponent sortComponent;

@Autowired
private PageComponent pageComponent;

@Autowired
private FilterComponent filterComponent;

@Autowired
private ExpandComponent expandComponent;

public DefaultCrudRepository(JpaEntityInformation<T, BigInteger> jpaEntityInformation, EntityManager entityManager,
        EntityPathResolver resolver) {
    super(jpaEntityInformation, entityManager, resolver);
    this.jpaEntityInformation = jpaEntityInformation;
    this.entityManager = entityManager;
    this.path = resolver.createPath(jpaEntityInformation.getJavaType());
    this.builder = new PathBuilder<T>(path.getType(), path.getMetadata());
    this.querydsl = new Querydsl(entityManager, builder);
    this.expandComponent = new DefaultExpandComponent(entityManager);
    this.sortComponent = new DefaultSortComponent();
    this.filterComponent = new DefaultFilterComponent();
    this.pageComponent = new DefaultPageComponent();
    init();
}

public DefaultCrudRepository(JpaEntityInformation<T, BigInteger> jpaEntityInformation,
        EntityManager entityManager) {
    this(jpaEntityInformation, entityManager, DEFAULT_ENTITY_PATH_RESOLVER);
    this.jpaEntityInformation = jpaEntityInformation;
    this.entityManager = entityManager;
}

/*
 * private Class<?> getDomainClass(Class<?> clazz) { Type type =
 * clazz.getGenericSuperclass(); if (type instanceof ParameterizedType) {
 * ParameterizedType parameterizedType = (ParameterizedType) type; return
 * (Class<?>) parameterizedType.getActualTypeArguments()[0]; } else { return
 * getDomainClass(clazz.getSuperclass()); } }
 */

@PostConstruct
private void init() {
    this.filterComponent.init(this.jpaEntityInformation.getJavaType());
    this.expandComponent.init(this.jpaEntityInformation.getJavaType());
}

@Override
public <S extends T> List<S> save(Iterable<S> entities) {
    List<S> savedEntities = super.save(entities);
    super.flush();
    this.entityManager.refresh(savedEntities);
    return savedEntities;
}

@Override
public <S extends T> S save(S entity) {
    S savedEntity = super.save(entity);
    super.flush();
    if (!this.jpaEntityInformation.isNew(entity)) {
        this.entityManager.refresh(savedEntity);
    }
    return savedEntity;
}

protected JPQLQuery<T> createQuery(final Predicate predicate, final EntityGraph<?> entityGraph) {
    JPQLQuery<?> query = createQuery(predicate);
    if (entityGraph != null) {
        ((AbstractJPAQuery<?, ?>) query).setHint(EntityGraphType.LOAD.getKey(), entityGraph);

    }

    return query.select(path);
}

protected Page<T> findAll(final Pageable pageable, final Predicate predicate, final EntityGraph<?> entityGraph) {

    final JPQLQuery<?> countQuery = createCountQuery(predicate);
    JPQLQuery<T> query = querydsl.applyPagination(pageable, createQuery(predicate, entityGraph));

    return PageableExecutionUtils.getPage(query.fetch(), pageable, new LongSupplier() {

        @Override
        public long getAsLong() {
            return countQuery.fetchCount();
        }
    });
}



@Override
public Page<T> findAll(Integer pageNumber, Integer pageSize, BooleanExpression booleanExpression,
        String filterExpression, String sortExpression, String expandExpression)
        throws InvalidFilterExpressionException, InvalidSortExpressionException, 
        InvalidExpandExpressionException {

    Sort sort = null;
    if (sortExpression != null && !sortExpression.isEmpty()) {
        sort = this.sortComponent.getSort(sortExpression);
    }

    Pageable pageable = this.pageComponent.getPage(pageNumber, pageSize, sort);

    BooleanExpression filterBooleanExpression = null;

    if (filterExpression != null) {
        filterBooleanExpression = this.filterComponent.getBooleanExpression(filterExpression);
    }

    BooleanExpression mergedBooleanExpression = null;
    if (booleanExpression != null && filterBooleanExpression != null) {
        mergedBooleanExpression = booleanExpression.and(filterBooleanExpression);
    } else if (booleanExpression != null && filterBooleanExpression == null) {
        mergedBooleanExpression = booleanExpression;
    } else if (booleanExpression == null && filterBooleanExpression != null) {
        mergedBooleanExpression = filterBooleanExpression;
    }

    EntityGraph<?> entityGraph = null;
    if (expandExpression != null && !expandExpression.isEmpty()) {
        entityGraph = this.expandComponent.getEntityGraph(expandExpression);
    }

    return this.findAll(pageable, mergedBooleanExpression, entityGraph);
}

protected Predicate getPredicate(final BigInteger identifier, final Predicate predicate) {
    Class<?> clazz = this.jpaEntityInformation.getJavaType();
    String name = CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, clazz.getSimpleName());
    Path<?> rootPath = Expressions.path(this.jpaEntityInformation.getJavaType(), name);
    Class<?> idType = this.jpaEntityInformation.getIdType();
    String idAttributeName = this.jpaEntityInformation.getIdAttribute().getName();
    Path<?> leftPath = Expressions.path(idType, rootPath, idAttributeName);
    Expression<?> rightExpression = Expressions.constant(identifier);
    BooleanExpression booleanExpression = Expressions.predicate(Ops.EQ, leftPath, rightExpression);
    BooleanBuilder booleanBuilder = new BooleanBuilder(booleanExpression);
    booleanBuilder.and(predicate);
    return booleanBuilder.getValue();
}

protected T findOne(final BigInteger identifier, final BooleanExpression booleanExpression,
        final EntityGraph<?> entityGraph) {
    Assert.notNull(identifier, "The given id must not be null!");
    T object = null;
    if (booleanExpression != null) {
        Predicate mergedPredicate = getPredicate(identifier, booleanExpression);
        JPQLQuery<T> query = createQuery(mergedPredicate, entityGraph);
        object = query.fetchOne();
    } else {
        Map<String, Object> hints = new HashMap<String, Object>();
        if (entityGraph != null) {
            hints.put("javax.persistence.loadgraph", entityGraph);
        }
        object = this.entityManager.find(this.jpaEntityInformation.getJavaType(), identifier, hints);
    }
    return object;
}

@Override
public T findOne(final BigInteger identifier, final BooleanExpression booleanExpression,
        final String expandExpression) throws InvalidExpandExpressionException {

    EntityGraph<?> entityGraph = null;
    if (booleanExpression != null) {
        entityGraph = this.expandComponent.getEntityGraph(expandExpression);
    }

    return this.findOne(identifier, booleanExpression, entityGraph);
}

@Override
public Map<Number, T> findAllRevisions(final BigInteger identifier) {
    Assert.notNull(identifier, "The given id must not be null!");
    AuditReader auditReader = AuditReaderFactory.get(this.entityManager);
    List<Number> revisionList = auditReader.getRevisions(this.jpaEntityInformation.getJavaType(), identifier);
    if (revisionList == null || revisionList.isEmpty()) {
        return null;
    }
    Set<Number> revisionSet = new LinkedHashSet<Number>(revisionList);
    return auditReader.findRevisions(this.jpaEntityInformation.getJavaType(), revisionSet);
}

@Override
public void delete(Iterable<? extends T> entities) {
    super.delete(entities);
    super.flush();
}

@Override
public void delete(T entity) {
    super.delete(entity);
    super.flush();
}

}

公共类DefaultCrudepository扩展了QueryDslJpaRepository
器具积垢{
私有静态最终EntityPathResolver默认\u实体\u路径\u解析器=SimpleEntityPathResolver.INSTANCE；
私人JpaEntityInformation JpaEntityInformation；
私人实体管理者实体管理者；
私有实体路径；
私有路径生成器；
私人查询；
@自动连线
私有SortComponent SortComponent；
@自动连线
专用页面组件页面组件；
@自动连线
专用过滤器组件过滤器组件；
@自动连线
私有可扩展组件可扩展组件；

你说的是JPA存储库接口还是自定义存储库实现？如果是第一个，那么自动连接在那里就不起作用。如果是后者，那么它应该起作用，因为你的实现应该是一个Springbean。但是，如果没有显示任何代码，很难猜测问题出在哪里。@dunni谢谢。我已经添加了相关的存储库实现的一部分请编辑您的问题并在那里添加代码。还有哪些字段为空？全部为空？另外，您能否显示实际使用此存储库类的代码？如何初始化它？感谢dunni-在第一个问题中添加了源代码，是的，所有自动连接的字段都为空，因为它将在初始化是通过包扫描…使用@EnableJpaRepositories完成的。

public class AbstractCrudService<T extends IdentifiableEntity> implements CrudService<T> {

@Autowired(required=false)
private CrudRepository<T> repository;

@Autowired(required=false)
private NotificationComponent<T> notificationComponent;

private NotificationContext<T> geNotificationContext(String action, List<T> payload) {
    DefaultNotificationContext<T> defaultNotificationContext = new DefaultNotificationContext<T>();
    /*defaultNotificationContext.setAction(action);
    defaultNotificationContext.setObject(this.domainClazz.getSimpleName());
    defaultNotificationContext.setInstant(Instant.now());
    defaultNotificationContext.setResponsibleId(null);
    defaultNotificationContext.setPayload(payload);*/
    return defaultNotificationContext;
}

private NotificationContext<T> geNotificationContext(String action, Page<T> payload) {
    return geNotificationContext(action, payload.getContent());
}

private NotificationContext<T> geNotificationContext(String action, T payload) {
    List<T> payloadList = new ArrayList<T>();
    payloadList.add(payload);
    return geNotificationContext(action, payloadList);
}

@Override
@Transactional(dontRollbackOn = LongTermRunningException.class)
@TypeTaskCriteria(pre = PreSaveTask.class, post = PostSaveTask.class, referenceGenericType = AbstractCrudService.class)
public List<T> save(List<T> objects)
        throws ConcurrentModificationException, UnexpectedException {

    List<T> savedObjectList = this.repository.save(objects);

    if (this.notificationComponent != null) {
        this.notificationComponent.notify(geNotificationContext(NotificationContext.SAVE, savedObjectList));
    }

    return savedObjectList;
}

@Override
@Transactional(dontRollbackOn = LongTermRunningException.class)
@TypeTaskCriteria(pre = PreSaveTask.class, post = PostSaveTask.class, referenceGenericType = AbstractCrudService.class)
public T save(T object) throws ConcurrentModificationException, UnexpectedException {

    T savedObject = this.repository.save(object);

    if (this.notificationComponent != null) {
        this.notificationComponent.notify(geNotificationContext(NotificationContext.SAVE, savedObject));
    }

    return savedObject;
}

@Override
@TypeTaskCriteria(pre = PreRetrieveTask.class, post = PostRetrieveTask.class, referenceGenericType = AbstractCrudService.class)
public Page<T> retrieve(
        @P(PAGE_NUMBER) final Integer pageNumber,
        @P(PAGE_SIZE) final Integer pageSize,
        @P(FILTER_EXPRESSION) final String filterExpression,
        @P(SORT_EXPRESSION) final String sortExpression,
        @P(EXPAND_EXPRESSION) final String expandExpression,
        @P(PARAMETERS) final Map<String, String> parameters) throws InvalidParameterException, UnexpectedException {

    DefaultRetrieveTaskContext context = TaskContextHolder.getContext();
    BooleanExpression booleanExpression = context.getBooleanExpression();

    Page<T> page = null;
    try {
        page = new Page<T>(this.repository.findAll(pageNumber, pageSize, booleanExpression, filterExpression, sortExpression, expandExpression));
    } catch (InvalidFilterExpressionException | InvalidSortExpressionException
            | InvalidExpandExpressionException e) {
        throw new UnexpectedException(e);
    }

    if (this.notificationComponent != null) {
        this.notificationComponent.notify(geNotificationContext(NotificationContext.RETRIEVE, page));
    }

    return page;
}

@Override
@TypeTaskCriteria(pre = PreRetrieveTask.class, post = PostRetrieveTask.class, referenceGenericType = AbstractCrudService.class)
public T retrieve(BigInteger identifyer, String expandExpression) throws NotFoundException, UnexpectedException {

    RetrieveTaskContext context = TaskContextHolder.getContext();
    BooleanExpression booleanExpression = context.getBooleanExpression();

    T object = null;
    try {
        object = this.repository.findOne(identifyer, booleanExpression, expandExpression);
    } catch (InvalidExpandExpressionException invalidExpandExpressionException) {
        throw new UnexpectedException(invalidExpandExpressionException);
    }

    if (this.notificationComponent != null) {
        this.notificationComponent.notify(geNotificationContext(NotificationContext.RETRIEVE, object));
    }   

    return object;
}

@Override
@Transactional(dontRollbackOn = LongTermRunningException.class)
@TypeTaskCriteria(pre = PreDeleteTask.class, post = PostDeleteTask.class, referenceGenericType = AbstractCrudService.class)
public void delete(List<T> objects) throws ConcurrentModificationException, UnexpectedException {

    this.repository.delete(objects);

    if (this.notificationComponent != null) {
        this.notificationComponent.notify(geNotificationContext(NotificationContext.DELETE, (List<T>) null));
    }
}

@Override
@Transactional(dontRollbackOn = LongTermRunningException.class)
@TypeTaskCriteria(pre = PreDeleteTask.class, post = PostDeleteTask.class, referenceGenericType = AbstractCrudService.class)
public void delete(T object) throws ConcurrentModificationException, UnexpectedException {

    this.repository.delete(object);

    if (this.notificationComponent != null) {
        this.notificationComponent.notify(geNotificationContext(NotificationContext.DELETE, (T) null));
    }
}

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(value = "br.org.ccee", repositoryFactoryBeanClass =     CrudRepositoryFactoryBean.class)
@EnableAspectJAutoProxy
public class ServiceConfiguration {

@Bean
//@Scope("request")
public ServiceContext serviceContext() {
    DefaultServiceContext defaultServiceContext = new DefaultServiceContext();
    defaultServiceContext.setInstant(Instant.now());
    defaultServiceContext.setUserId(new BigInteger("33"));
    defaultServiceContext.setTenantId(new BigInteger("69"));
    return defaultServiceContext;
}

@Bean
public TenantEventListener tenantEventListener() {
    return new TenantEventListener();
}

@Bean
public AuditEventListener auditEventListener() {
    return new AuditEventListener();
}

@Bean
public EventListenerRegistry eventListenerRegistry(
        LocalContainerEntityManagerFactoryBean entityManagerFactory, 
        TenantEventListener tenantEventListener,
        AuditEventListener auditEventListener) {
    SessionFactoryImpl sessionFactoryImpl = (SessionFactoryImpl) entityManagerFactory.getNativeEntityManagerFactory();
    ServiceRegistryImplementor serviceRegistryImplementor = sessionFactoryImpl.getServiceRegistry();
    EventListenerRegistry eventListenerRegistry = serviceRegistryImplementor.getService(EventListenerRegistry.class);
    eventListenerRegistry.prependListeners(EventType.PRE_INSERT, auditEventListener);
    eventListenerRegistry.prependListeners(EventType.PRE_INSERT, tenantEventListener);
    eventListenerRegistry.prependListeners(EventType.PRE_UPDATE, auditEventListener);
    return eventListenerRegistry;
}

public class DefaultCrudRepository<T extends IdentifiableEntity> extends QueryDslJpaRepository<T, BigInteger>
        implements CrudRepository<T> {

    private static final EntityPathResolver DEFAULT_ENTITY_PATH_RESOLVER = SimpleEntityPathResolver.INSTANCE;

    private JpaEntityInformation<T, BigInteger> jpaEntityInformation;
    private EntityManager entityManager;
    private EntityPath<T> path;
    private PathBuilder<T> builder;
    private Querydsl querydsl;

    @Autowired
    private SortComponent sortComponent;

    @Autowired
    private PageComponent pageComponent;

    @Autowired
    private FilterComponent filterComponent;

    @Autowired
    private ExpandComponent expandComponent;