DATAJDBC-189 - Polishing.

Removed DefaultNamingStrategy since we don't have GA release breaking APIs is still ok.
Introduced an instance of NamingStrategy so we don't have to create a new class whereever we just want the default implementation.

JavaDoc.
Formatting

Original pull request: #36.

Author: schauder

src/main/java/org/springframework/data/jdbc/mapping/model/DefaultNamingStrategy.java

@@ -22,14 +22,14 @@
  * column name based on {@link JdbcPersistentProperty}. The default delimiter is '_', resulting in snake case.
  *
  * @author Kazuki Shimizu
+ * @author Jens Schauder
  */
-public class DelimiterNamingStrategy extends DefaultNamingStrategy {
+public class DelimiterNamingStrategy implements NamingStrategy {
 
 	private final String delimiter;
 
 	/**
-	 * Construct a instance with '_' as delimiter.
-	 * This results in a snake case naming strategy.
+	 * Construct a instance with '_' as delimiter. This results in a snake case naming strategy.
 	 */
 	public DelimiterNamingStrategy() {
 		this("_");
@@ -49,15 +49,15 @@ public DelimiterNamingStrategy(String delimiter) {
 	 */
 	@Override
 	public String getTableName(Class<?> type) {
-		return ParsingUtils.reconcatenateCamelCase(super.getTableName(type), delimiter);
+		return ParsingUtils.reconcatenateCamelCase(NamingStrategy.super.getTableName(type), delimiter);
 	}
 
 	/**
 	 * Look up the {@link JdbcPersistentProperty}'s name after converting to separated word using with {@code delimiter}.
 	 */
 	@Override
 	public String getColumnName(JdbcPersistentProperty property) {
-		return ParsingUtils.reconcatenateCamelCase(super.getColumnName(property), delimiter);
+		return ParsingUtils.reconcatenateCamelCase(NamingStrategy.super.getColumnName(property), delimiter);
 	}
 
 	/**

src/main/java/org/springframework/data/jdbc/mapping/model/DelimiterNamingStrategy.java

@@ -71,7 +71,7 @@ public JdbcMappingContext(NamingStrategy namingStrategy, NamedParameterJdbcOpera
 	}
 
 	public JdbcMappingContext(NamedParameterJdbcOperations template) {
-		this(new DefaultNamingStrategy(), template, __ -> {});
+		this(NamingStrategy.INSTANCE, template, __ -> {});
 	}
 
 	@Override

src/main/java/org/springframework/data/jdbc/mapping/model/JdbcMappingContext.java

@@ -16,21 +16,28 @@
 package org.springframework.data.jdbc.mapping.model;
 
 /**
- * Interface and default implementation of a naming strategy. Defaults to no schema, 
- * table name based on {@link Class} and column name based on {@link JdbcPersistentProperty}.
- *
- * NOTE: Can also be used as an adapter. Create a lambda or an anonymous subclass and 
- * override any settings to implement a different strategy on the fly.
+ * Interface and default implementation of a naming strategy. Defaults to no schema, table name based on {@link Class}
+ * and column name based on {@link JdbcPersistentProperty}.
+ * <p>
+ * NOTE: Can also be used as an adapter. Create a lambda or an anonymous subclass and override any settings to implement
+ * a different strategy on the fly.
  * 
  * @author Greg Turnquist
  * @author Michael Simons
  */
 public interface NamingStrategy {
 
+	/**
+	 * Empty implementation of the interface utilizing only the default implementation.
+	 * <p>
+	 * Using this avoids creating essentially the same class over and over again.
+	 */
+	NamingStrategy INSTANCE = new NamingStrategy() {};
+
 	/**
 	 * Defaults to no schema.
 	 *
-	 * @return No schema
+	 * @return Empty String representing no schema
 	 */
 	default String getSchema() {
 		return "";
@@ -58,17 +65,19 @@ default String getQualifiedTableName(Class<?> type) {
 	 * For a reference A -&gt; B this is the name in the table for B which references A.
 	 *
 	 * @param property The property who's column name in the owner table is required
-	 * @return a column name.
+	 * @return a column name. Must not be {@code null}.
 	 */
 	default String getReverseColumnName(JdbcPersistentProperty property) {
 		return property.getOwner().getTableName();
 	}
 
 	/**
-	 * For a map valued reference A -> Map&gt;X,B&lt; this is the name of the column in the tabel for B holding the key of the map.
-	 * @return
+	 * For a map valued reference A -> Map&gt;X,B&lt; this is the name of the column in the table for B holding the key of
+	 * the map.
+	 * 
+	 * @return name of the key column. Must not be {@code null}.
 	 */
-	default String getKeyColumn(JdbcPersistentProperty property){
+	default String getKeyColumn(JdbcPersistentProperty property) {
 		return getReverseColumnName(property) + "_key";
 	}
 

src/main/java/org/springframework/data/jdbc/mapping/model/NamingStrategy.java

@@ -20,7 +20,6 @@
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.data.jdbc.mapping.model.ConversionCustomizer;
-import org.springframework.data.jdbc.mapping.model.DefaultNamingStrategy;
 import org.springframework.data.jdbc.mapping.model.JdbcMappingContext;
 import org.springframework.data.jdbc.mapping.model.NamingStrategy;
 import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
@@ -35,9 +34,9 @@ public class JdbcConfiguration {
 
 	@Bean
 	JdbcMappingContext jdbcMappingContext(NamedParameterJdbcTemplate template, Optional<NamingStrategy> namingStrategy,
-										  Optional<ConversionCustomizer> conversionCustomizer) {
+			Optional<ConversionCustomizer> conversionCustomizer) {
 
-		return new JdbcMappingContext(
-				namingStrategy.orElse(new DefaultNamingStrategy()), template, conversionCustomizer.orElse(conversionService -> {}));
+		return new JdbcMappingContext(namingStrategy.orElse(NamingStrategy.INSTANCE), template,
+				conversionCustomizer.orElse(conversionService -> {}));
 	}
 }

src/main/java/org/springframework/data/jdbc/repository/config/JdbcConfiguration.java

@@ -25,8 +25,8 @@
 import org.junit.Test;
 import org.mockito.ArgumentCaptor;
 import org.springframework.data.annotation.Id;
-import org.springframework.data.jdbc.mapping.model.DefaultNamingStrategy;
 import org.springframework.data.jdbc.mapping.model.JdbcMappingContext;
+import org.springframework.data.jdbc.mapping.model.NamingStrategy;
 import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
 import org.springframework.jdbc.core.namedparam.SqlParameterSource;
 import org.springframework.jdbc.support.KeyHolder;
@@ -42,7 +42,7 @@ public class DefaultDataAccessStrategyUnitTests {
 	public static final long ORIGINAL_ID = 4711L;
 
 	NamedParameterJdbcOperations jdbcOperations = mock(NamedParameterJdbcOperations.class);
-	JdbcMappingContext context = new JdbcMappingContext(new DefaultNamingStrategy(), jdbcOperations, __ -> {});
+	JdbcMappingContext context = new JdbcMappingContext(NamingStrategy.INSTANCE, jdbcOperations, __ -> {});
 	HashMap<String, Object> additionalParameters = new HashMap<>();
 	ArgumentCaptor<SqlParameterSource> paramSourceCaptor = ArgumentCaptor.forClass(SqlParameterSource.class);
 

src/test/java/org/springframework/data/jdbc/core/DefaultDataAccessStrategyUnitTests.java

@@ -27,9 +27,9 @@
 import org.springframework.data.jdbc.core.conversion.DbAction;
 import org.springframework.data.jdbc.core.conversion.DbAction.Insert;
 import org.springframework.data.jdbc.core.conversion.JdbcPropertyPath;
-import org.springframework.data.jdbc.mapping.model.DefaultNamingStrategy;
 import org.springframework.data.jdbc.mapping.model.JdbcMappingContext;
 import org.springframework.data.jdbc.mapping.model.JdbcPersistentProperty;
+import org.springframework.data.jdbc.mapping.model.NamingStrategy;
 import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
 
 /**
@@ -42,7 +42,7 @@ public class DefaultJdbcInterpreterUnitTests {
 	static final long CONTAINER_ID = 23L;
 	static final String BACK_REFERENCE = "back-reference";
 
-	JdbcMappingContext context = new JdbcMappingContext(new DefaultNamingStrategy() {
+	JdbcMappingContext context = new JdbcMappingContext(new NamingStrategy() {
 		@Override
 		public String getReverseColumnName(JdbcPersistentProperty property) {
 			return BACK_REFERENCE;

src/test/java/org/springframework/data/jdbc/core/DefaultJdbcInterpreterUnitTests.java

@@ -15,37 +15,38 @@
  */
 package org.springframework.data.jdbc.core;
 
+import static java.util.Arrays.*;
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
 import lombok.RequiredArgsConstructor;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.AbstractMap.SimpleEntry;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.naming.OperationNotSupportedException;
+
 import org.junit.Test;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 import org.springframework.core.convert.support.DefaultConversionService;
 import org.springframework.core.convert.support.GenericConversionService;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.convert.Jsr310Converters;
-import org.springframework.data.jdbc.mapping.model.DefaultNamingStrategy;
 import org.springframework.data.jdbc.mapping.model.JdbcMappingContext;
 import org.springframework.data.jdbc.mapping.model.JdbcPersistentEntity;
 import org.springframework.data.jdbc.mapping.model.JdbcPersistentProperty;
 import org.springframework.data.jdbc.mapping.model.NamingStrategy;
 import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
 import org.springframework.util.Assert;
 
-import javax.naming.OperationNotSupportedException;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.AbstractMap.SimpleEntry;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import static java.util.Arrays.*;
-import static org.assertj.core.api.Assertions.*;
-import static org.mockito.Mockito.*;
-
 /**
  * Tests the extraction of entities from a {@link ResultSet} by the {@link EntityRowMapper}.
  *
@@ -56,10 +57,10 @@ public class EntityRowMapperUnitTests {
 	public static final long ID_FOR_ENTITY_REFERENCING_MAP = 42L;
 	public static final long ID_FOR_ENTITY_REFERENCING_LIST = 4711L;
 	public static final long ID_FOR_ENTITY_NOT_REFERENCING_MAP = 23L;
-	public static final DefaultNamingStrategy X_APPENDING_NAMINGSTRATEGY = new DefaultNamingStrategy() {
+	public static final NamingStrategy X_APPENDING_NAMINGSTRATEGY = new NamingStrategy() {
 		@Override
 		public String getColumnName(JdbcPersistentProperty property) {
-			return super.getColumnName(property) + "x";
+			return NamingStrategy.super.getColumnName(property) + "x";
 		}
 	};
 
@@ -169,23 +170,22 @@ public void listReferenceGetsLoadedWithAdditionalSelect() throws SQLException {
 	}
 
 	private <T> EntityRowMapper<T> createRowMapper(Class<T> type) {
-		return createRowMapper(type, new DefaultNamingStrategy());
+		return createRowMapper(type, NamingStrategy.INSTANCE);
 	}
 
 	private <T> EntityRowMapper<T> createRowMapper(Class<T> type, NamingStrategy namingStrategy) {
 
 		JdbcMappingContext context = new JdbcMappingContext( //
 				namingStrategy, //
 				mock(NamedParameterJdbcOperations.class), //
-				__ -> {
-				} //
+				__ -> {} //
 		);
 
 		DataAccessStrategy accessStrategy = mock(DataAccessStrategy.class);
 
 		// the ID of the entity is used to determine what kind of ResultSet is needed for subsequent selects.
-		doReturn(new HashSet<>(asList(new Trivial(), new Trivial()))).when(accessStrategy).findAllByProperty(eq(ID_FOR_ENTITY_NOT_REFERENCING_MAP),
-				any(JdbcPersistentProperty.class));
+		doReturn(new HashSet<>(asList(new Trivial(), new Trivial()))).when(accessStrategy)
+				.findAllByProperty(eq(ID_FOR_ENTITY_NOT_REFERENCING_MAP), any(JdbcPersistentProperty.class));
 
 		doReturn(new HashSet<>(asList( //
 				new SimpleEntry("one", new Trivial()), //
@@ -202,8 +202,8 @@ private <T> EntityRowMapper<T> createRowMapper(Class<T> type, NamingStrategy nam
 		DefaultConversionService.addDefaultConverters(conversionService);
 		Jsr310Converters.getConvertersToRegister().forEach(conversionService::addConverter);
 
-		return new EntityRowMapper<>((JdbcPersistentEntity<T>) context.getRequiredPersistentEntity(type),
-				context, accessStrategy);
+		return new EntityRowMapper<>((JdbcPersistentEntity<T>) context.getRequiredPersistentEntity(type), context,
+				accessStrategy);
 	}
 
 	private static ResultSet mockResultSet(List<String> columns, Object... values) {
@@ -215,7 +215,7 @@ private static ResultSet mockResultSet(List<String> columns, Object... values) {
 								"Number of values [%d] must be a multiple of the number of columns [%d]", //
 								values.length, //
 								columns.size() //
-						) //
+				) //
 		);
 
 		List<Map<String, Object>> result = convertValues(columns, values);
@@ -291,7 +291,8 @@ private Object getObject(String column) {
 
 			Map<String, Object> rowMap = values.get(index);
 
-			Assert.isTrue(rowMap.containsKey(column), String.format("Trying to access a column (%s) that does not exist", column));
+			Assert.isTrue(rowMap.containsKey(column),
+					String.format("Trying to access a column (%s) that does not exist", column));
 
 			return rowMap.get(column);
 		}
@@ -306,46 +307,40 @@ private boolean next() {
 	@RequiredArgsConstructor
 	static class TrivialImmutable {
 
-		@Id
-		private final Long id;
+		@Id private final Long id;
 		private final String name;
 	}
 
 	static class Trivial {
 
-		@Id
-		Long id;
+		@Id Long id;
 		String name;
 	}
 
 	static class OneToOne {
 
-		@Id
-		Long id;
+		@Id Long id;
 		String name;
 		Trivial child;
 	}
 
 	static class OneToSet {
 
-		@Id
-		Long id;
+		@Id Long id;
 		String name;
 		Set<Trivial> children;
 	}
 
 	static class OneToMap {
 
-		@Id
-		Long id;
+		@Id Long id;
 		String name;
 		Map<String, Trivial> children;
 	}
 
 	static class OneToList {
 
-		@Id
-		Long id;
+		@Id Long id;
 		String name;
 		List<Trivial> children;
 	}