DATAJDBC-137 - Fixes warnings and improves Javadoc.

All packages now use @NoNullApi.
All warnings related to that fixed, except a few cases where upstream annotations are simply wrong.
Added null checks.
Fixed generic types where possible.
Improved Javadoc.
Code Formatting.

Author: schauder

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

@@ -65,7 +65,7 @@ public <T> void deleteAll(Class<T> domainType) {
 	}
 
 	@Override
-	public <T> void deleteAll(PropertyPath propertyPath) {
+	public void deleteAll(PropertyPath propertyPath) {
 		collectVoid(das -> das.deleteAll(propertyPath));
 	}
 
@@ -100,7 +100,7 @@ public <T> boolean existsById(Object id, Class<T> domainType) {
 	}
 
 	private <T> T collect(Function<DataAccessStrategy, T> function) {
-		return strategies.stream().collect(new FunctionCollector<T>(function));
+		return strategies.stream().collect(new FunctionCollector<>(function));
 	}
 
 	private void collectVoid(Consumer<DataAccessStrategy> consumer) {

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

@@ -19,45 +19,108 @@
 
 import org.springframework.data.jdbc.core.mapping.JdbcPersistentProperty;
 import org.springframework.data.mapping.PropertyPath;
+import org.springframework.lang.Nullable;
 
 /**
- * Abstraction for accesses to the database that should be implementable with a single SQL statement and relates to a
- * single entity as opposed to {@link JdbcEntityOperations} which provides interactions related to complete aggregates.
+ * Abstraction for accesses to the database that should be implementable with a single SQL statement per method and
+ * relates to a single entity as opposed to {@link JdbcAggregateOperations} which provides interactions related to
+ * complete aggregates.
  *
  * @author Jens Schauder
  * @since 1.0
  */
 public interface DataAccessStrategy {
 
+	/**
+	 * Inserts a the data of a single entity. Referenced entities don't get handled.
+	 * 
+	 * @param instance the instance to be stored. Must not be {@code null}.
+	 * @param domainType the type of the instance. Must not be {@code null}.
+	 * @param additionalParameters name-value pairs of additional parameters. Especially ids of parent entities that need
+	 *          to get referenced are contained in this map. Must not be {@code null}.
+	 * @param <T> the type of the instance.
+	 */
 	<T> void insert(T instance, Class<T> domainType, Map<String, Object> additionalParameters);
 
+	/**
+	 * Updates the data of a single entity in the database. Referenced entities don't get handled.
+	 *
+	 * @param instance the instance to save. Must not be {@code null}.
+	 * @param domainType the type of the instance to save. Must not be {@code null}.
+	 * @param <T> the type of the instance to save.
+	 */
 	<T> void update(T instance, Class<T> domainType);
 
+	/**
+	 * deletes a single row identified by the id, from the table identified by the domainType. Does not handle cascading
+	 * deletes.
+	 *
+	 * @param id the id of the row to be deleted. Must not be {@code null}.
+	 * @param domainType the type of entity to be deleted. Implicitely determines the table to operate on. Must not be
+	 *          {@code null}.
+	 */
 	void delete(Object id, Class<?> domainType);
 
 	/**
 	 * Deletes all entities reachable via {@literal propertyPath} from the instance identified by {@literal rootId}.
 	 *
-	 * @param rootId Id of the root object on which the {@literal propertyPath} is based.
-	 * @param propertyPath Leading from the root object to the entities to be deleted.
+	 * @param rootId Id of the root object on which the {@literal propertyPath} is based. Must not be {@code null}.
+	 * @param propertyPath Leading from the root object to the entities to be deleted. Must not be {@code null}.
 	 */
 	void delete(Object rootId, PropertyPath propertyPath);
 
+	/**
+	 * Deletes all entities of the given domain type.
+	 * 
+	 * @param domainType the domain type for which to delete all entries. Must not be {@code null}.
+	 * @param <T> type of the domain type.
+	 */
 	<T> void deleteAll(Class<T> domainType);
 
 	/**
 	 * Deletes all entities reachable via {@literal propertyPath} from any instance.
 	 *
-	 * @param propertyPath Leading from the root object to the entities to be deleted.
+	 * @param propertyPath Leading from the root object to the entities to be deleted. Must not be {@code null}.
 	 */
-	<T> void deleteAll(PropertyPath propertyPath);
+	void deleteAll(PropertyPath propertyPath);
 
+	/**
+	 * Counts the rows in the table representing the given domain type.
+	 *
+	 * @param domainType the domain type for which to count the elements. Must not be {@code null}.
+	 * @return the count. Guaranteed to be not {@code null}.
+	 */
 	long count(Class<?> domainType);
 
+	/**
+	 * Loads a single entity identified by type and id.
+	 *
+	 * @param id the id of the entity to load. Must not be {@code null}.
+	 * @param domainType the domain type of the entity. Must not be {@code null}.
+	 * @param <T> the type of the entity.
+	 * @return Might return {@code null}.
+	 */
+	@Nullable
 	<T> T findById(Object id, Class<T> domainType);
 
+	/**
+	 * Loads alls entities of the given type.
+	 *
+	 * @param domainType the type of entities to load. Must not be {@code null}.
+	 * @param <T> the type of entities to load.
+	 * @return Guaranteed to be not {@code null}.
+	 */
 	<T> Iterable<T> findAll(Class<T> domainType);
 
+	/**
+	 * Loads all entities that match one of the ids passed as an argument. It is not guaranteed that the number of ids
+	 * passed in matches the number of entities returned.
+	 * 
+	 * @param ids the Ids of the entities to load. Must not be {@code null}.
+	 * @param domainType the type of entities to laod. Must not be {@code null}.
+	 * @param <T> type of entities to load.
+	 * @return the loaded entities. Guaranteed to be not {@code null}.
+	 */
 	<T> Iterable<T> findAllById(Iterable<?> ids, Class<T> domainType);
 
 	/**
@@ -68,5 +131,13 @@ public interface DataAccessStrategy {
 	 */
 	<T> Iterable<T> findAllByProperty(Object rootId, JdbcPersistentProperty property);
 
+	/**
+	 * returns if a row with the given id exists for the given type.
+	 * 
+	 * @param id the id of the entity for which to check. Must not be {@code null}.
+	 * @param domainType the type of the entity to check for. Must not be {@code null}.
+	 * @param <T> the type of the entity.
+	 * @return {@code true} if a matching row exists, otherwise {@code false}.
+	 */
 	<T> boolean existsById(Object id, Class<T> domainType);
 }

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

@@ -41,6 +41,7 @@
 import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
 import org.springframework.jdbc.support.GeneratedKeyHolder;
 import org.springframework.jdbc.support.KeyHolder;
+import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 /**
@@ -88,6 +89,9 @@ public <T> void insert(T instance, Class<T> domainType, Map<String, Object> addi
 		JdbcPersistentProperty idProperty = persistentEntity.getIdProperty();
 
 		if (idValue != null) {
+
+			Assert.notNull(idProperty, "Since we have a non-null idValue, we must have an idProperty as well.");
+
 			additionalParameters.put(idProperty.getColumnName(), convert(idValue, idProperty.getColumnType()));
 		}
 
@@ -167,7 +171,7 @@ public <T> void deleteAll(Class<T> domainType) {
 	 * @see org.springframework.data.jdbc.core.DataAccessStrategy#deleteAll(org.springframework.data.mapping.PropertyPath)
 	 */
 	@Override
-	public <T> void deleteAll(PropertyPath propertyPath) {
+	public void deleteAll(PropertyPath propertyPath) {
 		operations.getJdbcOperations().update(sql(propertyPath.getOwningType().getType()).createDeleteAllSql(propertyPath));
 	}
 
@@ -177,21 +181,27 @@ public <T> void deleteAll(PropertyPath propertyPath) {
 	 */
 	@Override
 	public long count(Class<?> domainType) {
-		return operations.getJdbcOperations().queryForObject(sql(domainType).getCount(), Long.class);
+
+		Long result = operations.getJdbcOperations().queryForObject(sql(domainType).getCount(), Long.class);
+
+		Assert.notNull(result, "The result of a count query must not be null.");
+
+		return result;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.jdbc.core.DataAccessStrategy#findById(java.lang.Object, java.lang.Class)
 	 */
+	@SuppressWarnings("unchecked")
 	@Override
 	public <T> T findById(Object id, Class<T> domainType) {
 
 		String findOneSql = sql(domainType).getFindOne();
 		MapSqlParameterSource parameter = createIdParameterSource(id, domainType);
 
 		try {
-			return operations.queryForObject(findOneSql, parameter, getEntityRowMapper(domainType));
+			return operations.queryForObject(findOneSql, parameter, (RowMapper<T>) getEntityRowMapper(domainType));
 		} catch (EmptyResultDataAccessException e) {
 			return null;
 		}
@@ -201,15 +211,17 @@ public <T> T findById(Object id, Class<T> domainType) {
 	 * (non-Javadoc)
 	 * @see org.springframework.data.jdbc.core.DataAccessStrategy#findAll(java.lang.Class)
 	 */
+	@SuppressWarnings("unchecked")
 	@Override
 	public <T> Iterable<T> findAll(Class<T> domainType) {
-		return operations.query(sql(domainType).getFindAll(), getEntityRowMapper(domainType));
+		return operations.query(sql(domainType).getFindAll(), (RowMapper<T>) getEntityRowMapper(domainType));
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.jdbc.core.DataAccessStrategy#findAllById(java.lang.Iterable, java.lang.Class)
 	 */
+	@SuppressWarnings("unchecked")
 	@Override
 	public <T> Iterable<T> findAllById(Iterable<?> ids, Class<T> domainType) {
 
@@ -223,7 +235,7 @@ public <T> Iterable<T> findAllById(Iterable<?> ids, Class<T> domainType) {
 						.collect(Collectors.toList()) //
 		);
 
-		return operations.query(findAllInListSql, parameter, getEntityRowMapper(domainType));
+		return operations.query(findAllInListSql, parameter, (RowMapper<T>) getEntityRowMapper(domainType));
 	}
 
 	/*
@@ -242,9 +254,10 @@ public <T> Iterable<T> findAllByProperty(Object rootId, JdbcPersistentProperty p
 
 		MapSqlParameterSource parameter = new MapSqlParameterSource(property.getReverseColumnName(), rootId);
 
-		return (Iterable<T>) operations.query(findAllByProperty, parameter, property.isMap() //
-				? getMapEntityRowMapper(property) //
-				: getEntityRowMapper(actualType));
+		return operations.query(findAllByProperty, parameter, //
+				(RowMapper<T>) (property.isMap() //
+						? this.getMapEntityRowMapper(property) //
+						: this.getEntityRowMapper(actualType)));
 	}
 
 	/*
@@ -257,7 +270,11 @@ public <T> boolean existsById(Object id, Class<T> domainType) {
 		String existsSql = sql(domainType).getExists();
 		MapSqlParameterSource parameter = createIdParameterSource(id, domainType);
 
-		return operations.queryForObject(existsSql, parameter, Boolean.class);
+		Boolean result = operations.queryForObject(existsSql, parameter, Boolean.class);
+
+		Assert.notNull(result, "The result of an exists query must not be null");
+
+		return result;
 	}
 
 	private <S> MapSqlParameterSource getPropertyMap(final S instance, JdbcPersistentEntity<S> persistentEntity) {
@@ -277,14 +294,16 @@ private <S> MapSqlParameterSource getPropertyMap(final S instance, JdbcPersisten
 	}
 
 	@SuppressWarnings("unchecked")
+	@Nullable
 	private <S, ID> ID getIdValueOrNull(S instance, JdbcPersistentEntity<S> persistentEntity) {
 
 		ID idValue = (ID) persistentEntity.getIdentifierAccessor(instance).getIdentifier();
 
 		return isIdPropertyNullOrScalarZero(idValue, persistentEntity) ? null : idValue;
 	}
 
-	private static <S, ID> boolean isIdPropertyNullOrScalarZero(ID idValue, JdbcPersistentEntity<S> persistentEntity) {
+	private static <S, ID> boolean isIdPropertyNullOrScalarZero(@Nullable ID idValue,
+			JdbcPersistentEntity<S> persistentEntity) {
 
 		JdbcPersistentProperty idProperty = persistentEntity.getIdProperty();
 		return idValue == null //
@@ -319,30 +338,38 @@ private <S> Optional<Object> getIdFromHolder(KeyHolder holder, JdbcPersistentEnt
 			return Optional.ofNullable(holder.getKey());
 		} catch (InvalidDataAccessApiUsageException e) {
 			// Postgres returns a value for each column
-			return Optional.ofNullable(holder.getKeys().get(persistentEntity.getIdColumn()));
+			Map<String, Object> keys = holder.getKeys();
+			return Optional.ofNullable(keys == null ? null : keys.get(persistentEntity.getIdColumn()));
 		}
 	}
 
-	public <T> EntityRowMapper<T> getEntityRowMapper(Class<T> domainType) {
+	public EntityRowMapper<?> getEntityRowMapper(Class<?> domainType) {
 		return new EntityRowMapper<>(getRequiredPersistentEntity(domainType), context, instantiators, accessStrategy);
 	}
 
-	private RowMapper getMapEntityRowMapper(JdbcPersistentProperty property) {
-		return new MapEntityRowMapper(getEntityRowMapper(property.getActualType()), property.getKeyColumn());
+	@SuppressWarnings("unchecked")
+	private RowMapper<?> getMapEntityRowMapper(JdbcPersistentProperty property) {
+
+		String keyColumn = property.getKeyColumn();
+
+		Assert.notNull(keyColumn, () -> "keyColumn must not be null for " + property);
+
+		return new MapEntityRowMapper<>(getEntityRowMapper(property.getActualType()), keyColumn);
 	}
 
 	private <T> MapSqlParameterSource createIdParameterSource(Object id, Class<T> domainType) {
 
-		return new MapSqlParameterSource("id",
-				convert(id, getRequiredPersistentEntity(domainType).getRequiredIdProperty().getColumnType()));
+		Class<?> columnType = getRequiredPersistentEntity(domainType).getRequiredIdProperty().getColumnType();
+		return new MapSqlParameterSource("id", convert(id, columnType));
 	}
 
 	@SuppressWarnings("unchecked")
 	private <S> JdbcPersistentEntity<S> getRequiredPersistentEntity(Class<S> domainType) {
 		return (JdbcPersistentEntity<S>) context.getRequiredPersistentEntity(domainType);
 	}
 
-	private <V> V convert(Object from, Class<V> to) {
+	@Nullable
+	private <V> V convert(@Nullable Object from, Class<V> to) {
 
 		if (from == null) {
 			return null;

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

@@ -27,6 +27,7 @@
 import org.springframework.data.jdbc.core.mapping.JdbcPersistentEntity;
 import org.springframework.data.jdbc.core.conversion.Interpreter;
 import org.springframework.data.mapping.PropertyPath;
+import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 /**
@@ -103,6 +104,7 @@ private <T> void addDependingOnInformation(Insert<T> insert, Map<String, Object>
 		additionalColumnValues.put(columnName, identifier);
 	}
 
+	@Nullable
 	private Object getIdFromEntityDependingOn(DbAction dependingOn, JdbcPersistentEntity<?> persistentEntity) {
 		return persistentEntity.getIdentifierAccessor(dependingOn.getEntity()).getIdentifier();
 	}

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

@@ -58,7 +58,7 @@ public <T> void deleteAll(Class<T> domainType) {
 	}
 
 	@Override
-	public <T> void deleteAll(PropertyPath propertyPath) {
+	public void deleteAll(PropertyPath propertyPath) {
 		delegate.deleteAll(propertyPath);
 	}