Skip to content

Commit d7551cb

Browse files
yrodiereyrodiere
committed
HHH-18976 Get rid of dynamic array instantiations used only to resolve type descriptors
1 parent 06cbf3b commit d7551cb

File tree

7 files changed

+67
-58
lines changed

7 files changed

+67
-58
lines changed

‎hibernate-core/src/main/java/org/hibernate/loader/ast/internal/CollectionBatchLoaderArrayParam.java‎

Lines changed: 2 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -51,7 +51,6 @@ public class CollectionBatchLoaderArrayParam
5151
private final SelectStatement sqlSelect;
5252
private final JdbcOperationQuerySelect jdbcSelectOperation;
5353

54-
@AllowReflection
5554
public CollectionBatchLoaderArrayParam(
5655
int domainBatchSize,
5756
LoadQueryInfluencers loadQueryInfluencers,
@@ -69,13 +68,12 @@ public CollectionBatchLoaderArrayParam(
6968

7069
final ForeignKeyDescriptor keyDescriptor = getLoadable().getKeyDescriptor();
7170
final JdbcMapping jdbcMapping = keyDescriptor.getSingleJdbcMapping();
72-
final Class<?> jdbcArrayClass = Array.newInstance( jdbcMapping.getJdbcJavaType().getJavaTypeClass(), 0 )
73-
.getClass();
71+
final Class<?> jdbcJavaTypeClass = jdbcMapping.getJdbcJavaType().getJavaTypeClass();
7472
keyDomainType = getKeyType( keyDescriptor.getKeyPart() );
7573

7674
arrayJdbcMapping = MultiKeyLoadHelper.resolveArrayJdbcMapping(
7775
jdbcMapping,
78-
jdbcArrayClass,
76+
jdbcJavaTypeClass,
7977
getSessionFactory()
8078
);
8179

‎hibernate-core/src/main/java/org/hibernate/loader/ast/internal/EntityBatchLoaderArrayParam.java‎

Lines changed: 2 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -59,7 +59,6 @@ public class EntityBatchLoaderArrayParam<T>
5959
* {@link EntityIdentifierMapping} is not available at that time. On first use, we know we
6060
* have it available
6161
*/
62-
@AllowReflection
6362
public EntityBatchLoaderArrayParam(
6463
int domainBatchSize,
6564
EntityMappingType entityDescriptor,
@@ -77,11 +76,10 @@ public EntityBatchLoaderArrayParam(
7776
}
7877

7978
identifierMapping = (BasicEntityIdentifierMapping) getLoadable().getIdentifierMapping();
80-
final Class<?> arrayClass =
81-
Array.newInstance( identifierMapping.getJavaType().getJavaTypeClass(), 0 ).getClass();
79+
final Class<?> idClass = identifierMapping.getJavaType().getJavaTypeClass();
8280
arrayJdbcMapping = MultiKeyLoadHelper.resolveArrayJdbcMapping(
8381
identifierMapping.getJdbcMapping(),
84-
arrayClass,
82+
idClass,
8583
sessionFactory
8684
);
8785

‎hibernate-core/src/main/java/org/hibernate/loader/ast/internal/MultiIdEntityLoaderArrayParam.java‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -49,10 +49,10 @@ public MultiIdEntityLoaderArrayParam(
4949
EntityMappingType entityDescriptor,
5050
SessionFactoryImplementor sessionFactory) {
5151
super( entityDescriptor, sessionFactory );
52-
final Class<?> idArrayClass = idArray.getClass();
52+
final Class<?> idClass = idArray.getClass().getComponentType();
5353
arrayJdbcMapping = resolveArrayJdbcMapping(
5454
getIdentifierMapping().getJdbcMapping(),
55-
idArrayClass,
55+
idClass,
5656
getSessionFactory()
5757
);
5858
jdbcParameter = new JdbcParameterImpl( arrayJdbcMapping );

‎hibernate-core/src/main/java/org/hibernate/loader/ast/internal/MultiKeyLoadHelper.java‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -28,20 +28,20 @@ public static boolean supportsSqlArrayType(Dialect dialect) {
2828

2929
public static JdbcMapping resolveArrayJdbcMapping(
3030
JdbcMapping keyMapping,
31-
Class<?> arrayClass,
31+
Class<?> elementClass,
3232
SessionFactoryImplementor sessionFactory) {
3333
BasicType<?> arrayBasicType = sessionFactory.getTypeConfiguration().getBasicTypeRegistry()
34-
.getRegisteredType( arrayClass );
34+
.getRegisteredArrayType( elementClass );
3535
if ( arrayBasicType != null ) {
3636
return arrayBasicType;
3737
}
3838

3939
final TypeConfiguration typeConfiguration = sessionFactory.getTypeConfiguration();
4040
final JavaTypeRegistry javaTypeRegistry = typeConfiguration.getJavaTypeRegistry();
4141

42-
final JavaType<Object> rawArrayJavaType = javaTypeRegistry.resolveDescriptor( arrayClass );
43-
if ( !(rawArrayJavaType instanceof BasicPluralJavaType<?> arrayJavaType) ) {
44-
throw new IllegalArgumentException( "Expecting BasicPluralJavaType for array class `" + arrayClass.getName() + "`, but got `" + rawArrayJavaType + "`" );
42+
final JavaType<?> rawArrayJavaType = javaTypeRegistry.resolveArrayDescriptor( elementClass );
43+
if ( !(rawArrayJavaType instanceof BasicPluralJavaType<?> arrayJavaType ) ) {
44+
throw new IllegalArgumentException( "Expecting BasicPluralJavaType for array class `" + elementClass.getTypeName() + "[]`, but got `" + rawArrayJavaType + "`" );
4545
}
4646

4747
//noinspection unchecked,rawtypes

‎hibernate-core/src/main/java/org/hibernate/loader/ast/internal/MultiNaturalIdLoaderArrayParam.java‎

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -29,15 +29,14 @@
2929
*/
3030
public class MultiNaturalIdLoaderArrayParam<E> implements MultiNaturalIdLoader<E>, SqlArrayMultiKeyLoader {
3131
private final EntityMappingType entityDescriptor;
32-
private final Class<?> keyArrayClass;
32+
private final Class<?> keyClass;
3333

3434
public MultiNaturalIdLoaderArrayParam(EntityMappingType entityDescriptor) {
3535
assert entityDescriptor.getNaturalIdMapping() instanceof SimpleNaturalIdMapping;
3636

3737
this.entityDescriptor = entityDescriptor;
3838

39-
final Class<?> keyClass = entityDescriptor.getNaturalIdMapping().getJavaType().getJavaTypeClass();
40-
this.keyArrayClass = LoaderHelper.createTypedArray( keyClass, 0 ).getClass();
39+
this.keyClass = entityDescriptor.getNaturalIdMapping().getJavaType().getJavaTypeClass();
4140
}
4241

4342
@Override
@@ -77,7 +76,7 @@ public <K> List<E> multiLoad(K[] naturalIds, MultiNaturalIdLoadOptions loadOptio
7776

7877
final JdbcMapping arrayJdbcMapping = MultiKeyLoadHelper.resolveArrayJdbcMapping(
7978
getNaturalIdMapping().getSingleJdbcMapping(),
80-
keyArrayClass,
79+
keyClass,
8180
sessionFactory
8281
);
8382
final JdbcParameter jdbcParameter = new JdbcParameterImpl( arrayJdbcMapping );

‎hibernate-core/src/main/java/org/hibernate/type/BasicTypeRegistry.java‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -117,6 +117,10 @@ public <J> BasicType<J> getRegisteredType(Class<J> javaType) {
117117
return getRegisteredType( javaType.getTypeName() );
118118
}
119119

120+
public BasicType<?> getRegisteredArrayType(java.lang.reflect.Type javaElementType) {
121+
return getRegisteredType( javaElementType.getTypeName() + "[]" );
122+
}
123+
120124
public <J> BasicType<J> resolve(BasicTypeReference<J> basicTypeReference) {
121125
return getRegisteredType( basicTypeReference.getName() );
122126
}

‎hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/JavaTypeRegistry.java‎

Lines changed: 49 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -34,7 +34,7 @@ public class JavaTypeRegistry implements JavaTypeBaseline.BaselineTarget, Serial
3434
private static final Logger log = Logger.getLogger( JavaTypeRegistry.class );
3535

3636
private final TypeConfiguration typeConfiguration;
37-
private final ConcurrentHashMap<Type, JavaType<?>> descriptorsByType = new ConcurrentHashMap<>();
37+
private final ConcurrentHashMap<String, JavaType<?>> descriptorsByTypeName = new ConcurrentHashMap<>();
3838

3939
public JavaTypeRegistry(TypeConfiguration typeConfiguration) {
4040
this.typeConfiguration = typeConfiguration;
@@ -56,7 +56,7 @@ public void addBaselineDescriptor(JavaType<?> descriptor) {
5656
@Override
5757
public void addBaselineDescriptor(Type describedJavaType, JavaType<?> descriptor) {
5858
performInjections( descriptor );
59-
descriptorsByType.put( describedJavaType, descriptor );
59+
descriptorsByTypeName.put( describedJavaType.getTypeName(), descriptor );
6060
}
6161

6262
private void performInjections(JavaType<?> descriptor) {
@@ -71,15 +71,15 @@ private void performInjections(JavaType<?> descriptor) {
7171
// descriptor access
7272

7373
public void forEachDescriptor(Consumer<JavaType<?>> consumer) {
74-
descriptorsByType.values().forEach( consumer );
74+
descriptorsByTypeName.values().forEach( consumer );
7575
}
7676

7777
public <T> JavaType<T> getDescriptor(Type javaType) {
7878
return resolveDescriptor( javaType );
7979
}
8080

8181
public void addDescriptor(JavaType<?> descriptor) {
82-
JavaType<?> old = descriptorsByType.put( descriptor.getJavaType(), descriptor );
82+
JavaType<?> old = descriptorsByTypeName.put( descriptor.getJavaType().getTypeName(), descriptor );
8383
if ( old != null ) {
8484
log.debugf(
8585
"JavaTypeRegistry entry replaced : %s -> %s (was %s)",
@@ -93,74 +93,84 @@ public void addDescriptor(JavaType<?> descriptor) {
9393

9494
public <J> JavaType<J> findDescriptor(Type javaType) {
9595
//noinspection unchecked
96-
return (JavaType<J>) descriptorsByType.get( javaType );
96+
return (JavaType<J>) descriptorsByTypeName.get( javaType.getTypeName() );
9797
}
9898

9999
public <J> JavaType<J> resolveDescriptor(Type javaType, Supplier<JavaType<J>> creator) {
100-
final JavaType<?> cached = descriptorsByType.get( javaType );
100+
return resolveDescriptor( javaType.getTypeName(), creator );
101+
}
102+
103+
private <J> JavaType<J> resolveDescriptor(String javaTypeName, Supplier<JavaType<J>> creator) {
104+
final JavaType<?> cached = descriptorsByTypeName.get( javaTypeName );
101105
if ( cached != null ) {
102106
//noinspection unchecked
103107
return (JavaType<J>) cached;
104108
}
105109

106110
final JavaType<J> created = creator.get();
107-
descriptorsByType.put( javaType, created );
111+
descriptorsByTypeName.put( javaTypeName, created );
108112
return created;
109113
}
110114

111115
public <J> JavaType<J> resolveDescriptor(Type javaType) {
112-
return resolveDescriptor( javaType, (elementJavaType, typeConfiguration) -> {
113-
final MutabilityPlan<J> determinedPlan = RegistryHelper.INSTANCE.determineMutabilityPlan(
114-
elementJavaType,
115-
typeConfiguration
116-
);
117-
if ( determinedPlan != null ) {
118-
return determinedPlan;
119-
}
116+
return resolveDescriptor( javaType, JavaTypeRegistry::createMutabilityPlan );
117+
}
118+
119+
private static <J> MutabilityPlan<?> createMutabilityPlan(Type elementJavaType, TypeConfiguration typeConfiguration) {
120+
final MutabilityPlan<J> determinedPlan = RegistryHelper.INSTANCE.determineMutabilityPlan(
121+
elementJavaType,
122+
typeConfiguration
123+
);
124+
if ( determinedPlan != null ) {
125+
return determinedPlan;
126+
}
127+
128+
return MutableMutabilityPlan.INSTANCE;
129+
}
120130

121-
return MutableMutabilityPlan.INSTANCE;
122-
} );
131+
public JavaType<?> resolveArrayDescriptor(Class<?> elementJavaType) {
132+
return resolveDescriptor( elementJavaType.getTypeName() + "[]",
133+
() -> createArrayTypeDescriptor( elementJavaType, JavaTypeRegistry::createMutabilityPlan) );
123134
}
124135

125136
public <J> JavaType<J> resolveDescriptor(
126137
Type javaType,
127138
BiFunction<Type, TypeConfiguration, MutabilityPlan<?>> mutabilityPlanCreator) {
128139
return resolveDescriptor(
129-
javaType,
140+
javaType.getTypeName(),
130141
() -> {
131142
if ( javaType instanceof ParameterizedType parameterizedType ) {
132143
final JavaType<J> rawType = findDescriptor( parameterizedType.getRawType() );
133144
if ( rawType != null ) {
134145
return rawType.createJavaType( parameterizedType, typeConfiguration );
135146
}
136147
}
137-
final Type elementJavaType;
138-
JavaType<J> elementTypeDescriptor;
139-
if ( javaType instanceof Class<?> && ( (Class<?>) javaType ).isArray() ) {
140-
elementJavaType = ( (Class<?>) javaType ).getComponentType();
141-
elementTypeDescriptor = findDescriptor( elementJavaType );
142-
}
143-
else {
144-
elementJavaType = javaType;
145-
elementTypeDescriptor = null;
146-
}
147-
if ( elementTypeDescriptor == null ) {
148-
//noinspection unchecked
149-
elementTypeDescriptor = RegistryHelper.INSTANCE.createTypeDescriptor(
150-
elementJavaType,
151-
() -> (MutabilityPlan<J>) mutabilityPlanCreator.apply( elementJavaType, typeConfiguration ),
152-
typeConfiguration
153-
);
154-
}
155-
if ( javaType != elementJavaType ) {
148+
else if ( javaType instanceof Class<?> javaClass && javaClass.isArray() ) {
156149
//noinspection unchecked
157-
return (JavaType<J>) new ArrayJavaType<>( elementTypeDescriptor );
150+
return (JavaType<J>) createArrayTypeDescriptor( javaClass.getComponentType(), mutabilityPlanCreator );
158151
}
159-
return elementTypeDescriptor;
152+
return createTypeDescriptor( javaType, mutabilityPlanCreator );
160153
}
161154
);
162155
}
163156

157+
private <J> JavaType<J[]> createArrayTypeDescriptor(Class<J> elementJavaType, BiFunction<Type, TypeConfiguration, MutabilityPlan<?>> mutabilityPlanCreator) {
158+
JavaType<J> elementTypeDescriptor = findDescriptor( elementJavaType );
159+
if ( elementTypeDescriptor == null ) {
160+
elementTypeDescriptor = createTypeDescriptor( elementJavaType, mutabilityPlanCreator );
161+
}
162+
return new ArrayJavaType<>( elementTypeDescriptor );
163+
}
164+
165+
private <J> JavaType<J> createTypeDescriptor(Type javaType, BiFunction<Type, TypeConfiguration, MutabilityPlan<?>> mutabilityPlanCreator) {
166+
//noinspection unchecked
167+
return RegistryHelper.INSTANCE.createTypeDescriptor(
168+
javaType,
169+
() -> (MutabilityPlan<J>) mutabilityPlanCreator.apply( javaType, typeConfiguration ),
170+
typeConfiguration
171+
);
172+
}
173+
164174
public <J> JavaType<J> resolveManagedTypeDescriptor(Type javaType) {
165175
return resolveManagedTypeDescriptor( javaType, false );
166176
}

0 commit comments

Comments
 (0)