DATAJDBC-137 - Improve EntityInformation usage.

Moved to both the usage of the newly introduced PersistentEntity.isNew(…) and identifier lookups via PersistentEntity instead of using a custom EntityInformation implementation. JdbcRepositoryFactory now creates a PersistentEntityInformation, SimpleJdbcRepository simply works with a PersistentEntity.

Removed references to EntityInformation (a repository subsystem concept) from the template implementation. Removed BasicJdbcPersistentEntity and its tests entirely. JdbcAuditingEventListener is now using an IsNewAwareAuditingHandler.

Related tickets: DATACMNS-1333.

Author: odrotbohm

src/main/java/org/springframework/data/jdbc/core/DefaultDataAccessStrategy.java

@@ -27,15 +27,14 @@
 import org.springframework.dao.EmptyResultDataAccessException;
 import org.springframework.dao.InvalidDataAccessApiUsageException;
 import org.springframework.dao.NonTransientDataAccessException;
-import org.springframework.data.jdbc.core.mapping.BasicJdbcPersistentEntityInformation;
 import org.springframework.data.jdbc.core.mapping.JdbcMappingContext;
 import org.springframework.data.jdbc.core.mapping.JdbcPersistentEntity;
-import org.springframework.data.jdbc.core.mapping.JdbcPersistentEntityInformation;
 import org.springframework.data.jdbc.core.mapping.JdbcPersistentProperty;
 import org.springframework.data.jdbc.support.JdbcUtil;
+import org.springframework.data.mapping.PersistentPropertyAccessor;
 import org.springframework.data.mapping.PropertyHandler;
 import org.springframework.data.mapping.PropertyPath;
-import org.springframework.data.repository.core.EntityInformation;
+import org.springframework.data.mapping.model.ConvertingPropertyAccessor;
 import org.springframework.jdbc.core.RowMapper;
 import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
 import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
@@ -58,8 +57,8 @@ public class DefaultDataAccessStrategy implements DataAccessStrategy {
 
 	private final @NonNull SqlGeneratorSource sqlGeneratorSource;
 	private final @NonNull JdbcMappingContext context;
-	private final @NonNull DataAccessStrategy accessStrategy;
 	private final @NonNull NamedParameterJdbcOperations operations;
+	private final @NonNull DataAccessStrategy accessStrategy;
 
 	/**
 	 * Creates a {@link DefaultDataAccessStrategy} which references it self for resolution of recursive data accesses.
@@ -79,8 +78,6 @@ public <T> void insert(T instance, Class<T> domainType, Map<String, Object> addi
 
 		KeyHolder holder = new GeneratedKeyHolder();
 		JdbcPersistentEntity<T> persistentEntity = getRequiredPersistentEntity(domainType);
-		JdbcPersistentEntityInformation<T, ?> entityInformation = context
-				.getRequiredPersistentEntityInformation(domainType);
 
 		MapSqlParameterSource parameterSource = getPropertyMap(instance, persistentEntity);
 
@@ -103,7 +100,8 @@ public <T> void insert(T instance, Class<T> domainType, Map<String, Object> addi
 
 		// if there is an id property and it was null before the save
 		// The database should have created an id and provided it.
-		if (idProperty != null && idValue == null && entityInformation.isNew(instance)) {
+
+		if (idProperty != null && idValue == null && persistentEntity.isNew(instance)) {
 			throw new IllegalStateException(String.format(ENTITY_NEW_AFTER_INSERT, persistentEntity));
 		}
 	}
@@ -278,15 +276,12 @@ private <S> MapSqlParameterSource getPropertyMap(final S instance, JdbcPersisten
 	@SuppressWarnings("unchecked")
 	private <S, ID> ID getIdValueOrNull(S instance, JdbcPersistentEntity<S> persistentEntity) {
 
-		EntityInformation<S, ID> entityInformation = (EntityInformation<S, ID>) context
-				.getRequiredPersistentEntityInformation(persistentEntity.getType());
-
-		ID idValue = entityInformation.getId(instance);
+		ID idValue = (ID) persistentEntity.getIdentifierAccessor(instance).getIdentifier();
 
 		return isIdPropertyNullOrScalarZero(idValue, persistentEntity) ? null : idValue;
 	}
 
-	private <S, ID> boolean isIdPropertyNullOrScalarZero(ID idValue, JdbcPersistentEntity<S> persistentEntity) {
+	private static <S, ID> boolean isIdPropertyNullOrScalarZero(ID idValue, JdbcPersistentEntity<S> persistentEntity) {
 
 		JdbcPersistentProperty idProperty = persistentEntity.getIdProperty();
 		return idValue == null //
@@ -297,16 +292,16 @@ private <S, ID> boolean isIdPropertyNullOrScalarZero(ID idValue, JdbcPersistentE
 
 	private <S> void setIdFromJdbc(S instance, KeyHolder holder, JdbcPersistentEntity<S> persistentEntity) {
 
-		JdbcPersistentEntityInformation<S, ?> entityInformation = new BasicJdbcPersistentEntityInformation<>(
-				persistentEntity);
-
 		try {
 
 			getIdFromHolder(holder, persistentEntity).ifPresent(it -> {
 
-				Class<?> targetType = persistentEntity.getRequiredIdProperty().getType();
-				Object converted = convert(it, targetType);
-				entityInformation.setId(instance, converted);
+				PersistentPropertyAccessor accessor = persistentEntity.getPropertyAccessor(instance);
+				ConvertingPropertyAccessor convertingPropertyAccessor = new ConvertingPropertyAccessor(accessor,
+						context.getConversions());
+				JdbcPersistentProperty idProperty = persistentEntity.getRequiredIdProperty();
+
+				convertingPropertyAccessor.setProperty(idProperty, it);
 			});
 
 		} catch (NonTransientDataAccessException e) {

src/main/java/org/springframework/data/jdbc/core/JdbcAggregateTemplate.java

@@ -24,14 +24,16 @@
 import org.springframework.data.jdbc.core.conversion.JdbcEntityDeleteWriter;
 import org.springframework.data.jdbc.core.conversion.JdbcEntityWriter;
 import org.springframework.data.jdbc.core.mapping.JdbcMappingContext;
-import org.springframework.data.jdbc.core.mapping.JdbcPersistentEntityInformation;
+import org.springframework.data.jdbc.core.mapping.JdbcPersistentEntity;
 import org.springframework.data.jdbc.core.mapping.event.AfterDeleteEvent;
 import org.springframework.data.jdbc.core.mapping.event.AfterLoadEvent;
 import org.springframework.data.jdbc.core.mapping.event.AfterSaveEvent;
 import org.springframework.data.jdbc.core.mapping.event.BeforeDeleteEvent;
 import org.springframework.data.jdbc.core.mapping.event.BeforeSaveEvent;
 import org.springframework.data.jdbc.core.mapping.event.Identifier;
 import org.springframework.data.jdbc.core.mapping.event.Identifier.Specified;
+import org.springframework.data.mapping.IdentifierAccessor;
+import org.springframework.util.Assert;
 
 /**
  * {@link JdbcAggregateOperations} implementation, storing aggregates in and obtaining them from a JDBC data store.
@@ -52,7 +54,7 @@ public class JdbcAggregateTemplate implements JdbcAggregateOperations {
 	private final DataAccessStrategy accessStrategy;
 
 	public JdbcAggregateTemplate(ApplicationEventPublisher publisher, JdbcMappingContext context,
-								 DataAccessStrategy dataAccessStrategy) {
+			DataAccessStrategy dataAccessStrategy) {
 
 		this.publisher = publisher;
 		this.context = context;
@@ -66,21 +68,23 @@ public JdbcAggregateTemplate(ApplicationEventPublisher publisher, JdbcMappingCon
 	@Override
 	public <T> void save(T instance) {
 
-		JdbcPersistentEntityInformation<T, ?> entityInformation = context
-				.getRequiredPersistentEntityInformation((Class<T>) instance.getClass());
+		Assert.notNull(instance, "Agggregate instance must not be null!");
+
+		JdbcPersistentEntity<?> entity = context.getRequiredPersistentEntity(instance.getClass());
+		IdentifierAccessor identifierAccessor = entity.getIdentifierAccessor(instance);
 
 		AggregateChange change = createChange(instance);
 
 		publisher.publishEvent(new BeforeSaveEvent( //
-				Identifier.ofNullable(entityInformation.getId(instance)), //
+				Identifier.ofNullable(identifierAccessor.getIdentifier()), //
 				instance, //
 				change //
 		));
 
 		change.executeWith(interpreter);
 
 		publisher.publishEvent(new AfterSaveEvent( //
-				Identifier.of(entityInformation.getId(instance)), //
+				Identifier.of(identifierAccessor.getIdentifier()), //
 				instance, //
 				change //
 		));
@@ -125,9 +129,10 @@ public <T> Iterable<T> findAllById(Iterable<?> ids, Class<T> domainType) {
 	@Override
 	public <S> void delete(S entity, Class<S> domainType) {
 
-		JdbcPersistentEntityInformation<S, ?> entityInformation = context
-				.getRequiredPersistentEntityInformation(domainType);
-		deleteTree(entityInformation.getRequiredId(entity), entity, domainType);
+		IdentifierAccessor identifierAccessor = context.getRequiredPersistentEntity(domainType)
+				.getIdentifierAccessor(entity);
+
+		deleteTree(identifierAccessor.getRequiredIdentifier(), entity, domainType);
 	}
 
 	@Override
@@ -178,11 +183,14 @@ private AggregateChange createDeletingChange(Class<?> domainType) {
 		return aggregateChange;
 	}
 
-	@SuppressWarnings("unchecked")
 	private <T> void publishAfterLoad(Iterable<T> all) {
 
 		for (T e : all) {
-			publishAfterLoad(context.getRequiredPersistentEntityInformation((Class<T>) e.getClass()).getRequiredId(e), e);
+
+			JdbcPersistentEntity<?> entity = context.getPersistentEntity(e.getClass());
+			IdentifierAccessor identifierAccessor = entity.getIdentifierAccessor(e);
+
+			publishAfterLoad(identifierAccessor.getRequiredIdentifier(), e);
 		}
 	}
 

src/main/java/org/springframework/data/jdbc/core/conversion/JdbcEntityWriter.java

@@ -27,12 +27,12 @@
 import org.springframework.data.jdbc.core.conversion.DbAction.Update;
 import org.springframework.data.jdbc.core.mapping.JdbcMappingContext;
 import org.springframework.data.jdbc.core.mapping.JdbcPersistentEntity;
-import org.springframework.data.jdbc.core.mapping.JdbcPersistentEntityInformation;
 import org.springframework.data.jdbc.core.mapping.JdbcPersistentProperty;
+import org.springframework.data.mapping.IdentifierAccessor;
+import org.springframework.data.mapping.PersistentEntity;
 import org.springframework.data.mapping.PersistentProperty;
 import org.springframework.data.mapping.PersistentPropertyAccessor;
 import org.springframework.data.util.StreamUtils;
-import org.springframework.util.ClassUtils;
 
 /**
  * Converts an entity that is about to be saved into {@link DbAction}s inside a {@link AggregateChange} that need to be
@@ -43,8 +43,13 @@
  */
 public class JdbcEntityWriter extends JdbcEntityWriterSupport {
 
+	private final JdbcMappingContext context;
+
 	public JdbcEntityWriter(JdbcMappingContext context) {
+
 		super(context);
+
+		this.context = context;
 	}
 
 	@Override
@@ -54,11 +59,12 @@ public void write(Object o, AggregateChange aggregateChange) {
 
 	private void write(Object o, AggregateChange aggregateChange, DbAction dependingOn) {
 
-		Class<Object> type = (Class<Object>) o.getClass();
-		JdbcPersistentEntityInformation<Object, ?> entityInformation = context.getRequiredPersistentEntityInformation(type);
+		Class<?> type = o.getClass();
 		JdbcPropertyPath propertyPath = JdbcPropertyPath.from("", type);
 
-		if (entityInformation.isNew(o)) {
+		PersistentEntity<?, JdbcPersistentProperty> persistentEntity = context.getRequiredPersistentEntity(type);
+
+		if (persistentEntity.isNew(o)) {
 
 			Insert<Object> insert = DbAction.insert(o, propertyPath, dependingOn);
 			aggregateChange.addAction(insert);
@@ -71,10 +77,13 @@ private void write(Object o, AggregateChange aggregateChange, DbAction depending
 									aggregateChange, //
 									propertyPath.nested(propertyAndValue.property.getName()), //
 									insert) //
-			);
+					);
 		} else {
 
-			deleteReferencedEntities(entityInformation.getRequiredId(o), aggregateChange);
+			JdbcPersistentEntity<?> entity = context.getPersistentEntity(type);
+			IdentifierAccessor identifierAccessor = entity.getIdentifierAccessor(o);
+
+			deleteReferencedEntities(identifierAccessor.getRequiredIdentifier(), aggregateChange);
 
 			Update<Object> update = DbAction.update(o, propertyPath, dependingOn);
 			aggregateChange.addAction(update);
@@ -104,7 +113,7 @@ private void insertReferencedEntities(PropertyAndValue propertyAndValue, Aggrega
 						aggregateChange, //
 						propertyPath.nested(pav.property.getName()), //
 						dependingOn) //
-		);
+				);
 	}
 
 	private Stream<PropertyAndValue> referencedEntities(Object o) {
@@ -116,7 +125,7 @@ private Stream<PropertyAndValue> referencedEntities(Object o) {
 				.flatMap( //
 						p -> referencedEntity(p, persistentEntity.getPropertyAccessor(o)) //
 								.map(e -> new PropertyAndValue(p, e)) //
-		);
+				);
 	}
 
 	private Stream<Object> referencedEntity(JdbcPersistentProperty p, PersistentPropertyAccessor propertyAccessor) {

src/main/java/org/springframework/data/jdbc/core/mapping/BasicJdbcPersistentEntityInformation.java

@@ -139,11 +139,6 @@ protected JdbcPersistentProperty createPersistentProperty(Property property, Jdb
 		return new BasicJdbcPersistentProperty(property, owner, simpleTypeHolder, this);
 	}
 
-	@SuppressWarnings("unchecked")
-	public <T> JdbcPersistentEntityInformation<T, ?> getRequiredPersistentEntityInformation(Class<T> type) {
-		return new BasicJdbcPersistentEntityInformation<>((JdbcPersistentEntity<T>) getRequiredPersistentEntity(type));
-	}
-
 	public ConversionService getConversions() {
 		return conversions;
 	}