Skip to content

Commit e477d76

Browse files
schauderschauder
committed
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.
1 parent a6e4380 commit e477d76

15 files changed

+100
-130
lines changed

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

Lines changed: 0 additions & 30 deletions
This file was deleted.

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

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -22,14 +22,14 @@
2222
* column name based on {@link JdbcPersistentProperty}. The default delimiter is '_', resulting in snake case.
2323
*
2424
* @author Kazuki Shimizu
25+
* @author Jens Schauder
2526
*/
26-
public class DelimiterNamingStrategy extends DefaultNamingStrategy {
27+
public class DelimiterNamingStrategy implements NamingStrategy {
2728

2829
private final String delimiter;
2930

3031
/**
31-
* Construct a instance with '_' as delimiter.
32-
* This results in a snake case naming strategy.
32+
* Construct a instance with '_' as delimiter. This results in a snake case naming strategy.
3333
*/
3434
public DelimiterNamingStrategy() {
3535
this("_");
@@ -49,15 +49,15 @@ public DelimiterNamingStrategy(String delimiter) {
4949
*/
5050
@Override
5151
public String getTableName(Class<?> type) {
52-
return ParsingUtils.reconcatenateCamelCase(super.getTableName(type), delimiter);
52+
return ParsingUtils.reconcatenateCamelCase(NamingStrategy.super.getTableName(type), delimiter);
5353
}
5454

5555
/**
5656
* Look up the {@link JdbcPersistentProperty}'s name after converting to separated word using with {@code delimiter}.
5757
*/
5858
@Override
5959
public String getColumnName(JdbcPersistentProperty property) {
60-
return ParsingUtils.reconcatenateCamelCase(super.getColumnName(property), delimiter);
60+
return ParsingUtils.reconcatenateCamelCase(NamingStrategy.super.getColumnName(property), delimiter);
6161
}
6262

6363
/**

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -71,7 +71,7 @@ public JdbcMappingContext(NamingStrategy namingStrategy, NamedParameterJdbcOpera
7171
}
7272

7373
public JdbcMappingContext(NamedParameterJdbcOperations template) {
74-
this(new DefaultNamingStrategy(), template, __ -> {});
74+
this(NamingStrategy.INSTANCE, template, __ -> {});
7575
}
7676

7777
@Override

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

Lines changed: 19 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -16,21 +16,28 @@
1616
package org.springframework.data.jdbc.mapping.model;
1717

1818
/**
19-
* Interface and default implementation of a naming strategy. Defaults to no schema,
20-
* table name based on {@link Class} and column name based on {@link JdbcPersistentProperty}.
21-
*
22-
* NOTE: Can also be used as an adapter. Create a lambda or an anonymous subclass and
23-
* override any settings to implement a different strategy on the fly.
19+
* Interface and default implementation of a naming strategy. Defaults to no schema, table name based on {@link Class}
20+
* and column name based on {@link JdbcPersistentProperty}.
21+
* <p>
22+
* NOTE: Can also be used as an adapter. Create a lambda or an anonymous subclass and override any settings to implement
23+
* a different strategy on the fly.
2424
*
2525
* @author Greg Turnquist
2626
* @author Michael Simons
2727
*/
2828
public interface NamingStrategy {
2929

30+
/**
31+
* Empty implementation of the interface utilizing only the default implementation.
32+
* <p>
33+
* Using this avoids creating essentially the same class over and over again.
34+
*/
35+
NamingStrategy INSTANCE = new NamingStrategy() {};
36+
3037
/**
3138
* Defaults to no schema.
3239
*
33-
* @return No schema
40+
* @return Empty String representing no schema
3441
*/
3542
default String getSchema() {
3643
return "";
@@ -58,17 +65,19 @@ default String getQualifiedTableName(Class<?> type) {
5865
* For a reference A -&gt; B this is the name in the table for B which references A.
5966
*
6067
* @param property The property who's column name in the owner table is required
61-
* @return a column name.
68+
* @return a column name. Must not be {@code null}.
6269
*/
6370
default String getReverseColumnName(JdbcPersistentProperty property) {
6471
return property.getOwner().getTableName();
6572
}
6673

6774
/**
68-
* 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.
69-
* @return
75+
* 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
76+
* the map.
77+
*
78+
* @return name of the key column. Must not be {@code null}.
7079
*/
71-
default String getKeyColumn(JdbcPersistentProperty property){
80+
default String getKeyColumn(JdbcPersistentProperty property) {
7281
return getReverseColumnName(property) + "_key";
7382
}
7483

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

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,6 @@
2020
import org.springframework.context.annotation.Bean;
2121
import org.springframework.context.annotation.Configuration;
2222
import org.springframework.data.jdbc.mapping.model.ConversionCustomizer;
23-
import org.springframework.data.jdbc.mapping.model.DefaultNamingStrategy;
2423
import org.springframework.data.jdbc.mapping.model.JdbcMappingContext;
2524
import org.springframework.data.jdbc.mapping.model.NamingStrategy;
2625
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
@@ -35,9 +34,9 @@ public class JdbcConfiguration {
3534

3635
@Bean
3736
JdbcMappingContext jdbcMappingContext(NamedParameterJdbcTemplate template, Optional<NamingStrategy> namingStrategy,
38-
Optional<ConversionCustomizer> conversionCustomizer) {
37+
Optional<ConversionCustomizer> conversionCustomizer) {
3938

40-
return new JdbcMappingContext(
41-
namingStrategy.orElse(new DefaultNamingStrategy()), template, conversionCustomizer.orElse(conversionService -> {}));
39+
return new JdbcMappingContext(namingStrategy.orElse(NamingStrategy.INSTANCE), template,
40+
conversionCustomizer.orElse(conversionService -> {}));
4241
}
4342
}

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

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -25,8 +25,8 @@
2525
import org.junit.Test;
2626
import org.mockito.ArgumentCaptor;
2727
import org.springframework.data.annotation.Id;
28-
import org.springframework.data.jdbc.mapping.model.DefaultNamingStrategy;
2928
import org.springframework.data.jdbc.mapping.model.JdbcMappingContext;
29+
import org.springframework.data.jdbc.mapping.model.NamingStrategy;
3030
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
3131
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
3232
import org.springframework.jdbc.support.KeyHolder;
@@ -42,7 +42,7 @@ public class DefaultDataAccessStrategyUnitTests {
4242
public static final long ORIGINAL_ID = 4711L;
4343

4444
NamedParameterJdbcOperations jdbcOperations = mock(NamedParameterJdbcOperations.class);
45-
JdbcMappingContext context = new JdbcMappingContext(new DefaultNamingStrategy(), jdbcOperations, __ -> {});
45+
JdbcMappingContext context = new JdbcMappingContext(NamingStrategy.INSTANCE, jdbcOperations, __ -> {});
4646
HashMap<String, Object> additionalParameters = new HashMap<>();
4747
ArgumentCaptor<SqlParameterSource> paramSourceCaptor = ArgumentCaptor.forClass(SqlParameterSource.class);
4848

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

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -27,9 +27,9 @@
2727
import org.springframework.data.jdbc.core.conversion.DbAction;
2828
import org.springframework.data.jdbc.core.conversion.DbAction.Insert;
2929
import org.springframework.data.jdbc.core.conversion.JdbcPropertyPath;
30-
import org.springframework.data.jdbc.mapping.model.DefaultNamingStrategy;
3130
import org.springframework.data.jdbc.mapping.model.JdbcMappingContext;
3231
import org.springframework.data.jdbc.mapping.model.JdbcPersistentProperty;
32+
import org.springframework.data.jdbc.mapping.model.NamingStrategy;
3333
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
3434

3535
/**
@@ -42,7 +42,7 @@ public class DefaultJdbcInterpreterUnitTests {
4242
static final long CONTAINER_ID = 23L;
4343
static final String BACK_REFERENCE = "back-reference";
4444

45-
JdbcMappingContext context = new JdbcMappingContext(new DefaultNamingStrategy() {
45+
JdbcMappingContext context = new JdbcMappingContext(new NamingStrategy() {
4646
@Override
4747
public String getReverseColumnName(JdbcPersistentProperty property) {
4848
return BACK_REFERENCE;

‎src/test/java/org/springframework/data/jdbc/core/EntityRowMapperUnitTests.java‎

Lines changed: 34 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -15,37 +15,38 @@
1515
*/
1616
package org.springframework.data.jdbc.core;
1717

18+
import static java.util.Arrays.*;
19+
import static org.assertj.core.api.Assertions.*;
20+
import static org.mockito.Mockito.*;
21+
1822
import lombok.RequiredArgsConstructor;
23+
24+
import java.sql.ResultSet;
25+
import java.sql.SQLException;
26+
import java.util.AbstractMap.SimpleEntry;
27+
import java.util.ArrayList;
28+
import java.util.HashMap;
29+
import java.util.HashSet;
30+
import java.util.List;
31+
import java.util.Map;
32+
import java.util.Set;
33+
34+
import javax.naming.OperationNotSupportedException;
35+
1936
import org.junit.Test;
2037
import org.mockito.invocation.InvocationOnMock;
2138
import org.mockito.stubbing.Answer;
2239
import org.springframework.core.convert.support.DefaultConversionService;
2340
import org.springframework.core.convert.support.GenericConversionService;
2441
import org.springframework.data.annotation.Id;
2542
import org.springframework.data.convert.Jsr310Converters;
26-
import org.springframework.data.jdbc.mapping.model.DefaultNamingStrategy;
2743
import org.springframework.data.jdbc.mapping.model.JdbcMappingContext;
2844
import org.springframework.data.jdbc.mapping.model.JdbcPersistentEntity;
2945
import org.springframework.data.jdbc.mapping.model.JdbcPersistentProperty;
3046
import org.springframework.data.jdbc.mapping.model.NamingStrategy;
3147
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
3248
import org.springframework.util.Assert;
3349

34-
import javax.naming.OperationNotSupportedException;
35-
import java.sql.ResultSet;
36-
import java.sql.SQLException;
37-
import java.util.AbstractMap.SimpleEntry;
38-
import java.util.ArrayList;
39-
import java.util.HashMap;
40-
import java.util.HashSet;
41-
import java.util.List;
42-
import java.util.Map;
43-
import java.util.Set;
44-
45-
import static java.util.Arrays.*;
46-
import static org.assertj.core.api.Assertions.*;
47-
import static org.mockito.Mockito.*;
48-
4950
/**
5051
* Tests the extraction of entities from a {@link ResultSet} by the {@link EntityRowMapper}.
5152
*
@@ -56,10 +57,10 @@ public class EntityRowMapperUnitTests {
5657
public static final long ID_FOR_ENTITY_REFERENCING_MAP = 42L;
5758
public static final long ID_FOR_ENTITY_REFERENCING_LIST = 4711L;
5859
public static final long ID_FOR_ENTITY_NOT_REFERENCING_MAP = 23L;
59-
public static final DefaultNamingStrategy X_APPENDING_NAMINGSTRATEGY = new DefaultNamingStrategy() {
60+
public static final NamingStrategy X_APPENDING_NAMINGSTRATEGY = new NamingStrategy() {
6061
@Override
6162
public String getColumnName(JdbcPersistentProperty property) {
62-
return super.getColumnName(property) + "x";
63+
return NamingStrategy.super.getColumnName(property) + "x";
6364
}
6465
};
6566

@@ -169,23 +170,22 @@ public void listReferenceGetsLoadedWithAdditionalSelect() throws SQLException {
169170
}
170171

171172
private <T> EntityRowMapper<T> createRowMapper(Class<T> type) {
172-
return createRowMapper(type, new DefaultNamingStrategy());
173+
return createRowMapper(type, NamingStrategy.INSTANCE);
173174
}
174175

175176
private <T> EntityRowMapper<T> createRowMapper(Class<T> type, NamingStrategy namingStrategy) {
176177

177178
JdbcMappingContext context = new JdbcMappingContext( //
178179
namingStrategy, //
179180
mock(NamedParameterJdbcOperations.class), //
180-
__ -> {
181-
} //
181+
__ -> {} //
182182
);
183183

184184
DataAccessStrategy accessStrategy = mock(DataAccessStrategy.class);
185185

186186
// the ID of the entity is used to determine what kind of ResultSet is needed for subsequent selects.
187-
doReturn(new HashSet<>(asList(new Trivial(), new Trivial()))).when(accessStrategy).findAllByProperty(eq(ID_FOR_ENTITY_NOT_REFERENCING_MAP),
188-
any(JdbcPersistentProperty.class));
187+
doReturn(new HashSet<>(asList(new Trivial(), new Trivial()))).when(accessStrategy)
188+
.findAllByProperty(eq(ID_FOR_ENTITY_NOT_REFERENCING_MAP), any(JdbcPersistentProperty.class));
189189

190190
doReturn(new HashSet<>(asList( //
191191
new SimpleEntry("one", new Trivial()), //
@@ -202,8 +202,8 @@ private <T> EntityRowMapper<T> createRowMapper(Class<T> type, NamingStrategy nam
202202
DefaultConversionService.addDefaultConverters(conversionService);
203203
Jsr310Converters.getConvertersToRegister().forEach(conversionService::addConverter);
204204

205-
return new EntityRowMapper<>((JdbcPersistentEntity<T>) context.getRequiredPersistentEntity(type),
206-
context, accessStrategy);
205+
return new EntityRowMapper<>((JdbcPersistentEntity<T>) context.getRequiredPersistentEntity(type), context,
206+
accessStrategy);
207207
}
208208

209209
private static ResultSet mockResultSet(List<String> columns, Object... values) {
@@ -215,7 +215,7 @@ private static ResultSet mockResultSet(List<String> columns, Object... values) {
215215
"Number of values [%d] must be a multiple of the number of columns [%d]", //
216216
values.length, //
217217
columns.size() //
218-
) //
218+
) //
219219
);
220220

221221
List<Map<String, Object>> result = convertValues(columns, values);
@@ -291,7 +291,8 @@ private Object getObject(String column) {
291291

292292
Map<String, Object> rowMap = values.get(index);
293293

294-
Assert.isTrue(rowMap.containsKey(column), String.format("Trying to access a column (%s) that does not exist", column));
294+
Assert.isTrue(rowMap.containsKey(column),
295+
String.format("Trying to access a column (%s) that does not exist", column));
295296

296297
return rowMap.get(column);
297298
}
@@ -306,46 +307,40 @@ private boolean next() {
306307
@RequiredArgsConstructor
307308
static class TrivialImmutable {
308309

309-
@Id
310-
private final Long id;
310+
@Id private final Long id;
311311
private final String name;
312312
}
313313

314314
static class Trivial {
315315

316-
@Id
317-
Long id;
316+
@Id Long id;
318317
String name;
319318
}
320319

321320
static class OneToOne {
322321

323-
@Id
324-
Long id;
322+
@Id Long id;
325323
String name;
326324
Trivial child;
327325
}
328326

329327
static class OneToSet {
330328

331-
@Id
332-
Long id;
329+
@Id Long id;
333330
String name;
334331
Set<Trivial> children;
335332
}
336333

337334
static class OneToMap {
338335

339-
@Id
340-
Long id;
336+
@Id Long id;
341337
String name;
342338
Map<String, Trivial> children;
343339
}
344340

345341
static class OneToList {
346342

347-
@Id
348-
Long id;
343+
@Id Long id;
349344
String name;
350345
List<Trivial> children;
351346
}

0 commit comments

Comments
 (0)