, P extends PersistentProperty>
implements MappingContext, ApplicationEventPublisherAware, ApplicationContextAware, InitializingBean {
+ private static final Logger LOGGER = LoggerFactory.getLogger(MappingContext.class);
+
private final Optional NONE = Optional.empty();
private final Map, Optional> persistentEntities = new HashMap<>();
private final PersistentPropertyAccessorFactory persistentPropertyAccessorFactory;
@@ -550,6 +556,9 @@ private void createAndRegisterProperty(Property input) {
return;
}
+ if (shouldSkipOverrideProperty(property)) {
+ return;
+ }
entity.addPersistentProperty(property);
if (property.isAssociation()) {
@@ -562,8 +571,87 @@ private void createAndRegisterProperty(Property input) {
property.getPersistentEntityTypes().forEach(AbstractMappingContext.this::addPersistentEntity);
}
+
+ protected boolean shouldSkipOverrideProperty(P property) {
+
+ P existingProperty = entity.getPersistentProperty(property.getName());
+
+ if (existingProperty == null) {
+ return false;
+ }
+
+ Class declaringClass = getDeclaringClass(property);
+ Class existingDeclaringClass = getDeclaringClass(existingProperty);
+
+ Class propertyType = getPropertyType(property);
+ Class existingPropertyType = getPropertyType(existingProperty);
+
+ if (!propertyType.isAssignableFrom(existingPropertyType)) {
+
+ if (LOGGER.isDebugEnabled()) {
+ LOGGER.warn(String.format("Offending property declaration in '%s %s.%s' shadowing '%s %s.%s' in '%s'. ",
+ propertyType.getSimpleName(), declaringClass.getName(), property.getName(),
+ existingPropertyType.getSimpleName(), existingDeclaringClass.getName(), existingProperty.getName(),
+ entity.getType().getSimpleName()));
+ }
+
+ return true;
+ }
+
+ return false;
+ }
+
+ private Class getDeclaringClass(PersistentProperty persistentProperty) {
+
+ Field field = persistentProperty.getField();
+ if (field != null) {
+ return field.getDeclaringClass();
+ }
+
+ Method accessor = persistentProperty.getGetter();
+
+ if (accessor == null) {
+ accessor = persistentProperty.getSetter();
+ }
+
+ if (accessor == null) {
+ accessor = persistentProperty.getWither();
+ }
+
+ if (accessor != null) {
+ return accessor.getDeclaringClass();
+ }
+
+ return persistentProperty.getOwner().getType();
+ }
+
+ private Class getPropertyType(PersistentProperty persistentProperty) {
+
+ Field field = persistentProperty.getField();
+ if (field != null) {
+ return field.getType();
+ }
+
+ Method getter = persistentProperty.getGetter();
+ if (getter != null) {
+ return getter.getReturnType();
+ }
+
+ Method setter = persistentProperty.getSetter();
+ if (setter != null) {
+ return setter.getParameterTypes()[0];
+ }
+
+ Method wither = persistentProperty.getWither();
+ if (wither != null) {
+ return wither.getParameterTypes()[0];
+ }
+
+ return persistentProperty.getType();
+ }
}
+
/**
* Filter rejecting static fields as well as artificially introduced ones. See
* {@link PersistentPropertyFilter#UNMAPPED_PROPERTIES} for details.
diff --git a/src/main/java/org/springframework/data/mapping/model/BeanWrapper.java b/src/main/java/org/springframework/data/mapping/model/BeanWrapper.java
index 344063e7c1..5f49c81e79 100644
--- a/src/main/java/org/springframework/data/mapping/model/BeanWrapper.java
+++ b/src/main/java/org/springframework/data/mapping/model/BeanWrapper.java
@@ -25,10 +25,10 @@
import java.util.List;
import java.util.Map;
-import org.springframework.core.KotlinDetector;
import org.springframework.data.mapping.MappingException;
import org.springframework.data.mapping.PersistentProperty;
import org.springframework.data.mapping.PersistentPropertyAccessor;
+import org.springframework.data.util.KotlinReflectionUtils;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.ConcurrentReferenceHashMap;
@@ -77,7 +77,7 @@ public void setProperty(PersistentProperty property, @Nullable Object value)
return;
}
- if (KotlinDetector.isKotlinType(property.getOwner().getType())) {
+ if (KotlinReflectionUtils.isDataClass(property.getOwner().getType())) {
this.bean = (T) KotlinCopyUtil.setProperty(property, bean, value);
return;
diff --git a/src/main/java/org/springframework/data/util/KotlinReflectionUtils.java b/src/main/java/org/springframework/data/util/KotlinReflectionUtils.java
index 5bc0b2a6ae..0c730d9f8a 100644
--- a/src/main/java/org/springframework/data/util/KotlinReflectionUtils.java
+++ b/src/main/java/org/springframework/data/util/KotlinReflectionUtils.java
@@ -66,6 +66,22 @@ public static boolean isSupportedKotlinClass(Class type) {
.anyMatch(it -> Integer.valueOf(KotlinClassHeaderKind.CLASS.id).equals(it));
}
+ /**
+ * Return {@literal true} if the specified class is a Kotlin data class.
+ *
+ * @return {@literal true} if {@code type} is a Kotlin data class.
+ * @since 2.6
+ */
+ public static boolean isDataClass(Class type) {
+
+ if (!KotlinDetector.isKotlinType(type)) {
+ return false;
+ }
+
+ KClass kotlinClass = JvmClassMappingKt.getKotlinClass(type);
+ return kotlinClass.isData();
+ }
+
/**
* Returns a {@link KFunction} instance corresponding to the given Java {@link Method} instance, or {@code null} if
* this method cannot be represented by a Kotlin function.
diff --git a/src/test/java/org/springframework/data/mapping/KotlinModelTypes.kt b/src/test/java/org/springframework/data/mapping/KotlinModelTypes.kt
new file mode 100644
index 0000000000..23ddc2f026
--- /dev/null
+++ b/src/test/java/org/springframework/data/mapping/KotlinModelTypes.kt
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2019 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.mapping
+
+open class ShadowedPropertyType {
+ open val shadowedProperty: Int = 1
+}
+
+class ShadowingPropertyType : ShadowedPropertyType() {
+ override var shadowedProperty: Int = 10
+}
+
+open class ShadowedPropertyTypeWithCtor(open val shadowedProperty: Int)
+
+class ShadowingPropertyTypeWithCtor(val someValue: String, override var shadowedProperty: Int = 1) : ShadowedPropertyTypeWithCtor(shadowedProperty)
+
+
diff --git a/src/test/java/org/springframework/data/mapping/context/AbstractMappingContextUnitTests.java b/src/test/java/org/springframework/data/mapping/context/AbstractMappingContextUnitTests.java
index d49ed04f7d..650afde73c 100755
--- a/src/test/java/org/springframework/data/mapping/context/AbstractMappingContextUnitTests.java
+++ b/src/test/java/org/springframework/data/mapping/context/AbstractMappingContextUnitTests.java
@@ -41,9 +41,15 @@
import org.springframework.data.annotation.Id;
import org.springframework.data.mapping.MappingException;
import org.springframework.data.mapping.PersistentEntity;
+import org.springframework.data.mapping.PropertyHandler;
+import org.springframework.data.mapping.ShadowedPropertyType;
+import org.springframework.data.mapping.ShadowedPropertyTypeWithCtor;
+import org.springframework.data.mapping.ShadowingPropertyType;
+import org.springframework.data.mapping.ShadowingPropertyTypeWithCtor;
import org.springframework.data.mapping.model.BasicPersistentEntity;
import org.springframework.data.mapping.model.SimpleTypeHolder;
import org.springframework.data.util.ClassTypeInformation;
+import org.springframework.data.util.StreamUtils;
import org.springframework.data.util.TypeInformation;
/**
@@ -52,10 +58,11 @@
* @author Oliver Gierke
* @author Thomas Darimont
* @author Mark Paluch
+ * @author Christoph Stobl
*/
class AbstractMappingContextUnitTests {
- SampleMappingContext context;
+ private SampleMappingContext context;
@BeforeEach
void setUp() {
@@ -216,6 +223,55 @@ void cleansUpCacheForRuntimeException() {
.isThrownBy(() -> context.getPersistentEntity(Unsupported.class));
}
+ @Test // GH-3113
+ void shouldIgnoreKotlinOverrideCtorPropertyInSuperClass() {
+
+ BasicPersistentEntity entity = context
+ .getPersistentEntity(ClassTypeInformation.from(ShadowingPropertyTypeWithCtor.class));
+ entity.doWithProperties((PropertyHandler) property -> {
+ assertThat(property.getField().getDeclaringClass()).isIn(ShadowingPropertyTypeWithCtor.class,
+ ShadowedPropertyTypeWithCtor.class);
+ });
+ }
+
+ @Test // GH-3113
+ void shouldIncludeAssignableKotlinOverridePropertyInSuperClass() {
+
+ BasicPersistentEntity entity = context
+ .getPersistentEntity(ClassTypeInformation.from(ShadowingPropertyType.class));
+ entity.doWithProperties((PropertyHandler) property -> {
+ assertThat(property.getField().getDeclaringClass()).isIn(ShadowedPropertyType.class, ShadowingPropertyType.class);
+ });
+ }
+
+ @Test // GH-3113
+ void shouldIncludeAssignableShadowedPropertyInSuperClass() {
+
+ BasicPersistentEntity entity = context
+ .getPersistentEntity(ClassTypeInformation.from(ShadowingPropertyAssignable.class));
+
+ assertThat(StreamUtils.createStreamFromIterator(entity.iterator())
+ .filter(it -> it.getField().getDeclaringClass().equals(ShadowedPropertyAssignable.class)).findFirst() //
+ ).isNotEmpty();
+
+ assertThat(entity).hasSize(2);
+
+ entity.doWithProperties((PropertyHandler) property -> {
+ assertThat(property.getField().getDeclaringClass()).isIn(ShadowedPropertyAssignable.class,
+ ShadowingPropertyAssignable.class);
+ });
+ }
+
+ @Test // GH-3113
+ void shouldIgnoreNonAssignableOverridePropertyInSuperClass() {
+
+ BasicPersistentEntity entity = context
+ .getPersistentEntity(ClassTypeInformation.from(ShadowingPropertyNotAssignable.class));
+ entity.doWithProperties((PropertyHandler) property -> {
+ assertThat(property.getField().getDeclaringClass()).isEqualTo(ShadowingPropertyNotAssignable.class);
+ });
+ }
+
private static void assertHasEntityFor(Class type, SampleMappingContext context, boolean expected) {
boolean found = false;
@@ -237,7 +293,7 @@ class Person {
LocalDateTime date;
}
- class Unsupported {
+ private class Unsupported {
}
@@ -306,4 +362,74 @@ public void verify() {
};
}
}
+
+ static class ShadowedProperty {
+
+ private final String value;
+
+ ShadowedProperty(String value) {
+ this.value = value;
+ }
+
+ public String getValue() {
+ return value;
+ }
+ }
+
+ static class ShadowingProperty extends ShadowedProperty {
+
+ private String value;
+
+ ShadowingProperty(String value) {
+ super(value);
+ this.value = value;
+ }
+
+ public void setValue(String value) {
+ this.value = value;
+ }
+
+ @Override
+ public String getValue() {
+ return value;
+ }
+ }
+
+ static class ShadowedPropertyNotAssignable {
+
+ private String value;
+ }
+
+ static class ShadowingPropertyNotAssignable extends ShadowedPropertyNotAssignable {
+
+ private Integer value;
+
+ ShadowingPropertyNotAssignable(Integer value) {
+ this.value = value;
+ }
+
+ public Integer getValue() {
+ return value;
+ }
+
+ public void setValue(Integer value) {
+ this.value = value;
+ }
+ }
+
+ static class ShadowedPropertyAssignable {
+
+ private Object value;
+
+ }
+
+ static class ShadowingPropertyAssignable extends ShadowedPropertyAssignable {
+
+ private Integer value;
+
+ ShadowingPropertyAssignable(Integer value) {
+ this.value = value;
+ }
+ }
+
}