Skip to content

Commit f6a9850

Browse files
gavinkinggavinking
committed
minor code cleanups in ArrayJavaType and ArrayJdbcType
1 parent ba0661b commit f6a9850

File tree

3 files changed

+116
-125
lines changed

3 files changed

+116
-125
lines changed

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

Lines changed: 29 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -4,23 +4,23 @@
44
*/
55
package org.hibernate.type.descriptor.java;
66

7-
import java.lang.reflect.Array;
8-
97
import org.hibernate.MappingException;
108
import org.hibernate.dialect.Dialect;
119
import org.hibernate.internal.build.AllowReflection;
1210
import org.hibernate.tool.schema.extract.spi.ColumnTypeInformation;
13-
import org.hibernate.type.descriptor.converter.internal.ArrayConverter;
1411
import org.hibernate.type.BasicArrayType;
1512
import org.hibernate.type.BasicPluralType;
1613
import org.hibernate.type.BasicType;
1714
import org.hibernate.type.ConvertedBasicArrayType;
15+
import org.hibernate.type.descriptor.converter.internal.ArrayConverter;
1816
import org.hibernate.type.descriptor.converter.spi.BasicValueConverter;
1917
import org.hibernate.type.descriptor.java.spi.UnknownBasicJavaType;
2018
import org.hibernate.type.descriptor.jdbc.JdbcType;
2119
import org.hibernate.type.descriptor.jdbc.JdbcTypeIndicators;
2220
import org.hibernate.type.spi.TypeConfiguration;
2321

22+
import static java.lang.reflect.Array.newInstance;
23+
2424
@AllowReflection
2525
public abstract class AbstractArrayJavaType<T, E> extends AbstractClassJavaType<T>
2626
implements BasicPluralJavaType<E> {
@@ -74,51 +74,53 @@ public BasicType<?> resolveType(
7474
|| elementJavaTypeClass != null && elementJavaTypeClass.isArray() ) {
7575
return null;
7676
}
77-
final BasicValueConverter<E, ?> valueConverter = elementType.getValueConverter();
77+
final var valueConverter = elementType.getValueConverter();
7878
return valueConverter == null
79-
? resolveType( typeConfiguration, dialect, this, elementType, columnTypeInformation, stdIndicators )
80-
: createTypeUsingConverter( typeConfiguration, dialect, elementType, columnTypeInformation, stdIndicators, valueConverter );
79+
? resolveType( typeConfiguration, this, elementType, columnTypeInformation, stdIndicators )
80+
: createTypeUsingConverter( typeConfiguration, elementType, columnTypeInformation, stdIndicators, valueConverter );
81+
}
82+
83+
private static JdbcType arrayJdbcType(
84+
TypeConfiguration typeConfiguration,
85+
BasicType<?> elementType,
86+
ColumnTypeInformation columnTypeInformation,
87+
JdbcTypeIndicators indicators) {
88+
final int arrayTypeCode =
89+
indicators.getPreferredSqlTypeCodeForArray( elementType.getJdbcType().getDefaultSqlTypeCode() );
90+
return typeConfiguration.getJdbcTypeRegistry()
91+
.resolveTypeConstructorDescriptor( arrayTypeCode, elementType, columnTypeInformation );
8192
}
8293

8394
<F> BasicType<T> createTypeUsingConverter(
8495
TypeConfiguration typeConfiguration,
85-
Dialect dialect,
8696
BasicType<E> elementType,
8797
ColumnTypeInformation columnTypeInformation,
88-
JdbcTypeIndicators stdIndicators,
98+
JdbcTypeIndicators indicators,
8999
BasicValueConverter<E, F> valueConverter) {
90100
final Class<F> convertedElementClass = valueConverter.getRelationalJavaType().getJavaTypeClass();
91-
final Class<?> convertedArrayClass = Array.newInstance( convertedElementClass, 0 ).getClass();
92-
final JavaType<?> relationalJavaType = typeConfiguration.getJavaTypeRegistry().getDescriptor( convertedArrayClass );
101+
final Class<?> convertedArrayClass = newInstance( convertedElementClass, 0 ).getClass();
102+
final JavaType<?> relationalJavaType =
103+
typeConfiguration.getJavaTypeRegistry()
104+
.getDescriptor( convertedArrayClass );
93105
return new ConvertedBasicArrayType<>(
94106
elementType,
95-
typeConfiguration.getJdbcTypeRegistry().resolveTypeConstructorDescriptor(
96-
stdIndicators.getPreferredSqlTypeCodeForArray( elementType.getJdbcType().getDefaultSqlTypeCode() ),
97-
elementType,
98-
columnTypeInformation
99-
),
107+
arrayJdbcType( typeConfiguration, elementType, columnTypeInformation, indicators ),
100108
this,
101109
new ArrayConverter<>( valueConverter, this, relationalJavaType )
102110
);
103111
}
104112

105113
BasicType<T> resolveType(
106114
TypeConfiguration typeConfiguration,
107-
Dialect dialect,
108115
AbstractArrayJavaType<T,E> arrayJavaType,
109116
BasicType<E> elementType,
110117
ColumnTypeInformation columnTypeInformation,
111-
JdbcTypeIndicators stdIndicators) {
112-
final JdbcType arrayJdbcType = typeConfiguration.getJdbcTypeRegistry().resolveTypeConstructorDescriptor(
113-
stdIndicators.getPreferredSqlTypeCodeForArray( elementType.getJdbcType().getDefaultSqlTypeCode() ),
114-
elementType,
115-
columnTypeInformation
116-
);
117-
return typeConfiguration.getBasicTypeRegistry().resolve(
118-
arrayJavaType,
119-
arrayJdbcType,
120-
() -> new BasicArrayType<>( elementType, arrayJdbcType, arrayJavaType )
121-
);
118+
JdbcTypeIndicators indicators) {
119+
final JdbcType arrayJdbcType =
120+
arrayJdbcType( typeConfiguration, elementType, columnTypeInformation, indicators );
121+
return typeConfiguration.getBasicTypeRegistry()
122+
.resolve( arrayJavaType, arrayJdbcType,
123+
() -> new BasicArrayType<>( elementType, arrayJdbcType, arrayJavaType ) );
122124
}
123125

124126
}

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

Lines changed: 36 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,6 @@
55
package org.hibernate.type.descriptor.java;
66

77
import java.io.Serializable;
8-
import java.lang.reflect.Array;
98
import java.sql.SQLException;
109
import java.util.Collection;
1110

@@ -24,6 +23,7 @@
2423
import org.hibernate.type.descriptor.jdbc.JdbcTypeIndicators;
2524
import org.hibernate.type.spi.TypeConfiguration;
2625

26+
import static java.lang.reflect.Array.newInstance;
2727
import static org.hibernate.internal.util.ReflectHelper.arrayClass;
2828

2929
/**
@@ -67,26 +67,28 @@ public BasicType<?> resolveType(
6767
);
6868
}
6969
}
70-
final Class<?> elementJavaTypeClass = elementType.getJavaTypeDescriptor().getJavaTypeClass();
70+
final JavaType<T> elementTypeJavaType = elementType.getJavaTypeDescriptor();
71+
final Class<?> elementJavaTypeClass = elementTypeJavaType.getJavaTypeClass();
7172
if ( elementType instanceof BasicPluralType<?, ?>
72-
|| elementJavaTypeClass != null && elementJavaTypeClass.isArray()
73-
&& elementJavaTypeClass != byte[].class ) {
73+
|| elementJavaTypeClass != null
74+
&& elementJavaTypeClass.isArray()
75+
&& elementJavaTypeClass != byte[].class ) {
7476
// No support for nested arrays, except for byte[][]
7577
return null;
7678
}
7779
final ArrayJavaType<T> arrayJavaType;
78-
if ( getElementJavaType() == elementType.getJavaTypeDescriptor() ) {
80+
if ( getElementJavaType() == elementTypeJavaType ) {
7981
arrayJavaType = this;
8082
}
8183
else {
82-
arrayJavaType = new ArrayJavaType<>( elementType.getJavaTypeDescriptor() );
84+
arrayJavaType = new ArrayJavaType<>( elementTypeJavaType );
8385
// Register the array type as that will be resolved in the next step
8486
typeConfiguration.getJavaTypeRegistry().addDescriptor( arrayJavaType );
8587
}
8688
final BasicValueConverter<T, ?> valueConverter = elementType.getValueConverter();
8789
return valueConverter == null
88-
? resolveType( typeConfiguration, dialect, arrayJavaType, elementType, columnTypeInformation, stdIndicators )
89-
: createTypeUsingConverter( typeConfiguration, dialect, elementType, columnTypeInformation, stdIndicators, valueConverter );
90+
? resolveType( typeConfiguration, arrayJavaType, elementType, columnTypeInformation, stdIndicators )
91+
: createTypeUsingConverter( typeConfiguration, elementType, columnTypeInformation, stdIndicators, valueConverter );
9092
}
9193

9294
@Override
@@ -134,9 +136,7 @@ public int extractHashCode(T[] value) {
134136
if ( value == null ) {
135137
return 0;
136138
}
137-
138139
int result = 1;
139-
140140
for ( T element : value ) {
141141
result = 31 * result + ( element == null ? 0 : getElementJavaType().extractHashCode( element ) );
142142
}
@@ -159,7 +159,7 @@ public String toString(T[] value) {
159159
continue;
160160
}
161161
sb.append( '"' );
162-
String valstr = getElementJavaType().toString( v );
162+
final String valstr = getElementJavaType().toString( v );
163163
// using replaceAll is a shorter, but much slower way to do this
164164
for (int i = 0, len = valstr.length(); i < len; i ++ ) {
165165
char c = valstr.charAt( i );
@@ -173,16 +173,15 @@ public String toString(T[] value) {
173173
glue = ",";
174174
}
175175
sb.append( '}' );
176-
final String result = sb.toString();
177-
return result;
176+
return sb.toString();
178177
}
179178

180179
@Override
181180
public T[] fromString(CharSequence charSequence) {
182181
if ( charSequence == null ) {
183182
return null;
184183
}
185-
java.util.ArrayList<String> lst = new java.util.ArrayList<>();
184+
final java.util.ArrayList<String> lst = new java.util.ArrayList<>();
186185
StringBuilder sb = null;
187186
char lastChar = charSequence.charAt( charSequence.length() - 1 );
188187
char firstChar = charSequence.charAt( 0 );
@@ -232,7 +231,7 @@ else if ( c == ',' ) {
232231
break;
233232
}
234233
throw new IllegalArgumentException( "Cannot parse given string into array of strings."
235-
+ " Outside of quote, but neither whitespace, comma, array end, nor null found." );
234+
+ " Outside of quote, but neither whitespace, comma, array end, nor null found." );
236235
}
237236
}
238237
else if ( c == '\\' && i + 2 < len && (charSequence.charAt( i + 1 ) == '\\' || charSequence.charAt( i + 1 ) == '"')) {
@@ -242,7 +241,7 @@ else if ( c == '\\' && i + 2 < len && (charSequence.charAt( i + 1 ) == '\\' || c
242241
sb.append( c );
243242
}
244243
//noinspection unchecked
245-
final T[] result = (T[]) Array.newInstance( getElementJavaType().getJavaTypeClass(), lst.size() );
244+
final T[] result = (T[]) newInstance( getElementJavaType().getJavaTypeClass(), lst.size() );
246245
for ( int i = 0; i < result.length; i ++ ) {
247246
if ( lst.get( i ) != null ) {
248247
result[i] = getElementJavaType().fromString( lst.get( i ) );
@@ -270,7 +269,7 @@ else if ( type == BinaryStream.class ) {
270269
}
271270
else if ( type.isArray() ) {
272271
final Class<?> preferredJavaTypeClass = type.getComponentType();
273-
final Object[] unwrapped = (Object[]) Array.newInstance( preferredJavaTypeClass, value.length );
272+
final Object[] unwrapped = (Object[]) newInstance( preferredJavaTypeClass, value.length );
274273
for ( int i = 0; i < value.length; i++ ) {
275274
unwrapped[i] = getElementJavaType().unwrap( value[i], preferredJavaTypeClass, options );
276275
}
@@ -298,10 +297,11 @@ public <X> T[] wrap(X value, WrapperOptions options) {
298297
}
299298
}
300299

300+
final JavaType<T> elementJavaType = getElementJavaType();
301301
if ( value instanceof Object[] raw ) {
302-
final Class<T> componentClass = getElementJavaType().getJavaTypeClass();
302+
final Class<T> componentClass = elementJavaType.getJavaTypeClass();
303303
//noinspection unchecked
304-
final T[] wrapped = (T[]) java.lang.reflect.Array.newInstance( componentClass, raw.length );
304+
final T[] wrapped = (T[]) newInstance( componentClass, raw.length );
305305
if ( componentClass.isAssignableFrom( value.getClass().getComponentType() ) ) {
306306
for (int i = 0; i < raw.length; i++) {
307307
//noinspection unchecked
@@ -310,7 +310,7 @@ public <X> T[] wrap(X value, WrapperOptions options) {
310310
}
311311
else {
312312
for ( int i = 0; i < raw.length; i++ ) {
313-
wrapped[i] = getElementJavaType().wrap( raw[i], options );
313+
wrapped[i] = elementJavaType.wrap( raw[i], options );
314314
}
315315
}
316316
return wrapped;
@@ -322,50 +322,52 @@ else if ( value instanceof BinaryStream binaryStream ) {
322322
// When the value is a BinaryStream, this is a deserialization request
323323
return fromBytes( binaryStream.getBytes() );
324324
}
325-
else if ( getElementJavaType().isInstance( value ) ) {
325+
else if ( elementJavaType.isInstance( value ) ) {
326326
// Support binding a single element as parameter value
327327
//noinspection unchecked
328-
final T[] wrapped = (T[]) java.lang.reflect.Array.newInstance( getElementJavaType().getJavaTypeClass(), 1 );
328+
final T[] wrapped = (T[]) newInstance( elementJavaType.getJavaTypeClass(), 1 );
329329
//noinspection unchecked
330330
wrapped[0] = (T) value;
331331
return wrapped;
332332
}
333333
else if ( value instanceof Collection<?> collection ) {
334334
//noinspection unchecked
335-
final T[] wrapped = (T[]) java.lang.reflect.Array.newInstance( getElementJavaType().getJavaTypeClass(), collection.size() );
335+
final T[] wrapped = (T[]) newInstance( elementJavaType.getJavaTypeClass(), collection.size() );
336336
int i = 0;
337337
for ( Object e : collection ) {
338-
wrapped[i++] = getElementJavaType().wrap( e, options );
338+
wrapped[i++] = elementJavaType.wrap( e, options );
339339
}
340340
return wrapped;
341341
}
342342

343343
throw unknownWrap( value.getClass() );
344344
}
345345

346-
private static <T> byte[] toBytes(T[] value) {
347-
if ( value.getClass().getComponentType().isEnum() ) {
348-
final byte[] array = new byte[value.length];
349-
for (int i = 0; i < value.length; i++ ) {
346+
private static <T> byte[] toBytes(T[] array) {
347+
if ( array.getClass().getComponentType().isEnum() ) {
348+
final byte[] bytes = new byte[array.length];
349+
for (int i = 0; i < array.length; i++ ) {
350+
final T value = array[i];
350351
// encode null enum value as -1
351-
array[i] = value[i] == null ? -1 : (byte) ((Enum<?>) value[i]).ordinal();
352+
bytes[i] = value == null ? -1 : (byte) ((Enum<?>) value).ordinal();
352353
}
353-
return array;
354+
return bytes;
354355

355356
}
356357
else {
357358
// byte[] can only be requested if the value should be serialized
358-
return SerializationHelper.serialize( value );
359+
return SerializationHelper.serialize( array );
359360
}
360361
}
361362

362363
private T[] fromBytes(byte[] bytes) {
363364
final Class<T> elementClass = getElementJavaType().getJavaTypeClass();
364365
if ( elementClass.isEnum() ) {
365-
final Object[] array = (Object[]) Array.newInstance( elementClass, bytes.length );
366+
final T[] enumConstants = elementClass.getEnumConstants();
367+
final Object[] array = (Object[]) newInstance( elementClass, bytes.length );
366368
for (int i = 0; i < bytes.length; i++ ) {
367369
// null enum value was encoded as -1
368-
array[i] = bytes[i] == -1 ? null : elementClass.getEnumConstants()[bytes[i]];
370+
array[i] = bytes[i] == -1 ? null : enumConstants[bytes[i]];
369371
}
370372
//noinspection unchecked
371373
return (T[]) array;
@@ -400,7 +402,7 @@ public T[] deepCopy(T[] value) {
400402
return null;
401403
}
402404
//noinspection unchecked
403-
final T[] copy = (T[]) Array.newInstance( componentClass, value.length );
405+
final T[] copy = (T[]) newInstance( componentClass, value.length );
404406
for ( int i = 0; i < value.length; i ++ ) {
405407
copy[ i ] = componentPlan.deepCopy( value[ i ] );
406408
}

0 commit comments

Comments
 (0)