Add support for AOT repositories.

Closes #3830

Author: christophstrobl

pom.xml

@@ -145,6 +145,11 @@
 			<version>${spring}</version>
 			<scope>provided</scope>
 		</dependency>
+		<dependency>
+			<groupId>org.jboss.logging</groupId>
+			<artifactId>jboss-logging</artifactId>
+			<version>3.6.1.Final</version>
+		</dependency>
 	</dependencies>
 
 	<build>

spring-data-envers/pom.xml

@@ -60,6 +60,12 @@
 			<version>${project.version}</version>
 		</dependency>
 
+		<dependency>
+			<groupId>org.jboss.logging</groupId>
+			<artifactId>jboss-logging</artifactId>
+			<version>3.6.1.Final</version>
+		</dependency>
+
 		<!-- Hibernate -->
 		<dependency>
 			<groupId>org.hibernate.orm</groupId>

spring-data-jpa/pom.xml

@@ -88,12 +88,16 @@
 			<optional>true</optional>
 		</dependency>
 
+        <dependency>
+            <groupId>org.junit.platform</groupId>
+            <artifactId>junit-platform-launcher</artifactId>
+            <scope>test</scope>
+        </dependency>
 		<dependency>
-			<groupId>org.junit.platform</groupId>
-			<artifactId>junit-platform-launcher</artifactId>
+			<groupId>org.springframework</groupId>
+			<artifactId>spring-core-test</artifactId>
 			<scope>test</scope>
 		</dependency>
-
 		<dependency>
 			<groupId>org.hsqldb</groupId>
 			<artifactId>hsqldb</artifactId>
@@ -239,6 +243,12 @@
 			<optional>true</optional>
 		</dependency>
 
+		<dependency>
+			<groupId>org.jboss.logging</groupId>
+			<artifactId>jboss-logging</artifactId>
+			<version>3.6.1.Final</version>
+		</dependency>
+
 	</dependencies>
 
 	<build>
@@ -370,6 +380,11 @@
 							<artifactId>jakarta.persistence-api</artifactId>
 							<version>${jakarta-persistence-api}</version>
 						</path>
+						<path>
+							<groupId>org.jboss.logging</groupId>
+							<artifactId>jboss-logging</artifactId>
+							<version>3.6.1.Final</version>
+						</path>
 					</annotationProcessorPaths>
 				</configuration>
 			</plugin>

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

@@ -0,0 +1,124 @@
+/*
+ * Copyright 2024-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.aot.generated;
+
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityManagerFactory;
+import jakarta.persistence.metamodel.EmbeddableType;
+import jakarta.persistence.metamodel.EntityType;
+import jakarta.persistence.metamodel.ManagedType;
+import jakarta.persistence.metamodel.Metamodel;
+import jakarta.persistence.spi.ClassTransformer;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.hibernate.jpa.HibernatePersistenceProvider;
+import org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl;
+import org.hibernate.jpa.boot.internal.PersistenceUnitInfoDescriptor;
+import org.springframework.data.util.Lazy;
+import org.springframework.instrument.classloading.SimpleThrowawayClassLoader;
+import org.springframework.orm.jpa.persistenceunit.MutablePersistenceUnitInfo;
+
+/**
+ * @author Christoph Strobl
+ */
+public class AotMetaModel implements Metamodel {
+
+	private final String persistenceUnit;
+	private final Set<Class<?>> managedTypes;
+	private final Lazy<EntityManagerFactory> entityManagerFactory = Lazy.of(this::init);
+	private final Lazy<Metamodel> metamodel = Lazy.of(() -> entityManagerFactory.get().getMetamodel());
+	private final Lazy<EntityManager> entityManager = Lazy.of(() -> entityManagerFactory.get().createEntityManager());
+
+	public AotMetaModel(Set<Class<?>> managedTypes) {
+		this("dynamic-tests", managedTypes);
+	}
+
+	private AotMetaModel(String persistenceUnit, Set<Class<?>> managedTypes) {
+		this.persistenceUnit = persistenceUnit;
+		this.managedTypes = managedTypes;
+	}
+
+	public static AotMetaModel hibernateModel(Class<?>... types) {
+		return new AotMetaModel(Set.of(types));
+	}
+
+	public static AotMetaModel hibernateModel(String persistenceUnit, Class<?>... types) {
+		return new AotMetaModel(persistenceUnit, Set.of(types));
+	}
+
+	public <X> EntityType<X> entity(Class<X> cls) {
+		return metamodel.get().entity(cls);
+	}
+
+	@Override
+	public EntityType<?> entity(String s) {
+		return metamodel.get().entity(s);
+	}
+
+	public <X> ManagedType<X> managedType(Class<X> cls) {
+		return metamodel.get().managedType(cls);
+	}
+
+	public <X> EmbeddableType<X> embeddable(Class<X> cls) {
+		return metamodel.get().embeddable(cls);
+	}
+
+	public Set<ManagedType<?>> getManagedTypes() {
+		return metamodel.get().getManagedTypes();
+	}
+
+	public Set<EntityType<?>> getEntities() {
+		return metamodel.get().getEntities();
+	}
+
+	public Set<EmbeddableType<?>> getEmbeddables() {
+		return metamodel.get().getEmbeddables();
+	}
+
+	public EntityManager entityManager() {
+		return entityManager.get();
+	}
+
+	EntityManagerFactory init() {
+
+		MutablePersistenceUnitInfo persistenceUnitInfo = new MutablePersistenceUnitInfo() {
+			@Override
+			public ClassLoader getNewTempClassLoader() {
+				return new SimpleThrowawayClassLoader(this.getClass().getClassLoader());
+			}
+
+			@Override
+			public void addTransformer(ClassTransformer classTransformer) {
+				// just ingnore it
+			}
+		};
+
+		persistenceUnitInfo.setPersistenceUnitName(persistenceUnit);
+		this.managedTypes.stream().map(Class::getName).forEach(persistenceUnitInfo::addManagedClassName);
+
+		persistenceUnitInfo.setPersistenceProviderClassName(HibernatePersistenceProvider.class.getName());
+
+		return new EntityManagerFactoryBuilderImpl(new PersistenceUnitInfoDescriptor(persistenceUnitInfo) {
+			@Override
+			public List<String> getManagedClassNames() {
+				return persistenceUnitInfo.getManagedClassNames();
+			}
+		}, Map.of("hibernate.dialect", "org.hibernate.dialect.H2Dialect")).build();
+	}
+}

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

@@ -0,0 +1,62 @@
+/*
+ * Copyright 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
+ *
+ *      http://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.aot.generated;
+
+import jakarta.persistence.metamodel.Metamodel;
+
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.jpa.repository.query.EscapeCharacter;
+import org.springframework.data.jpa.repository.query.JpaParameters;
+import org.springframework.data.jpa.repository.query.JpaQueryCreator;
+import org.springframework.data.jpa.repository.query.ParameterMetadataProvider;
+import org.springframework.data.jpa.repository.support.JpqlQueryTemplates;
+import org.springframework.data.repository.aot.generate.AotRepositoryMethodGenerationContext;
+import org.springframework.data.repository.query.ParametersSource;
+import org.springframework.data.repository.query.ReturnedType;
+import org.springframework.data.repository.query.parser.PartTree;
+
+/**
+ * @author Christoph Strobl
+ * @since 2025/01
+ */
+public class AotQueryCreator {
+
+	Metamodel metamodel;
+
+	public AotQueryCreator(Metamodel metamodel) {
+		this.metamodel = metamodel;
+	}
+
+	AotStringQuery createQuery(PartTree partTree, ReturnedType returnedType,
+			AotRepositoryMethodGenerationContext context) {
+
+		ParametersSource parametersSource = ParametersSource.of(context.getRepositoryInformation(), context.getMethod());
+		JpaParameters parameters = new JpaParameters(parametersSource);
+		ParameterMetadataProvider metadataProvider = new ParameterMetadataProvider(parameters, EscapeCharacter.DEFAULT,
+				JpqlQueryTemplates.UPPER);
+
+		JpaQueryCreator queryCreator = new JpaQueryCreator(partTree, returnedType, metadataProvider,
+				JpqlQueryTemplates.UPPER, metamodel);
+		AotStringQuery query = AotStringQuery.bindable(queryCreator.createQuery(), metadataProvider.getBindings());
+
+		if (partTree.isLimiting()) {
+			query.setLimit(partTree.getResultLimit());
+		}
+		query.setCountQuery(context.annotationValue(Query.class, "countQuery"));
+		return query;
+	}
+
+}

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

@@ -0,0 +1,106 @@
+/*
+ * Copyright 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.aot.generated;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.springframework.data.domain.Limit;
+import org.springframework.data.jpa.repository.query.ParameterBinding;
+import org.springframework.data.jpa.repository.query.ParameterBindingParser;
+import org.springframework.data.jpa.repository.query.ParameterBindingParser.Metadata;
+import org.springframework.data.jpa.repository.query.QueryUtils;
+import org.springframework.lang.Nullable;
+import org.springframework.util.StringUtils;
+
+/**
+ * @author Christoph Strobl
+ * @since 2025/01
+ */
+class AotStringQuery {
+
+	private final String raw;
+	private final String sanitized;
+	private @Nullable String countQuery;
+	private final List<ParameterBinding> parameterBindings;
+	private final Metadata parameterMetadata;
+	private Limit limit;
+	private boolean nativeQuery;
+
+	public AotStringQuery(String raw, String sanitized, List<ParameterBinding> parameterBindings,
+			Metadata parameterMetadata) {
+		this.raw = raw;
+		this.sanitized = sanitized;
+		this.parameterBindings = parameterBindings;
+		this.parameterMetadata = parameterMetadata;
+	}
+
+	static AotStringQuery of(String raw) {
+
+		List<ParameterBinding> bindings = new ArrayList<>();
+		Metadata metadata = new Metadata();
+		String targetQuery = ParameterBindingParser.INSTANCE
+				.parseParameterBindingsOfQueryIntoBindingsAndReturnCleanedQuery(raw, bindings, metadata);
+
+		return new AotStringQuery(raw, targetQuery, bindings, metadata);
+	}
+
+	static AotStringQuery nativeQuery(String raw) {
+		AotStringQuery q = of(raw);
+		q.nativeQuery = true;
+		return q;
+	}
+
+	static AotStringQuery bindable(String query, List<ParameterBinding> bindings) {
+		return new AotStringQuery(query, query, bindings, new Metadata());
+	}
+
+	public String getQueryString() {
+		return sanitized;
+	}
+
+	public String getCountQuery(@Nullable String projection) {
+
+		if (StringUtils.hasText(countQuery)) {
+			return countQuery;
+		}
+		return QueryUtils.createCountQueryFor(sanitized, StringUtils.hasText(projection) ? projection : null, nativeQuery);
+	}
+
+	public List<ParameterBinding> parameterBindings() {
+		return this.parameterBindings;
+	}
+
+	boolean isLimited() {
+		return limit != null && limit.isLimited();
+	}
+
+	Limit getLimit() {
+		return limit;
+	}
+
+	public void setLimit(Limit limit) {
+		this.limit = limit;
+	}
+
+	public boolean isNativeQuery() {
+		return nativeQuery;
+	}
+
+	public void setCountQuery(@Nullable String countQuery) {
+		this.countQuery = StringUtils.hasText(countQuery) ? countQuery : null;
+	}
+}