Consistently use JPA metamodel to determine entity name.

We now use JpaMetamodelEntityMetadata where possible to determine the entity name. Previously, we defaulted in many places to DefaultJpaEntityMetadata not considering XML-based entity names and also using improper unqualifying of entity names that lead to usage of Class.getSimpleName() without considering inner class prefixes. While this commit introduces a consistent scheme, we still have to resolve some package tangles and improve our design as entity information duplicates parts of JpaPersistentEntity and causing duplicate introspections for JpaEntityInformationSupport. We will have to revisit the design with #4037. Closes #4032

Author: mp911de

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/aot/JpaRepositoryContributor.java

@@ -17,12 +17,14 @@
 
 import jakarta.persistence.EntityManager;
 import jakarta.persistence.EntityManagerFactory;
+import jakarta.persistence.PersistenceUnitUtil;
 import jakarta.persistence.metamodel.Metamodel;
 import jakarta.persistence.spi.PersistenceUnitInfo;
 
 import java.lang.reflect.Method;
 import java.util.Map;
 import java.util.Optional;
+import java.util.function.Function;
 
 import org.jspecify.annotations.Nullable;
 
@@ -32,22 +34,28 @@
 import org.springframework.core.annotation.MergedAnnotation;
 import org.springframework.core.annotation.MergedAnnotations;
 import org.springframework.data.jpa.provider.PersistenceProvider;
+import org.springframework.data.jpa.provider.QueryExtractor;
 import org.springframework.data.jpa.repository.EntityGraph;
 import org.springframework.data.jpa.repository.Modifying;
 import org.springframework.data.jpa.repository.NativeQuery;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.jpa.repository.QueryHints;
+import org.springframework.data.jpa.repository.query.JpaEntityMetadata;
 import org.springframework.data.jpa.repository.query.JpaParameters;
 import org.springframework.data.jpa.repository.query.JpaQueryMethod;
 import org.springframework.data.jpa.repository.query.Procedure;
 import org.springframework.data.jpa.repository.query.QueryEnhancerSelector;
+import org.springframework.data.jpa.repository.support.JpaEntityInformationSupport;
+import org.springframework.data.projection.ProjectionFactory;
 import org.springframework.data.repository.aot.generate.AotRepositoryClassBuilder;
 import org.springframework.data.repository.aot.generate.AotRepositoryConstructorBuilder;
 import org.springframework.data.repository.aot.generate.MethodContributor;
 import org.springframework.data.repository.aot.generate.QueryMetadata;
 import org.springframework.data.repository.aot.generate.RepositoryContributor;
 import org.springframework.data.repository.config.AotRepositoryContext;
+import org.springframework.data.repository.core.RepositoryMetadata;
 import org.springframework.data.repository.core.support.RepositoryFactoryBeanSupport;
+import org.springframework.data.repository.query.ParametersSource;
 import org.springframework.data.repository.query.QueryMethod;
 import org.springframework.data.repository.query.ReturnedType;
 import org.springframework.data.util.TypeInformation;
@@ -70,6 +78,7 @@
 public class JpaRepositoryContributor extends RepositoryContributor {
 
 private final Metamodel metamodel;
+private final PersistenceUnitUtil persistenceUnitUtil;
 private final PersistenceProvider persistenceProvider;
 private final QueriesFactory queriesFactory;
 private final EntityGraphLookup entityGraphLookup;
@@ -88,28 +97,24 @@ public JpaRepositoryContributor(AotRepositoryContext repositoryContext, Persiste
 }
 
 public JpaRepositoryContributor(AotRepositoryContext repositoryContext, EntityManagerFactory entityManagerFactory) {
-this(repositoryContext, entityManagerFactory.getMetamodel(),
-PersistenceProvider.fromEntityManagerFactory(entityManagerFactory),
-new QueriesFactory(repositoryContext.getConfigurationSource(), entityManagerFactory,
-repositoryContext.getRequiredClassLoader()),
-new EntityGraphLookup(entityManagerFactory));
+this(repositoryContext, entityManagerFactory, entityManagerFactory.getMetamodel());
 }
 
 private JpaRepositoryContributor(AotRepositoryContext repositoryContext, AotMetamodel metamodel) {
-this(repositoryContext, metamodel,
-PersistenceProvider.fromEntityManagerFactory(metamodel.getEntityManagerFactory()),
-new QueriesFactory(repositoryContext.getConfigurationSource(), metamodel.getEntityManagerFactory(),
-repositoryContext.getRequiredClassLoader()),
-new EntityGraphLookup(metamodel.getEntityManagerFactory()));
+this(repositoryContext, metamodel.getEntityManagerFactory(), metamodel);
 }
 
-private JpaRepositoryContributor(AotRepositoryContext repositoryContext, Metamodel metamodel,
-PersistenceProvider persistenceProvider, QueriesFactory queriesFactory, EntityGraphLookup entityGraphLookup) {
+private JpaRepositoryContributor(AotRepositoryContext repositoryContext, EntityManagerFactory entityManagerFactory,
+Metamodel metamodel) {
+
 super(repositoryContext);
+
 this.metamodel = metamodel;
-this.persistenceProvider = persistenceProvider;
-this.queriesFactory = queriesFactory;
-this.entityGraphLookup = entityGraphLookup;
+this.persistenceUnitUtil = entityManagerFactory.getPersistenceUnitUtil();
+this.persistenceProvider = PersistenceProvider.fromEntityManagerFactory(entityManagerFactory);
+this.queriesFactory = new QueriesFactory(repositoryContext.getConfigurationSource(), entityManagerFactory,
+repositoryContext.getRequiredClassLoader());
+this.entityGraphLookup = new EntityGraphLookup(entityManagerFactory);
 this.context = repositoryContext;
 }
 
@@ -159,8 +164,10 @@ private Optional<Class<QueryEnhancerSelector>> getQueryEnhancerSelectorClass() {
 @Override
 protected @Nullable MethodContributor<? extends QueryMethod> contributeQueryMethod(Method method) {
 
-JpaQueryMethod queryMethod = new JpaQueryMethod(method, getRepositoryInformation(), getProjectionFactory(),
-persistenceProvider);
+JpaEntityMetadata<?> entityInformation = JpaEntityInformationSupport
+.getEntityInformation(getRepositoryInformation().getDomainType(), metamodel, persistenceUnitUtil);
+AotJpaQueryMethod queryMethod = new AotJpaQueryMethod(method, getRepositoryInformation(), entityInformation,
+getProjectionFactory(), persistenceProvider, JpaParameters::new);
 
 Optional<Class<QueryEnhancerSelector>> queryEnhancerSelectorClass = getQueryEnhancerSelectorClass();
 QueryEnhancerSelector selector = queryEnhancerSelectorClass.map(BeanUtils::instantiateClass)
@@ -271,4 +278,27 @@ public Map<String, Object> serialize() {
 }
 }
 
+/**
+ * AOT extension to {@link JpaQueryMethod} providing a metamodel backed {@link JpaEntityMetadata} object.
+ */
+static class AotJpaQueryMethod extends JpaQueryMethod {
+
+private final JpaEntityMetadata<?> entityMetadata;
+
+public AotJpaQueryMethod(Method method, RepositoryMetadata metadata, JpaEntityMetadata<?> entityMetadata,
+ProjectionFactory factory, QueryExtractor extractor,
+Function<ParametersSource, JpaParameters> parametersFunction) {
+
+super(method, metadata, factory, extractor, parametersFunction);
+
+this.entityMetadata = entityMetadata;
+}
+
+@Override
+public JpaEntityMetadata<?> getEntityInformation() {
+return this.entityMetadata;
+}
+
+}
+
 }

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/aot/QueriesFactory.java

@@ -271,7 +271,8 @@ private AotQueries buildPartTreeQuery(RepositoryInformation repositoryInformatio
 MergedAnnotation<Query> query, JpaQueryMethod queryMethod) {
 
 PartTree partTree = new PartTree(queryMethod.getName(), repositoryInformation.getDomainType());
-AotQuery aotQuery = createQuery(partTree, returnedType, queryMethod.getParameters(), templates);
+AotQuery aotQuery = createQuery(partTree, returnedType, queryMethod.getParameters(), templates,
+queryMethod.getEntityInformation());
 
 if (query.isPresent() && StringUtils.hasText(query.getString("countQuery"))) {
 return AotQueries.from(aotQuery, StringAotQuery.of(DeclaredQuery.jpqlQuery(query.getString("countQuery"))));
@@ -282,27 +283,28 @@ private AotQueries buildPartTreeQuery(RepositoryInformation repositoryInformatio
 createNamedAotQuery(returnedType, selector, queryMethod.getNamedCountQueryName(), queryMethod, false));
 }
 
-AotQuery partTreeCountQuery = createCountQuery(partTree, returnedType, queryMethod.getParameters(), templates);
+AotQuery partTreeCountQuery = createCountQuery(partTree, returnedType, queryMethod.getParameters(), templates,
+queryMethod.getEntityInformation());
 return AotQueries.from(aotQuery, partTreeCountQuery);
 }
 
 private AotQuery createQuery(PartTree partTree, ReturnedType returnedType, JpaParameters parameters,
-JpqlQueryTemplates templates) {
+JpqlQueryTemplates templates, JpaEntityMetadata<?> entityMetadata) {
 
 ParameterMetadataProvider metadataProvider = new ParameterMetadataProvider(parameters, escapeCharacter, templates);
 JpaQueryCreator queryCreator = new JpaQueryCreator(partTree, false, returnedType, metadataProvider, templates,
-metamodel);
+entityMetadata, metamodel);
 
 return StringAotQuery.jpqlQuery(queryCreator.createQuery(), metadataProvider.getBindings(),
 partTree.getResultLimit(), partTree.isDelete(), partTree.isExistsProjection());
 }
 
 private AotQuery createCountQuery(PartTree partTree, ReturnedType returnedType, JpaParameters parameters,
-JpqlQueryTemplates templates) {
+JpqlQueryTemplates templates, JpaEntityMetadata<?> entityMetadata) {
 
 ParameterMetadataProvider metadataProvider = new ParameterMetadataProvider(parameters, escapeCharacter, templates);
 JpaQueryCreator queryCreator = new JpaCountQueryCreator(partTree, returnedType, metadataProvider, templates,
-metamodel);
+entityMetadata, metamodel);
 
 return StringAotQuery.jpqlQuery(queryCreator.createQuery(), metadataProvider.getBindings(), Limit.unlimited(),
 false, false);
@@ -333,7 +335,6 @@ private AotQuery createCountQuery(PartTree partTree, ReturnedType returnedType,
 return returnedType.getReturnedType();
 }
 
-
 return result;
 }
 

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/query/DefaultJpaEntityMetadata.java

@@ -19,6 +19,8 @@
 
 import java.util.function.Function;
 
+import org.jspecify.annotations.Nullable;
+
 import org.springframework.core.annotation.AnnotatedElementUtils;
 import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;
@@ -32,6 +34,7 @@
 public class DefaultJpaEntityMetadata<T> implements JpaEntityMetadata<T> {
 
 private final Class<T> domainType;
+private final @Nullable Entity entity;
 
 /**
  * Creates a new {@link DefaultJpaEntityMetadata} for the given domain type.
@@ -41,7 +44,9 @@ public class DefaultJpaEntityMetadata<T> implements JpaEntityMetadata<T> {
 public DefaultJpaEntityMetadata(Class<T> domainType) {
 
 Assert.notNull(domainType, "Domain type must not be null");
+
 this.domainType = domainType;
+this.entity = AnnotatedElementUtils.findMergedAnnotation(domainType, Entity.class);
 }
 
 @Override
@@ -51,13 +56,20 @@ public Class<T> getJavaType() {
 
 @Override
 public String getEntityName() {
-return getEntityNameOr(Class::getSimpleName);
+return getEntityNameOr(DefaultJpaEntityMetadata::unqualify);
 }
 
-String getEntityNameOr(Function<Class<?>, String> alternative) {
+private String getEntityNameOr(Function<Class<?>, String> alternative) {
+return (entity != null && StringUtils.hasText(entity.name())) ? entity.name() : alternative.apply(domainType);
+}
+
+static String unqualify(Class<?> clazz) {
+return unqualify(clazz.getName());
+}
 
-Entity entity = AnnotatedElementUtils.findMergedAnnotation(domainType, Entity.class);
-return null != entity && StringUtils.hasText(entity.name()) ? entity.name() : alternative.apply(domainType);
+static String unqualify(String qualifiedName) {
+int loc = qualifiedName.lastIndexOf('.');
+return loc < 0 ? qualifiedName : qualifiedName.substring(loc + 1);
 }
 
 }

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/query/JpaCountQueryCreator.java

@@ -34,7 +34,6 @@
 public class JpaCountQueryCreator extends JpaQueryCreator {
 
 private final boolean distinct;
-private final ReturnedType returnedType;
 
 /**
  * Creates a new {@link JpaCountQueryCreator}
@@ -51,7 +50,6 @@ public JpaCountQueryCreator(PartTree tree, ReturnedType returnedType, ParameterM
 super(tree, returnedType, provider, templates, em.getMetamodel());
 
 this.distinct = tree.isDistinct();
-this.returnedType = returnedType;
 }
 
 /**
@@ -69,12 +67,21 @@ public JpaCountQueryCreator(PartTree tree, ReturnedType returnedType, ParameterM
 super(tree, returnedType, provider, templates, metamodel);
 
 this.distinct = tree.isDistinct();
-this.returnedType = returnedType;
+}
+
+public JpaCountQueryCreator(PartTree tree, ReturnedType returnedType, ParameterMetadataProvider provider,
+JpqlQueryTemplates templates, JpaEntityMetadata<?> entityMetadata, Metamodel metamodel) {
+
+super(tree, false, returnedType, provider, templates, entityMetadata, metamodel);
+
+this.distinct = tree.isDistinct();
 }
 
 @Override
 protected JpqlQueryBuilder.Select buildQuery(Sort sort) {
-JpqlQueryBuilder.SelectStep selectStep = JpqlQueryBuilder.selectFrom(returnedType.getDomainType());
+
+JpqlQueryBuilder.SelectStep selectStep = JpqlQueryBuilder.selectFrom(getEntity());
+
 if (this.distinct) {
 selectStep = selectStep.distinct();
 }

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/query/JpaKeysetScrollQueryCreator.java

@@ -16,6 +16,7 @@
 package org.springframework.data.jpa.repository.query;
 
 import jakarta.persistence.EntityManager;
+import jakarta.persistence.metamodel.Metamodel;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -40,6 +41,7 @@
  */
 class JpaKeysetScrollQueryCreator extends JpaQueryCreator {
 
+private final Metamodel metamodel;
 private final JpaEntityInformation<?, ?> entityInformation;
 private final KeysetScrollPosition scrollPosition;
 private final ParameterMetadataProvider provider;
@@ -49,8 +51,9 @@ public JpaKeysetScrollQueryCreator(PartTree tree, ReturnedType type, ParameterMe
 JpqlQueryTemplates templates, JpaEntityInformation<?, ?> entityInformation, KeysetScrollPosition scrollPosition,
 EntityManager em) {
 
-super(tree, type, provider, templates, em.getMetamodel());
+super(tree, false, type, provider, templates, entityInformation, em.getMetamodel());
 
+this.metamodel = em.getMetamodel();
 this.entityInformation = entityInformation;
 this.scrollPosition = scrollPosition;
 this.provider = provider;
@@ -76,7 +79,7 @@ protected JpqlQueryBuilder.AbstractJpqlQuery createQuery(JpqlQueryBuilder.@Nulla
 JpqlQueryBuilder.Select query = buildQuery(keysetSpec.sort());
 
 Map<String, Map<Object, ParameterBinding>> cachedBindings = new LinkedHashMap<>();
-JpqlQueryBuilder.Predicate keysetPredicate = keysetSpec.createJpqlPredicate(getFrom(), getEntity(),
+JpqlQueryBuilder.Predicate keysetPredicate = keysetSpec.createJpqlPredicate(metamodel, getFrom(), getEntity(),
 (property, value) -> {
 
 Map<Object, ParameterBinding> bindings = cachedBindings.computeIfAbsent(property, k -> new LinkedHashMap<>());

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/query/JpaMetamodelEntityMetadata.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2013-2025 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.jpa.repository.query;
+
+import jakarta.persistence.metamodel.EntityType;
+
+import org.springframework.util.Assert;
+
+/**
+ * Metamodel-based implementation for {@link JpaEntityMetadata}.
+ *
+ * @author Mark Paluch
+ * @since 4.0
+ */
+public class JpaMetamodelEntityMetadata<T> implements JpaEntityMetadata<T> {
+
+private final EntityType<T> entityType;
+
+/**
+ * Creates a new {@link JpaMetamodelEntityMetadata} for the given domain type.
+ *
+ * @param entityType must not be {@literal null}.
+ */
+public JpaMetamodelEntityMetadata(EntityType<T> entityType) {
+
+Assert.notNull(entityType, "Entity type must not be null");
+this.entityType = entityType;
+}
+
+@Override
+public Class<T> getJavaType() {
+return entityType.getJavaType();
+}
+
+@Override
+public String getEntityName() {
+return entityType.getName();
+}
+
+}

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/query/JpaQueryCreator.java

@@ -115,8 +115,15 @@ public JpaQueryCreator(PartTree tree, ReturnedType type, ParameterMetadataProvid
 this(tree, false, type, provider, templates, metamodel);
 }
 
+@SuppressWarnings({ "rawtypes", "unchecked" })
 public JpaQueryCreator(PartTree tree, boolean searchQuery, ReturnedType type, ParameterMetadataProvider provider,
 JpqlQueryTemplates templates, Metamodel metamodel) {
+this(tree, searchQuery, type, provider, templates,
+new JpaMetamodelEntityMetadata(metamodel.entity(type.getDomainType())), metamodel);
+}
+
+public JpaQueryCreator(PartTree tree, boolean searchQuery, ReturnedType type, ParameterMetadataProvider provider,
+JpqlQueryTemplates templates, JpaEntityMetadata<?> entityMetadata, Metamodel metamodel) {
 
 super(tree);
 
@@ -144,7 +151,7 @@ public JpaQueryCreator(PartTree tree, boolean searchQuery, ReturnedType type, Pa
 this.templates = templates;
 this.escape = provider.getEscape();
 this.entityType = metamodel.entity(type.getDomainType());
-this.entity = JpqlQueryBuilder.entity(returnedType.getDomainType());
+this.entity = JpqlQueryBuilder.entity(entityMetadata);
 this.metamodel = metamodel;
 this.similarityNormalizer = provider.getSimilarityNormalizer();
 }