Skip to content

Commit d04055d

Browse files
mp911dechristophstrobl
mp911de
authored and
christophstrobl
committed
Avoid repeated creation of EntityManagerFactory in AOT repository generation.
We use now a cached variant by deferring EntityManagerFactory creation. Closes: #4068 Original Pull Request: #4071
1 parent 4446026 commit d04055d

File tree

5 files changed

+170
-44
lines changed

5 files changed

+170
-44
lines changed

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

Lines changed: 144 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,144 @@
1+
/*
2+
* Copyright 2025 the original author or authors.
3+
*
4+
* Licensed under the Apache License, Version 2.0 (the "License");
5+
* you may not use this file except in compliance with the License.
6+
* You may obtain a copy of the License at
7+
*
8+
* https://www.apache.org/licenses/LICENSE-2.0
9+
*
10+
* Unless required by applicable law or agreed to in writing, software
11+
* distributed under the License is distributed on an "AS IS" BASIS,
12+
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13+
* See the License for the specific language governing permissions and
14+
* limitations under the License.
15+
*/
16+
package org.springframework.data.jpa.repository.aot;
17+
18+
import jakarta.persistence.Converter;
19+
import jakarta.persistence.Embeddable;
20+
import jakarta.persistence.Entity;
21+
import jakarta.persistence.EntityManagerFactory;
22+
import jakarta.persistence.MappedSuperclass;
23+
import jakarta.persistence.spi.PersistenceUnitInfo;
24+
25+
import java.util.List;
26+
import java.util.function.Supplier;
27+
28+
import org.springframework.data.repository.config.AotRepositoryContext;
29+
import org.springframework.data.util.Lazy;
30+
import org.springframework.orm.jpa.persistenceunit.PersistenceManagedTypes;
31+
import org.springframework.util.ObjectUtils;
32+
33+
/**
34+
* Wrapper for {@link EntityManagerFactory}. The wrapper object implements equality checks based on its creation
35+
* arguments and can be conveniently used as cache key.
36+
* <p>
37+
* Factory methods provide ways to create instances based on provided {@link EntityManagerFactory} or contextual holders
38+
* to extract managed types and create an in-memory {@link EntityManagerFactory} variant for metamodel introspection
39+
* during AOT processing.
40+
*
41+
* @author Mark Paluch
42+
* @since 4.0
43+
*/
44+
public class AotEntityManagerFactoryCreator {
45+
46+
private final Supplier<EntityManagerFactory> factory;
47+
private final Object key;
48+
49+
private AotEntityManagerFactoryCreator(Supplier<EntityManagerFactory> factory, Object key) {
50+
this.factory = Lazy.of(factory);
51+
this.key = key;
52+
}
53+
54+
/**
55+
* Create a {@code PersistenceUnitContext} from the given {@link AotRepositoryContext} using Jakarta
56+
* Persistence-annotated classes.
57+
* <p>
58+
* The underlying {@link jakarta.persistence.metamodel.Metamodel} requires Hibernate to build metamodel information.
59+
*
60+
* @param repositoryContext repository context providing classes.
61+
*/
62+
public static AotEntityManagerFactoryCreator from(AotRepositoryContext repositoryContext) {
63+
64+
List<String> typeNames = repositoryContext.getResolvedTypes().stream()
65+
.filter(AotEntityManagerFactoryCreator::isJakartaAnnotated).map(Class::getName).toList();
66+
67+
return from(PersistenceManagedTypes.of(typeNames, List.of()), typeNames);
68+
}
69+
70+
/**
71+
* Create a {@code PersistenceUnitContext} from the given {@link PersistenceUnitInfo}.
72+
* <p>
73+
* The underlying {@link jakarta.persistence.metamodel.Metamodel} requires Hibernate to build metamodel information.
74+
*
75+
* @param persistenceUnitInfo persistence unit info to use.
76+
*/
77+
public static AotEntityManagerFactoryCreator from(PersistenceUnitInfo persistenceUnitInfo) {
78+
return from(() -> new AotMetamodel(persistenceUnitInfo), persistenceUnitInfo);
79+
}
80+
81+
/**
82+
* Create a {@code PersistenceUnitContext} from the given {@link PersistenceManagedTypes}.
83+
* <p>
84+
* The underlying {@link jakarta.persistence.metamodel.Metamodel} requires Hibernate to build metamodel information.
85+
*
86+
* @param managedTypes managed types to use.
87+
*/
88+
public static AotEntityManagerFactoryCreator from(PersistenceManagedTypes managedTypes) {
89+
return from(managedTypes, managedTypes);
90+
}
91+
92+
private static AotEntityManagerFactoryCreator from(PersistenceManagedTypes managedTypes, Object cacheKey) {
93+
return from(() -> new AotMetamodel(managedTypes), cacheKey);
94+
}
95+
96+
/**
97+
* Create a {@code PersistenceUnitContext} from the given {@link EntityManagerFactory}.
98+
*
99+
* @param entityManagerFactory the entity manager factory to use.
100+
*/
101+
public static AotEntityManagerFactoryCreator just(EntityManagerFactory entityManagerFactory) {
102+
return new AotEntityManagerFactoryCreator(() -> entityManagerFactory, entityManagerFactory.getMetamodel());
103+
}
104+
105+
private static AotEntityManagerFactoryCreator from(Supplier<? extends AotMetamodel> metamodel, Object key) {
106+
return new AotEntityManagerFactoryCreator(() -> metamodel.get().getEntityManagerFactory(), key);
107+
}
108+
109+
private static boolean isJakartaAnnotated(Class<?> cls) {
110+
111+
return cls.isAnnotationPresent(Entity.class) //
112+
|| cls.isAnnotationPresent(Embeddable.class) //
113+
|| cls.isAnnotationPresent(MappedSuperclass.class) //
114+
|| cls.isAnnotationPresent(Converter.class);
115+
}
116+
117+
/**
118+
* Return the {@link EntityManagerFactory}.
119+
*
120+
* @return the entity manager factory to use during AOT processing.
121+
*/
122+
public EntityManagerFactory getEntityManagerFactory() {
123+
return factory.get();
124+
}
125+
126+
@Override
127+
public boolean equals(Object o) {
128+
if (!(o instanceof AotEntityManagerFactoryCreator that)) {
129+
return false;
130+
}
131+
return ObjectUtils.nullSafeEquals(key, that.key);
132+
}
133+
134+
@Override
135+
public int hashCode() {
136+
return ObjectUtils.nullSafeHashCode(key);
137+
}
138+
139+
@Override
140+
public String toString() {
141+
return "AotEntityManagerFactory{" + key + '}';
142+
}
143+
144+
}

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

Lines changed: 1 addition & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -37,7 +37,7 @@
3737
import org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl;
3838
import org.hibernate.jpa.boot.internal.PersistenceUnitInfoDescriptor;
3939
import org.jspecify.annotations.Nullable;
40-
import org.springframework.data.repository.config.AotRepositoryContext;
40+
4141
import org.springframework.data.util.Lazy;
4242
import org.springframework.orm.jpa.persistenceunit.PersistenceManagedTypes;
4343
import org.springframework.orm.jpa.persistenceunit.SpringPersistenceUnitInfo;
@@ -55,19 +55,6 @@ class AotMetamodel implements Metamodel {
5555
private final Lazy<EntityManagerFactory> entityManagerFactory;
5656
private final Lazy<EntityManager> entityManager = Lazy.of(() -> getEntityManagerFactory().createEntityManager());
5757

58-
public AotMetamodel(AotRepositoryContext repositoryContext) {
59-
this(repositoryContext.getResolvedTypes().stream().filter(AotMetamodel::isJakartaAnnotated).map(Class::getName)
60-
.toList(), null);
61-
}
62-
63-
private static boolean isJakartaAnnotated(Class<?> cls) {
64-
65-
return cls.isAnnotationPresent(jakarta.persistence.Entity.class)
66-
|| cls.isAnnotationPresent(jakarta.persistence.Embeddable.class)
67-
|| cls.isAnnotationPresent(jakarta.persistence.MappedSuperclass.class)
68-
|| cls.isAnnotationPresent(jakarta.persistence.Converter.class);
69-
}
70-
7158
public AotMetamodel(PersistenceManagedTypes managedTypes) {
7259
this(managedTypes.getManagedClassNames(), managedTypes.getPersistenceUnitRootUrl());
7360
}

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

Lines changed: 11 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,6 @@
1919
import jakarta.persistence.EntityManagerFactory;
2020
import jakarta.persistence.PersistenceUnitUtil;
2121
import jakarta.persistence.metamodel.Metamodel;
22-
import jakarta.persistence.spi.PersistenceUnitInfo;
2322

2423
import java.lang.reflect.Method;
2524
import java.util.Map;
@@ -61,7 +60,6 @@
6160
import org.springframework.data.repository.query.ReturnedType;
6261
import org.springframework.javapoet.CodeBlock;
6362
import org.springframework.javapoet.TypeName;
64-
import org.springframework.orm.jpa.persistenceunit.PersistenceManagedTypes;
6563
import org.springframework.util.ClassUtils;
6664
import org.springframework.util.StringUtils;
6765

@@ -77,39 +75,24 @@
7775
*/
7876
public class JpaRepositoryContributor extends RepositoryContributor {
7977

78+
private final AotRepositoryContext context;
79+
private final EntityManagerFactory entityManagerFactory;
8080
private final Metamodel metamodel;
8181
private final PersistenceUnitUtil persistenceUnitUtil;
8282
private final PersistenceProvider persistenceProvider;
8383
private final QueriesFactory queriesFactory;
8484
private final EntityGraphLookup entityGraphLookup;
85-
private final AotRepositoryContext context;
8685

8786
public JpaRepositoryContributor(AotRepositoryContext repositoryContext) {
88-
this(repositoryContext, new AotMetamodel(repositoryContext));
89-
}
90-
91-
public JpaRepositoryContributor(AotRepositoryContext repositoryContext, PersistenceUnitInfo unitInfo) {
92-
this(repositoryContext, new AotMetamodel(unitInfo));
93-
}
94-
95-
public JpaRepositoryContributor(AotRepositoryContext repositoryContext, PersistenceManagedTypes managedTypes) {
96-
this(repositoryContext, new AotMetamodel(managedTypes));
87+
this(repositoryContext, AotEntityManagerFactoryCreator.from(repositoryContext).getEntityManagerFactory());
9788
}
9889

9990
public JpaRepositoryContributor(AotRepositoryContext repositoryContext, EntityManagerFactory entityManagerFactory) {
100-
this(repositoryContext, entityManagerFactory, entityManagerFactory.getMetamodel());
101-
}
102-
103-
private JpaRepositoryContributor(AotRepositoryContext repositoryContext, AotMetamodel metamodel) {
104-
this(repositoryContext, metamodel.getEntityManagerFactory(), metamodel);
105-
}
106-
107-
private JpaRepositoryContributor(AotRepositoryContext repositoryContext, EntityManagerFactory entityManagerFactory,
108-
Metamodel metamodel) {
10991

11092
super(repositoryContext);
11193

112-
this.metamodel = metamodel;
94+
this.entityManagerFactory = entityManagerFactory;
95+
this.metamodel = entityManagerFactory.getMetamodel();
11396
this.persistenceUnitUtil = entityManagerFactory.getPersistenceUnitUtil();
11497
this.persistenceProvider = PersistenceProvider.fromEntityManagerFactory(entityManagerFactory);
11598
this.queriesFactory = new QueriesFactory(repositoryContext.getConfigurationSource(), entityManagerFactory,
@@ -118,6 +101,10 @@ private JpaRepositoryContributor(AotRepositoryContext repositoryContext, EntityM
118101
this.context = repositoryContext;
119102
}
120103

104+
public EntityManagerFactory getEntityManagerFactory() {
105+
return entityManagerFactory;
106+
}
107+
121108
@Override
122109
protected void customizeClass(AotRepositoryClassBuilder classBuilder) {
123110
classBuilder.customize(builder -> builder.superclass(TypeName.get(AotRepositoryFragmentSupport.class)));
@@ -258,16 +245,13 @@ private Optional<Class<QueryEnhancerSelector>> getQueryEnhancerSelectorClass() {
258245
});
259246
}
260247

261-
public Metamodel getMetamodel() {
262-
return metamodel;
263-
}
264-
265248
record StoredProcedureMetadata(String procedure) implements QueryMetadata {
266249

267250
@Override
268251
public Map<String, Object> serialize() {
269252
return Map.of("procedure", procedure());
270253
}
254+
271255
}
272256

273257
record NamedStoredProcedureMetadata(String procedureName) implements QueryMetadata {
@@ -276,6 +260,7 @@ record NamedStoredProcedureMetadata(String procedureName) implements QueryMetada
276260
public Map<String, Object> serialize() {
277261
return Map.of("procedure-name", procedureName());
278262
}
263+
279264
}
280265

281266
/**

‎spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/config/JpaRepositoryConfigExtension.java‎

Lines changed: 13 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -60,6 +60,7 @@
6060
import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
6161
import org.springframework.data.aot.AotContext;
6262
import org.springframework.data.jpa.repository.JpaRepository;
63+
import org.springframework.data.jpa.repository.aot.AotEntityManagerFactoryCreator;
6364
import org.springframework.data.jpa.repository.aot.JpaRepositoryContributor;
6465
import org.springframework.data.jpa.repository.support.DefaultJpaContext;
6566
import org.springframework.data.jpa.repository.support.JpaEvaluationContextExtension;
@@ -75,6 +76,7 @@
7576
import org.springframework.orm.jpa.persistenceunit.PersistenceManagedTypes;
7677
import org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor;
7778
import org.springframework.util.ClassUtils;
79+
import org.springframework.util.ConcurrentLruCache;
7880
import org.springframework.util.ObjectUtils;
7981
import org.springframework.util.StringUtils;
8082

@@ -378,6 +380,9 @@ public static class JpaRepositoryRegistrationAotProcessor extends RepositoryRegi
378380

379381
private static final String MODULE_NAME = "jpa";
380382

383+
private final ConcurrentLruCache<AotEntityManagerFactoryCreator, EntityManagerFactory> factoryCache = new ConcurrentLruCache<>(
384+
16, AotEntityManagerFactoryCreator::getEntityManagerFactory);
385+
381386
@Override
382387
protected void configureTypeContributions(AotRepositoryContext repositoryContext,
383388
GenerationContext generationContext) {
@@ -421,7 +426,7 @@ protected void configureTypeContribution(Class<?> type, AotContext aotContext) {
421426
if (managedTypes != null) {
422427

423428
log.debug("Using PersistenceManagedTypes for AOT repository generation");
424-
return new JpaRepositoryContributor(repositoryContext, managedTypes);
429+
return contribute(repositoryContext, AotEntityManagerFactoryCreator.from(managedTypes));
425430
}
426431

427432
ObjectProvider<PersistenceUnitInfo> infoProvider = beanFactory.getBeanProvider(PersistenceUnitInfo.class);
@@ -430,11 +435,16 @@ protected void configureTypeContribution(Class<?> type, AotContext aotContext) {
430435
if (unitInfo != null) {
431436

432437
log.debug("Using PersistenceUnitInfo for AOT repository generation");
433-
return new JpaRepositoryContributor(repositoryContext, unitInfo);
438+
return contribute(repositoryContext, AotEntityManagerFactoryCreator.from(unitInfo));
434439
}
435440

436441
log.debug("Using scanned types for AOT repository generation");
437-
return new JpaRepositoryContributor(repositoryContext);
442+
return contribute(repositoryContext, AotEntityManagerFactoryCreator.from(repositoryContext));
443+
}
444+
445+
private JpaRepositoryContributor contribute(AotRepositoryContext repositoryContext,
446+
AotEntityManagerFactoryCreator factory) {
447+
return new JpaRepositoryContributor(repositoryContext, factoryCache.get(factory));
438448
}
439449

440450
}

‎spring-data-jpa/src/test/java/org/springframework/data/jpa/repository/config/JpaRepositoryRegistrationAotProcessorUnitTests.java‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -131,7 +131,7 @@ public List<String> getManagedPackages() {
131131
JpaRepositoryContributor contributor = new JpaRepositoryConfigExtension.JpaRepositoryRegistrationAotProcessor()
132132
.contributeAotRepository(new DummyAotRepositoryContext(context));
133133

134-
assertThat(contributor.getMetamodel().managedType(Person.class)).isNotNull();
134+
assertThat(contributor.getEntityManagerFactory().getMetamodel().managedType(Person.class)).isNotNull();
135135
}
136136

137137
@Test // GH-3899

0 commit comments

Comments
 (0)