From f1f5ca98c1918e42297fee07cdc78ca6778538f8 Mon Sep 17 00:00:00 2001 From: Oliver Gierke Date: Mon, 3 Jul 2017 14:49:27 +0200 Subject: [PATCH] DATAJPA-1143 - Adapt to API changes in mapping subsystem. Rolled back API usage of Optional in mapping APIs. --- .../jpa/mapping/JpaPersistentEntityImpl.java | 15 ++-- .../mapping/JpaPersistentPropertyImpl.java | 87 ++++++++++++------- .../JpaMetamodelEntityInformation.java | 7 +- .../JpaPersistableEntityInformation.java | 6 +- ...tamodelMappingContextIntegrationTests.java | 3 +- .../JpaPersistentPropertyImplUnitTests.java | 3 +- .../JpaEntityInformationSupportUnitTests.java | 5 +- ...odelEntityInformationIntegrationTests.java | 10 +-- ...paMetamodelEntityInformationUnitTests.java | 3 +- ...PersistableEntityInformationUnitTests.java | 6 +- 10 files changed, 78 insertions(+), 67 deletions(-) diff --git a/src/main/java/org/springframework/data/jpa/mapping/JpaPersistentEntityImpl.java b/src/main/java/org/springframework/data/jpa/mapping/JpaPersistentEntityImpl.java index 2bc449993..daf93c4cc 100644 --- a/src/main/java/org/springframework/data/jpa/mapping/JpaPersistentEntityImpl.java +++ b/src/main/java/org/springframework/data/jpa/mapping/JpaPersistentEntityImpl.java @@ -16,7 +16,6 @@ package org.springframework.data.jpa.mapping; import java.util.Comparator; -import java.util.Optional; import org.springframework.data.annotation.Version; import org.springframework.data.jpa.provider.ProxyIdAccessor; @@ -51,7 +50,7 @@ class JpaPersistentEntityImpl extends BasicPersistentEntity information, ProxyIdAccessor proxyIdAccessor) { - super(information, Optional.empty()); + super(information, null); Assert.notNull(proxyIdAccessor, "ProxyIdAccessor must not be null!"); this.proxyIdAccessor = proxyIdAccessor; @@ -84,13 +83,11 @@ class JpaPersistentEntityImpl extends BasicPersistentEntity versionProperty = getVersionProperty(); + getVersionProperty(); - if (!versionProperty.isPresent()) { - return; - } + JpaPersistentProperty versionProperty = getVersionProperty(); - if (versionProperty.get().isAnnotationPresent(Version.class)) { + if (versionProperty != null && versionProperty.isAnnotationPresent(Version.class)) { throw new IllegalArgumentException(String.format(INVALID_VERSION_ANNOTATION, versionProperty)); } } @@ -131,10 +128,10 @@ class JpaPersistentEntityImpl extends BasicPersistentEntity getIdentifier() { + public Object getIdentifier() { return proxyIdAccessor.shouldUseAccessorFor(bean) // - ? Optional.ofNullable(proxyIdAccessor.getIdentifierFrom(bean))// + ? proxyIdAccessor.getIdentifierFrom(bean)// : super.getIdentifier(); } } diff --git a/src/main/java/org/springframework/data/jpa/mapping/JpaPersistentPropertyImpl.java b/src/main/java/org/springframework/data/jpa/mapping/JpaPersistentPropertyImpl.java index d6a723ba6..2fa61af99 100644 --- a/src/main/java/org/springframework/data/jpa/mapping/JpaPersistentPropertyImpl.java +++ b/src/main/java/org/springframework/data/jpa/mapping/JpaPersistentPropertyImpl.java @@ -19,7 +19,6 @@ import java.lang.annotation.Annotation; import java.util.Collection; import java.util.Collections; import java.util.HashSet; -import java.util.Optional; import java.util.Set; import javax.persistence.Access; @@ -47,7 +46,6 @@ import org.springframework.data.mapping.model.AnnotationBasedPersistentProperty; import org.springframework.data.mapping.model.Property; import org.springframework.data.mapping.model.SimpleTypeHolder; import org.springframework.data.util.ClassTypeInformation; -import org.springframework.data.util.Optionals; import org.springframework.data.util.TypeInformation; import org.springframework.util.Assert; @@ -90,8 +88,8 @@ class JpaPersistentPropertyImpl extends AnnotationBasedPersistentProperty usePropertyAccess; - private final Optional> associationTargetType; + private final Boolean usePropertyAccess; + private final TypeInformation associationTargetType; private final boolean updateable; private final JpaMetamodel metamodel; @@ -122,7 +120,7 @@ class JpaPersistentPropertyImpl extends AnnotationBasedPersistentProperty getActualType() { - return associationTargetType.isPresent() ? associationTargetType.get().getType() : super.getActualType(); + return associationTargetType != null ? associationTargetType.getType() : super.getActualType(); } /* @@ -131,7 +129,7 @@ class JpaPersistentPropertyImpl extends AnnotationBasedPersistentProperty> getPersistentEntityType() { - return associationTargetType.isPresent() ? Collections.singleton(associationTargetType.get()) + return associationTargetType != null ? Collections.singleton(associationTargetType) : super.getPersistentEntityType(); } @@ -160,8 +158,10 @@ class JpaPersistentPropertyImpl extends AnnotationBasedPersistentProperty findAnnotation(it).isPresent())) { - return true; + for (Class annotationType : ASSOCIATION_ANNOTATIONS) { + if (findAnnotation(annotationType) != null) { + return true; + } } return getType().isAnnotationPresent(Embeddable.class); @@ -191,7 +191,7 @@ class JpaPersistentPropertyImpl extends AnnotationBasedPersistentProperty super.usePropertyAccess()); + return usePropertyAccess != null ? usePropertyAccess : super.usePropertyAccess(); } /* @@ -220,29 +220,34 @@ class JpaPersistentPropertyImpl extends AnnotationBasedPersistentProperty detectPropertyAccess() { + private Boolean detectPropertyAccess() { - Optional accessType = findAnnotation( + org.springframework.data.annotation.AccessType accessType = findAnnotation( org.springframework.data.annotation.AccessType.class); - if (accessType.isPresent()) { - return accessType.map(it -> Type.PROPERTY.equals(it.value())); + if (accessType != null) { + return Type.PROPERTY.equals(accessType.value()); } - Optional access = findAnnotation(Access.class); + Access access = findAnnotation(Access.class); - if (access.isPresent()) { - return access.map(it -> AccessType.PROPERTY.equals(it.value())); + if (access != null) { + return AccessType.PROPERTY.equals(access.value()); } accessType = findPropertyOrOwnerAnnotation(org.springframework.data.annotation.AccessType.class); - if (accessType.isPresent()) { - return accessType.map(it -> Type.PROPERTY.equals(it.value())); + if (accessType != null) { + return Type.PROPERTY.equals(accessType.value()); } access = findPropertyOrOwnerAnnotation(Access.class); - return access.map(t -> AccessType.PROPERTY.equals(t.value())); + + if (access != null) { + return AccessType.PROPERTY.equals(access.value()); + } + + return null; } /** @@ -250,18 +255,30 @@ class JpaPersistentPropertyImpl extends AnnotationBasedPersistentProperty> detectAssociationTargetType() { + private TypeInformation detectAssociationTargetType() { if (!isAssociation()) { - return Optional.empty(); + return null; } - return ASSOCIATION_ANNOTATIONS.stream()// - .flatMap(it -> Optionals.toStream(findAnnotation(it)))// - .map(it -> AnnotationUtils.getValue(it, "targetEntity"))// - .filter(it -> it != null && !void.class.equals(it))// - .map(it -> (Class) it)// - .findFirst().map(it -> (TypeInformation) ClassTypeInformation.from(it)); + for (Class annotationType : ASSOCIATION_ANNOTATIONS) { + + Annotation annotation = findAnnotation(annotationType); + + if (annotation == null) { + continue; + } + + Object entityValue = AnnotationUtils.getValue(annotation, "targetEntity"); + + if (entityValue == null || entityValue.equals(void.class)) { + continue; + } + + return ClassTypeInformation.from((Class) entityValue); + } + + return null; } /** @@ -272,9 +289,17 @@ class JpaPersistentPropertyImpl extends AnnotationBasedPersistentProperty Optionals.toStream(findAnnotation(it)))// - .map(it -> AnnotationUtils.getValue(it, "updatable"))// - .anyMatch(it -> it.equals(Boolean.FALSE)); + for (Class annotationType : UPDATEABLE_ANNOTATIONS) { + + Annotation annotation = findAnnotation(annotationType); + + if (annotation == null) { + continue; + } + + return (boolean) AnnotationUtils.getValue(annotation, "updatable"); + } + + return true; } } diff --git a/src/main/java/org/springframework/data/jpa/repository/support/JpaMetamodelEntityInformation.java b/src/main/java/org/springframework/data/jpa/repository/support/JpaMetamodelEntityInformation.java index 62f7a2cbe..73a83c82c 100644 --- a/src/main/java/org/springframework/data/jpa/repository/support/JpaMetamodelEntityInformation.java +++ b/src/main/java/org/springframework/data/jpa/repository/support/JpaMetamodelEntityInformation.java @@ -19,7 +19,6 @@ import java.util.ArrayList; import java.util.Collections; import java.util.Iterator; import java.util.List; -import java.util.Optional; import java.util.Set; import javax.persistence.IdClass; @@ -141,12 +140,12 @@ public class JpaMetamodelEntityInformation extends JpaEntityInformationSu * @see org.springframework.data.repository.core.EntityInformation#getId(java.lang.Object) */ @SuppressWarnings("unchecked") - public Optional getId(T entity) { + public ID getId(T entity) { BeanWrapper entityWrapper = new DirectFieldAccessFallbackBeanWrapper(entity); if (idMetadata.hasSimpleId()) { - return Optional.ofNullable((ID) entityWrapper.getPropertyValue(idMetadata.getSimpleIdAttribute().getName())); + return (ID) entityWrapper.getPropertyValue(idMetadata.getSimpleIdAttribute().getName()); } BeanWrapper idWrapper = new IdentifierDerivingDirectFieldAccessFallbackBeanWrapper(idMetadata.getType(), metamodel); @@ -162,7 +161,7 @@ public class JpaMetamodelEntityInformation extends JpaEntityInformationSu idWrapper.setPropertyValue(attribute.getName(), propertyValue); } - return partialIdValueFound ? Optional.ofNullable((ID) idWrapper.getWrappedInstance()) : Optional.empty(); + return partialIdValueFound ? (ID) idWrapper.getWrappedInstance() : null; } /* diff --git a/src/main/java/org/springframework/data/jpa/repository/support/JpaPersistableEntityInformation.java b/src/main/java/org/springframework/data/jpa/repository/support/JpaPersistableEntityInformation.java index 578923aaa..8bf352f67 100644 --- a/src/main/java/org/springframework/data/jpa/repository/support/JpaPersistableEntityInformation.java +++ b/src/main/java/org/springframework/data/jpa/repository/support/JpaPersistableEntityInformation.java @@ -15,8 +15,6 @@ */ package org.springframework.data.jpa.repository.support; -import java.util.Optional; - import javax.persistence.metamodel.Metamodel; import org.springframework.data.domain.Persistable; @@ -54,7 +52,7 @@ public class JpaPersistableEntityInformation, ID> * @see org.springframework.data.jpa.repository.support.JpaMetamodelEntityInformation#getId(java.lang.Object) */ @Override - public Optional getId(T entity) { - return Optional.ofNullable(entity.getId()); + public ID getId(T entity) { + return entity.getId(); } } diff --git a/src/test/java/org/springframework/data/jpa/mapping/JpaMetamodelMappingContextIntegrationTests.java b/src/test/java/org/springframework/data/jpa/mapping/JpaMetamodelMappingContextIntegrationTests.java index a2be59db2..d8512a98e 100644 --- a/src/test/java/org/springframework/data/jpa/mapping/JpaMetamodelMappingContextIntegrationTests.java +++ b/src/test/java/org/springframework/data/jpa/mapping/JpaMetamodelMappingContextIntegrationTests.java @@ -19,7 +19,6 @@ import static org.hamcrest.CoreMatchers.*; import static org.junit.Assert.*; import java.util.Collections; -import java.util.Optional; import javax.persistence.EntityManager; @@ -139,7 +138,7 @@ public class JpaMetamodelMappingContextIntegrationTests { JpaPersistentEntity entity = context.getRequiredPersistentEntity(Product.class); IdentifierAccessor accessor = entity.getIdentifierAccessor(loadedProduct); - assertThat(accessor.getIdentifier(), is(Optional.of(category.getProduct().getId()))); + assertThat(accessor.getIdentifier(), is(category.getProduct().getId())); assertThat(loadedProduct, is(instanceOf(HibernateProxy.class))); assertThat(((HibernateProxy) loadedProduct).getHibernateLazyInitializer().isUninitialized(), is(true)); diff --git a/src/test/java/org/springframework/data/jpa/mapping/JpaPersistentPropertyImplUnitTests.java b/src/test/java/org/springframework/data/jpa/mapping/JpaPersistentPropertyImplUnitTests.java index 29fc87d7b..59e8a3e1d 100644 --- a/src/test/java/org/springframework/data/jpa/mapping/JpaPersistentPropertyImplUnitTests.java +++ b/src/test/java/org/springframework/data/jpa/mapping/JpaPersistentPropertyImplUnitTests.java @@ -21,7 +21,6 @@ import static org.junit.Assert.assertThat; import static org.mockito.Mockito.*; import java.util.Collections; -import java.util.Optional; import javax.persistence.Access; import javax.persistence.AccessType; @@ -74,7 +73,7 @@ public class JpaPersistentPropertyImplUnitTests { @Test // DATAJPA-376 public void considersJpaTransientFieldsAsTransient() { - assertThat(entity.getPersistentProperty("transientProp"), is(Optional.empty())); + assertThat(entity.getPersistentProperty("transientProp"), is(nullValue())); } @Test // DATAJPA-484 diff --git a/src/test/java/org/springframework/data/jpa/repository/support/JpaEntityInformationSupportUnitTests.java b/src/test/java/org/springframework/data/jpa/repository/support/JpaEntityInformationSupportUnitTests.java index 0e1ce2607..9fdabbf6d 100644 --- a/src/test/java/org/springframework/data/jpa/repository/support/JpaEntityInformationSupportUnitTests.java +++ b/src/test/java/org/springframework/data/jpa/repository/support/JpaEntityInformationSupportUnitTests.java @@ -20,7 +20,6 @@ import static org.mockito.Mockito.*; import java.io.Serializable; import java.util.Collections; -import java.util.Optional; import javax.persistence.Entity; import javax.persistence.EntityManager; @@ -79,8 +78,8 @@ public class JpaEntityInformationSupportUnitTests { return null; } - public Optional getId(T entity) { - return Optional.empty(); + public ID getId(T entity) { + return null; } public Class getIdType() { diff --git a/src/test/java/org/springframework/data/jpa/repository/support/JpaMetamodelEntityInformationIntegrationTests.java b/src/test/java/org/springframework/data/jpa/repository/support/JpaMetamodelEntityInformationIntegrationTests.java index f19691404..30f57c1f9 100644 --- a/src/test/java/org/springframework/data/jpa/repository/support/JpaMetamodelEntityInformationIntegrationTests.java +++ b/src/test/java/org/springframework/data/jpa/repository/support/JpaMetamodelEntityInformationIntegrationTests.java @@ -22,7 +22,6 @@ import static org.springframework.data.jpa.repository.support.JpaEntityInformati import java.io.Serializable; import java.sql.Timestamp; import java.util.Date; -import java.util.Optional; import javax.persistence.Access; import javax.persistence.AccessType; @@ -40,7 +39,6 @@ import org.hibernate.Version; import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; - import org.springframework.data.jpa.domain.AbstractPersistable; import org.springframework.data.jpa.domain.sample.ConcreteType1; import org.springframework.data.jpa.domain.sample.Item; @@ -112,7 +110,7 @@ public class JpaMetamodelEntityInformationIntegrationTests { em); Object id = information.getId(entity); - assertThat(id, is(Optional.of(new PersistableWithIdClassPK(2L, 4L)))); + assertThat(id, is(new PersistableWithIdClassPK(2L, 4L))); } @Test // DATAJPA-413 @@ -123,7 +121,7 @@ public class JpaMetamodelEntityInformationIntegrationTests { JpaEntityInformation information = getEntityInformation(Item.class, em); Object id = information.getId(item); - assertThat(id, is(Optional.of(new ItemId(2, 1)))); + assertThat(id, is(new ItemId(2, 1))); } @Test // DATAJPA-413 @@ -137,7 +135,7 @@ public class JpaMetamodelEntityInformationIntegrationTests { JpaEntityInformation information = getEntityInformation(ItemSite.class, em); Object id = information.getId(itemSite); - assertThat(id, is(Optional.of(new ItemSiteId(new ItemId(1, 2), 3)))); + assertThat(id, is(new ItemSiteId(new ItemId(1, 2), 3))); } @Test // DATAJPA-413 @@ -151,7 +149,7 @@ public class JpaMetamodelEntityInformationIntegrationTests { JpaEntityInformation information = getEntityInformation(ItemSite.class, em); Object id = information.getId(itemSite); - assertThat(id, is(Optional.of(new ItemSiteId(new ItemId(1, null), 3)))); + assertThat(id, is(new ItemSiteId(new ItemId(1, null), 3))); } @Test // DATAJPA-119 diff --git a/src/test/java/org/springframework/data/jpa/repository/support/JpaMetamodelEntityInformationUnitTests.java b/src/test/java/org/springframework/data/jpa/repository/support/JpaMetamodelEntityInformationUnitTests.java index 25da6cd58..fd719fb0b 100644 --- a/src/test/java/org/springframework/data/jpa/repository/support/JpaMetamodelEntityInformationUnitTests.java +++ b/src/test/java/org/springframework/data/jpa/repository/support/JpaMetamodelEntityInformationUnitTests.java @@ -22,7 +22,6 @@ import static org.mockito.Mockito.*; import java.io.Serializable; import java.util.HashSet; -import java.util.Optional; import java.util.Set; import javax.persistence.metamodel.IdentifiableType; @@ -78,7 +77,7 @@ public class JpaMetamodelEntityInformationUnitTests { PersistableWithIdClass.class, metamodel); PersistableWithIdClass entity = new PersistableWithIdClass(null, null); - assertThat(information.getId(entity), is(Optional.empty())); + assertThat(information.getId(entity), is(nullValue())); entity = new PersistableWithIdClass(2L, null); assertThat(information.getId(entity), is(notNullValue())); diff --git a/src/test/java/org/springframework/data/jpa/repository/support/JpaPersistableEntityInformationUnitTests.java b/src/test/java/org/springframework/data/jpa/repository/support/JpaPersistableEntityInformationUnitTests.java index 648112b99..725331018 100644 --- a/src/test/java/org/springframework/data/jpa/repository/support/JpaPersistableEntityInformationUnitTests.java +++ b/src/test/java/org/springframework/data/jpa/repository/support/JpaPersistableEntityInformationUnitTests.java @@ -19,8 +19,6 @@ import static org.hamcrest.CoreMatchers.*; import static org.junit.Assert.*; import static org.mockito.Mockito.*; -import java.util.Optional; - import javax.persistence.metamodel.EntityType; import javax.persistence.metamodel.Metamodel; import javax.persistence.metamodel.Type; @@ -64,11 +62,11 @@ public class JpaPersistableEntityInformationUnitTests { Foo foo = new Foo(); assertThat(entityInformation.isNew(foo), is(false)); - assertThat(entityInformation.getId(foo), is(Optional.empty())); + assertThat(entityInformation.getId(foo), is(nullValue())); foo.id = 1L; assertThat(entityInformation.isNew(foo), is(true)); - assertThat(entityInformation.getId(foo), is(Optional.of(1L))); + assertThat(entityInformation.getId(foo), is(1L)); } @SuppressWarnings("serial")